@sourcegraph/cody-web 0.22.0 → 0.23.1

package/dist/util-CBKiMezg.mjs

@@ -0,0 +1,1811 @@
+import { c as commonjsGlobal } from "./browser-C8ruBrnx.mjs";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var inherits_browser = { exports: {} };
+if (typeof Object.create === "function") {
+  inherits_browser.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor;
+      ctor.prototype = Object.create(superCtor.prototype, {
+        constructor: {
+          value: ctor,
+          enumerable: false,
+          writable: true,
+          configurable: true
+        }
+      });
+    }
+  };
+} else {
+  inherits_browser.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor;
+      var TempCtor = function() {
+      };
+      TempCtor.prototype = superCtor.prototype;
+      ctor.prototype = new TempCtor();
+      ctor.prototype.constructor = ctor;
+    }
+  };
+}
+var inherits_browserExports = inherits_browser.exports;
+var util$1 = {};
+var types = {};
+var shams$1 = function hasSymbols() {
+  if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
+    return false;
+  }
+  if (typeof Symbol.iterator === "symbol") {
+    return true;
+  }
+  var obj = {};
+  var sym = Symbol("test");
+  var symObj = Object(sym);
+  if (typeof sym === "string") {
+    return false;
+  }
+  if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
+    return false;
+  }
+  if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
+    return false;
+  }
+  var symVal = 42;
+  obj[sym] = symVal;
+  for (sym in obj) {
+    return false;
+  }
+  if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
+    return false;
+  }
+  if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
+    return false;
+  }
+  var syms = Object.getOwnPropertySymbols(obj);
+  if (syms.length !== 1 || syms[0] !== sym) {
+    return false;
+  }
+  if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+    return false;
+  }
+  if (typeof Object.getOwnPropertyDescriptor === "function") {
+    var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+    if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+      return false;
+    }
+  }
+  return true;
+};
+var hasSymbols$2 = shams$1;
+var shams = function hasToStringTagShams() {
+  return hasSymbols$2() && !!Symbol.toStringTag;
+};
+var esErrors = Error;
+var _eval = EvalError;
+var range = RangeError;
+var ref = ReferenceError;
+var syntax = SyntaxError;
+var type = TypeError;
+var uri = URIError;
+var origSymbol = typeof Symbol !== "undefined" && Symbol;
+var hasSymbolSham = shams$1;
+var hasSymbols$1 = function hasNativeSymbols() {
+  if (typeof origSymbol !== "function") {
+    return false;
+  }
+  if (typeof Symbol !== "function") {
+    return false;
+  }
+  if (typeof origSymbol("foo") !== "symbol") {
+    return false;
+  }
+  if (typeof Symbol("bar") !== "symbol") {
+    return false;
+  }
+  return hasSymbolSham();
+};
+var test = {
+  __proto__: null,
+  foo: {}
+};
+var $Object = Object;
+var hasProto$1 = function hasProto() {
+  return { __proto__: test }.foo === test.foo && !(test instanceof $Object);
+};
+var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+var toStr$3 = Object.prototype.toString;
+var max = Math.max;
+var funcType = "[object Function]";
+var concatty = function concatty2(a, b) {
+  var arr = [];
+  for (var i = 0; i < a.length; i += 1) {
+    arr[i] = a[i];
+  }
+  for (var j = 0; j < b.length; j += 1) {
+    arr[j + a.length] = b[j];
+  }
+  return arr;
+};
+var slicy = function slicy2(arrLike, offset) {
+  var arr = [];
+  for (var i = offset, j = 0; i < arrLike.length; i += 1, j += 1) {
+    arr[j] = arrLike[i];
+  }
+  return arr;
+};
+var joiny = function(arr, joiner) {
+  var str = "";
+  for (var i = 0; i < arr.length; i += 1) {
+    str += arr[i];
+    if (i + 1 < arr.length) {
+      str += joiner;
+    }
+  }
+  return str;
+};
+var implementation$1 = function bind(that) {
+  var target = this;
+  if (typeof target !== "function" || toStr$3.apply(target) !== funcType) {
+    throw new TypeError(ERROR_MESSAGE + target);
+  }
+  var args = slicy(arguments, 1);
+  var bound;
+  var binder = function() {
+    if (this instanceof bound) {
+      var result = target.apply(
+        this,
+        concatty(args, arguments)
+      );
+      if (Object(result) === result) {
+        return result;
+      }
+      return this;
+    }
+    return target.apply(
+      that,
+      concatty(args, arguments)
+    );
+  };
+  var boundLength = max(0, target.length - args.length);
+  var boundArgs = [];
+  for (var i = 0; i < boundLength; i++) {
+    boundArgs[i] = "$" + i;
+  }
+  bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+  if (target.prototype) {
+    var Empty = function Empty2() {
+    };
+    Empty.prototype = target.prototype;
+    bound.prototype = new Empty();
+    Empty.prototype = null;
+  }
+  return bound;
+};
+var implementation = implementation$1;
+var functionBind = Function.prototype.bind || implementation;
+var call = Function.prototype.call;
+var $hasOwn = Object.prototype.hasOwnProperty;
+var bind$1 = functionBind;
+var hasown = bind$1.call(call, $hasOwn);
+var undefined$1;
+var $Error = esErrors;
+var $EvalError = _eval;
+var $RangeError = range;
+var $ReferenceError = ref;
+var $SyntaxError$1 = syntax;
+var $TypeError$2 = type;
+var $URIError = uri;
+var $Function = Function;
+var getEvalledConstructor = function(expressionSyntax) {
+  try {
+    return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+  } catch (e) {
+  }
+};
+var $gOPD$1 = Object.getOwnPropertyDescriptor;
+if ($gOPD$1) {
+  try {
+    $gOPD$1({}, "");
+  } catch (e) {
+    $gOPD$1 = null;
+  }
+}
+var throwTypeError = function() {
+  throw new $TypeError$2();
+};
+var ThrowTypeError = $gOPD$1 ? function() {
+  try {
+    arguments.callee;
+    return throwTypeError;
+  } catch (calleeThrows) {
+    try {
+      return $gOPD$1(arguments, "callee").get;
+    } catch (gOPDthrows) {
+      return throwTypeError;
+    }
+  }
+}() : throwTypeError;
+var hasSymbols2 = hasSymbols$1();
+var hasProto2 = hasProto$1();
+var getProto$1 = Object.getPrototypeOf || (hasProto2 ? function(x) {
+  return x.__proto__;
+} : null);
+var needsEval = {};
+var TypedArray = typeof Uint8Array === "undefined" || !getProto$1 ? undefined$1 : getProto$1(Uint8Array);
+var INTRINSICS = {
+  __proto__: null,
+  "%AggregateError%": typeof AggregateError === "undefined" ? undefined$1 : AggregateError,
+  "%Array%": Array,
+  "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined$1 : ArrayBuffer,
+  "%ArrayIteratorPrototype%": hasSymbols2 && getProto$1 ? getProto$1([][Symbol.iterator]()) : undefined$1,
+  "%AsyncFromSyncIteratorPrototype%": undefined$1,
+  "%AsyncFunction%": needsEval,
+  "%AsyncGenerator%": needsEval,
+  "%AsyncGeneratorFunction%": needsEval,
+  "%AsyncIteratorPrototype%": needsEval,
+  "%Atomics%": typeof Atomics === "undefined" ? undefined$1 : Atomics,
+  "%BigInt%": typeof BigInt === "undefined" ? undefined$1 : BigInt,
+  "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined$1 : BigInt64Array,
+  "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined$1 : BigUint64Array,
+  "%Boolean%": Boolean,
+  "%DataView%": typeof DataView === "undefined" ? undefined$1 : DataView,
+  "%Date%": Date,
+  "%decodeURI%": decodeURI,
+  "%decodeURIComponent%": decodeURIComponent,
+  "%encodeURI%": encodeURI,
+  "%encodeURIComponent%": encodeURIComponent,
+  "%Error%": $Error,
+  "%eval%": eval,
+  // eslint-disable-line no-eval
+  "%EvalError%": $EvalError,
+  "%Float32Array%": typeof Float32Array === "undefined" ? undefined$1 : Float32Array,
+  "%Float64Array%": typeof Float64Array === "undefined" ? undefined$1 : Float64Array,
+  "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined$1 : FinalizationRegistry,
+  "%Function%": $Function,
+  "%GeneratorFunction%": needsEval,
+  "%Int8Array%": typeof Int8Array === "undefined" ? undefined$1 : Int8Array,
+  "%Int16Array%": typeof Int16Array === "undefined" ? undefined$1 : Int16Array,
+  "%Int32Array%": typeof Int32Array === "undefined" ? undefined$1 : Int32Array,
+  "%isFinite%": isFinite,
+  "%isNaN%": isNaN,
+  "%IteratorPrototype%": hasSymbols2 && getProto$1 ? getProto$1(getProto$1([][Symbol.iterator]())) : undefined$1,
+  "%JSON%": typeof JSON === "object" ? JSON : undefined$1,
+  "%Map%": typeof Map === "undefined" ? undefined$1 : Map,
+  "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols2 || !getProto$1 ? undefined$1 : getProto$1((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+  "%Math%": Math,
+  "%Number%": Number,
+  "%Object%": Object,
+  "%parseFloat%": parseFloat,
+  "%parseInt%": parseInt,
+  "%Promise%": typeof Promise === "undefined" ? undefined$1 : Promise,
+  "%Proxy%": typeof Proxy === "undefined" ? undefined$1 : Proxy,
+  "%RangeError%": $RangeError,
+  "%ReferenceError%": $ReferenceError,
+  "%Reflect%": typeof Reflect === "undefined" ? undefined$1 : Reflect,
+  "%RegExp%": RegExp,
+  "%Set%": typeof Set === "undefined" ? undefined$1 : Set,
+  "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols2 || !getProto$1 ? undefined$1 : getProto$1((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+  "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined$1 : SharedArrayBuffer,
+  "%String%": String,
+  "%StringIteratorPrototype%": hasSymbols2 && getProto$1 ? getProto$1(""[Symbol.iterator]()) : undefined$1,
+  "%Symbol%": hasSymbols2 ? Symbol : undefined$1,
+  "%SyntaxError%": $SyntaxError$1,
+  "%ThrowTypeError%": ThrowTypeError,
+  "%TypedArray%": TypedArray,
+  "%TypeError%": $TypeError$2,
+  "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined$1 : Uint8Array,
+  "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined$1 : Uint8ClampedArray,
+  "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined$1 : Uint16Array,
+  "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined$1 : Uint32Array,
+  "%URIError%": $URIError,
+  "%WeakMap%": typeof WeakMap === "undefined" ? undefined$1 : WeakMap,
+  "%WeakRef%": typeof WeakRef === "undefined" ? undefined$1 : WeakRef,
+  "%WeakSet%": typeof WeakSet === "undefined" ? undefined$1 : WeakSet
+};
+if (getProto$1) {
+  try {
+    null.error;
+  } catch (e) {
+    var errorProto = getProto$1(getProto$1(e));
+    INTRINSICS["%Error.prototype%"] = errorProto;
+  }
+}
+var doEval = function doEval2(name) {
+  var value;
+  if (name === "%AsyncFunction%") {
+    value = getEvalledConstructor("async function () {}");
+  } else if (name === "%GeneratorFunction%") {
+    value = getEvalledConstructor("function* () {}");
+  } else if (name === "%AsyncGeneratorFunction%") {
+    value = getEvalledConstructor("async function* () {}");
+  } else if (name === "%AsyncGenerator%") {
+    var fn = doEval2("%AsyncGeneratorFunction%");
+    if (fn) {
+      value = fn.prototype;
+    }
+  } else if (name === "%AsyncIteratorPrototype%") {
+    var gen = doEval2("%AsyncGenerator%");
+    if (gen && getProto$1) {
+      value = getProto$1(gen.prototype);
+    }
+  }
+  INTRINSICS[name] = value;
+  return value;
+};
+var LEGACY_ALIASES = {
+  __proto__: null,
+  "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+  "%ArrayPrototype%": ["Array", "prototype"],
+  "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+  "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+  "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+  "%ArrayProto_values%": ["Array", "prototype", "values"],
+  "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+  "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+  "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
+  "%BooleanPrototype%": ["Boolean", "prototype"],
+  "%DataViewPrototype%": ["DataView", "prototype"],
+  "%DatePrototype%": ["Date", "prototype"],
+  "%ErrorPrototype%": ["Error", "prototype"],
+  "%EvalErrorPrototype%": ["EvalError", "prototype"],
+  "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+  "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+  "%FunctionPrototype%": ["Function", "prototype"],
+  "%Generator%": ["GeneratorFunction", "prototype"],
+  "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+  "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+  "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+  "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+  "%JSONParse%": ["JSON", "parse"],
+  "%JSONStringify%": ["JSON", "stringify"],
+  "%MapPrototype%": ["Map", "prototype"],
+  "%NumberPrototype%": ["Number", "prototype"],
+  "%ObjectPrototype%": ["Object", "prototype"],
+  "%ObjProto_toString%": ["Object", "prototype", "toString"],
+  "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+  "%PromisePrototype%": ["Promise", "prototype"],
+  "%PromiseProto_then%": ["Promise", "prototype", "then"],
+  "%Promise_all%": ["Promise", "all"],
+  "%Promise_reject%": ["Promise", "reject"],
+  "%Promise_resolve%": ["Promise", "resolve"],
+  "%RangeErrorPrototype%": ["RangeError", "prototype"],
+  "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+  "%RegExpPrototype%": ["RegExp", "prototype"],
+  "%SetPrototype%": ["Set", "prototype"],
+  "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+  "%StringPrototype%": ["String", "prototype"],
+  "%SymbolPrototype%": ["Symbol", "prototype"],
+  "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+  "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+  "%TypeErrorPrototype%": ["TypeError", "prototype"],
+  "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+  "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+  "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+  "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+  "%URIErrorPrototype%": ["URIError", "prototype"],
+  "%WeakMapPrototype%": ["WeakMap", "prototype"],
+  "%WeakSetPrototype%": ["WeakSet", "prototype"]
+};
+var bind2 = functionBind;
+var hasOwn = hasown;
+var $concat = bind2.call(Function.call, Array.prototype.concat);
+var $spliceApply = bind2.call(Function.apply, Array.prototype.splice);
+var $replace = bind2.call(Function.call, String.prototype.replace);
+var $strSlice = bind2.call(Function.call, String.prototype.slice);
+var $exec = bind2.call(Function.call, RegExp.prototype.exec);
+var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = function stringToPath2(string) {
+  var first = $strSlice(string, 0, 1);
+  var last = $strSlice(string, -1);
+  if (first === "%" && last !== "%") {
+    throw new $SyntaxError$1("invalid intrinsic syntax, expected closing `%`");
+  } else if (last === "%" && first !== "%") {
+    throw new $SyntaxError$1("invalid intrinsic syntax, expected opening `%`");
+  }
+  var result = [];
+  $replace(string, rePropName, function(match, number, quote, subString) {
+    result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
+  });
+  return result;
+};
+var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
+  var intrinsicName = name;
+  var alias;
+  if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+    alias = LEGACY_ALIASES[intrinsicName];
+    intrinsicName = "%" + alias[0] + "%";
+  }
+  if (hasOwn(INTRINSICS, intrinsicName)) {
+    var value = INTRINSICS[intrinsicName];
+    if (value === needsEval) {
+      value = doEval(intrinsicName);
+    }
+    if (typeof value === "undefined" && !allowMissing) {
+      throw new $TypeError$2("intrinsic " + name + " exists, but is not available. Please file an issue!");
+    }
+    return {
+      alias,
+      name: intrinsicName,
+      value
+    };
+  }
+  throw new $SyntaxError$1("intrinsic " + name + " does not exist!");
+};
+var getIntrinsic = function GetIntrinsic(name, allowMissing) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new $TypeError$2("intrinsic name must be a non-empty string");
+  }
+  if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+    throw new $TypeError$2('"allowMissing" argument must be a boolean');
+  }
+  if ($exec(/^%?[^%]*%?$/, name) === null) {
+    throw new $SyntaxError$1("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+  }
+  var parts = stringToPath(name);
+  var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+  var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
+  var intrinsicRealName = intrinsic.name;
+  var value = intrinsic.value;
+  var skipFurtherCaching = false;
+  var alias = intrinsic.alias;
+  if (alias) {
+    intrinsicBaseName = alias[0];
+    $spliceApply(parts, $concat([0, 1], alias));
+  }
+  for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+    var part = parts[i];
+    var first = $strSlice(part, 0, 1);
+    var last = $strSlice(part, -1);
+    if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
+      throw new $SyntaxError$1("property names with quotes must have matching quotes");
+    }
+    if (part === "constructor" || !isOwn) {
+      skipFurtherCaching = true;
+    }
+    intrinsicBaseName += "." + part;
+    intrinsicRealName = "%" + intrinsicBaseName + "%";
+    if (hasOwn(INTRINSICS, intrinsicRealName)) {
+      value = INTRINSICS[intrinsicRealName];
+    } else if (value != null) {
+      if (!(part in value)) {
+        if (!allowMissing) {
+          throw new $TypeError$2("base intrinsic for " + name + " exists, but the property is not available.");
+        }
+        return void 0;
+      }
+      if ($gOPD$1 && i + 1 >= parts.length) {
+        var desc = $gOPD$1(value, part);
+        isOwn = !!desc;
+        if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
+          value = desc.get;
+        } else {
+          value = value[part];
+        }
+      } else {
+        isOwn = hasOwn(value, part);
+        value = value[part];
+      }
+      if (isOwn && !skipFurtherCaching) {
+        INTRINSICS[intrinsicRealName] = value;
+      }
+    }
+  }
+  return value;
+};
+var callBind$2 = { exports: {} };
+var esDefineProperty;
+var hasRequiredEsDefineProperty;
+function requireEsDefineProperty() {
+  if (hasRequiredEsDefineProperty) return esDefineProperty;
+  hasRequiredEsDefineProperty = 1;
+  var GetIntrinsic3 = getIntrinsic;
+  var $defineProperty2 = GetIntrinsic3("%Object.defineProperty%", true) || false;
+  if ($defineProperty2) {
+    try {
+      $defineProperty2({}, "a", { value: 1 });
+    } catch (e) {
+      $defineProperty2 = false;
+    }
+  }
+  esDefineProperty = $defineProperty2;
+  return esDefineProperty;
+}
+var GetIntrinsic$2 = getIntrinsic;
+var $gOPD = GetIntrinsic$2("%Object.getOwnPropertyDescriptor%", true);
+if ($gOPD) {
+  try {
+    $gOPD([], "length");
+  } catch (e) {
+    $gOPD = null;
+  }
+}
+var gopd$1 = $gOPD;
+var $defineProperty$1 = requireEsDefineProperty();
+var $SyntaxError = syntax;
+var $TypeError$1 = type;
+var gopd = gopd$1;
+var defineDataProperty = function defineDataProperty2(obj, property, value) {
+  if (!obj || typeof obj !== "object" && typeof obj !== "function") {
+    throw new $TypeError$1("`obj` must be an object or a function`");
+  }
+  if (typeof property !== "string" && typeof property !== "symbol") {
+    throw new $TypeError$1("`property` must be a string or a symbol`");
+  }
+  if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) {
+    throw new $TypeError$1("`nonEnumerable`, if provided, must be a boolean or null");
+  }
+  if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) {
+    throw new $TypeError$1("`nonWritable`, if provided, must be a boolean or null");
+  }
+  if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) {
+    throw new $TypeError$1("`nonConfigurable`, if provided, must be a boolean or null");
+  }
+  if (arguments.length > 6 && typeof arguments[6] !== "boolean") {
+    throw new $TypeError$1("`loose`, if provided, must be a boolean");
+  }
+  var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
+  var nonWritable = arguments.length > 4 ? arguments[4] : null;
+  var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
+  var loose = arguments.length > 6 ? arguments[6] : false;
+  var desc = !!gopd && gopd(obj, property);
+  if ($defineProperty$1) {
+    $defineProperty$1(obj, property, {
+      configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
+      enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
+      value,
+      writable: nonWritable === null && desc ? desc.writable : !nonWritable
+    });
+  } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {
+    obj[property] = value;
+  } else {
+    throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
+  }
+};
+var $defineProperty = requireEsDefineProperty();
+var hasPropertyDescriptors = function hasPropertyDescriptors2() {
+  return !!$defineProperty;
+};
+hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+  if (!$defineProperty) {
+    return null;
+  }
+  try {
+    return $defineProperty([], "length", { value: 1 }).length !== 1;
+  } catch (e) {
+    return true;
+  }
+};
+var hasPropertyDescriptors_1 = hasPropertyDescriptors;
+var GetIntrinsic$1 = getIntrinsic;
+var define = defineDataProperty;
+var hasDescriptors = hasPropertyDescriptors_1();
+var gOPD$1 = gopd$1;
+var $TypeError = type;
+var $floor = GetIntrinsic$1("%Math.floor%");
+var setFunctionLength = function setFunctionLength2(fn, length) {
+  if (typeof fn !== "function") {
+    throw new $TypeError("`fn` is not a function");
+  }
+  if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length) {
+    throw new $TypeError("`length` must be a positive 32-bit integer");
+  }
+  var loose = arguments.length > 2 && !!arguments[2];
+  var functionLengthIsConfigurable = true;
+  var functionLengthIsWritable = true;
+  if ("length" in fn && gOPD$1) {
+    var desc = gOPD$1(fn, "length");
+    if (desc && !desc.configurable) {
+      functionLengthIsConfigurable = false;
+    }
+    if (desc && !desc.writable) {
+      functionLengthIsWritable = false;
+    }
+  }
+  if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
+    if (hasDescriptors) {
+      define(
+        /** @type {Parameters<define>[0]} */
+        fn,
+        "length",
+        length,
+        true,
+        true
+      );
+    } else {
+      define(
+        /** @type {Parameters<define>[0]} */
+        fn,
+        "length",
+        length
+      );
+    }
+  }
+  return fn;
+};
+(function(module) {
+  var bind3 = functionBind;
+  var GetIntrinsic3 = getIntrinsic;
+  var setFunctionLength$1 = setFunctionLength;
+  var $TypeError2 = type;
+  var $apply = GetIntrinsic3("%Function.prototype.apply%");
+  var $call = GetIntrinsic3("%Function.prototype.call%");
+  var $reflectApply = GetIntrinsic3("%Reflect.apply%", true) || bind3.call($call, $apply);
+  var $defineProperty2 = requireEsDefineProperty();
+  var $max = GetIntrinsic3("%Math.max%");
+  module.exports = function callBind2(originalFunction) {
+    if (typeof originalFunction !== "function") {
+      throw new $TypeError2("a function is required");
+    }
+    var func = $reflectApply(bind3, $call, arguments);
+    return setFunctionLength$1(
+      func,
+      1 + $max(0, originalFunction.length - (arguments.length - 1)),
+      true
+    );
+  };
+  var applyBind = function applyBind2() {
+    return $reflectApply(bind3, $apply, arguments);
+  };
+  if ($defineProperty2) {
+    $defineProperty2(module.exports, "apply", { value: applyBind });
+  } else {
+    module.exports.apply = applyBind;
+  }
+})(callBind$2);
+var callBindExports = callBind$2.exports;
+var GetIntrinsic2 = getIntrinsic;
+var callBind$1 = callBindExports;
+var $indexOf$1 = callBind$1(GetIntrinsic2("String.prototype.indexOf"));
+var callBound$2 = function callBoundIntrinsic(name, allowMissing) {
+  var intrinsic = GetIntrinsic2(name, !!allowMissing);
+  if (typeof intrinsic === "function" && $indexOf$1(name, ".prototype.") > -1) {
+    return callBind$1(intrinsic);
+  }
+  return intrinsic;
+};
+var hasToStringTag$3 = shams();
+var callBound$1 = callBound$2;
+var $toString$1 = callBound$1("Object.prototype.toString");
+var isStandardArguments = function isArguments(value) {
+  if (hasToStringTag$3 && value && typeof value === "object" && Symbol.toStringTag in value) {
+    return false;
+  }
+  return $toString$1(value) === "[object Arguments]";
+};
+var isLegacyArguments = function isArguments2(value) {
+  if (isStandardArguments(value)) {
+    return true;
+  }
+  return value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && $toString$1(value) !== "[object Array]" && $toString$1(value.callee) === "[object Function]";
+};
+var supportsStandardArguments = function() {
+  return isStandardArguments(arguments);
+}();
+isStandardArguments.isLegacyArguments = isLegacyArguments;
+var isArguments3 = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
+var toStr$2 = Object.prototype.toString;
+var fnToStr$1 = Function.prototype.toString;
+var isFnRegex = /^\s*(?:function)?\*/;
+var hasToStringTag$2 = shams();
+var getProto = Object.getPrototypeOf;
+var getGeneratorFunc = function() {
+  if (!hasToStringTag$2) {
+    return false;
+  }
+  try {
+    return Function("return function*() {}")();
+  } catch (e) {
+  }
+};
+var GeneratorFunction;
+var isGeneratorFunction = function isGeneratorFunction2(fn) {
+  if (typeof fn !== "function") {
+    return false;
+  }
+  if (isFnRegex.test(fnToStr$1.call(fn))) {
+    return true;
+  }
+  if (!hasToStringTag$2) {
+    var str = toStr$2.call(fn);
+    return str === "[object GeneratorFunction]";
+  }
+  if (!getProto) {
+    return false;
+  }
+  if (typeof GeneratorFunction === "undefined") {
+    var generatorFunc = getGeneratorFunc();
+    GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;
+  }
+  return getProto(fn) === GeneratorFunction;
+};
+var fnToStr = Function.prototype.toString;
+var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply;
+var badArrayLike;
+var isCallableMarker;
+if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") {
+  try {
+    badArrayLike = Object.defineProperty({}, "length", {
+      get: function() {
+        throw isCallableMarker;
+      }
+    });
+    isCallableMarker = {};
+    reflectApply(function() {
+      throw 42;
+    }, null, badArrayLike);
+  } catch (_) {
+    if (_ !== isCallableMarker) {
+      reflectApply = null;
+    }
+  }
+} else {
+  reflectApply = null;
+}
+var constructorRegex = /^\s*class\b/;
+var isES6ClassFn = function isES6ClassFunction(value) {
+  try {
+    var fnStr = fnToStr.call(value);
+    return constructorRegex.test(fnStr);
+  } catch (e) {
+    return false;
+  }
+};
+var tryFunctionObject = function tryFunctionToStr(value) {
+  try {
+    if (isES6ClassFn(value)) {
+      return false;
+    }
+    fnToStr.call(value);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+var toStr$1 = Object.prototype.toString;
+var objectClass = "[object Object]";
+var fnClass = "[object Function]";
+var genClass = "[object GeneratorFunction]";
+var ddaClass = "[object HTMLAllCollection]";
+var ddaClass2 = "[object HTML document.all class]";
+var ddaClass3 = "[object HTMLCollection]";
+var hasToStringTag$1 = typeof Symbol === "function" && !!Symbol.toStringTag;
+var isIE68 = !(0 in [,]);
+var isDDA = function isDocumentDotAll() {
+  return false;
+};
+if (typeof document === "object") {
+  var all = document.all;
+  if (toStr$1.call(all) === toStr$1.call(document.all)) {
+    isDDA = function isDocumentDotAll2(value) {
+      if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) {
+        try {
+          var str = toStr$1.call(value);
+          return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
+        } catch (e) {
+        }
+      }
+      return false;
+    };
+  }
+}
+var isCallable$1 = reflectApply ? function isCallable(value) {
+  if (isDDA(value)) {
+    return true;
+  }
+  if (!value) {
+    return false;
+  }
+  if (typeof value !== "function" && typeof value !== "object") {
+    return false;
+  }
+  try {
+    reflectApply(value, null, badArrayLike);
+  } catch (e) {
+    if (e !== isCallableMarker) {
+      return false;
+    }
+  }
+  return !isES6ClassFn(value) && tryFunctionObject(value);
+} : function isCallable2(value) {
+  if (isDDA(value)) {
+    return true;
+  }
+  if (!value) {
+    return false;
+  }
+  if (typeof value !== "function" && typeof value !== "object") {
+    return false;
+  }
+  if (hasToStringTag$1) {
+    return tryFunctionObject(value);
+  }
+  if (isES6ClassFn(value)) {
+    return false;
+  }
+  var strClass = toStr$1.call(value);
+  if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) {
+    return false;
+  }
+  return tryFunctionObject(value);
+};
+var isCallable3 = isCallable$1;
+var toStr = Object.prototype.toString;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var forEachArray = function forEachArray2(array, iterator, receiver) {
+  for (var i = 0, len = array.length; i < len; i++) {
+    if (hasOwnProperty.call(array, i)) {
+      if (receiver == null) {
+        iterator(array[i], i, array);
+      } else {
+        iterator.call(receiver, array[i], i, array);
+      }
+    }
+  }
+};
+var forEachString = function forEachString2(string, iterator, receiver) {
+  for (var i = 0, len = string.length; i < len; i++) {
+    if (receiver == null) {
+      iterator(string.charAt(i), i, string);
+    } else {
+      iterator.call(receiver, string.charAt(i), i, string);
+    }
+  }
+};
+var forEachObject = function forEachObject2(object, iterator, receiver) {
+  for (var k in object) {
+    if (hasOwnProperty.call(object, k)) {
+      if (receiver == null) {
+        iterator(object[k], k, object);
+      } else {
+        iterator.call(receiver, object[k], k, object);
+      }
+    }
+  }
+};
+var forEach$1 = function forEach(list, iterator, thisArg) {
+  if (!isCallable3(iterator)) {
+    throw new TypeError("iterator must be a function");
+  }
+  var receiver;
+  if (arguments.length >= 3) {
+    receiver = thisArg;
+  }
+  if (toStr.call(list) === "[object Array]") {
+    forEachArray(list, iterator, receiver);
+  } else if (typeof list === "string") {
+    forEachString(list, iterator, receiver);
+  } else {
+    forEachObject(list, iterator, receiver);
+  }
+};
+var forEach_1 = forEach$1;
+var possibleTypedArrayNames = [
+  "Float32Array",
+  "Float64Array",
+  "Int8Array",
+  "Int16Array",
+  "Int32Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Uint16Array",
+  "Uint32Array",
+  "BigInt64Array",
+  "BigUint64Array"
+];
+var possibleNames = possibleTypedArrayNames;
+var g$1 = typeof globalThis === "undefined" ? commonjsGlobal : globalThis;
+var availableTypedArrays$1 = function availableTypedArrays() {
+  var out = [];
+  for (var i = 0; i < possibleNames.length; i++) {
+    if (typeof g$1[possibleNames[i]] === "function") {
+      out[out.length] = possibleNames[i];
+    }
+  }
+  return out;
+};
+var forEach2 = forEach_1;
+var availableTypedArrays2 = availableTypedArrays$1;
+var callBind = callBindExports;
+var callBound = callBound$2;
+var gOPD = gopd$1;
+var $toString = callBound("Object.prototype.toString");
+var hasToStringTag = shams();
+var g = typeof globalThis === "undefined" ? commonjsGlobal : globalThis;
+var typedArrays = availableTypedArrays2();
+var $slice = callBound("String.prototype.slice");
+var getPrototypeOf = Object.getPrototypeOf;
+var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) {
+  for (var i = 0; i < array.length; i += 1) {
+    if (array[i] === value) {
+      return i;
+    }
+  }
+  return -1;
+};
+var cache = { __proto__: null };
+if (hasToStringTag && gOPD && getPrototypeOf) {
+  forEach2(typedArrays, function(typedArray) {
+    var arr = new g[typedArray]();
+    if (Symbol.toStringTag in arr) {
+      var proto = getPrototypeOf(arr);
+      var descriptor = gOPD(proto, Symbol.toStringTag);
+      if (!descriptor) {
+        var superProto = getPrototypeOf(proto);
+        descriptor = gOPD(superProto, Symbol.toStringTag);
+      }
+      cache["$" + typedArray] = callBind(descriptor.get);
+    }
+  });
+} else {
+  forEach2(typedArrays, function(typedArray) {
+    var arr = new g[typedArray]();
+    var fn = arr.slice || arr.set;
+    if (fn) {
+      cache["$" + typedArray] = callBind(fn);
+    }
+  });
+}
+var tryTypedArrays = function tryAllTypedArrays(value) {
+  var found = false;
+  forEach2(
+    // eslint-disable-next-line no-extra-parens
+    /** @type {Record<`\$${TypedArrayName}`, Getter>} */
+    /** @type {any} */
+    cache,
+    /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
+    function(getter, typedArray) {
+      if (!found) {
+        try {
+          if ("$" + getter(value) === typedArray) {
+            found = $slice(typedArray, 1);
+          }
+        } catch (e) {
+        }
+      }
+    }
+  );
+  return found;
+};
+var trySlices = function tryAllSlices(value) {
+  var found = false;
+  forEach2(
+    // eslint-disable-next-line no-extra-parens
+    /** @type {Record<`\$${TypedArrayName}`, Getter>} */
+    /** @type {any} */
+    cache,
+    /** @type {(getter: typeof cache, name: `\$${import('.').TypedArrayName}`) => void} */
+    function(getter, name) {
+      if (!found) {
+        try {
+          getter(value);
+          found = $slice(name, 1);
+        } catch (e) {
+        }
+      }
+    }
+  );
+  return found;
+};
+var whichTypedArray$1 = function whichTypedArray(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (!hasToStringTag) {
+    var tag = $slice($toString(value), 8, -1);
+    if ($indexOf(typedArrays, tag) > -1) {
+      return tag;
+    }
+    if (tag !== "Object") {
+      return false;
+    }
+    return trySlices(value);
+  }
+  if (!gOPD) {
+    return null;
+  }
+  return tryTypedArrays(value);
+};
+var whichTypedArray2 = whichTypedArray$1;
+var isTypedArray = function isTypedArray2(value) {
+  return !!whichTypedArray2(value);
+};
+(function(exports) {
+  var isArgumentsObject = isArguments3;
+  var isGeneratorFunction$1 = isGeneratorFunction;
+  var whichTypedArray3 = whichTypedArray$1;
+  var isTypedArray$1 = isTypedArray;
+  function uncurryThis(f) {
+    return f.call.bind(f);
+  }
+  var BigIntSupported = typeof BigInt !== "undefined";
+  var SymbolSupported = typeof Symbol !== "undefined";
+  var ObjectToString = uncurryThis(Object.prototype.toString);
+  var numberValue = uncurryThis(Number.prototype.valueOf);
+  var stringValue = uncurryThis(String.prototype.valueOf);
+  var booleanValue = uncurryThis(Boolean.prototype.valueOf);
+  if (BigIntSupported) {
+    var bigIntValue = uncurryThis(BigInt.prototype.valueOf);
+  }
+  if (SymbolSupported) {
+    var symbolValue = uncurryThis(Symbol.prototype.valueOf);
+  }
+  function checkBoxedPrimitive(value, prototypeValueOf) {
+    if (typeof value !== "object") {
+      return false;
+    }
+    try {
+      prototypeValueOf(value);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  exports.isArgumentsObject = isArgumentsObject;
+  exports.isGeneratorFunction = isGeneratorFunction$1;
+  exports.isTypedArray = isTypedArray$1;
+  function isPromise(input) {
+    return typeof Promise !== "undefined" && input instanceof Promise || input !== null && typeof input === "object" && typeof input.then === "function" && typeof input.catch === "function";
+  }
+  exports.isPromise = isPromise;
+  function isArrayBufferView(value) {
+    if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+      return ArrayBuffer.isView(value);
+    }
+    return isTypedArray$1(value) || isDataView(value);
+  }
+  exports.isArrayBufferView = isArrayBufferView;
+  function isUint8Array(value) {
+    return whichTypedArray3(value) === "Uint8Array";
+  }
+  exports.isUint8Array = isUint8Array;
+  function isUint8ClampedArray(value) {
+    return whichTypedArray3(value) === "Uint8ClampedArray";
+  }
+  exports.isUint8ClampedArray = isUint8ClampedArray;
+  function isUint16Array(value) {
+    return whichTypedArray3(value) === "Uint16Array";
+  }
+  exports.isUint16Array = isUint16Array;
+  function isUint32Array(value) {
+    return whichTypedArray3(value) === "Uint32Array";
+  }
+  exports.isUint32Array = isUint32Array;
+  function isInt8Array(value) {
+    return whichTypedArray3(value) === "Int8Array";
+  }
+  exports.isInt8Array = isInt8Array;
+  function isInt16Array(value) {
+    return whichTypedArray3(value) === "Int16Array";
+  }
+  exports.isInt16Array = isInt16Array;
+  function isInt32Array(value) {
+    return whichTypedArray3(value) === "Int32Array";
+  }
+  exports.isInt32Array = isInt32Array;
+  function isFloat32Array(value) {
+    return whichTypedArray3(value) === "Float32Array";
+  }
+  exports.isFloat32Array = isFloat32Array;
+  function isFloat64Array(value) {
+    return whichTypedArray3(value) === "Float64Array";
+  }
+  exports.isFloat64Array = isFloat64Array;
+  function isBigInt64Array(value) {
+    return whichTypedArray3(value) === "BigInt64Array";
+  }
+  exports.isBigInt64Array = isBigInt64Array;
+  function isBigUint64Array(value) {
+    return whichTypedArray3(value) === "BigUint64Array";
+  }
+  exports.isBigUint64Array = isBigUint64Array;
+  function isMapToString(value) {
+    return ObjectToString(value) === "[object Map]";
+  }
+  isMapToString.working = typeof Map !== "undefined" && isMapToString(/* @__PURE__ */ new Map());
+  function isMap(value) {
+    if (typeof Map === "undefined") {
+      return false;
+    }
+    return isMapToString.working ? isMapToString(value) : value instanceof Map;
+  }
+  exports.isMap = isMap;
+  function isSetToString(value) {
+    return ObjectToString(value) === "[object Set]";
+  }
+  isSetToString.working = typeof Set !== "undefined" && isSetToString(/* @__PURE__ */ new Set());
+  function isSet(value) {
+    if (typeof Set === "undefined") {
+      return false;
+    }
+    return isSetToString.working ? isSetToString(value) : value instanceof Set;
+  }
+  exports.isSet = isSet;
+  function isWeakMapToString(value) {
+    return ObjectToString(value) === "[object WeakMap]";
+  }
+  isWeakMapToString.working = typeof WeakMap !== "undefined" && isWeakMapToString(/* @__PURE__ */ new WeakMap());
+  function isWeakMap(value) {
+    if (typeof WeakMap === "undefined") {
+      return false;
+    }
+    return isWeakMapToString.working ? isWeakMapToString(value) : value instanceof WeakMap;
+  }
+  exports.isWeakMap = isWeakMap;
+  function isWeakSetToString(value) {
+    return ObjectToString(value) === "[object WeakSet]";
+  }
+  isWeakSetToString.working = typeof WeakSet !== "undefined" && isWeakSetToString(/* @__PURE__ */ new WeakSet());
+  function isWeakSet(value) {
+    return isWeakSetToString(value);
+  }
+  exports.isWeakSet = isWeakSet;
+  function isArrayBufferToString(value) {
+    return ObjectToString(value) === "[object ArrayBuffer]";
+  }
+  isArrayBufferToString.working = typeof ArrayBuffer !== "undefined" && isArrayBufferToString(new ArrayBuffer());
+  function isArrayBuffer(value) {
+    if (typeof ArrayBuffer === "undefined") {
+      return false;
+    }
+    return isArrayBufferToString.working ? isArrayBufferToString(value) : value instanceof ArrayBuffer;
+  }
+  exports.isArrayBuffer = isArrayBuffer;
+  function isDataViewToString(value) {
+    return ObjectToString(value) === "[object DataView]";
+  }
+  isDataViewToString.working = typeof ArrayBuffer !== "undefined" && typeof DataView !== "undefined" && isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1));
+  function isDataView(value) {
+    if (typeof DataView === "undefined") {
+      return false;
+    }
+    return isDataViewToString.working ? isDataViewToString(value) : value instanceof DataView;
+  }
+  exports.isDataView = isDataView;
+  var SharedArrayBufferCopy = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : void 0;
+  function isSharedArrayBufferToString(value) {
+    return ObjectToString(value) === "[object SharedArrayBuffer]";
+  }
+  function isSharedArrayBuffer(value) {
+    if (typeof SharedArrayBufferCopy === "undefined") {
+      return false;
+    }
+    if (typeof isSharedArrayBufferToString.working === "undefined") {
+      isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());
+    }
+    return isSharedArrayBufferToString.working ? isSharedArrayBufferToString(value) : value instanceof SharedArrayBufferCopy;
+  }
+  exports.isSharedArrayBuffer = isSharedArrayBuffer;
+  function isAsyncFunction(value) {
+    return ObjectToString(value) === "[object AsyncFunction]";
+  }
+  exports.isAsyncFunction = isAsyncFunction;
+  function isMapIterator(value) {
+    return ObjectToString(value) === "[object Map Iterator]";
+  }
+  exports.isMapIterator = isMapIterator;
+  function isSetIterator(value) {
+    return ObjectToString(value) === "[object Set Iterator]";
+  }
+  exports.isSetIterator = isSetIterator;
+  function isGeneratorObject(value) {
+    return ObjectToString(value) === "[object Generator]";
+  }
+  exports.isGeneratorObject = isGeneratorObject;
+  function isWebAssemblyCompiledModule(value) {
+    return ObjectToString(value) === "[object WebAssembly.Module]";
+  }
+  exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;
+  function isNumberObject(value) {
+    return checkBoxedPrimitive(value, numberValue);
+  }
+  exports.isNumberObject = isNumberObject;
+  function isStringObject(value) {
+    return checkBoxedPrimitive(value, stringValue);
+  }
+  exports.isStringObject = isStringObject;
+  function isBooleanObject(value) {
+    return checkBoxedPrimitive(value, booleanValue);
+  }
+  exports.isBooleanObject = isBooleanObject;
+  function isBigIntObject(value) {
+    return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);
+  }
+  exports.isBigIntObject = isBigIntObject;
+  function isSymbolObject(value) {
+    return SymbolSupported && checkBoxedPrimitive(value, symbolValue);
+  }
+  exports.isSymbolObject = isSymbolObject;
+  function isBoxedPrimitive(value) {
+    return isNumberObject(value) || isStringObject(value) || isBooleanObject(value) || isBigIntObject(value) || isSymbolObject(value);
+  }
+  exports.isBoxedPrimitive = isBoxedPrimitive;
+  function isAnyArrayBuffer(value) {
+    return typeof Uint8Array !== "undefined" && (isArrayBuffer(value) || isSharedArrayBuffer(value));
+  }
+  exports.isAnyArrayBuffer = isAnyArrayBuffer;
+  ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(method) {
+    Object.defineProperty(exports, method, {
+      enumerable: false,
+      value: function() {
+        throw new Error(method + " is not supported in userland");
+      }
+    });
+  });
+})(types);
+var isBufferBrowser = function isBuffer(arg) {
+  return arg && typeof arg === "object" && typeof arg.copy === "function" && typeof arg.fill === "function" && typeof arg.readUInt8 === "function";
+};
+(function(exports) {
+  var define_process_default = { env: {} };
+  var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors2(obj) {
+    var keys = Object.keys(obj);
+    var descriptors = {};
+    for (var i = 0; i < keys.length; i++) {
+      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
+    }
+    return descriptors;
+  };
+  var formatRegExp = /%[sdj%]/g;
+  exports.format = function(f) {
+    if (!isString(f)) {
+      var objects = [];
+      for (var i = 0; i < arguments.length; i++) {
+        objects.push(inspect(arguments[i]));
+      }
+      return objects.join(" ");
+    }
+    var i = 1;
+    var args = arguments;
+    var len = args.length;
+    var str = String(f).replace(formatRegExp, function(x2) {
+      if (x2 === "%%") return "%";
+      if (i >= len) return x2;
+      switch (x2) {
+        case "%s":
+          return String(args[i++]);
+        case "%d":
+          return Number(args[i++]);
+        case "%j":
+          try {
+            return JSON.stringify(args[i++]);
+          } catch (_) {
+            return "[Circular]";
+          }
+        default:
+          return x2;
+      }
+    });
+    for (var x = args[i]; i < len; x = args[++i]) {
+      if (isNull(x) || !isObject(x)) {
+        str += " " + x;
+      } else {
+        str += " " + inspect(x);
+      }
+    }
+    return str;
+  };
+  exports.deprecate = function(fn, msg) {
+    if (typeof define_process_default !== "undefined" && define_process_default.noDeprecation === true) {
+      return fn;
+    }
+    if (typeof define_process_default === "undefined") {
+      return function() {
+        return exports.deprecate(fn, msg).apply(this, arguments);
+      };
+    }
+    var warned = false;
+    function deprecated() {
+      if (!warned) {
+        if (define_process_default.throwDeprecation) {
+          throw new Error(msg);
+        } else if (define_process_default.traceDeprecation) {
+          console.trace(msg);
+        } else {
+          console.error(msg);
+        }
+        warned = true;
+      }
+      return fn.apply(this, arguments);
+    }
+    return deprecated;
+  };
+  var debugs = {};
+  var debugEnvRegex = /^$/;
+  exports.debuglog = function(set) {
+    set = set.toUpperCase();
+    if (!debugs[set]) {
+      if (debugEnvRegex.test(set)) {
+        var pid = define_process_default.pid;
+        debugs[set] = function() {
+          var msg = exports.format.apply(exports, arguments);
+          console.error("%s %d: %s", set, pid, msg);
+        };
+      } else {
+        debugs[set] = function() {
+        };
+      }
+    }
+    return debugs[set];
+  };
+  function inspect(obj, opts) {
+    var ctx = {
+      seen: [],
+      stylize: stylizeNoColor
+    };
+    if (arguments.length >= 3) ctx.depth = arguments[2];
+    if (arguments.length >= 4) ctx.colors = arguments[3];
+    if (isBoolean(opts)) {
+      ctx.showHidden = opts;
+    } else if (opts) {
+      exports._extend(ctx, opts);
+    }
+    if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+    if (isUndefined(ctx.depth)) ctx.depth = 2;
+    if (isUndefined(ctx.colors)) ctx.colors = false;
+    if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+    if (ctx.colors) ctx.stylize = stylizeWithColor;
+    return formatValue(ctx, obj, ctx.depth);
+  }
+  exports.inspect = inspect;
+  inspect.colors = {
+    "bold": [1, 22],
+    "italic": [3, 23],
+    "underline": [4, 24],
+    "inverse": [7, 27],
+    "white": [37, 39],
+    "grey": [90, 39],
+    "black": [30, 39],
+    "blue": [34, 39],
+    "cyan": [36, 39],
+    "green": [32, 39],
+    "magenta": [35, 39],
+    "red": [31, 39],
+    "yellow": [33, 39]
+  };
+  inspect.styles = {
+    "special": "cyan",
+    "number": "yellow",
+    "boolean": "yellow",
+    "undefined": "grey",
+    "null": "bold",
+    "string": "green",
+    "date": "magenta",
+    // "name": intentionally not styling
+    "regexp": "red"
+  };
+  function stylizeWithColor(str, styleType) {
+    var style = inspect.styles[styleType];
+    if (style) {
+      return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
+    } else {
+      return str;
+    }
+  }
+  function stylizeNoColor(str, styleType) {
+    return str;
+  }
+  function arrayToHash(array) {
+    var hash = {};
+    array.forEach(function(val, idx) {
+      hash[val] = true;
+    });
+    return hash;
+  }
+  function formatValue(ctx, value, recurseTimes) {
+    if (ctx.customInspect && value && isFunction(value.inspect) && // Filter out the util module, it's inspect function is special
+    value.inspect !== exports.inspect && // Also filter out any prototype objects using the circular check.
+    !(value.constructor && value.constructor.prototype === value)) {
+      var ret = value.inspect(recurseTimes, ctx);
+      if (!isString(ret)) {
+        ret = formatValue(ctx, ret, recurseTimes);
+      }
+      return ret;
+    }
+    var primitive = formatPrimitive(ctx, value);
+    if (primitive) {
+      return primitive;
+    }
+    var keys = Object.keys(value);
+    var visibleKeys = arrayToHash(keys);
+    if (ctx.showHidden) {
+      keys = Object.getOwnPropertyNames(value);
+    }
+    if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) {
+      return formatError(value);
+    }
+    if (keys.length === 0) {
+      if (isFunction(value)) {
+        var name = value.name ? ": " + value.name : "";
+        return ctx.stylize("[Function" + name + "]", "special");
+      }
+      if (isRegExp(value)) {
+        return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+      }
+      if (isDate(value)) {
+        return ctx.stylize(Date.prototype.toString.call(value), "date");
+      }
+      if (isError(value)) {
+        return formatError(value);
+      }
+    }
+    var base = "", array = false, braces = ["{", "}"];
+    if (isArray(value)) {
+      array = true;
+      braces = ["[", "]"];
+    }
+    if (isFunction(value)) {
+      var n = value.name ? ": " + value.name : "";
+      base = " [Function" + n + "]";
+    }
+    if (isRegExp(value)) {
+      base = " " + RegExp.prototype.toString.call(value);
+    }
+    if (isDate(value)) {
+      base = " " + Date.prototype.toUTCString.call(value);
+    }
+    if (isError(value)) {
+      base = " " + formatError(value);
+    }
+    if (keys.length === 0 && (!array || value.length == 0)) {
+      return braces[0] + base + braces[1];
+    }
+    if (recurseTimes < 0) {
+      if (isRegExp(value)) {
+        return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+      } else {
+        return ctx.stylize("[Object]", "special");
+      }
+    }
+    ctx.seen.push(value);
+    var output;
+    if (array) {
+      output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+    } else {
+      output = keys.map(function(key) {
+        return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+      });
+    }
+    ctx.seen.pop();
+    return reduceToSingleString(output, base, braces);
+  }
+  function formatPrimitive(ctx, value) {
+    if (isUndefined(value))
+      return ctx.stylize("undefined", "undefined");
+    if (isString(value)) {
+      var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+      return ctx.stylize(simple, "string");
+    }
+    if (isNumber(value))
+      return ctx.stylize("" + value, "number");
+    if (isBoolean(value))
+      return ctx.stylize("" + value, "boolean");
+    if (isNull(value))
+      return ctx.stylize("null", "null");
+  }
+  function formatError(value) {
+    return "[" + Error.prototype.toString.call(value) + "]";
+  }
+  function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+    var output = [];
+    for (var i = 0, l = value.length; i < l; ++i) {
+      if (hasOwnProperty2(value, String(i))) {
+        output.push(formatProperty(
+          ctx,
+          value,
+          recurseTimes,
+          visibleKeys,
+          String(i),
+          true
+        ));
+      } else {
+        output.push("");
+      }
+    }
+    keys.forEach(function(key) {
+      if (!key.match(/^\d+$/)) {
+        output.push(formatProperty(
+          ctx,
+          value,
+          recurseTimes,
+          visibleKeys,
+          key,
+          true
+        ));
+      }
+    });
+    return output;
+  }
+  function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+    var name, str, desc;
+    desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+    if (desc.get) {
+      if (desc.set) {
+        str = ctx.stylize("[Getter/Setter]", "special");
+      } else {
+        str = ctx.stylize("[Getter]", "special");
+      }
+    } else {
+      if (desc.set) {
+        str = ctx.stylize("[Setter]", "special");
+      }
+    }
+    if (!hasOwnProperty2(visibleKeys, key)) {
+      name = "[" + key + "]";
+    }
+    if (!str) {
+      if (ctx.seen.indexOf(desc.value) < 0) {
+        if (isNull(recurseTimes)) {
+          str = formatValue(ctx, desc.value, null);
+        } else {
+          str = formatValue(ctx, desc.value, recurseTimes - 1);
+        }
+        if (str.indexOf("\n") > -1) {
+          if (array) {
+            str = str.split("\n").map(function(line) {
+              return "  " + line;
+            }).join("\n").slice(2);
+          } else {
+            str = "\n" + str.split("\n").map(function(line) {
+              return "   " + line;
+            }).join("\n");
+          }
+        }
+      } else {
+        str = ctx.stylize("[Circular]", "special");
+      }
+    }
+    if (isUndefined(name)) {
+      if (array && key.match(/^\d+$/)) {
+        return str;
+      }
+      name = JSON.stringify("" + key);
+      if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+        name = name.slice(1, -1);
+        name = ctx.stylize(name, "name");
+      } else {
+        name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+        name = ctx.stylize(name, "string");
+      }
+    }
+    return name + ": " + str;
+  }
+  function reduceToSingleString(output, base, braces) {
+    var length = output.reduce(function(prev, cur) {
+      if (cur.indexOf("\n") >= 0) ;
+      return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+    }, 0);
+    if (length > 60) {
+      return braces[0] + (base === "" ? "" : base + "\n ") + " " + output.join(",\n  ") + " " + braces[1];
+    }
+    return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+  }
+  exports.types = types;
+  function isArray(ar) {
+    return Array.isArray(ar);
+  }
+  exports.isArray = isArray;
+  function isBoolean(arg) {
+    return typeof arg === "boolean";
+  }
+  exports.isBoolean = isBoolean;
+  function isNull(arg) {
+    return arg === null;
+  }
+  exports.isNull = isNull;
+  function isNullOrUndefined(arg) {
+    return arg == null;
+  }
+  exports.isNullOrUndefined = isNullOrUndefined;
+  function isNumber(arg) {
+    return typeof arg === "number";
+  }
+  exports.isNumber = isNumber;
+  function isString(arg) {
+    return typeof arg === "string";
+  }
+  exports.isString = isString;
+  function isSymbol(arg) {
+    return typeof arg === "symbol";
+  }
+  exports.isSymbol = isSymbol;
+  function isUndefined(arg) {
+    return arg === void 0;
+  }
+  exports.isUndefined = isUndefined;
+  function isRegExp(re) {
+    return isObject(re) && objectToString(re) === "[object RegExp]";
+  }
+  exports.isRegExp = isRegExp;
+  exports.types.isRegExp = isRegExp;
+  function isObject(arg) {
+    return typeof arg === "object" && arg !== null;
+  }
+  exports.isObject = isObject;
+  function isDate(d) {
+    return isObject(d) && objectToString(d) === "[object Date]";
+  }
+  exports.isDate = isDate;
+  exports.types.isDate = isDate;
+  function isError(e) {
+    return isObject(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
+  }
+  exports.isError = isError;
+  exports.types.isNativeError = isError;
+  function isFunction(arg) {
+    return typeof arg === "function";
+  }
+  exports.isFunction = isFunction;
+  function isPrimitive(arg) {
+    return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
+    typeof arg === "undefined";
+  }
+  exports.isPrimitive = isPrimitive;
+  exports.isBuffer = isBufferBrowser;
+  function objectToString(o) {
+    return Object.prototype.toString.call(o);
+  }
+  function pad(n) {
+    return n < 10 ? "0" + n.toString(10) : n.toString(10);
+  }
+  var months = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ];
+  function timestamp() {
+    var d = /* @__PURE__ */ new Date();
+    var time = [
+      pad(d.getHours()),
+      pad(d.getMinutes()),
+      pad(d.getSeconds())
+    ].join(":");
+    return [d.getDate(), months[d.getMonth()], time].join(" ");
+  }
+  exports.log = function() {
+    console.log("%s - %s", timestamp(), exports.format.apply(exports, arguments));
+  };
+  exports.inherits = inherits_browserExports;
+  exports._extend = function(origin, add) {
+    if (!add || !isObject(add)) return origin;
+    var keys = Object.keys(add);
+    var i = keys.length;
+    while (i--) {
+      origin[keys[i]] = add[keys[i]];
+    }
+    return origin;
+  };
+  function hasOwnProperty2(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+  }
+  var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
+  exports.promisify = function promisify(original) {
+    if (typeof original !== "function")
+      throw new TypeError('The "original" argument must be of type Function');
+    if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+      var fn = original[kCustomPromisifiedSymbol];
+      if (typeof fn !== "function") {
+        throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+      }
+      Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+        value: fn,
+        enumerable: false,
+        writable: false,
+        configurable: true
+      });
+      return fn;
+    }
+    function fn() {
+      var promiseResolve, promiseReject;
+      var promise = new Promise(function(resolve, reject) {
+        promiseResolve = resolve;
+        promiseReject = reject;
+      });
+      var args = [];
+      for (var i = 0; i < arguments.length; i++) {
+        args.push(arguments[i]);
+      }
+      args.push(function(err, value) {
+        if (err) {
+          promiseReject(err);
+        } else {
+          promiseResolve(value);
+        }
+      });
+      try {
+        original.apply(this, args);
+      } catch (err) {
+        promiseReject(err);
+      }
+      return promise;
+    }
+    Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+    if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+      value: fn,
+      enumerable: false,
+      writable: false,
+      configurable: true
+    });
+    return Object.defineProperties(
+      fn,
+      getOwnPropertyDescriptors(original)
+    );
+  };
+  exports.promisify.custom = kCustomPromisifiedSymbol;
+  function callbackifyOnRejected(reason, cb) {
+    if (!reason) {
+      var newReason = new Error("Promise was rejected with a falsy value");
+      newReason.reason = reason;
+      reason = newReason;
+    }
+    return cb(reason);
+  }
+  function callbackify(original) {
+    if (typeof original !== "function") {
+      throw new TypeError('The "original" argument must be of type Function');
+    }
+    function callbackified() {
+      var args = [];
+      for (var i = 0; i < arguments.length; i++) {
+        args.push(arguments[i]);
+      }
+      var maybeCb = args.pop();
+      if (typeof maybeCb !== "function") {
+        throw new TypeError("The last argument must be of type Function");
+      }
+      var self = this;
+      var cb = function() {
+        return maybeCb.apply(self, arguments);
+      };
+      original.apply(this, args).then(
+        function(ret) {
+          define_process_default.nextTick(cb.bind(null, null, ret));
+        },
+        function(rej) {
+          define_process_default.nextTick(callbackifyOnRejected.bind(null, rej, cb));
+        }
+      );
+    }
+    Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
+    Object.defineProperties(
+      callbackified,
+      getOwnPropertyDescriptors(original)
+    );
+    return callbackified;
+  }
+  exports.callbackify = callbackify;
+})(util$1);
+const util = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null
+}, [util$1]);
+export {
+  util$1 as a,
+  inherits_browserExports as i,
+  util as u
+};