@sap/ux-ui5-tooling 1.18.4 → 1.18.6

package/dist/middlewares/fiori-tools-appreload.js

@@ -4325,8 +4325,8 @@ var require_DataView = __commonJS({
   "../../node_modules/lodash/_DataView.js"(exports2, module2) {
     var getNative = require_getNative();
     var root = require_root();
-    var DataView = getNative(root, "DataView");
-    module2.exports = DataView;
+    var DataView2 = getNative(root, "DataView");
+    module2.exports = DataView2;
   }
 });
 
@@ -4355,19 +4355,19 @@ var require_WeakMap = __commonJS({
   "../../node_modules/lodash/_WeakMap.js"(exports2, module2) {
     var getNative = require_getNative();
     var root = require_root();
-    var WeakMap = getNative(root, "WeakMap");
-    module2.exports = WeakMap;
+    var WeakMap2 = getNative(root, "WeakMap");
+    module2.exports = WeakMap2;
   }
 });
 
 // ../../node_modules/lodash/_getTag.js
 var require_getTag = __commonJS({
   "../../node_modules/lodash/_getTag.js"(exports2, module2) {
-    var DataView = require_DataView();
+    var DataView2 = require_DataView();
     var Map2 = require_Map();
     var Promise2 = require_Promise();
     var Set2 = require_Set();
-    var WeakMap = require_WeakMap();
+    var WeakMap2 = require_WeakMap();
     var baseGetTag = require_baseGetTag();
     var toSource = require_toSource();
     var mapTag = "[object Map]";
@@ -4376,13 +4376,13 @@ var require_getTag = __commonJS({
     var setTag = "[object Set]";
     var weakMapTag = "[object WeakMap]";
     var dataViewTag = "[object DataView]";
-    var dataViewCtorString = toSource(DataView);
+    var dataViewCtorString = toSource(DataView2);
     var mapCtorString = toSource(Map2);
     var promiseCtorString = toSource(Promise2);
     var setCtorString = toSource(Set2);
-    var weakMapCtorString = toSource(WeakMap);
+    var weakMapCtorString = toSource(WeakMap2);
     var getTag = baseGetTag;
-    if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+    if (DataView2 && getTag(new DataView2(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
       getTag = function(value) {
         var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
         if (ctorString) {
@@ -21074,10 +21074,10 @@ var require_lodash = __commonJS({
         }();
         var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, ctxNow = Date2 && Date2.now !== root.Date.now && Date2.now, ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
         var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : undefined2, nativeIsFinite = context.isFinite, nativeJoin = arrayProto.join, nativeKeys = overArg(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date2.now, nativeParseInt = context.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto.reverse;
-        var DataView = getNative(context, "DataView"), Map2 = getNative(context, "Map"), Promise2 = getNative(context, "Promise"), Set2 = getNative(context, "Set"), WeakMap = getNative(context, "WeakMap"), nativeCreate = getNative(Object2, "create");
-        var metaMap = WeakMap && new WeakMap();
+        var DataView2 = getNative(context, "DataView"), Map2 = getNative(context, "Map"), Promise2 = getNative(context, "Promise"), Set2 = getNative(context, "Set"), WeakMap2 = getNative(context, "WeakMap"), nativeCreate = getNative(Object2, "create");
+        var metaMap = WeakMap2 && new WeakMap2();
         var realNames = {};
-        var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map2), promiseCtorString = toSource(Promise2), setCtorString = toSource(Set2), weakMapCtorString = toSource(WeakMap);
+        var dataViewCtorString = toSource(DataView2), mapCtorString = toSource(Map2), promiseCtorString = toSource(Promise2), setCtorString = toSource(Set2), weakMapCtorString = toSource(WeakMap2);
         var symbolProto = Symbol2 ? Symbol2.prototype : undefined2, symbolValueOf = symbolProto ? symbolProto.valueOf : undefined2, symbolToString = symbolProto ? symbolProto.toString : undefined2;
         function lodash(value) {
           if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
@@ -23131,7 +23131,7 @@ var require_lodash = __commonJS({
           return result2;
         };
         var getTag = baseGetTag;
-        if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+        if (DataView2 && getTag(new DataView2(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
           getTag = function(value) {
             var result2 = baseGetTag(value), Ctor = result2 == objectTag ? value.constructor : undefined2, ctorString = Ctor ? toSource(Ctor) : "";
             if (ctorString) {
@@ -34769,9 +34769,1017 @@ var require_asynckit = __commonJS({
   }
 });
 
+// ../../node_modules/es-object-atoms/index.js
+var require_es_object_atoms = __commonJS({
+  "../../node_modules/es-object-atoms/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Object;
+  }
+});
+
+// ../../node_modules/es-errors/index.js
+var require_es_errors = __commonJS({
+  "../../node_modules/es-errors/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Error;
+  }
+});
+
+// ../../node_modules/es-errors/eval.js
+var require_eval = __commonJS({
+  "../../node_modules/es-errors/eval.js"(exports2, module2) {
+    "use strict";
+    module2.exports = EvalError;
+  }
+});
+
+// ../../node_modules/es-errors/range.js
+var require_range = __commonJS({
+  "../../node_modules/es-errors/range.js"(exports2, module2) {
+    "use strict";
+    module2.exports = RangeError;
+  }
+});
+
+// ../../node_modules/es-errors/ref.js
+var require_ref = __commonJS({
+  "../../node_modules/es-errors/ref.js"(exports2, module2) {
+    "use strict";
+    module2.exports = ReferenceError;
+  }
+});
+
+// ../../node_modules/es-errors/syntax.js
+var require_syntax = __commonJS({
+  "../../node_modules/es-errors/syntax.js"(exports2, module2) {
+    "use strict";
+    module2.exports = SyntaxError;
+  }
+});
+
+// ../../node_modules/es-errors/type.js
+var require_type = __commonJS({
+  "../../node_modules/es-errors/type.js"(exports2, module2) {
+    "use strict";
+    module2.exports = TypeError;
+  }
+});
+
+// ../../node_modules/es-errors/uri.js
+var require_uri = __commonJS({
+  "../../node_modules/es-errors/uri.js"(exports2, module2) {
+    "use strict";
+    module2.exports = URIError;
+  }
+});
+
+// ../../node_modules/math-intrinsics/abs.js
+var require_abs = __commonJS({
+  "../../node_modules/math-intrinsics/abs.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.abs;
+  }
+});
+
+// ../../node_modules/math-intrinsics/floor.js
+var require_floor = __commonJS({
+  "../../node_modules/math-intrinsics/floor.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.floor;
+  }
+});
+
+// ../../node_modules/math-intrinsics/max.js
+var require_max = __commonJS({
+  "../../node_modules/math-intrinsics/max.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.max;
+  }
+});
+
+// ../../node_modules/math-intrinsics/min.js
+var require_min = __commonJS({
+  "../../node_modules/math-intrinsics/min.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.min;
+  }
+});
+
+// ../../node_modules/math-intrinsics/pow.js
+var require_pow = __commonJS({
+  "../../node_modules/math-intrinsics/pow.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.pow;
+  }
+});
+
+// ../../node_modules/math-intrinsics/round.js
+var require_round = __commonJS({
+  "../../node_modules/math-intrinsics/round.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Math.round;
+  }
+});
+
+// ../../node_modules/math-intrinsics/isNaN.js
+var require_isNaN = __commonJS({
+  "../../node_modules/math-intrinsics/isNaN.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Number.isNaN || function isNaN2(a) {
+      return a !== a;
+    };
+  }
+});
+
+// ../../node_modules/math-intrinsics/sign.js
+var require_sign = __commonJS({
+  "../../node_modules/math-intrinsics/sign.js"(exports2, module2) {
+    "use strict";
+    var $isNaN = require_isNaN();
+    module2.exports = function sign(number) {
+      if ($isNaN(number) || number === 0) {
+        return number;
+      }
+      return number < 0 ? -1 : 1;
+    };
+  }
+});
+
+// ../../node_modules/form-data/node_modules/gopd/gOPD.js
+var require_gOPD = __commonJS({
+  "../../node_modules/form-data/node_modules/gopd/gOPD.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Object.getOwnPropertyDescriptor;
+  }
+});
+
+// ../../node_modules/form-data/node_modules/gopd/index.js
+var require_gopd = __commonJS({
+  "../../node_modules/form-data/node_modules/gopd/index.js"(exports2, module2) {
+    "use strict";
+    var $gOPD = require_gOPD();
+    if ($gOPD) {
+      try {
+        $gOPD([], "length");
+      } catch (e) {
+        $gOPD = null;
+      }
+    }
+    module2.exports = $gOPD;
+  }
+});
+
+// ../../node_modules/form-data/node_modules/es-define-property/index.js
+var require_es_define_property = __commonJS({
+  "../../node_modules/form-data/node_modules/es-define-property/index.js"(exports2, module2) {
+    "use strict";
+    var $defineProperty = Object.defineProperty || false;
+    if ($defineProperty) {
+      try {
+        $defineProperty({}, "a", { value: 1 });
+      } catch (e) {
+        $defineProperty = false;
+      }
+    }
+    module2.exports = $defineProperty;
+  }
+});
+
+// ../../node_modules/form-data/node_modules/get-intrinsic/node_modules/has-symbols/shams.js
+var require_shams = __commonJS({
+  "../../node_modules/form-data/node_modules/get-intrinsic/node_modules/has-symbols/shams.js"(exports2, module2) {
+    "use strict";
+    module2.exports = 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 (var _ 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 = (
+          /** @type {PropertyDescriptor} */
+          Object.getOwnPropertyDescriptor(obj, sym)
+        );
+        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+});
+
+// ../../node_modules/form-data/node_modules/get-intrinsic/node_modules/has-symbols/index.js
+var require_has_symbols = __commonJS({
+  "../../node_modules/form-data/node_modules/get-intrinsic/node_modules/has-symbols/index.js"(exports2, module2) {
+    "use strict";
+    var origSymbol = typeof Symbol !== "undefined" && Symbol;
+    var hasSymbolSham = require_shams();
+    module2.exports = 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();
+    };
+  }
+});
+
+// ../../node_modules/get-proto/Reflect.getPrototypeOf.js
+var require_Reflect_getPrototypeOf = __commonJS({
+  "../../node_modules/get-proto/Reflect.getPrototypeOf.js"(exports2, module2) {
+    "use strict";
+    module2.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
+  }
+});
+
+// ../../node_modules/get-proto/Object.getPrototypeOf.js
+var require_Object_getPrototypeOf = __commonJS({
+  "../../node_modules/get-proto/Object.getPrototypeOf.js"(exports2, module2) {
+    "use strict";
+    var $Object = require_es_object_atoms();
+    module2.exports = $Object.getPrototypeOf || null;
+  }
+});
+
+// ../../node_modules/call-bind-apply-helpers/node_modules/function-bind/implementation.js
+var require_implementation = __commonJS({
+  "../../node_modules/call-bind-apply-helpers/node_modules/function-bind/implementation.js"(exports2, module2) {
+    "use strict";
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+    var toStr = 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 || 0, 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;
+    };
+    module2.exports = function bind(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.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;
+    };
+  }
+});
+
+// ../../node_modules/call-bind-apply-helpers/node_modules/function-bind/index.js
+var require_function_bind = __commonJS({
+  "../../node_modules/call-bind-apply-helpers/node_modules/function-bind/index.js"(exports2, module2) {
+    "use strict";
+    var implementation = require_implementation();
+    module2.exports = Function.prototype.bind || implementation;
+  }
+});
+
+// ../../node_modules/call-bind-apply-helpers/functionCall.js
+var require_functionCall = __commonJS({
+  "../../node_modules/call-bind-apply-helpers/functionCall.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Function.prototype.call;
+  }
+});
+
+// ../../node_modules/call-bind-apply-helpers/functionApply.js
+var require_functionApply = __commonJS({
+  "../../node_modules/call-bind-apply-helpers/functionApply.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Function.prototype.apply;
+  }
+});
+
+// ../../node_modules/call-bind-apply-helpers/reflectApply.js
+var require_reflectApply = __commonJS({
+  "../../node_modules/call-bind-apply-helpers/reflectApply.js"(exports2, module2) {
+    "use strict";
+    module2.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+  }
+});
+
+// ../../node_modules/call-bind-apply-helpers/actualApply.js
+var require_actualApply = __commonJS({
+  "../../node_modules/call-bind-apply-helpers/actualApply.js"(exports2, module2) {
+    "use strict";
+    var bind = require_function_bind();
+    var $apply = require_functionApply();
+    var $call = require_functionCall();
+    var $reflectApply = require_reflectApply();
+    module2.exports = $reflectApply || bind.call($call, $apply);
+  }
+});
+
+// ../../node_modules/call-bind-apply-helpers/index.js
+var require_call_bind_apply_helpers = __commonJS({
+  "../../node_modules/call-bind-apply-helpers/index.js"(exports2, module2) {
+    "use strict";
+    var bind = require_function_bind();
+    var $TypeError = require_type();
+    var $call = require_functionCall();
+    var $actualApply = require_actualApply();
+    module2.exports = function callBindBasic(args) {
+      if (args.length < 1 || typeof args[0] !== "function") {
+        throw new $TypeError("a function is required");
+      }
+      return $actualApply(bind, $call, args);
+    };
+  }
+});
+
+// ../../node_modules/dunder-proto/node_modules/gopd/gOPD.js
+var require_gOPD2 = __commonJS({
+  "../../node_modules/dunder-proto/node_modules/gopd/gOPD.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Object.getOwnPropertyDescriptor;
+  }
+});
+
+// ../../node_modules/dunder-proto/node_modules/gopd/index.js
+var require_gopd2 = __commonJS({
+  "../../node_modules/dunder-proto/node_modules/gopd/index.js"(exports2, module2) {
+    "use strict";
+    var $gOPD = require_gOPD2();
+    if ($gOPD) {
+      try {
+        $gOPD([], "length");
+      } catch (e) {
+        $gOPD = null;
+      }
+    }
+    module2.exports = $gOPD;
+  }
+});
+
+// ../../node_modules/dunder-proto/get.js
+var require_get = __commonJS({
+  "../../node_modules/dunder-proto/get.js"(exports2, module2) {
+    "use strict";
+    var callBind = require_call_bind_apply_helpers();
+    var gOPD = require_gopd2();
+    var hasProtoAccessor;
+    try {
+      hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
+      [].__proto__ === Array.prototype;
+    } catch (e) {
+      if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
+        throw e;
+      }
+    }
+    var desc = !!hasProtoAccessor && gOPD && gOPD(
+      Object.prototype,
+      /** @type {keyof typeof Object.prototype} */
+      "__proto__"
+    );
+    var $Object = Object;
+    var $getPrototypeOf = $Object.getPrototypeOf;
+    module2.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? (
+      /** @type {import('./get')} */
+      function getDunder(value) {
+        return $getPrototypeOf(value == null ? value : $Object(value));
+      }
+    ) : false;
+  }
+});
+
+// ../../node_modules/get-proto/index.js
+var require_get_proto = __commonJS({
+  "../../node_modules/get-proto/index.js"(exports2, module2) {
+    "use strict";
+    var reflectGetProto = require_Reflect_getPrototypeOf();
+    var originalGetProto = require_Object_getPrototypeOf();
+    var getDunderProto = require_get();
+    module2.exports = reflectGetProto ? function getProto(O) {
+      return reflectGetProto(O);
+    } : originalGetProto ? function getProto(O) {
+      if (!O || typeof O !== "object" && typeof O !== "function") {
+        throw new TypeError("getProto: not an object");
+      }
+      return originalGetProto(O);
+    } : getDunderProto ? function getProto(O) {
+      return getDunderProto(O);
+    } : null;
+  }
+});
+
+// ../../node_modules/form-data/node_modules/function-bind/implementation.js
+var require_implementation2 = __commonJS({
+  "../../node_modules/form-data/node_modules/function-bind/implementation.js"(exports2, module2) {
+    "use strict";
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+    var toStr = 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 || 0, 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;
+    };
+    module2.exports = function bind(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.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;
+    };
+  }
+});
+
+// ../../node_modules/form-data/node_modules/function-bind/index.js
+var require_function_bind2 = __commonJS({
+  "../../node_modules/form-data/node_modules/function-bind/index.js"(exports2, module2) {
+    "use strict";
+    var implementation = require_implementation2();
+    module2.exports = Function.prototype.bind || implementation;
+  }
+});
+
+// ../../node_modules/form-data/node_modules/hasown/index.js
+var require_hasown = __commonJS({
+  "../../node_modules/form-data/node_modules/hasown/index.js"(exports2, module2) {
+    "use strict";
+    var call = Function.prototype.call;
+    var $hasOwn = Object.prototype.hasOwnProperty;
+    var bind = require_function_bind2();
+    module2.exports = bind.call(call, $hasOwn);
+  }
+});
+
+// ../../node_modules/form-data/node_modules/get-intrinsic/index.js
+var require_get_intrinsic = __commonJS({
+  "../../node_modules/form-data/node_modules/get-intrinsic/index.js"(exports2, module2) {
+    "use strict";
+    var undefined2;
+    var $Object = require_es_object_atoms();
+    var $Error = require_es_errors();
+    var $EvalError = require_eval();
+    var $RangeError = require_range();
+    var $ReferenceError = require_ref();
+    var $SyntaxError = require_syntax();
+    var $TypeError = require_type();
+    var $URIError = require_uri();
+    var abs = require_abs();
+    var floor = require_floor();
+    var max = require_max();
+    var min = require_min();
+    var pow = require_pow();
+    var round = require_round();
+    var sign = require_sign();
+    var $Function = Function;
+    var getEvalledConstructor = function(expressionSyntax) {
+      try {
+        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+      } catch (e) {
+      }
+    };
+    var $gOPD = require_gopd();
+    var $defineProperty = require_es_define_property();
+    var throwTypeError = function() {
+      throw new $TypeError();
+    };
+    var ThrowTypeError = $gOPD ? function() {
+      try {
+        arguments.callee;
+        return throwTypeError;
+      } catch (calleeThrows) {
+        try {
+          return $gOPD(arguments, "callee").get;
+        } catch (gOPDthrows) {
+          return throwTypeError;
+        }
+      }
+    }() : throwTypeError;
+    var hasSymbols = require_has_symbols()();
+    var getProto = require_get_proto();
+    var $ObjectGPO = require_Object_getPrototypeOf();
+    var $ReflectGPO = require_Reflect_getPrototypeOf();
+    var $apply = require_functionApply();
+    var $call = require_functionCall();
+    var needsEval = {};
+    var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
+    var INTRINSICS = {
+      __proto__: null,
+      "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError,
+      "%Array%": Array,
+      "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
+      "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,
+      "%AsyncFromSyncIteratorPrototype%": undefined2,
+      "%AsyncFunction%": needsEval,
+      "%AsyncGenerator%": needsEval,
+      "%AsyncGeneratorFunction%": needsEval,
+      "%AsyncIteratorPrototype%": needsEval,
+      "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
+      "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
+      "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array,
+      "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array,
+      "%Boolean%": Boolean,
+      "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
+      "%Date%": Date,
+      "%decodeURI%": decodeURI,
+      "%decodeURIComponent%": decodeURIComponent,
+      "%encodeURI%": encodeURI,
+      "%encodeURIComponent%": encodeURIComponent,
+      "%Error%": $Error,
+      "%eval%": eval,
+      // eslint-disable-line no-eval
+      "%EvalError%": $EvalError,
+      "%Float16Array%": typeof Float16Array === "undefined" ? undefined2 : Float16Array,
+      "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
+      "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
+      "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
+      "%Function%": $Function,
+      "%GeneratorFunction%": needsEval,
+      "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
+      "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
+      "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array,
+      "%isFinite%": isFinite,
+      "%isNaN%": isNaN,
+      "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,
+      "%JSON%": typeof JSON === "object" ? JSON : undefined2,
+      "%Map%": typeof Map === "undefined" ? undefined2 : Map,
+      "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+      "%Math%": Math,
+      "%Number%": Number,
+      "%Object%": $Object,
+      "%Object.getOwnPropertyDescriptor%": $gOPD,
+      "%parseFloat%": parseFloat,
+      "%parseInt%": parseInt,
+      "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
+      "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
+      "%RangeError%": $RangeError,
+      "%ReferenceError%": $ReferenceError,
+      "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
+      "%RegExp%": RegExp,
+      "%Set%": typeof Set === "undefined" ? undefined2 : Set,
+      "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+      "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer,
+      "%String%": String,
+      "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2,
+      "%Symbol%": hasSymbols ? Symbol : undefined2,
+      "%SyntaxError%": $SyntaxError,
+      "%ThrowTypeError%": ThrowTypeError,
+      "%TypedArray%": TypedArray,
+      "%TypeError%": $TypeError,
+      "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
+      "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
+      "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
+      "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
+      "%URIError%": $URIError,
+      "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
+      "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
+      "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet,
+      "%Function.prototype.call%": $call,
+      "%Function.prototype.apply%": $apply,
+      "%Object.defineProperty%": $defineProperty,
+      "%Object.getPrototypeOf%": $ObjectGPO,
+      "%Math.abs%": abs,
+      "%Math.floor%": floor,
+      "%Math.max%": max,
+      "%Math.min%": min,
+      "%Math.pow%": pow,
+      "%Math.round%": round,
+      "%Math.sign%": sign,
+      "%Reflect.getPrototypeOf%": $ReflectGPO
+    };
+    if (getProto) {
+      try {
+        null.error;
+      } catch (e) {
+        errorProto = getProto(getProto(e));
+        INTRINSICS["%Error.prototype%"] = errorProto;
+      }
+    }
+    var 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) {
+          value = getProto(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 bind = require_function_bind2();
+    var hasOwn = require_hasown();
+    var $concat = bind.call($call, Array.prototype.concat);
+    var $spliceApply = bind.call($apply, Array.prototype.splice);
+    var $replace = bind.call($call, String.prototype.replace);
+    var $strSlice = bind.call($call, String.prototype.slice);
+    var $exec = bind.call($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("invalid intrinsic syntax, expected closing `%`");
+      } else if (last === "%" && first !== "%") {
+        throw new $SyntaxError("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("intrinsic " + name + " exists, but is not available. Please file an issue!");
+        }
+        return {
+          alias,
+          name: intrinsicName,
+          value
+        };
+      }
+      throw new $SyntaxError("intrinsic " + name + " does not exist!");
+    };
+    module2.exports = function GetIntrinsic(name, allowMissing) {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new $TypeError("intrinsic name must be a non-empty string");
+      }
+      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+        throw new $TypeError('"allowMissing" argument must be a boolean');
+      }
+      if ($exec(/^%?[^%]*%?$/, name) === null) {
+        throw new $SyntaxError("`%` 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("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("base intrinsic for " + name + " exists, but the property is not available.");
+            }
+            return void undefined2;
+          }
+          if ($gOPD && i + 1 >= parts.length) {
+            var desc = $gOPD(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;
+    };
+  }
+});
+
+// ../../node_modules/has-symbols/shams.js
+var require_shams2 = __commonJS({
+  "../../node_modules/has-symbols/shams.js"(exports2, module2) {
+    "use strict";
+    module2.exports = 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;
+    };
+  }
+});
+
+// ../../node_modules/form-data/node_modules/has-tostringtag/shams.js
+var require_shams3 = __commonJS({
+  "../../node_modules/form-data/node_modules/has-tostringtag/shams.js"(exports2, module2) {
+    "use strict";
+    var hasSymbols = require_shams2();
+    module2.exports = function hasToStringTagShams() {
+      return hasSymbols() && !!Symbol.toStringTag;
+    };
+  }
+});
+
+// ../../node_modules/form-data/node_modules/es-set-tostringtag/index.js
+var require_es_set_tostringtag = __commonJS({
+  "../../node_modules/form-data/node_modules/es-set-tostringtag/index.js"(exports2, module2) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
+    var hasToStringTag = require_shams3()();
+    var hasOwn = require_hasown();
+    var $TypeError = require_type();
+    var toStringTag = hasToStringTag ? Symbol.toStringTag : null;
+    module2.exports = function setToStringTag(object, value) {
+      var overrideIfSet = arguments.length > 2 && !!arguments[2] && arguments[2].force;
+      var nonConfigurable = arguments.length > 2 && !!arguments[2] && arguments[2].nonConfigurable;
+      if (typeof overrideIfSet !== "undefined" && typeof overrideIfSet !== "boolean" || typeof nonConfigurable !== "undefined" && typeof nonConfigurable !== "boolean") {
+        throw new $TypeError("if provided, the `overrideIfSet` and `nonConfigurable` options must be booleans");
+      }
+      if (toStringTag && (overrideIfSet || !hasOwn(object, toStringTag))) {
+        if ($defineProperty) {
+          $defineProperty(object, toStringTag, {
+            configurable: !nonConfigurable,
+            enumerable: false,
+            value,
+            writable: false
+          });
+        } else {
+          object[toStringTag] = value;
+        }
+      }
+    };
+  }
+});
+
 // ../../node_modules/form-data/lib/populate.js
 var require_populate = __commonJS({
   "../../node_modules/form-data/lib/populate.js"(exports2, module2) {
+    "use strict";
     module2.exports = function(dst, src) {
       Object.keys(src).forEach(function(prop) {
         dst[prop] = dst[prop] || src[prop];
@@ -34784,6 +35792,7 @@ var require_populate = __commonJS({
 // ../../node_modules/form-data/lib/form_data.js
 var require_form_data = __commonJS({
   "../../node_modules/form-data/lib/form_data.js"(exports2, module2) {
+    "use strict";
     var CombinedStream = require_combined_stream();
     var util = require("util");
     var path = require("path");
@@ -34792,11 +35801,12 @@ var require_form_data = __commonJS({
     var parseUrl = require("url").parse;
     var fs = require("fs");
     var Stream = require("stream").Stream;
+    var crypto = require("crypto");
     var mime = require_mime_types();
     var asynckit = require_asynckit();
+    var setToStringTag = require_es_set_tostringtag();
+    var hasOwn = require_hasown();
     var populate = require_populate();
-    module2.exports = FormData2;
-    util.inherits(FormData2, CombinedStream);
     function FormData2(options2) {
       if (!(this instanceof FormData2)) {
         return new FormData2(options2);
@@ -34810,18 +35820,19 @@ var require_form_data = __commonJS({
         this[option] = options2[option];
       }
     }
+    util.inherits(FormData2, CombinedStream);
     FormData2.LINE_BREAK = "\r\n";
     FormData2.DEFAULT_CONTENT_TYPE = "application/octet-stream";
     FormData2.prototype.append = function(field, value, options2) {
       options2 = options2 || {};
-      if (typeof options2 == "string") {
+      if (typeof options2 === "string") {
         options2 = { filename: options2 };
       }
       var append = CombinedStream.prototype.append.bind(this);
-      if (typeof value == "number") {
-        value = "" + value;
+      if (typeof value === "number" || value == null) {
+        value = String(value);
       }
-      if (util.isArray(value)) {
+      if (Array.isArray(value)) {
         this._error(new Error("Arrays are not supported."));
         return;
       }
@@ -34835,7 +35846,7 @@ var require_form_data = __commonJS({
     FormData2.prototype._trackLength = function(header, value, options2) {
       var valueLength = 0;
       if (options2.knownLength != null) {
-        valueLength += +options2.knownLength;
+        valueLength += Number(options2.knownLength);
       } else if (Buffer.isBuffer(value)) {
         valueLength = value.length;
       } else if (typeof value === "string") {
@@ -34843,7 +35854,7 @@ var require_form_data = __commonJS({
       }
       this._valueLength += valueLength;
       this._overheadLength += Buffer.byteLength(header) + FormData2.LINE_BREAK.length;
-      if (!value || !value.path && !(value.readable && value.hasOwnProperty("httpVersion")) && !(value instanceof Stream)) {
+      if (!value || !value.path && !(value.readable && hasOwn(value, "httpVersion")) && !(value instanceof Stream)) {
         return;
       }
       if (!options2.knownLength) {
@@ -34851,26 +35862,25 @@ var require_form_data = __commonJS({
       }
     };
     FormData2.prototype._lengthRetriever = function(value, callback) {
-      if (value.hasOwnProperty("fd")) {
+      if (hasOwn(value, "fd")) {
         if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
           callback(null, value.end + 1 - (value.start ? value.start : 0));
         } else {
           fs.stat(value.path, function(err, stat) {
-            var fileSize;
             if (err) {
               callback(err);
               return;
             }
-            fileSize = stat.size - (value.start ? value.start : 0);
+            var fileSize = stat.size - (value.start ? value.start : 0);
             callback(null, fileSize);
           });
         }
-      } else if (value.hasOwnProperty("httpVersion")) {
-        callback(null, +value.headers["content-length"]);
-      } else if (value.hasOwnProperty("httpModule")) {
+      } else if (hasOwn(value, "httpVersion")) {
+        callback(null, Number(value.headers["content-length"]));
+      } else if (hasOwn(value, "httpModule")) {
         value.on("response", function(response) {
           value.pause();
-          callback(null, +response.headers["content-length"]);
+          callback(null, Number(response.headers["content-length"]));
         });
         value.resume();
       } else {
@@ -34878,7 +35888,7 @@ var require_form_data = __commonJS({
       }
     };
     FormData2.prototype._multiPartHeader = function(field, value, options2) {
-      if (typeof options2.header == "string") {
+      if (typeof options2.header === "string") {
         return options2.header;
       }
       var contentDisposition = this._getContentDisposition(value, options2);
@@ -34890,54 +35900,54 @@ var require_form_data = __commonJS({
         // if no content type. allow it to be empty array
         "Content-Type": [].concat(contentType || [])
       };
-      if (typeof options2.header == "object") {
+      if (typeof options2.header === "object") {
         populate(headers, options2.header);
       }
       var header;
       for (var prop in headers) {
-        if (!headers.hasOwnProperty(prop)) continue;
-        header = headers[prop];
-        if (header == null) {
-          continue;
-        }
-        if (!Array.isArray(header)) {
-          header = [header];
-        }
-        if (header.length) {
-          contents += prop + ": " + header.join("; ") + FormData2.LINE_BREAK;
+        if (hasOwn(headers, prop)) {
+          header = headers[prop];
+          if (header == null) {
+            continue;
+          }
+          if (!Array.isArray(header)) {
+            header = [header];
+          }
+          if (header.length) {
+            contents += prop + ": " + header.join("; ") + FormData2.LINE_BREAK;
+          }
         }
       }
       return "--" + this.getBoundary() + FormData2.LINE_BREAK + contents + FormData2.LINE_BREAK;
     };
     FormData2.prototype._getContentDisposition = function(value, options2) {
-      var filename, contentDisposition;
+      var filename;
       if (typeof options2.filepath === "string") {
         filename = path.normalize(options2.filepath).replace(/\\/g, "/");
-      } else if (options2.filename || value.name || value.path) {
-        filename = path.basename(options2.filename || value.name || value.path);
-      } else if (value.readable && value.hasOwnProperty("httpVersion")) {
+      } else if (options2.filename || value && (value.name || value.path)) {
+        filename = path.basename(options2.filename || value && (value.name || value.path));
+      } else if (value && value.readable && hasOwn(value, "httpVersion")) {
         filename = path.basename(value.client._httpMessage.path || "");
       }
       if (filename) {
-        contentDisposition = 'filename="' + filename + '"';
+        return 'filename="' + filename + '"';
       }
-      return contentDisposition;
     };
     FormData2.prototype._getContentType = function(value, options2) {
       var contentType = options2.contentType;
-      if (!contentType && value.name) {
+      if (!contentType && value && value.name) {
         contentType = mime.lookup(value.name);
       }
-      if (!contentType && value.path) {
+      if (!contentType && value && value.path) {
         contentType = mime.lookup(value.path);
       }
-      if (!contentType && value.readable && value.hasOwnProperty("httpVersion")) {
+      if (!contentType && value && value.readable && hasOwn(value, "httpVersion")) {
         contentType = value.headers["content-type"];
       }
       if (!contentType && (options2.filepath || options2.filename)) {
         contentType = mime.lookup(options2.filepath || options2.filename);
       }
-      if (!contentType && typeof value == "object") {
+      if (!contentType && value && typeof value === "object") {
         contentType = FormData2.DEFAULT_CONTENT_TYPE;
       }
       return contentType;
@@ -34961,13 +35971,16 @@ var require_form_data = __commonJS({
         "content-type": "multipart/form-data; boundary=" + this.getBoundary()
       };
       for (header in userHeaders) {
-        if (userHeaders.hasOwnProperty(header)) {
+        if (hasOwn(userHeaders, header)) {
           formHeaders[header.toLowerCase()] = userHeaders[header];
         }
       }
       return formHeaders;
     };
     FormData2.prototype.setBoundary = function(boundary) {
+      if (typeof boundary !== "string") {
+        throw new TypeError("FormData boundary must be a string");
+      }
       this._boundary = boundary;
     };
     FormData2.prototype.getBoundary = function() {
@@ -34994,11 +36007,7 @@ var require_form_data = __commonJS({
       return Buffer.concat([dataBuffer, Buffer.from(this._lastBoundary())]);
     };
     FormData2.prototype._generateBoundary = function() {
-      var boundary = "--------------------------";
-      for (var i = 0; i < 24; i++) {
-        boundary += Math.floor(Math.random() * 10).toString(16);
-      }
-      this._boundary = boundary;
+      this._boundary = "--------------------------" + crypto.randomBytes(12).toString("hex");
     };
     FormData2.prototype.getLengthSync = function() {
       var knownLength = this._overheadLength + this._valueLength;
@@ -35038,8 +36047,10 @@ var require_form_data = __commonJS({
       });
     };
     FormData2.prototype.submit = function(params, cb) {
-      var request, options2, defaults = { method: "post" };
-      if (typeof params == "string") {
+      var request;
+      var options2;
+      var defaults = { method: "post" };
+      if (typeof params === "string") {
         params = parseUrl(params);
         options2 = populate({
           port: params.port,
@@ -35050,11 +36061,11 @@ var require_form_data = __commonJS({
       } else {
         options2 = populate(params, defaults);
         if (!options2.port) {
-          options2.port = options2.protocol == "https:" ? 443 : 80;
+          options2.port = options2.protocol === "https:" ? 443 : 80;
         }
       }
       options2.headers = this.getHeaders(params.headers);
-      if (options2.protocol == "https:") {
+      if (options2.protocol === "https:") {
         request = https.request(options2);
       } else {
         request = http.request(options2);
@@ -35092,6 +36103,8 @@ var require_form_data = __commonJS({
     FormData2.prototype.toString = function() {
       return "[object FormData]";
     };
+    setToStringTag(FormData2, "FormData");
+    module2.exports = FormData2;
   }
 });
 
@@ -36340,6 +37353,7 @@ var require_axios = __commonJS({
     }
     var { toString } = Object.prototype;
     var { getPrototypeOf } = Object;
+    var { iterator, toStringTag } = Symbol;
     var kindOf = /* @__PURE__ */ ((cache) => (thing) => {
       const str = toString.call(thing);
       return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
@@ -36374,7 +37388,17 @@ var require_axios = __commonJS({
         return false;
       }
       const prototype2 = getPrototypeOf(val);
-      return (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);
+      return (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && !(toStringTag in val) && !(iterator in val);
+    };
+    var isEmptyObject = (val) => {
+      if (!isObject(val) || isBuffer(val)) {
+        return false;
+      }
+      try {
+        return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
+      } catch (e) {
+        return false;
+      }
     };
     var isDate = kindOfTest("Date");
     var isFile = kindOfTest("File");
@@ -36403,6 +37427,9 @@ var require_axios = __commonJS({
           fn.call(null, obj[i], i, obj);
         }
       } else {
+        if (isBuffer(obj)) {
+          return;
+        }
         const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
         const len = keys.length;
         let key;
@@ -36413,6 +37440,9 @@ var require_axios = __commonJS({
       }
     }
     function findKey(obj, key) {
+      if (isBuffer(obj)) {
+        return null;
+      }
       key = key.toLowerCase();
       const keys = Object.keys(obj);
       let i = keys.length;
@@ -36521,10 +37551,10 @@ var require_axios = __commonJS({
       };
     })(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array));
     var forEachEntry = (obj, fn) => {
-      const generator = obj && obj[Symbol.iterator];
-      const iterator = generator.call(obj);
+      const generator = obj && obj[iterator];
+      const _iterator = generator.call(obj);
       let result;
-      while ((result = iterator.next()) && !result.done) {
+      while ((result = _iterator.next()) && !result.done) {
         const pair = result.value;
         fn.call(obj, pair[0], pair[1]);
       }
@@ -36594,7 +37624,7 @@ var require_axios = __commonJS({
       return value != null && Number.isFinite(value = +value) ? value : defaultValue;
     };
     function isSpecCompliantForm(thing) {
-      return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === "FormData" && thing[Symbol.iterator]);
+      return !!(thing && isFunction(thing.append) && thing[toStringTag] === "FormData" && thing[iterator]);
     }
     var toJSONObject = (obj) => {
       const stack = new Array(10);
@@ -36603,6 +37633,9 @@ var require_axios = __commonJS({
           if (stack.indexOf(source) >= 0) {
             return;
           }
+          if (isBuffer(source)) {
+            return source;
+          }
           if (!("toJSON" in source)) {
             stack[i] = source;
             const target = isArray(source) ? [] : {};
@@ -36640,6 +37673,7 @@ var require_axios = __commonJS({
       isFunction(_global.postMessage)
     );
     var asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate;
+    var isIterable = (thing) => thing != null && isFunction(thing[iterator]);
     var utils$1 = {
       isArray,
       isArrayBuffer,
@@ -36651,6 +37685,7 @@ var require_axios = __commonJS({
       isBoolean,
       isObject,
       isPlainObject,
+      isEmptyObject,
       isReadableStream,
       isRequest,
       isResponse,
@@ -36696,7 +37731,8 @@ var require_axios = __commonJS({
       isAsyncFn,
       isThenable,
       setImmediate: _setImmediate,
-      asap
+      asap,
+      isIterable
     };
     function AxiosError(message, code, config, request, response) {
       Error.call(this);
@@ -36815,6 +37851,9 @@ var require_axios = __commonJS({
         if (utils$1.isDate(value)) {
           return value.toISOString();
         }
+        if (utils$1.isBoolean(value)) {
+          return value.toString();
+        }
         if (!useBlob && utils$1.isBlob(value)) {
           throw new AxiosError("Blob is not supported. Use a Buffer instead.");
         }
@@ -37055,15 +38094,16 @@ var require_axios = __commonJS({
       ...platform$1
     };
     function toURLEncodedForm(data, options2) {
-      return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
+      return toFormData(data, new platform.classes.URLSearchParams(), {
         visitor: function(value, key, path, helpers) {
           if (platform.isNode && utils$1.isBuffer(value)) {
             this.append(key, value.toString("base64"));
             return false;
           }
           return helpers.defaultVisitor.apply(this, arguments);
-        }
-      }, options2));
+        },
+        ...options2
+      });
     }
     function parsePropPath(name) {
       return utils$1.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
@@ -37337,10 +38377,15 @@ var require_axios = __commonJS({
           setHeaders(header, valueOrRewrite);
         } else if (utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
           setHeaders(parseHeaders(header), valueOrRewrite);
-        } else if (utils$1.isHeaders(header)) {
-          for (const [key, value] of header.entries()) {
-            setHeader(value, key, rewrite);
+        } else if (utils$1.isObject(header) && utils$1.isIterable(header)) {
+          let obj = {}, dest, key;
+          for (const entry of header) {
+            if (!utils$1.isArray(entry)) {
+              throw TypeError("Object iterator must return a key-value pair");
+            }
+            obj[key = entry[0]] = (dest = obj[key]) ? utils$1.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]] : entry[1];
           }
+          setHeaders(obj, valueOrRewrite);
         } else {
           header != null && setHeader(valueOrRewrite, header, rewrite);
         }
@@ -37444,6 +38489,9 @@ var require_axios = __commonJS({
       toString() {
         return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
       }
+      getSetCookie() {
+        return this.get("set-cookie") || [];
+      }
       get [Symbol.toStringTag]() {
         return "AxiosHeaders";
       }
@@ -37527,12 +38575,12 @@ var require_axios = __commonJS({
     }
     function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
       let isRelativeUrl = !isAbsoluteURL(requestedURL);
-      if (baseURL && isRelativeUrl || allowAbsoluteUrls == false) {
+      if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
         return combineURLs(baseURL, requestedURL);
       }
       return requestedURL;
     }
-    var VERSION = "1.8.2";
+    var VERSION = "1.11.0";
     function parseProtocol(url2) {
       const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url2);
       return match && match[1] || "";
@@ -37741,7 +38789,7 @@ var require_axios = __commonJS({
         throw Error("boundary must be 10-70 characters long");
       }
       const boundaryBytes = textEncoder.encode("--" + boundary + CRLF);
-      const footerBytes = textEncoder.encode("--" + boundary + "--" + CRLF + CRLF);
+      const footerBytes = textEncoder.encode("--" + boundary + "--" + CRLF);
       let contentLength = footerBytes.byteLength;
       const parts = Array.from(form.entries()).map(([name, value]) => {
         const part = new FormDataPart(name, value);
@@ -37843,7 +38891,7 @@ var require_axios = __commonJS({
           clearTimeout(timer);
           timer = null;
         }
-        fn.apply(null, args);
+        fn(...args);
       };
       const throttled = (...args) => {
         const now = Date.now();
@@ -38504,7 +39552,7 @@ var require_axios = __commonJS({
         validateStatus: mergeDirectKeys,
         headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
       };
-      utils$1.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
+      utils$1.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
         const merge2 = mergeMap[prop] || mergeDeepProperties;
         const configValue = merge2(config1[prop], config2[prop], prop);
         utils$1.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
@@ -38515,7 +39563,7 @@ var require_axios = __commonJS({
       const newConfig = mergeConfig({}, config);
       let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
       newConfig.headers = headers = AxiosHeaders$1.from(headers);
-      newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url), config.params, config.paramsSerializer);
+      newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);
       if (auth) {
         headers.set(
           "Authorization",
@@ -38739,7 +39787,7 @@ var require_axios = __commonJS({
       }
     };
     var trackStream = (stream2, chunkSize, onProgress, onFinish) => {
-      const iterator = readBytes(stream2, chunkSize);
+      const iterator2 = readBytes(stream2, chunkSize);
       let bytes = 0;
       let done;
       let _onFinish = (e) => {
@@ -38751,7 +39799,7 @@ var require_axios = __commonJS({
       return new ReadableStream({
         async pull(controller) {
           try {
-            const { done: done2, value } = await iterator.next();
+            const { done: done2, value } = await iterator2.next();
             if (done2) {
               _onFinish();
               controller.close();
@@ -38770,7 +39818,7 @@ var require_axios = __commonJS({
         },
         cancel(reason) {
           _onFinish(reason);
-          return iterator.return();
+          return iterator2.return();
         }
       }, {
         highWaterMark: 2
@@ -38892,7 +39940,7 @@ var require_axios = __commonJS({
           duplex: "half",
           credentials: isCredentialsSupported ? withCredentials : void 0
         });
-        let response = await fetch(request);
+        let response = await fetch(request, fetchOptions);
         const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
         if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
           const options2 = {};
@@ -38927,7 +39975,7 @@ var require_axios = __commonJS({
         });
       } catch (err) {
         unsubscribe && unsubscribe();
-        if (err && err.name === "TypeError" && /fetch/i.test(err.message)) {
+        if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
           throw Object.assign(
             new AxiosError("Network Error", AxiosError.ERR_NETWORK, config, request),
             {
@@ -39098,7 +40146,7 @@ var require_axios = __commonJS({
     var validators = validator.validators;
     var Axios = class {
       constructor(instanceConfig) {
-        this.defaults = instanceConfig;
+        this.defaults = instanceConfig || {};
         this.interceptors = {
           request: new InterceptorManager$1(),
           response: new InterceptorManager$1()
@@ -39200,8 +40248,8 @@ var require_axios = __commonJS({
         let len;
         if (!synchronousRequestInterceptors) {
           const chain = [dispatchRequest.bind(this), void 0];
-          chain.unshift.apply(chain, requestInterceptorChain);
-          chain.push.apply(chain, responseInterceptorChain);
+          chain.unshift(...requestInterceptorChain);
+          chain.push(...responseInterceptorChain);
           len = chain.length;
           promise = Promise.resolve(config);
           while (i < len) {
@@ -39848,12 +40896,18 @@ var require_create_destination = __commonJS({
 var require_constants = __commonJS({
   "../../node_modules/ws/lib/constants.js"(exports2, module2) {
     "use strict";
+    var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
+    var hasBlob = typeof Blob !== "undefined";
+    if (hasBlob) BINARY_TYPES.push("blob");
     module2.exports = {
-      BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
+      BINARY_TYPES,
+      EMPTY_BUFFER: Buffer.alloc(0),
       GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
+      hasBlob,
+      kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
+      kListener: Symbol("kListener"),
       kStatusCode: Symbol("status-code"),
       kWebSocket: Symbol("websocket"),
-      EMPTY_BUFFER: Buffer.alloc(0),
       NOOP: () => {
       }
     };
@@ -39865,6 +40919,7 @@ var require_buffer_util = __commonJS({
   "../../node_modules/ws/lib/buffer-util.js"(exports2, module2) {
     "use strict";
     var { EMPTY_BUFFER } = require_constants();
+    var FastBuffer = Buffer[Symbol.species];
     function concat2(list, totalLength) {
       if (list.length === 0) return EMPTY_BUFFER;
       if (list.length === 1) return list[0];
@@ -39875,7 +40930,9 @@ var require_buffer_util = __commonJS({
         target.set(buf, offset);
         offset += buf.length;
       }
-      if (offset < totalLength) return target.slice(0, offset);
+      if (offset < totalLength) {
+        return new FastBuffer(target.buffer, target.byteOffset, offset);
+      }
       return target;
     }
     function _mask(source, mask, output, offset, length) {
@@ -39884,55 +40941,50 @@ var require_buffer_util = __commonJS({
       }
     }
     function _unmask(buffer, mask) {
-      const length = buffer.length;
-      for (let i = 0; i < length; i++) {
+      for (let i = 0; i < buffer.length; i++) {
         buffer[i] ^= mask[i & 3];
       }
     }
     function toArrayBuffer(buf) {
-      if (buf.byteLength === buf.buffer.byteLength) {
+      if (buf.length === buf.buffer.byteLength) {
         return buf.buffer;
       }
-      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
     }
     function toBuffer(data) {
       toBuffer.readOnly = true;
       if (Buffer.isBuffer(data)) return data;
       let buf;
       if (data instanceof ArrayBuffer) {
-        buf = Buffer.from(data);
+        buf = new FastBuffer(data);
       } else if (ArrayBuffer.isView(data)) {
-        buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+        buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
       } else {
         buf = Buffer.from(data);
         toBuffer.readOnly = false;
       }
       return buf;
     }
-    try {
-      const bufferUtil = require("bufferutil");
-      const bu = bufferUtil.BufferUtil || bufferUtil;
-      module2.exports = {
-        concat: concat2,
-        mask(source, mask, output, offset, length) {
+    module2.exports = {
+      concat: concat2,
+      mask: _mask,
+      toArrayBuffer,
+      toBuffer,
+      unmask: _unmask
+    };
+    if (!process.env.WS_NO_BUFFER_UTIL) {
+      try {
+        const bufferUtil = require("bufferutil");
+        module2.exports.mask = function(source, mask, output, offset, length) {
           if (length < 48) _mask(source, mask, output, offset, length);
-          else bu.mask(source, mask, output, offset, length);
-        },
-        toArrayBuffer,
-        toBuffer,
-        unmask(buffer, mask) {
+          else bufferUtil.mask(source, mask, output, offset, length);
+        };
+        module2.exports.unmask = function(buffer, mask) {
           if (buffer.length < 32) _unmask(buffer, mask);
-          else bu.unmask(buffer, mask);
-        }
-      };
-    } catch (e) {
-      module2.exports = {
-        concat: concat2,
-        mask: _mask,
-        toArrayBuffer,
-        toBuffer,
-        unmask: _unmask
-      };
+          else bufferUtil.unmask(buffer, mask);
+        };
+      } catch (e) {
+      }
     }
   }
 });
@@ -39994,7 +41046,8 @@ var require_permessage_deflate = __commonJS({
     var zlib = require("zlib");
     var bufferUtil = require_buffer_util();
     var Limiter = require_limiter();
-    var { kStatusCode, NOOP } = require_constants();
+    var { kStatusCode } = require_constants();
+    var FastBuffer = Buffer[Symbol.species];
     var TRAILER = Buffer.from([0, 0, 255, 255]);
     var kPerMessageDeflate = Symbol("permessage-deflate");
     var kTotalLength = Symbol("total-length");
@@ -40007,22 +41060,22 @@ var require_permessage_deflate = __commonJS({
        * Creates a PerMessageDeflate instance.
        *
        * @param {Object} [options] Configuration options
-       * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
-       *     disabling of server context takeover
+       * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+       *     for, or request, a custom client window size
        * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
        *     acknowledge disabling of client context takeover
+       * @param {Number} [options.concurrencyLimit=10] The number of concurrent
+       *     calls to zlib
        * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
        *     use of a custom server window size
-       * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
-       *     for, or request, a custom client window size
+       * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+       *     disabling of server context takeover
+       * @param {Number} [options.threshold=1024] Size (in bytes) below which
+       *     messages should not be compressed if context takeover is disabled
        * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
        *     deflate
        * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
        *     inflate
-       * @param {Number} [options.threshold=1024] Size (in bytes) below which
-       *     messages should not be compressed
-       * @param {Number} [options.concurrencyLimit=10] The number of concurrent
-       *     calls to zlib
        * @param {Boolean} [isServer=false] Create the instance in either server or
        *     client mode
        * @param {Number} [maxPayload=0] The maximum allowed message length
@@ -40232,7 +41285,7 @@ var require_permessage_deflate = __commonJS({
       /**
        * Compress data. Concurrency limited.
        *
-       * @param {Buffer} data Data to compress
+       * @param {(Buffer|String)} data Data to compress
        * @param {Boolean} fin Specifies whether or not this is the last fragment
        * @param {Function} callback Callback
        * @public
@@ -40299,7 +41352,7 @@ var require_permessage_deflate = __commonJS({
       /**
        * Compress data.
        *
-       * @param {Buffer} data Data to compress
+       * @param {(Buffer|String)} data Data to compress
        * @param {Boolean} fin Specifies whether or not this is the last fragment
        * @param {Function} callback Callback
        * @private
@@ -40315,7 +41368,6 @@ var require_permessage_deflate = __commonJS({
           });
           this._deflate[kTotalLength] = 0;
           this._deflate[kBuffers] = [];
-          this._deflate.on("error", NOOP);
           this._deflate.on("data", deflateOnData);
         }
         this._deflate[kCallback] = callback;
@@ -40328,7 +41380,9 @@ var require_permessage_deflate = __commonJS({
             this._deflate[kBuffers],
             this._deflate[kTotalLength]
           );
-          if (fin) data2 = data2.slice(0, data2.length - 4);
+          if (fin) {
+            data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4);
+          }
           this._deflate[kCallback] = null;
           this._deflate[kTotalLength] = 0;
           this._deflate[kBuffers] = [];
@@ -40358,6 +41412,10 @@ var require_permessage_deflate = __commonJS({
     }
     function inflateOnError(err) {
       this[kPerMessageDeflate]._inflate = null;
+      if (this[kError]) {
+        this[kCallback](this[kError]);
+        return;
+      }
       err[kStatusCode] = 1007;
       this[kCallback](err);
     }
@@ -40368,6 +41426,146 @@ var require_permessage_deflate = __commonJS({
 var require_validation = __commonJS({
   "../../node_modules/ws/lib/validation.js"(exports2, module2) {
     "use strict";
+    var { isUtf8 } = require("buffer");
+    var { hasBlob } = require_constants();
+    var tokenChars = [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      // 0 - 15
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      // 16 - 31
+      0,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0,
+      1,
+      1,
+      0,
+      1,
+      1,
+      0,
+      // 32 - 47
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      // 48 - 63
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      // 64 - 79
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0,
+      1,
+      1,
+      // 80 - 95
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      // 96 - 111
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      0,
+      1,
+      0
+      // 112 - 127
+    ];
     function isValidStatusCode(code) {
       return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
     }
@@ -40400,22 +41598,27 @@ var require_validation = __commonJS({
       }
       return true;
     }
-    try {
-      let isValidUTF8 = require("utf-8-validate");
-      if (typeof isValidUTF8 === "object") {
-        isValidUTF8 = isValidUTF8.Validation.isValidUTF8;
-      }
-      module2.exports = {
-        isValidStatusCode,
-        isValidUTF8(buf) {
-          return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
-        }
-      };
-    } catch (e) {
-      module2.exports = {
-        isValidStatusCode,
-        isValidUTF8: _isValidUTF8
+    function isBlob(value) {
+      return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File");
+    }
+    module2.exports = {
+      isBlob,
+      isValidStatusCode,
+      isValidUTF8: _isValidUTF8,
+      tokenChars
+    };
+    if (isUtf8) {
+      module2.exports.isValidUTF8 = function(buf) {
+        return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
       };
+    } else if (!process.env.WS_NO_UTF_8_VALIDATE) {
+      try {
+        const isValidUTF8 = require("utf-8-validate");
+        module2.exports.isValidUTF8 = function(buf) {
+          return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
+        };
+      } catch (e) {
+      }
     }
   }
 });
@@ -40434,29 +41637,40 @@ var require_receiver = __commonJS({
     } = require_constants();
     var { concat: concat2, toArrayBuffer, unmask } = require_buffer_util();
     var { isValidStatusCode, isValidUTF8 } = require_validation();
+    var FastBuffer = Buffer[Symbol.species];
     var GET_INFO = 0;
     var GET_PAYLOAD_LENGTH_16 = 1;
     var GET_PAYLOAD_LENGTH_64 = 2;
     var GET_MASK = 3;
     var GET_DATA = 4;
     var INFLATING = 5;
+    var DEFER_EVENT = 6;
     var Receiver = class extends Writable {
       /**
        * Creates a Receiver instance.
        *
-       * @param {String} [binaryType=nodebuffer] The type for binary data
-       * @param {Object} [extensions] An object containing the negotiated extensions
-       * @param {Boolean} [isServer=false] Specifies whether to operate in client or
-       *     server mode
-       * @param {Number} [maxPayload=0] The maximum allowed message length
+       * @param {Object} [options] Options object
+       * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+       *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+       *     multiple times in the same tick
+       * @param {String} [options.binaryType=nodebuffer] The type for binary data
+       * @param {Object} [options.extensions] An object containing the negotiated
+       *     extensions
+       * @param {Boolean} [options.isServer=false] Specifies whether to operate in
+       *     client or server mode
+       * @param {Number} [options.maxPayload=0] The maximum allowed message length
+       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+       *     not to skip UTF-8 validation for text and close messages
        */
-      constructor(binaryType, extensions, isServer, maxPayload) {
+      constructor(options2 = {}) {
         super();
-        this._binaryType = binaryType || BINARY_TYPES[0];
+        this._allowSynchronousEvents = options2.allowSynchronousEvents !== void 0 ? options2.allowSynchronousEvents : true;
+        this._binaryType = options2.binaryType || BINARY_TYPES[0];
+        this._extensions = options2.extensions || {};
+        this._isServer = !!options2.isServer;
+        this._maxPayload = options2.maxPayload | 0;
+        this._skipUTF8Validation = !!options2.skipUTF8Validation;
         this[kWebSocket] = void 0;
-        this._extensions = extensions || {};
-        this._isServer = !!isServer;
-        this._maxPayload = maxPayload | 0;
         this._bufferedBytes = 0;
         this._buffers = [];
         this._compressed = false;
@@ -40469,8 +41683,9 @@ var require_receiver = __commonJS({
         this._totalPayloadLength = 0;
         this._messageLength = 0;
         this._fragments = [];
-        this._state = GET_INFO;
+        this._errored = false;
         this._loop = false;
+        this._state = GET_INFO;
       }
       /**
        * Implements `Writable.prototype._write()`.
@@ -40498,8 +41713,12 @@ var require_receiver = __commonJS({
         if (n === this._buffers[0].length) return this._buffers.shift();
         if (n < this._buffers[0].length) {
           const buf = this._buffers[0];
-          this._buffers[0] = buf.slice(n);
-          return buf.slice(0, n);
+          this._buffers[0] = new FastBuffer(
+            buf.buffer,
+            buf.byteOffset + n,
+            buf.length - n
+          );
+          return new FastBuffer(buf.buffer, buf.byteOffset, n);
         }
         const dst = Buffer.allocUnsafe(n);
         do {
@@ -40509,7 +41728,11 @@ var require_receiver = __commonJS({
             dst.set(this._buffers.shift(), offset);
           } else {
             dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
-            this._buffers[0] = buf.slice(n);
+            this._buffers[0] = new FastBuffer(
+              buf.buffer,
+              buf.byteOffset + n,
+              buf.length - n
+            );
           }
           n -= buf.length;
         } while (n > 0);
@@ -40522,191 +41745,202 @@ var require_receiver = __commonJS({
        * @private
        */
       startLoop(cb) {
-        let err;
         this._loop = true;
         do {
           switch (this._state) {
             case GET_INFO:
-              err = this.getInfo();
+              this.getInfo(cb);
               break;
             case GET_PAYLOAD_LENGTH_16:
-              err = this.getPayloadLength16();
+              this.getPayloadLength16(cb);
               break;
             case GET_PAYLOAD_LENGTH_64:
-              err = this.getPayloadLength64();
+              this.getPayloadLength64(cb);
               break;
             case GET_MASK:
               this.getMask();
               break;
             case GET_DATA:
-              err = this.getData(cb);
+              this.getData(cb);
               break;
-            default:
+            case INFLATING:
+            case DEFER_EVENT:
               this._loop = false;
               return;
           }
         } while (this._loop);
-        cb(err);
+        if (!this._errored) cb();
       }
       /**
        * Reads the first two bytes of a frame.
        *
-       * @return {(RangeError|undefined)} A possible error
+       * @param {Function} cb Callback
        * @private
        */
-      getInfo() {
+      getInfo(cb) {
         if (this._bufferedBytes < 2) {
           this._loop = false;
           return;
         }
         const buf = this.consume(2);
         if ((buf[0] & 48) !== 0) {
-          this._loop = false;
-          return error(
+          const error = this.createError(
             RangeError,
             "RSV2 and RSV3 must be clear",
             true,
             1002,
             "WS_ERR_UNEXPECTED_RSV_2_3"
           );
+          cb(error);
+          return;
         }
         const compressed = (buf[0] & 64) === 64;
         if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
-          this._loop = false;
-          return error(
+          const error = this.createError(
             RangeError,
             "RSV1 must be clear",
             true,
             1002,
             "WS_ERR_UNEXPECTED_RSV_1"
           );
+          cb(error);
+          return;
         }
         this._fin = (buf[0] & 128) === 128;
         this._opcode = buf[0] & 15;
         this._payloadLength = buf[1] & 127;
         if (this._opcode === 0) {
           if (compressed) {
-            this._loop = false;
-            return error(
+            const error = this.createError(
               RangeError,
               "RSV1 must be clear",
               true,
               1002,
               "WS_ERR_UNEXPECTED_RSV_1"
             );
+            cb(error);
+            return;
           }
           if (!this._fragmented) {
-            this._loop = false;
-            return error(
+            const error = this.createError(
               RangeError,
               "invalid opcode 0",
               true,
               1002,
               "WS_ERR_INVALID_OPCODE"
             );
+            cb(error);
+            return;
           }
           this._opcode = this._fragmented;
         } else if (this._opcode === 1 || this._opcode === 2) {
           if (this._fragmented) {
-            this._loop = false;
-            return error(
+            const error = this.createError(
               RangeError,
               `invalid opcode ${this._opcode}`,
               true,
               1002,
               "WS_ERR_INVALID_OPCODE"
             );
+            cb(error);
+            return;
           }
           this._compressed = compressed;
         } else if (this._opcode > 7 && this._opcode < 11) {
           if (!this._fin) {
-            this._loop = false;
-            return error(
+            const error = this.createError(
               RangeError,
               "FIN must be set",
               true,
               1002,
               "WS_ERR_EXPECTED_FIN"
             );
+            cb(error);
+            return;
           }
           if (compressed) {
-            this._loop = false;
-            return error(
+            const error = this.createError(
               RangeError,
               "RSV1 must be clear",
               true,
               1002,
               "WS_ERR_UNEXPECTED_RSV_1"
             );
+            cb(error);
+            return;
           }
-          if (this._payloadLength > 125) {
-            this._loop = false;
-            return error(
+          if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
+            const error = this.createError(
               RangeError,
               `invalid payload length ${this._payloadLength}`,
               true,
               1002,
               "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
             );
+            cb(error);
+            return;
           }
         } else {
-          this._loop = false;
-          return error(
+          const error = this.createError(
             RangeError,
             `invalid opcode ${this._opcode}`,
             true,
             1002,
             "WS_ERR_INVALID_OPCODE"
           );
+          cb(error);
+          return;
         }
         if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
         this._masked = (buf[1] & 128) === 128;
         if (this._isServer) {
           if (!this._masked) {
-            this._loop = false;
-            return error(
+            const error = this.createError(
               RangeError,
               "MASK must be set",
               true,
               1002,
               "WS_ERR_EXPECTED_MASK"
             );
+            cb(error);
+            return;
           }
         } else if (this._masked) {
-          this._loop = false;
-          return error(
+          const error = this.createError(
             RangeError,
             "MASK must be clear",
             true,
             1002,
             "WS_ERR_UNEXPECTED_MASK"
           );
+          cb(error);
+          return;
         }
         if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
         else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
-        else return this.haveLength();
+        else this.haveLength(cb);
       }
       /**
        * Gets extended payload length (7+16).
        *
-       * @return {(RangeError|undefined)} A possible error
+       * @param {Function} cb Callback
        * @private
        */
-      getPayloadLength16() {
+      getPayloadLength16(cb) {
         if (this._bufferedBytes < 2) {
           this._loop = false;
           return;
         }
         this._payloadLength = this.consume(2).readUInt16BE(0);
-        return this.haveLength();
+        this.haveLength(cb);
       }
       /**
        * Gets extended payload length (7+64).
        *
-       * @return {(RangeError|undefined)} A possible error
+       * @param {Function} cb Callback
        * @private
        */
-      getPayloadLength64() {
+      getPayloadLength64(cb) {
         if (this._bufferedBytes < 8) {
           this._loop = false;
           return;
@@ -40714,36 +41948,38 @@ var require_receiver = __commonJS({
         const buf = this.consume(8);
         const num = buf.readUInt32BE(0);
         if (num > Math.pow(2, 53 - 32) - 1) {
-          this._loop = false;
-          return error(
+          const error = this.createError(
             RangeError,
             "Unsupported WebSocket frame: payload length > 2^53 - 1",
             false,
             1009,
             "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
           );
+          cb(error);
+          return;
         }
         this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
-        return this.haveLength();
+        this.haveLength(cb);
       }
       /**
        * Payload length has been read.
        *
-       * @return {(RangeError|undefined)} A possible error
+       * @param {Function} cb Callback
        * @private
        */
-      haveLength() {
+      haveLength(cb) {
         if (this._payloadLength && this._opcode < 8) {
           this._totalPayloadLength += this._payloadLength;
           if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
-            this._loop = false;
-            return error(
+            const error = this.createError(
               RangeError,
               "Max payload size exceeded",
               false,
               1009,
               "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
             );
+            cb(error);
+            return;
           }
         }
         if (this._masked) this._state = GET_MASK;
@@ -40766,7 +42002,6 @@ var require_receiver = __commonJS({
        * Reads data bytes.
        *
        * @param {Function} cb Callback
-       * @return {(Error|RangeError|undefined)} A possible error
        * @private
        */
       getData(cb) {
@@ -40777,9 +42012,14 @@ var require_receiver = __commonJS({
             return;
           }
           data = this.consume(this._payloadLength);
-          if (this._masked) unmask(data, this._mask);
+          if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) {
+            unmask(data, this._mask);
+          }
+        }
+        if (this._opcode > 7) {
+          this.controlMessage(data, cb);
+          return;
         }
-        if (this._opcode > 7) return this.controlMessage(data);
         if (this._compressed) {
           this._state = INFLATING;
           this.decompress(data, cb);
@@ -40789,7 +42029,7 @@ var require_receiver = __commonJS({
           this._messageLength = this._totalPayloadLength;
           this._fragments.push(data);
         }
-        return this.dataMessage();
+        this.dataMessage(cb);
       }
       /**
        * Decompresses data.
@@ -40805,63 +42045,86 @@ var require_receiver = __commonJS({
           if (buf.length) {
             this._messageLength += buf.length;
             if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
-              return cb(
-                error(
-                  RangeError,
-                  "Max payload size exceeded",
-                  false,
-                  1009,
-                  "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
-                )
+              const error = this.createError(
+                RangeError,
+                "Max payload size exceeded",
+                false,
+                1009,
+                "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
               );
+              cb(error);
+              return;
             }
             this._fragments.push(buf);
           }
-          const er = this.dataMessage();
-          if (er) return cb(er);
-          this.startLoop(cb);
+          this.dataMessage(cb);
+          if (this._state === GET_INFO) this.startLoop(cb);
         });
       }
       /**
        * Handles a data message.
        *
-       * @return {(Error|undefined)} A possible error
+       * @param {Function} cb Callback
        * @private
        */
-      dataMessage() {
-        if (this._fin) {
-          const messageLength = this._messageLength;
-          const fragments = this._fragments;
-          this._totalPayloadLength = 0;
-          this._messageLength = 0;
-          this._fragmented = 0;
-          this._fragments = [];
-          if (this._opcode === 2) {
-            let data;
-            if (this._binaryType === "nodebuffer") {
-              data = concat2(fragments, messageLength);
-            } else if (this._binaryType === "arraybuffer") {
-              data = toArrayBuffer(concat2(fragments, messageLength));
-            } else {
-              data = fragments;
-            }
-            this.emit("message", data);
+      dataMessage(cb) {
+        if (!this._fin) {
+          this._state = GET_INFO;
+          return;
+        }
+        const messageLength = this._messageLength;
+        const fragments = this._fragments;
+        this._totalPayloadLength = 0;
+        this._messageLength = 0;
+        this._fragmented = 0;
+        this._fragments = [];
+        if (this._opcode === 2) {
+          let data;
+          if (this._binaryType === "nodebuffer") {
+            data = concat2(fragments, messageLength);
+          } else if (this._binaryType === "arraybuffer") {
+            data = toArrayBuffer(concat2(fragments, messageLength));
+          } else if (this._binaryType === "blob") {
+            data = new Blob(fragments);
           } else {
-            const buf = concat2(fragments, messageLength);
-            if (!isValidUTF8(buf)) {
-              this._loop = false;
-              return error(
-                Error,
-                "invalid UTF-8 sequence",
-                true,
-                1007,
-                "WS_ERR_INVALID_UTF8"
-              );
-            }
-            this.emit("message", buf.toString());
+            data = fragments;
+          }
+          if (this._allowSynchronousEvents) {
+            this.emit("message", data, true);
+            this._state = GET_INFO;
+          } else {
+            this._state = DEFER_EVENT;
+            setImmediate(() => {
+              this.emit("message", data, true);
+              this._state = GET_INFO;
+              this.startLoop(cb);
+            });
+          }
+        } else {
+          const buf = concat2(fragments, messageLength);
+          if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+            const error = this.createError(
+              Error,
+              "invalid UTF-8 sequence",
+              true,
+              1007,
+              "WS_ERR_INVALID_UTF8"
+            );
+            cb(error);
+            return;
+          }
+          if (this._state === INFLATING || this._allowSynchronousEvents) {
+            this.emit("message", buf, false);
+            this._state = GET_INFO;
+          } else {
+            this._state = DEFER_EVENT;
+            setImmediate(() => {
+              this.emit("message", buf, false);
+              this._state = GET_INFO;
+              this.startLoop(cb);
+            });
           }
         }
-        this._state = GET_INFO;
       }
       /**
        * Handles a control message.
@@ -40870,62 +42133,85 @@ var require_receiver = __commonJS({
        * @return {(Error|RangeError|undefined)} A possible error
        * @private
        */
-      controlMessage(data) {
+      controlMessage(data, cb) {
         if (this._opcode === 8) {
-          this._loop = false;
           if (data.length === 0) {
-            this.emit("conclude", 1005, "");
+            this._loop = false;
+            this.emit("conclude", 1005, EMPTY_BUFFER);
             this.end();
-          } else if (data.length === 1) {
-            return error(
-              RangeError,
-              "invalid payload length 1",
-              true,
-              1002,
-              "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
-            );
           } else {
             const code = data.readUInt16BE(0);
             if (!isValidStatusCode(code)) {
-              return error(
+              const error = this.createError(
                 RangeError,
                 `invalid status code ${code}`,
                 true,
                 1002,
                 "WS_ERR_INVALID_CLOSE_CODE"
               );
+              cb(error);
+              return;
             }
-            const buf = data.slice(2);
-            if (!isValidUTF8(buf)) {
-              return error(
+            const buf = new FastBuffer(
+              data.buffer,
+              data.byteOffset + 2,
+              data.length - 2
+            );
+            if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+              const error = this.createError(
                 Error,
                 "invalid UTF-8 sequence",
                 true,
                 1007,
                 "WS_ERR_INVALID_UTF8"
               );
+              cb(error);
+              return;
             }
-            this.emit("conclude", code, buf.toString());
+            this._loop = false;
+            this.emit("conclude", code, buf);
             this.end();
           }
-        } else if (this._opcode === 9) {
-          this.emit("ping", data);
+          this._state = GET_INFO;
+          return;
+        }
+        if (this._allowSynchronousEvents) {
+          this.emit(this._opcode === 9 ? "ping" : "pong", data);
+          this._state = GET_INFO;
         } else {
-          this.emit("pong", data);
+          this._state = DEFER_EVENT;
+          setImmediate(() => {
+            this.emit(this._opcode === 9 ? "ping" : "pong", data);
+            this._state = GET_INFO;
+            this.startLoop(cb);
+          });
         }
-        this._state = GET_INFO;
+      }
+      /**
+       * Builds an error object.
+       *
+       * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
+       * @param {String} message The error message
+       * @param {Boolean} prefix Specifies whether or not to add a default prefix to
+       *     `message`
+       * @param {Number} statusCode The status code
+       * @param {String} errorCode The exposed error code
+       * @return {(Error|RangeError)} The error
+       * @private
+       */
+      createError(ErrorCtor, message, prefix, statusCode, errorCode) {
+        this._loop = false;
+        this._errored = true;
+        const err = new ErrorCtor(
+          prefix ? `Invalid WebSocket frame: ${message}` : message
+        );
+        Error.captureStackTrace(err, this.createError);
+        err.code = errorCode;
+        err[kStatusCode] = statusCode;
+        return err;
       }
     };
     module2.exports = Receiver;
-    function error(ErrorCtor, message, prefix, statusCode, errorCode) {
-      const err = new ErrorCtor(
-        prefix ? `Invalid WebSocket frame: ${message}` : message
-      );
-      Error.captureStackTrace(err, error);
-      err.code = errorCode;
-      err[kStatusCode] = statusCode;
-      return err;
-    }
   }
 });
 
@@ -40933,98 +42219,150 @@ var require_receiver = __commonJS({
 var require_sender = __commonJS({
   "../../node_modules/ws/lib/sender.js"(exports2, module2) {
     "use strict";
-    var net = require("net");
-    var tls = require("tls");
+    var { Duplex } = require("stream");
     var { randomFillSync } = require("crypto");
     var PerMessageDeflate = require_permessage_deflate();
-    var { EMPTY_BUFFER } = require_constants();
-    var { isValidStatusCode } = require_validation();
+    var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
+    var { isBlob, isValidStatusCode } = require_validation();
     var { mask: applyMask, toBuffer } = require_buffer_util();
-    var mask = Buffer.alloc(4);
+    var kByteLength = Symbol("kByteLength");
+    var maskBuffer = Buffer.alloc(4);
+    var RANDOM_POOL_SIZE = 8 * 1024;
+    var randomPool;
+    var randomPoolPointer = RANDOM_POOL_SIZE;
+    var DEFAULT = 0;
+    var DEFLATING = 1;
+    var GET_BLOB_DATA = 2;
     var Sender = class _Sender {
       /**
        * Creates a Sender instance.
        *
-       * @param {(net.Socket|tls.Socket)} socket The connection socket
+       * @param {Duplex} socket The connection socket
        * @param {Object} [extensions] An object containing the negotiated extensions
+       * @param {Function} [generateMask] The function used to generate the masking
+       *     key
        */
-      constructor(socket, extensions) {
+      constructor(socket, extensions, generateMask) {
         this._extensions = extensions || {};
+        if (generateMask) {
+          this._generateMask = generateMask;
+          this._maskBuffer = Buffer.alloc(4);
+        }
         this._socket = socket;
         this._firstFragment = true;
         this._compress = false;
         this._bufferedBytes = 0;
-        this._deflating = false;
         this._queue = [];
+        this._state = DEFAULT;
+        this.onerror = NOOP;
+        this[kWebSocket] = void 0;
       }
       /**
        * Frames a piece of data according to the HyBi WebSocket protocol.
        *
-       * @param {Buffer} data The data to frame
+       * @param {(Buffer|String)} data The data to frame
        * @param {Object} options Options object
-       * @param {Number} options.opcode The opcode
-       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
-       *     modified
        * @param {Boolean} [options.fin=false] Specifies whether or not to set the
        *     FIN bit
+       * @param {Function} [options.generateMask] The function used to generate the
+       *     masking key
        * @param {Boolean} [options.mask=false] Specifies whether or not to mask
        *     `data`
+       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+       *     key
+       * @param {Number} options.opcode The opcode
+       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+       *     modified
        * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
        *     RSV1 bit
-       * @return {Buffer[]} The framed data as a list of `Buffer` instances
+       * @return {(Buffer|String)[]} The framed data
        * @public
        */
       static frame(data, options2) {
-        const merge = options2.mask && options2.readOnly;
-        let offset = options2.mask ? 6 : 2;
-        let payloadLength = data.length;
-        if (data.length >= 65536) {
+        let mask;
+        let merge = false;
+        let offset = 2;
+        let skipMasking = false;
+        if (options2.mask) {
+          mask = options2.maskBuffer || maskBuffer;
+          if (options2.generateMask) {
+            options2.generateMask(mask);
+          } else {
+            if (randomPoolPointer === RANDOM_POOL_SIZE) {
+              if (randomPool === void 0) {
+                randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
+              }
+              randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
+              randomPoolPointer = 0;
+            }
+            mask[0] = randomPool[randomPoolPointer++];
+            mask[1] = randomPool[randomPoolPointer++];
+            mask[2] = randomPool[randomPoolPointer++];
+            mask[3] = randomPool[randomPoolPointer++];
+          }
+          skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
+          offset = 6;
+        }
+        let dataLength;
+        if (typeof data === "string") {
+          if ((!options2.mask || skipMasking) && options2[kByteLength] !== void 0) {
+            dataLength = options2[kByteLength];
+          } else {
+            data = Buffer.from(data);
+            dataLength = data.length;
+          }
+        } else {
+          dataLength = data.length;
+          merge = options2.mask && options2.readOnly && !skipMasking;
+        }
+        let payloadLength = dataLength;
+        if (dataLength >= 65536) {
           offset += 8;
           payloadLength = 127;
-        } else if (data.length > 125) {
+        } else if (dataLength > 125) {
           offset += 2;
           payloadLength = 126;
         }
-        const target = Buffer.allocUnsafe(merge ? data.length + offset : offset);
+        const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
         target[0] = options2.fin ? options2.opcode | 128 : options2.opcode;
         if (options2.rsv1) target[0] |= 64;
         target[1] = payloadLength;
         if (payloadLength === 126) {
-          target.writeUInt16BE(data.length, 2);
+          target.writeUInt16BE(dataLength, 2);
         } else if (payloadLength === 127) {
-          target.writeUInt32BE(0, 2);
-          target.writeUInt32BE(data.length, 6);
+          target[2] = target[3] = 0;
+          target.writeUIntBE(dataLength, 4, 6);
         }
         if (!options2.mask) return [target, data];
-        randomFillSync(mask, 0, 4);
         target[1] |= 128;
         target[offset - 4] = mask[0];
         target[offset - 3] = mask[1];
         target[offset - 2] = mask[2];
         target[offset - 1] = mask[3];
+        if (skipMasking) return [target, data];
         if (merge) {
-          applyMask(data, mask, target, offset, data.length);
+          applyMask(data, mask, target, offset, dataLength);
           return [target];
         }
-        applyMask(data, mask, data, 0, data.length);
+        applyMask(data, mask, data, 0, dataLength);
         return [target, data];
       }
       /**
        * Sends a close message to the other peer.
        *
        * @param {Number} [code] The status code component of the body
-       * @param {String} [data] The message component of the body
+       * @param {(String|Buffer)} [data] The message component of the body
        * @param {Boolean} [mask=false] Specifies whether or not to mask the message
        * @param {Function} [cb] Callback
        * @public
        */
-      close(code, data, mask2, cb) {
+      close(code, data, mask, cb) {
         let buf;
         if (code === void 0) {
           buf = EMPTY_BUFFER;
         } else if (typeof code !== "number" || !isValidStatusCode(code)) {
           throw new TypeError("First argument must be a valid error code number");
-        } else if (data === void 0 || data === "") {
+        } else if (data === void 0 || !data.length) {
           buf = Buffer.allocUnsafe(2);
           buf.writeUInt16BE(code, 0);
         } else {
@@ -41034,34 +42372,28 @@ var require_sender = __commonJS({
           }
           buf = Buffer.allocUnsafe(2 + length);
           buf.writeUInt16BE(code, 0);
-          buf.write(data, 2);
+          if (typeof data === "string") {
+            buf.write(data, 2);
+          } else {
+            buf.set(data, 2);
+          }
         }
-        if (this._deflating) {
-          this.enqueue([this.doClose, buf, mask2, cb]);
+        const options2 = {
+          [kByteLength]: buf.length,
+          fin: true,
+          generateMask: this._generateMask,
+          mask,
+          maskBuffer: this._maskBuffer,
+          opcode: 8,
+          readOnly: false,
+          rsv1: false
+        };
+        if (this._state !== DEFAULT) {
+          this.enqueue([this.dispatch, buf, false, options2, cb]);
         } else {
-          this.doClose(buf, mask2, cb);
+          this.sendFrame(_Sender.frame(buf, options2), cb);
         }
       }
-      /**
-       * Frames and sends a close message.
-       *
-       * @param {Buffer} data The message to send
-       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-       * @param {Function} [cb] Callback
-       * @private
-       */
-      doClose(data, mask2, cb) {
-        this.sendFrame(
-          _Sender.frame(data, {
-            fin: true,
-            rsv1: false,
-            opcode: 8,
-            mask: mask2,
-            readOnly: false
-          }),
-          cb
-        );
-      }
       /**
        * Sends a ping message to the other peer.
        *
@@ -41070,38 +42402,45 @@ var require_sender = __commonJS({
        * @param {Function} [cb] Callback
        * @public
        */
-      ping(data, mask2, cb) {
-        const buf = toBuffer(data);
-        if (buf.length > 125) {
+      ping(data, mask, cb) {
+        let byteLength;
+        let readOnly;
+        if (typeof data === "string") {
+          byteLength = Buffer.byteLength(data);
+          readOnly = false;
+        } else if (isBlob(data)) {
+          byteLength = data.size;
+          readOnly = false;
+        } else {
+          data = toBuffer(data);
+          byteLength = data.length;
+          readOnly = toBuffer.readOnly;
+        }
+        if (byteLength > 125) {
           throw new RangeError("The data size must not be greater than 125 bytes");
         }
-        if (this._deflating) {
-          this.enqueue([this.doPing, buf, mask2, toBuffer.readOnly, cb]);
+        const options2 = {
+          [kByteLength]: byteLength,
+          fin: true,
+          generateMask: this._generateMask,
+          mask,
+          maskBuffer: this._maskBuffer,
+          opcode: 9,
+          readOnly,
+          rsv1: false
+        };
+        if (isBlob(data)) {
+          if (this._state !== DEFAULT) {
+            this.enqueue([this.getBlobData, data, false, options2, cb]);
+          } else {
+            this.getBlobData(data, false, options2, cb);
+          }
+        } else if (this._state !== DEFAULT) {
+          this.enqueue([this.dispatch, data, false, options2, cb]);
         } else {
-          this.doPing(buf, mask2, toBuffer.readOnly, cb);
+          this.sendFrame(_Sender.frame(data, options2), cb);
         }
       }
-      /**
-       * Frames and sends a ping message.
-       *
-       * @param {Buffer} data The message to send
-       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-       * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
-       * @param {Function} [cb] Callback
-       * @private
-       */
-      doPing(data, mask2, readOnly, cb) {
-        this.sendFrame(
-          _Sender.frame(data, {
-            fin: true,
-            rsv1: false,
-            opcode: 9,
-            mask: mask2,
-            readOnly
-          }),
-          cb
-        );
-      }
       /**
        * Sends a pong message to the other peer.
        *
@@ -41110,47 +42449,54 @@ var require_sender = __commonJS({
        * @param {Function} [cb] Callback
        * @public
        */
-      pong(data, mask2, cb) {
-        const buf = toBuffer(data);
-        if (buf.length > 125) {
+      pong(data, mask, cb) {
+        let byteLength;
+        let readOnly;
+        if (typeof data === "string") {
+          byteLength = Buffer.byteLength(data);
+          readOnly = false;
+        } else if (isBlob(data)) {
+          byteLength = data.size;
+          readOnly = false;
+        } else {
+          data = toBuffer(data);
+          byteLength = data.length;
+          readOnly = toBuffer.readOnly;
+        }
+        if (byteLength > 125) {
           throw new RangeError("The data size must not be greater than 125 bytes");
         }
-        if (this._deflating) {
-          this.enqueue([this.doPong, buf, mask2, toBuffer.readOnly, cb]);
+        const options2 = {
+          [kByteLength]: byteLength,
+          fin: true,
+          generateMask: this._generateMask,
+          mask,
+          maskBuffer: this._maskBuffer,
+          opcode: 10,
+          readOnly,
+          rsv1: false
+        };
+        if (isBlob(data)) {
+          if (this._state !== DEFAULT) {
+            this.enqueue([this.getBlobData, data, false, options2, cb]);
+          } else {
+            this.getBlobData(data, false, options2, cb);
+          }
+        } else if (this._state !== DEFAULT) {
+          this.enqueue([this.dispatch, data, false, options2, cb]);
         } else {
-          this.doPong(buf, mask2, toBuffer.readOnly, cb);
+          this.sendFrame(_Sender.frame(data, options2), cb);
         }
       }
-      /**
-       * Frames and sends a pong message.
-       *
-       * @param {Buffer} data The message to send
-       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-       * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
-       * @param {Function} [cb] Callback
-       * @private
-       */
-      doPong(data, mask2, readOnly, cb) {
-        this.sendFrame(
-          _Sender.frame(data, {
-            fin: true,
-            rsv1: false,
-            opcode: 10,
-            mask: mask2,
-            readOnly
-          }),
-          cb
-        );
-      }
       /**
        * Sends a data message to the other peer.
        *
        * @param {*} data The message to send
        * @param {Object} options Options object
-       * @param {Boolean} [options.compress=false] Specifies whether or not to
-       *     compress `data`
        * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
        *     or text
+       * @param {Boolean} [options.compress=false] Specifies whether or not to
+       *     compress `data`
        * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
        *     last one
        * @param {Boolean} [options.mask=false] Specifies whether or not to mask
@@ -41159,14 +42505,26 @@ var require_sender = __commonJS({
        * @public
        */
       send(data, options2, cb) {
-        const buf = toBuffer(data);
         const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
         let opcode = options2.binary ? 2 : 1;
         let rsv1 = options2.compress;
+        let byteLength;
+        let readOnly;
+        if (typeof data === "string") {
+          byteLength = Buffer.byteLength(data);
+          readOnly = false;
+        } else if (isBlob(data)) {
+          byteLength = data.size;
+          readOnly = false;
+        } else {
+          data = toBuffer(data);
+          byteLength = data.length;
+          readOnly = toBuffer.readOnly;
+        }
         if (this._firstFragment) {
           this._firstFragment = false;
-          if (rsv1 && perMessageDeflate) {
-            rsv1 = buf.length >= perMessageDeflate._threshold;
+          if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) {
+            rsv1 = byteLength >= perMessageDeflate._threshold;
           }
           this._compress = rsv1;
         } else {
@@ -41174,46 +42532,93 @@ var require_sender = __commonJS({
           opcode = 0;
         }
         if (options2.fin) this._firstFragment = true;
-        if (perMessageDeflate) {
-          const opts = {
-            fin: options2.fin,
-            rsv1,
-            opcode,
-            mask: options2.mask,
-            readOnly: toBuffer.readOnly
-          };
-          if (this._deflating) {
-            this.enqueue([this.dispatch, buf, this._compress, opts, cb]);
+        const opts = {
+          [kByteLength]: byteLength,
+          fin: options2.fin,
+          generateMask: this._generateMask,
+          mask: options2.mask,
+          maskBuffer: this._maskBuffer,
+          opcode,
+          readOnly,
+          rsv1
+        };
+        if (isBlob(data)) {
+          if (this._state !== DEFAULT) {
+            this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
           } else {
-            this.dispatch(buf, this._compress, opts, cb);
+            this.getBlobData(data, this._compress, opts, cb);
           }
+        } else if (this._state !== DEFAULT) {
+          this.enqueue([this.dispatch, data, this._compress, opts, cb]);
         } else {
-          this.sendFrame(
-            _Sender.frame(buf, {
-              fin: options2.fin,
-              rsv1: false,
-              opcode,
-              mask: options2.mask,
-              readOnly: toBuffer.readOnly
-            }),
-            cb
-          );
+          this.dispatch(data, this._compress, opts, cb);
         }
       }
       /**
-       * Dispatches a data message.
+       * Gets the contents of a blob as binary data.
        *
-       * @param {Buffer} data The message to send
+       * @param {Blob} blob The blob
        * @param {Boolean} [compress=false] Specifies whether or not to compress
-       *     `data`
+       *     the data
        * @param {Object} options Options object
+       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+       *     FIN bit
+       * @param {Function} [options.generateMask] The function used to generate the
+       *     masking key
+       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+       *     `data`
+       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+       *     key
        * @param {Number} options.opcode The opcode
        * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
        *     modified
+       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+       *     RSV1 bit
+       * @param {Function} [cb] Callback
+       * @private
+       */
+      getBlobData(blob, compress, options2, cb) {
+        this._bufferedBytes += options2[kByteLength];
+        this._state = GET_BLOB_DATA;
+        blob.arrayBuffer().then((arrayBuffer) => {
+          if (this._socket.destroyed) {
+            const err = new Error(
+              "The socket was closed while the blob was being read"
+            );
+            process.nextTick(callCallbacks, this, err, cb);
+            return;
+          }
+          this._bufferedBytes -= options2[kByteLength];
+          const data = toBuffer(arrayBuffer);
+          if (!compress) {
+            this._state = DEFAULT;
+            this.sendFrame(_Sender.frame(data, options2), cb);
+            this.dequeue();
+          } else {
+            this.dispatch(data, compress, options2, cb);
+          }
+        }).catch((err) => {
+          process.nextTick(onError, this, err, cb);
+        });
+      }
+      /**
+       * Dispatches a message.
+       *
+       * @param {(Buffer|String)} data The message to send
+       * @param {Boolean} [compress=false] Specifies whether or not to compress
+       *     `data`
+       * @param {Object} options Options object
        * @param {Boolean} [options.fin=false] Specifies whether or not to set the
        *     FIN bit
+       * @param {Function} [options.generateMask] The function used to generate the
+       *     masking key
        * @param {Boolean} [options.mask=false] Specifies whether or not to mask
        *     `data`
+       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+       *     key
+       * @param {Number} options.opcode The opcode
+       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+       *     modified
        * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
        *     RSV1 bit
        * @param {Function} [cb] Callback
@@ -41225,22 +42630,18 @@ var require_sender = __commonJS({
           return;
         }
         const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
-        this._bufferedBytes += data.length;
-        this._deflating = true;
+        this._bufferedBytes += options2[kByteLength];
+        this._state = DEFLATING;
         perMessageDeflate.compress(data, options2.fin, (_, buf) => {
           if (this._socket.destroyed) {
             const err = new Error(
               "The socket was closed while data was being compressed"
             );
-            if (typeof cb === "function") cb(err);
-            for (let i = 0; i < this._queue.length; i++) {
-              const callback = this._queue[i][4];
-              if (typeof callback === "function") callback(err);
-            }
+            callCallbacks(this, err, cb);
             return;
           }
-          this._bufferedBytes -= data.length;
-          this._deflating = false;
+          this._bufferedBytes -= options2[kByteLength];
+          this._state = DEFAULT;
           options2.readOnly = false;
           this.sendFrame(_Sender.frame(buf, options2), cb);
           this.dequeue();
@@ -41252,9 +42653,9 @@ var require_sender = __commonJS({
        * @private
        */
       dequeue() {
-        while (!this._deflating && this._queue.length) {
+        while (this._state === DEFAULT && this._queue.length) {
           const params = this._queue.shift();
-          this._bufferedBytes -= params[1].length;
+          this._bufferedBytes -= params[3][kByteLength];
           Reflect.apply(params[0], this, params.slice(1));
         }
       }
@@ -41265,13 +42666,13 @@ var require_sender = __commonJS({
        * @private
        */
       enqueue(params) {
-        this._bufferedBytes += params[1].length;
+        this._bufferedBytes += params[3][kByteLength];
         this._queue.push(params);
       }
       /**
        * Sends a frame.
        *
-       * @param {Buffer[]} list The frame to send
+       * @param {(Buffer | String)[]} list The frame to send
        * @param {Function} [cb] Callback
        * @private
        */
@@ -41287,6 +42688,18 @@ var require_sender = __commonJS({
       }
     };
     module2.exports = Sender;
+    function callCallbacks(sender, err, cb) {
+      if (typeof cb === "function") cb(err);
+      for (let i = 0; i < sender._queue.length; i++) {
+        const params = sender._queue[i];
+        const callback = params[params.length - 1];
+        if (typeof callback === "function") callback(err);
+      }
+    }
+    function onError(sender, err, cb) {
+      callCallbacks(sender, err, cb);
+      sender.onerror(err);
+    }
   }
 });
 
@@ -41294,136 +42707,228 @@ var require_sender = __commonJS({
 var require_event_target = __commonJS({
   "../../node_modules/ws/lib/event-target.js"(exports2, module2) {
     "use strict";
+    var { kForOnEventAttribute, kListener } = require_constants();
+    var kCode = Symbol("kCode");
+    var kData = Symbol("kData");
+    var kError = Symbol("kError");
+    var kMessage = Symbol("kMessage");
+    var kReason = Symbol("kReason");
+    var kTarget = Symbol("kTarget");
+    var kType = Symbol("kType");
+    var kWasClean = Symbol("kWasClean");
     var Event = class {
       /**
        * Create a new `Event`.
        *
        * @param {String} type The name of the event
-       * @param {Object} target A reference to the target to which the event was
-       *     dispatched
+       * @throws {TypeError} If the `type` argument is not specified
        */
-      constructor(type, target) {
-        this.target = target;
-        this.type = type;
+      constructor(type) {
+        this[kTarget] = null;
+        this[kType] = type;
       }
-    };
-    var MessageEvent = class extends Event {
       /**
-       * Create a new `MessageEvent`.
-       *
-       * @param {(String|Buffer|ArrayBuffer|Buffer[])} data The received data
-       * @param {WebSocket} target A reference to the target to which the event was
-       *     dispatched
+       * @type {*}
        */
-      constructor(data, target) {
-        super("message", target);
-        this.data = data;
+      get target() {
+        return this[kTarget];
+      }
+      /**
+       * @type {String}
+       */
+      get type() {
+        return this[kType];
       }
     };
+    Object.defineProperty(Event.prototype, "target", { enumerable: true });
+    Object.defineProperty(Event.prototype, "type", { enumerable: true });
     var CloseEvent = class extends Event {
       /**
        * Create a new `CloseEvent`.
        *
-       * @param {Number} code The status code explaining why the connection is being
-       *     closed
-       * @param {String} reason A human-readable string explaining why the
-       *     connection is closing
-       * @param {WebSocket} target A reference to the target to which the event was
-       *     dispatched
+       * @param {String} type The name of the event
+       * @param {Object} [options] A dictionary object that allows for setting
+       *     attributes via object members of the same name
+       * @param {Number} [options.code=0] The status code explaining why the
+       *     connection was closed
+       * @param {String} [options.reason=''] A human-readable string explaining why
+       *     the connection was closed
+       * @param {Boolean} [options.wasClean=false] Indicates whether or not the
+       *     connection was cleanly closed
        */
-      constructor(code, reason, target) {
-        super("close", target);
-        this.wasClean = target._closeFrameReceived && target._closeFrameSent;
-        this.reason = reason;
-        this.code = code;
+      constructor(type, options2 = {}) {
+        super(type);
+        this[kCode] = options2.code === void 0 ? 0 : options2.code;
+        this[kReason] = options2.reason === void 0 ? "" : options2.reason;
+        this[kWasClean] = options2.wasClean === void 0 ? false : options2.wasClean;
       }
-    };
-    var OpenEvent = class extends Event {
       /**
-       * Create a new `OpenEvent`.
-       *
-       * @param {WebSocket} target A reference to the target to which the event was
-       *     dispatched
+       * @type {Number}
+       */
+      get code() {
+        return this[kCode];
+      }
+      /**
+       * @type {String}
+       */
+      get reason() {
+        return this[kReason];
+      }
+      /**
+       * @type {Boolean}
        */
-      constructor(target) {
-        super("open", target);
+      get wasClean() {
+        return this[kWasClean];
       }
     };
+    Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
+    Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
+    Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
     var ErrorEvent = class extends Event {
       /**
        * Create a new `ErrorEvent`.
        *
-       * @param {Object} error The error that generated this event
-       * @param {WebSocket} target A reference to the target to which the event was
-       *     dispatched
+       * @param {String} type The name of the event
+       * @param {Object} [options] A dictionary object that allows for setting
+       *     attributes via object members of the same name
+       * @param {*} [options.error=null] The error that generated this event
+       * @param {String} [options.message=''] The error message
+       */
+      constructor(type, options2 = {}) {
+        super(type);
+        this[kError] = options2.error === void 0 ? null : options2.error;
+        this[kMessage] = options2.message === void 0 ? "" : options2.message;
+      }
+      /**
+       * @type {*}
+       */
+      get error() {
+        return this[kError];
+      }
+      /**
+       * @type {String}
+       */
+      get message() {
+        return this[kMessage];
+      }
+    };
+    Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true });
+    Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true });
+    var MessageEvent = class extends Event {
+      /**
+       * Create a new `MessageEvent`.
+       *
+       * @param {String} type The name of the event
+       * @param {Object} [options] A dictionary object that allows for setting
+       *     attributes via object members of the same name
+       * @param {*} [options.data=null] The message content
        */
-      constructor(error, target) {
-        super("error", target);
-        this.message = error.message;
-        this.error = error;
+      constructor(type, options2 = {}) {
+        super(type);
+        this[kData] = options2.data === void 0 ? null : options2.data;
+      }
+      /**
+       * @type {*}
+       */
+      get data() {
+        return this[kData];
       }
     };
+    Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
     var EventTarget = {
       /**
        * Register an event listener.
        *
        * @param {String} type A string representing the event type to listen for
-       * @param {Function} listener The listener to add
+       * @param {(Function|Object)} handler The listener to add
        * @param {Object} [options] An options object specifies characteristics about
        *     the event listener
-       * @param {Boolean} [options.once=false] A `Boolean`` indicating that the
+       * @param {Boolean} [options.once=false] A `Boolean` indicating that the
        *     listener should be invoked at most once after being added. If `true`,
        *     the listener would be automatically removed when invoked.
        * @public
        */
-      addEventListener(type, listener, options2) {
-        if (typeof listener !== "function") return;
-        function onMessage(data) {
-          listener.call(this, new MessageEvent(data, this));
-        }
-        function onClose(code, message) {
-          listener.call(this, new CloseEvent(code, message, this));
-        }
-        function onError(error) {
-          listener.call(this, new ErrorEvent(error, this));
-        }
-        function onOpen() {
-          listener.call(this, new OpenEvent(this));
+      addEventListener(type, handler, options2 = {}) {
+        for (const listener of this.listeners(type)) {
+          if (!options2[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+            return;
+          }
         }
-        const method = options2 && options2.once ? "once" : "on";
+        let wrapper;
         if (type === "message") {
-          onMessage._listener = listener;
-          this[method](type, onMessage);
+          wrapper = function onMessage(data, isBinary) {
+            const event = new MessageEvent("message", {
+              data: isBinary ? data : data.toString()
+            });
+            event[kTarget] = this;
+            callListener(handler, this, event);
+          };
         } else if (type === "close") {
-          onClose._listener = listener;
-          this[method](type, onClose);
+          wrapper = function onClose(code, message) {
+            const event = new CloseEvent("close", {
+              code,
+              reason: message.toString(),
+              wasClean: this._closeFrameReceived && this._closeFrameSent
+            });
+            event[kTarget] = this;
+            callListener(handler, this, event);
+          };
         } else if (type === "error") {
-          onError._listener = listener;
-          this[method](type, onError);
+          wrapper = function onError(error) {
+            const event = new ErrorEvent("error", {
+              error,
+              message: error.message
+            });
+            event[kTarget] = this;
+            callListener(handler, this, event);
+          };
         } else if (type === "open") {
-          onOpen._listener = listener;
-          this[method](type, onOpen);
+          wrapper = function onOpen() {
+            const event = new Event("open");
+            event[kTarget] = this;
+            callListener(handler, this, event);
+          };
         } else {
-          this[method](type, listener);
+          return;
+        }
+        wrapper[kForOnEventAttribute] = !!options2[kForOnEventAttribute];
+        wrapper[kListener] = handler;
+        if (options2.once) {
+          this.once(type, wrapper);
+        } else {
+          this.on(type, wrapper);
         }
       },
       /**
        * Remove an event listener.
        *
        * @param {String} type A string representing the event type to remove
-       * @param {Function} listener The listener to remove
+       * @param {(Function|Object)} handler The listener to remove
        * @public
        */
-      removeEventListener(type, listener) {
-        const listeners = this.listeners(type);
-        for (let i = 0; i < listeners.length; i++) {
-          if (listeners[i] === listener || listeners[i]._listener === listener) {
-            this.removeListener(type, listeners[i]);
+      removeEventListener(type, handler) {
+        for (const listener of this.listeners(type)) {
+          if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+            this.removeListener(type, listener);
+            break;
           }
         }
       }
     };
-    module2.exports = EventTarget;
+    module2.exports = {
+      CloseEvent,
+      ErrorEvent,
+      Event,
+      EventTarget,
+      MessageEvent
+    };
+    function callListener(listener, thisArg, event) {
+      if (typeof listener === "object" && listener.handleEvent) {
+        listener.handleEvent.call(listener, event);
+      } else {
+        listener.call(thisArg, event);
+      }
+    }
   }
 });
 
@@ -41431,151 +42936,13 @@ var require_event_target = __commonJS({
 var require_extension = __commonJS({
   "../../node_modules/ws/lib/extension.js"(exports2, module2) {
     "use strict";
-    var tokenChars = [
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 0 - 15
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 16 - 31
-      0,
-      1,
-      0,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      1,
-      1,
-      0,
-      1,
-      1,
-      0,
-      // 32 - 47
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 48 - 63
-      0,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      // 64 - 79
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      0,
-      1,
-      1,
-      // 80 - 95
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      // 96 - 111
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      1,
-      0,
-      1,
-      0
-      // 112 - 127
-    ];
+    var { tokenChars } = require_validation();
     function push(dest, name, elem) {
       if (dest[name] === void 0) dest[name] = [elem];
       else dest[name].push(elem);
     }
     function parse2(header) {
       const offers = /* @__PURE__ */ Object.create(null);
-      if (header === void 0 || header === "") return offers;
       let params = /* @__PURE__ */ Object.create(null);
       let mustUnescape = false;
       let isEscaping = false;
@@ -41583,14 +42950,15 @@ var require_extension = __commonJS({
       let extensionName;
       let paramName;
       let start = -1;
+      let code = -1;
       let end = -1;
       let i = 0;
       for (; i < header.length; i++) {
-        const code = header.charCodeAt(i);
+        code = header.charCodeAt(i);
         if (extensionName === void 0) {
           if (end === -1 && tokenChars[code] === 1) {
             if (start === -1) start = i;
-          } else if (code === 32 || code === 9) {
+          } else if (i !== 0 && (code === 32 || code === 9)) {
             if (end === -1 && start !== -1) end = i;
           } else if (code === 59 || code === 44) {
             if (start === -1) {
@@ -41679,7 +43047,7 @@ var require_extension = __commonJS({
           }
         }
       }
-      if (start === -1 || inQuotes) {
+      if (start === -1 || inQuotes || code === 32 || code === 9) {
         throw new SyntaxError("Unexpected end of input");
       }
       if (end === -1) end = i;
@@ -41727,25 +43095,32 @@ var require_websocket = __commonJS({
     var net = require("net");
     var tls = require("tls");
     var { randomBytes, createHash } = require("crypto");
-    var { Readable } = require("stream");
+    var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate = require_permessage_deflate();
     var Receiver = require_receiver();
     var Sender = require_sender();
+    var { isBlob } = require_validation();
     var {
       BINARY_TYPES,
       EMPTY_BUFFER,
       GUID,
+      kForOnEventAttribute,
+      kListener,
       kStatusCode,
       kWebSocket,
       NOOP
     } = require_constants();
-    var { addEventListener, removeEventListener } = require_event_target();
+    var {
+      EventTarget: { addEventListener, removeEventListener }
+    } = require_event_target();
     var { format: format2, parse: parse2 } = require_extension();
     var { toBuffer } = require_buffer_util();
-    var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
-    var protocolVersions = [8, 13];
     var closeTimeout = 30 * 1e3;
+    var kAborted = Symbol("kAborted");
+    var protocolVersions = [8, 13];
+    var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+    var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
     var WebSocket = class _WebSocket extends EventEmitter2 {
       /**
        * Create a new `WebSocket`.
@@ -41760,9 +43135,11 @@ var require_websocket = __commonJS({
         this._closeCode = 1006;
         this._closeFrameReceived = false;
         this._closeFrameSent = false;
-        this._closeMessage = "";
+        this._closeMessage = EMPTY_BUFFER;
         this._closeTimer = null;
+        this._errorEmitted = false;
         this._extensions = {};
+        this._paused = false;
         this._protocol = "";
         this._readyState = _WebSocket.CONNECTING;
         this._receiver = null;
@@ -41772,21 +43149,25 @@ var require_websocket = __commonJS({
           this._bufferedAmount = 0;
           this._isServer = false;
           this._redirects = 0;
-          if (Array.isArray(protocols)) {
-            protocols = protocols.join(", ");
-          } else if (typeof protocols === "object" && protocols !== null) {
-            options2 = protocols;
-            protocols = void 0;
+          if (protocols === void 0) {
+            protocols = [];
+          } else if (!Array.isArray(protocols)) {
+            if (typeof protocols === "object" && protocols !== null) {
+              options2 = protocols;
+              protocols = [];
+            } else {
+              protocols = [protocols];
+            }
           }
           initAsClient(this, address, protocols, options2);
         } else {
+          this._autoPong = options2.autoPong;
           this._isServer = true;
         }
       }
       /**
-       * This deviates from the WHATWG interface since ws doesn't support the
-       * required default "blob" type (instead we define a custom "nodebuffer"
-       * type).
+       * For historical reasons, the custom "nodebuffer" type is used by the default
+       * instead of "blob".
        *
        * @type {String}
        */
@@ -41811,45 +43192,39 @@ var require_websocket = __commonJS({
       get extensions() {
         return Object.keys(this._extensions).join();
       }
+      /**
+       * @type {Boolean}
+       */
+      get isPaused() {
+        return this._paused;
+      }
       /**
        * @type {Function}
        */
       /* istanbul ignore next */
       get onclose() {
-        return void 0;
-      }
-      /* istanbul ignore next */
-      set onclose(listener) {
+        return null;
       }
       /**
        * @type {Function}
        */
       /* istanbul ignore next */
       get onerror() {
-        return void 0;
-      }
-      /* istanbul ignore next */
-      set onerror(listener) {
+        return null;
       }
       /**
        * @type {Function}
        */
       /* istanbul ignore next */
       get onopen() {
-        return void 0;
-      }
-      /* istanbul ignore next */
-      set onopen(listener) {
+        return null;
       }
       /**
        * @type {Function}
        */
       /* istanbul ignore next */
       get onmessage() {
-        return void 0;
-      }
-      /* istanbul ignore next */
-      set onmessage(listener) {
+        return null;
       }
       /**
        * @type {String}
@@ -41872,23 +43247,34 @@ var require_websocket = __commonJS({
       /**
        * Set up the socket and the internal resources.
        *
-       * @param {(net.Socket|tls.Socket)} socket The network socket between the
-       *     server and client
+       * @param {Duplex} socket The network socket between the server and client
        * @param {Buffer} head The first packet of the upgraded stream
-       * @param {Number} [maxPayload=0] The maximum allowed message size
+       * @param {Object} options Options object
+       * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
+       *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+       *     multiple times in the same tick
+       * @param {Function} [options.generateMask] The function used to generate the
+       *     masking key
+       * @param {Number} [options.maxPayload=0] The maximum allowed message size
+       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+       *     not to skip UTF-8 validation for text and close messages
        * @private
        */
-      setSocket(socket, head, maxPayload) {
-        const receiver = new Receiver(
-          this.binaryType,
-          this._extensions,
-          this._isServer,
-          maxPayload
-        );
-        this._sender = new Sender(socket, this._extensions);
+      setSocket(socket, head, options2) {
+        const receiver = new Receiver({
+          allowSynchronousEvents: options2.allowSynchronousEvents,
+          binaryType: this.binaryType,
+          extensions: this._extensions,
+          isServer: this._isServer,
+          maxPayload: options2.maxPayload,
+          skipUTF8Validation: options2.skipUTF8Validation
+        });
+        const sender = new Sender(socket, this._extensions, options2.generateMask);
         this._receiver = receiver;
+        this._sender = sender;
         this._socket = socket;
         receiver[kWebSocket] = this;
+        sender[kWebSocket] = this;
         socket[kWebSocket] = this;
         receiver.on("conclude", receiverOnConclude);
         receiver.on("drain", receiverOnDrain);
@@ -41896,8 +43282,9 @@ var require_websocket = __commonJS({
         receiver.on("message", receiverOnMessage);
         receiver.on("ping", receiverOnPing);
         receiver.on("pong", receiverOnPong);
-        socket.setTimeout(0);
-        socket.setNoDelay();
+        sender.onerror = senderOnError;
+        if (socket.setTimeout) socket.setTimeout(0);
+        if (socket.setNoDelay) socket.setNoDelay();
         if (head.length > 0) socket.unshift(head);
         socket.on("close", socketOnClose);
         socket.on("data", socketOnData);
@@ -41940,14 +43327,16 @@ var require_websocket = __commonJS({
        *              +---+
        *
        * @param {Number} [code] Status code explaining why the connection is closing
-       * @param {String} [data] A string explaining why the connection is closing
+       * @param {(String|Buffer)} [data] The reason why the connection is
+       *     closing
        * @public
        */
       close(code, data) {
         if (this.readyState === _WebSocket.CLOSED) return;
         if (this.readyState === _WebSocket.CONNECTING) {
           const msg = "WebSocket was closed before the connection was established";
-          return abortHandshake(this, this._req, msg);
+          abortHandshake(this, this._req, msg);
+          return;
         }
         if (this.readyState === _WebSocket.CLOSING) {
           if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
@@ -41963,10 +43352,19 @@ var require_websocket = __commonJS({
             this._socket.end();
           }
         });
-        this._closeTimer = setTimeout(
-          this._socket.destroy.bind(this._socket),
-          closeTimeout
-        );
+        setCloseTimer(this);
+      }
+      /**
+       * Pause the socket.
+       *
+       * @public
+       */
+      pause() {
+        if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
+          return;
+        }
+        this._paused = true;
+        this._socket.pause();
       }
       /**
        * Send a ping.
@@ -42022,15 +43420,27 @@ var require_websocket = __commonJS({
         if (mask === void 0) mask = !this._isServer;
         this._sender.pong(data || EMPTY_BUFFER, mask, cb);
       }
+      /**
+       * Resume the socket.
+       *
+       * @public
+       */
+      resume() {
+        if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
+          return;
+        }
+        this._paused = false;
+        if (!this._receiver._writableState.needDrain) this._socket.resume();
+      }
       /**
        * Send a data message.
        *
        * @param {*} data The message to send
        * @param {Object} [options] Options object
-       * @param {Boolean} [options.compress] Specifies whether or not to compress
-       *     `data`
        * @param {Boolean} [options.binary] Specifies whether `data` is binary or
        *     text
+       * @param {Boolean} [options.compress] Specifies whether or not to compress
+       *     `data`
        * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
        *     last one
        * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
@@ -42071,7 +43481,8 @@ var require_websocket = __commonJS({
         if (this.readyState === _WebSocket.CLOSED) return;
         if (this.readyState === _WebSocket.CONNECTING) {
           const msg = "WebSocket was closed before the connection was established";
-          return abortHandshake(this, this._req, msg);
+          abortHandshake(this, this._req, msg);
+          return;
         }
         if (this._socket) {
           this._readyState = _WebSocket.CLOSING;
@@ -42115,6 +43526,7 @@ var require_websocket = __commonJS({
       "binaryType",
       "bufferedAmount",
       "extensions",
+      "isPaused",
       "protocol",
       "readyState",
       "url"
@@ -42125,18 +43537,22 @@ var require_websocket = __commonJS({
       Object.defineProperty(WebSocket.prototype, `on${method}`, {
         enumerable: true,
         get() {
-          const listeners = this.listeners(method);
-          for (let i = 0; i < listeners.length; i++) {
-            if (listeners[i]._listener) return listeners[i]._listener;
+          for (const listener of this.listeners(method)) {
+            if (listener[kForOnEventAttribute]) return listener[kListener];
           }
-          return void 0;
+          return null;
         },
-        set(listener) {
-          const listeners = this.listeners(method);
-          for (let i = 0; i < listeners.length; i++) {
-            if (listeners[i]._listener) this.removeListener(method, listeners[i]);
+        set(handler) {
+          for (const listener of this.listeners(method)) {
+            if (listener[kForOnEventAttribute]) {
+              this.removeListener(method, listener);
+              break;
+            }
           }
-          this.addEventListener(method, listener);
+          if (typeof handler !== "function") return;
+          this.addEventListener(method, handler, {
+            [kForOnEventAttribute]: true
+          });
         }
       });
     });
@@ -42145,22 +43561,25 @@ var require_websocket = __commonJS({
     module2.exports = WebSocket;
     function initAsClient(websocket, address, protocols, options2) {
       const opts = {
+        allowSynchronousEvents: true,
+        autoPong: true,
         protocolVersion: protocolVersions[1],
         maxPayload: 100 * 1024 * 1024,
+        skipUTF8Validation: false,
         perMessageDeflate: true,
         followRedirects: false,
         maxRedirects: 10,
         ...options2,
-        createConnection: void 0,
         socketPath: void 0,
         hostname: void 0,
         protocol: void 0,
         timeout: void 0,
-        method: void 0,
+        method: "GET",
         host: void 0,
         path: void 0,
         port: void 0
       };
+      websocket._autoPong = opts.autoPong;
       if (!protocolVersions.includes(opts.protocolVersion)) {
         throw new RangeError(
           `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
@@ -42169,14 +43588,31 @@ var require_websocket = __commonJS({
       let parsedUrl;
       if (address instanceof URL2) {
         parsedUrl = address;
-        websocket._url = address.href;
       } else {
-        parsedUrl = new URL2(address);
-        websocket._url = address;
-      }
-      const isUnixSocket = parsedUrl.protocol === "ws+unix:";
-      if (!parsedUrl.host && (!isUnixSocket || !parsedUrl.pathname)) {
-        const err = new Error(`Invalid URL: ${websocket.url}`);
+        try {
+          parsedUrl = new URL2(address);
+        } catch (e) {
+          throw new SyntaxError(`Invalid URL: ${address}`);
+        }
+      }
+      if (parsedUrl.protocol === "http:") {
+        parsedUrl.protocol = "ws:";
+      } else if (parsedUrl.protocol === "https:") {
+        parsedUrl.protocol = "wss:";
+      }
+      websocket._url = parsedUrl.href;
+      const isSecure = parsedUrl.protocol === "wss:";
+      const isIpcUrl = parsedUrl.protocol === "ws+unix:";
+      let invalidUrlMessage;
+      if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
+        invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https:", or "ws+unix:"`;
+      } else if (isIpcUrl && !parsedUrl.pathname) {
+        invalidUrlMessage = "The URL's pathname is empty";
+      } else if (parsedUrl.hash) {
+        invalidUrlMessage = "The URL contains a fragment identifier";
+      }
+      if (invalidUrlMessage) {
+        const err = new SyntaxError(invalidUrlMessage);
         if (websocket._redirects === 0) {
           throw err;
         } else {
@@ -42184,21 +43620,21 @@ var require_websocket = __commonJS({
           return;
         }
       }
-      const isSecure = parsedUrl.protocol === "wss:" || parsedUrl.protocol === "https:";
       const defaultPort = isSecure ? 443 : 80;
       const key = randomBytes(16).toString("base64");
-      const get2 = isSecure ? https.get : http.get;
+      const request = isSecure ? https.request : http.request;
+      const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
-      opts.createConnection = isSecure ? tlsConnect : netConnect;
+      opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
       opts.defaultPort = opts.defaultPort || defaultPort;
       opts.port = parsedUrl.port || defaultPort;
       opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
       opts.headers = {
+        ...opts.headers,
         "Sec-WebSocket-Version": opts.protocolVersion,
         "Sec-WebSocket-Key": key,
         Connection: "Upgrade",
-        Upgrade: "websocket",
-        ...opts.headers
+        Upgrade: "websocket"
       };
       opts.path = parsedUrl.pathname + parsedUrl.search;
       opts.timeout = opts.handshakeTimeout;
@@ -42212,8 +43648,16 @@ var require_websocket = __commonJS({
           [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
         });
       }
-      if (protocols) {
-        opts.headers["Sec-WebSocket-Protocol"] = protocols;
+      if (protocols.length) {
+        for (const protocol of protocols) {
+          if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) {
+            throw new SyntaxError(
+              "An invalid or duplicated subprotocol was specified"
+            );
+          }
+          protocolSet.add(protocol);
+        }
+        opts.headers["Sec-WebSocket-Protocol"] = protocols.join(",");
       }
       if (opts.origin) {
         if (opts.protocolVersion < 13) {
@@ -42225,16 +43669,17 @@ var require_websocket = __commonJS({
       if (parsedUrl.username || parsedUrl.password) {
         opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
       }
-      if (isUnixSocket) {
+      if (isIpcUrl) {
         const parts = opts.path.split(":");
         opts.socketPath = parts[0];
         opts.path = parts[1];
       }
+      let req;
       if (opts.followRedirects) {
         if (websocket._redirects === 0) {
-          websocket._originalUnixSocket = isUnixSocket;
+          websocket._originalIpc = isIpcUrl;
           websocket._originalSecure = isSecure;
-          websocket._originalHostOrSocketPath = isUnixSocket ? opts.socketPath : parsedUrl.host;
+          websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host;
           const headers = options2 && options2.headers;
           options2 = { ...options2, headers: {} };
           if (headers) {
@@ -42242,8 +43687,8 @@ var require_websocket = __commonJS({
               options2.headers[key2.toLowerCase()] = value;
             }
           }
-        } else {
-          const isSameHost = isUnixSocket ? websocket._originalUnixSocket ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalUnixSocket ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
+        } else if (websocket.listenerCount("redirect") === 0) {
+          const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
           if (!isSameHost || websocket._originalSecure && !isSecure) {
             delete opts.headers.authorization;
             delete opts.headers.cookie;
@@ -42254,15 +43699,20 @@ var require_websocket = __commonJS({
         if (opts.auth && !options2.headers.authorization) {
           options2.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
         }
+        req = websocket._req = request(opts);
+        if (websocket._redirects) {
+          websocket.emit("redirect", websocket.url, req);
+        }
+      } else {
+        req = websocket._req = request(opts);
       }
-      let req = websocket._req = get2(opts);
       if (opts.timeout) {
         req.on("timeout", () => {
           abortHandshake(websocket, req, "Opening handshake has timed out");
         });
       }
       req.on("error", (err) => {
-        if (req === null || req.aborted) return;
+        if (req === null || req[kAborted]) return;
         req = websocket._req = null;
         emitErrorAndClose(websocket, err);
       });
@@ -42278,7 +43728,8 @@ var require_websocket = __commonJS({
           let addr;
           try {
             addr = new URL2(location, address);
-          } catch (err) {
+          } catch (e) {
+            const err = new SyntaxError(`Invalid URL: ${location}`);
             emitErrorAndClose(websocket, err);
             return;
           }
@@ -42306,14 +43757,15 @@ var require_websocket = __commonJS({
           return;
         }
         const serverProt = res.headers["sec-websocket-protocol"];
-        const protList = (protocols || "").split(/, */);
         let protError;
-        if (!protocols && serverProt) {
-          protError = "Server sent a subprotocol but none was requested";
-        } else if (protocols && !serverProt) {
+        if (serverProt !== void 0) {
+          if (!protocolSet.size) {
+            protError = "Server sent a subprotocol but none was requested";
+          } else if (!protocolSet.has(serverProt)) {
+            protError = "Server sent an invalid subprotocol";
+          }
+        } else if (protocolSet.size) {
           protError = "Server sent no subprotocol";
-        } else if (serverProt && !protList.includes(serverProt)) {
-          protError = "Server sent an invalid subprotocol";
         }
         if (protError) {
           abortHandshake(websocket, socket, protError);
@@ -42336,27 +43788,36 @@ var require_websocket = __commonJS({
             return;
           }
           const extensionNames = Object.keys(extensions);
-          if (extensionNames.length) {
-            if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
-              const message = "Server indicated an extension that was not requested";
-              abortHandshake(websocket, socket, message);
-              return;
-            }
-            try {
-              perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
-            } catch (err) {
-              const message = "Invalid Sec-WebSocket-Extensions header";
-              abortHandshake(websocket, socket, message);
-              return;
-            }
-            websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+          if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
+            const message = "Server indicated an extension that was not requested";
+            abortHandshake(websocket, socket, message);
+            return;
+          }
+          try {
+            perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+          } catch (err) {
+            const message = "Invalid Sec-WebSocket-Extensions header";
+            abortHandshake(websocket, socket, message);
+            return;
           }
+          websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
         }
-        websocket.setSocket(socket, head, opts.maxPayload);
+        websocket.setSocket(socket, head, {
+          allowSynchronousEvents: opts.allowSynchronousEvents,
+          generateMask: opts.generateMask,
+          maxPayload: opts.maxPayload,
+          skipUTF8Validation: opts.skipUTF8Validation
+        });
       });
+      if (opts.finishRequest) {
+        opts.finishRequest(req, websocket);
+      } else {
+        req.end();
+      }
     }
     function emitErrorAndClose(websocket, err) {
       websocket._readyState = WebSocket.CLOSING;
+      websocket._errorEmitted = true;
       websocket.emit("error", err);
       websocket.emitClose();
     }
@@ -42376,12 +43837,12 @@ var require_websocket = __commonJS({
       const err = new Error(message);
       Error.captureStackTrace(err, abortHandshake);
       if (stream.setHeader) {
+        stream[kAborted] = true;
         stream.abort();
         if (stream.socket && !stream.socket.destroyed) {
           stream.socket.destroy();
         }
-        stream.once("abort", websocket.emitClose.bind(websocket));
-        websocket.emit("error", err);
+        process.nextTick(emitErrorAndClose, websocket, err);
       } else {
         stream.destroy(err);
         stream.once("error", websocket.emit.bind(websocket, "error"));
@@ -42390,7 +43851,7 @@ var require_websocket = __commonJS({
     }
     function sendAfterClose(websocket, data, cb) {
       if (data) {
-        const length = toBuffer(data).length;
+        const length = isBlob(data) ? data.size : toBuffer(data).length;
         if (websocket._socket) websocket._sender._bufferedBytes += length;
         else websocket._bufferedAmount += length;
       }
@@ -42398,7 +43859,7 @@ var require_websocket = __commonJS({
         const err = new Error(
           `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`
         );
-        cb(err);
+        process.nextTick(cb, err);
       }
     }
     function receiverOnConclude(code, reason) {
@@ -42413,7 +43874,8 @@ var require_websocket = __commonJS({
       else websocket.close(code, reason);
     }
     function receiverOnDrain() {
-      this[kWebSocket]._socket.resume();
+      const websocket = this[kWebSocket];
+      if (!websocket.isPaused) websocket._socket.resume();
     }
     function receiverOnError(err) {
       const websocket = this[kWebSocket];
@@ -42422,17 +43884,20 @@ var require_websocket = __commonJS({
         process.nextTick(resume, websocket._socket);
         websocket.close(err[kStatusCode]);
       }
-      websocket.emit("error", err);
+      if (!websocket._errorEmitted) {
+        websocket._errorEmitted = true;
+        websocket.emit("error", err);
+      }
     }
     function receiverOnFinish() {
       this[kWebSocket].emitClose();
     }
-    function receiverOnMessage(data) {
-      this[kWebSocket].emit("message", data);
+    function receiverOnMessage(data, isBinary) {
+      this[kWebSocket].emit("message", data, isBinary);
     }
     function receiverOnPing(data) {
       const websocket = this[kWebSocket];
-      websocket.pong(data, !websocket._isServer, NOOP);
+      if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
       websocket.emit("ping", data);
     }
     function receiverOnPong(data) {
@@ -42441,6 +43906,25 @@ var require_websocket = __commonJS({
     function resume(stream) {
       stream.resume();
     }
+    function senderOnError(err) {
+      const websocket = this[kWebSocket];
+      if (websocket.readyState === WebSocket.CLOSED) return;
+      if (websocket.readyState === WebSocket.OPEN) {
+        websocket._readyState = WebSocket.CLOSING;
+        setCloseTimer(websocket);
+      }
+      this._socket.end();
+      if (!websocket._errorEmitted) {
+        websocket._errorEmitted = true;
+        websocket.emit("error", err);
+      }
+    }
+    function setCloseTimer(websocket) {
+      websocket._closeTimer = setTimeout(
+        websocket._socket.destroy.bind(websocket._socket),
+        closeTimeout
+      );
+    }
     function socketOnClose() {
       const websocket = this[kWebSocket];
       this.removeListener("close", socketOnClose);
@@ -42488,6 +43972,7 @@ var require_websocket = __commonJS({
 var require_stream4 = __commonJS({
   "../../node_modules/ws/lib/stream.js"(exports2, module2) {
     "use strict";
+    var WebSocket = require_websocket();
     var { Duplex } = require("stream");
     function emitClose(stream) {
       stream.emit("close");
@@ -42505,20 +43990,7 @@ var require_stream4 = __commonJS({
       }
     }
     function createWebSocketStream(ws, options2) {
-      let resumeOnReceiverDrain = true;
       let terminateOnDestroy = true;
-      function receiverOnDrain() {
-        if (resumeOnReceiverDrain) ws._socket.resume();
-      }
-      if (ws.readyState === ws.CONNECTING) {
-        ws.once("open", function open() {
-          ws._receiver.removeAllListeners("drain");
-          ws._receiver.on("drain", receiverOnDrain);
-        });
-      } else {
-        ws._receiver.removeAllListeners("drain");
-        ws._receiver.on("drain", receiverOnDrain);
-      }
       const duplex = new Duplex({
         ...options2,
         autoDestroy: false,
@@ -42526,11 +43998,9 @@ var require_stream4 = __commonJS({
         objectMode: false,
         writableObjectMode: false
       });
-      ws.on("message", function message(msg) {
-        if (!duplex.push(msg)) {
-          resumeOnReceiverDrain = false;
-          ws._socket.pause();
-        }
+      ws.on("message", function message(msg, isBinary) {
+        const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+        if (!duplex.push(data)) ws.pause();
       });
       ws.once("error", function error(err) {
         if (duplex.destroyed) return;
@@ -42577,10 +44047,7 @@ var require_stream4 = __commonJS({
         }
       };
       duplex._read = function() {
-        if ((ws.readyState === ws.OPEN || ws.readyState === ws.CLOSING) && !resumeOnReceiverDrain) {
-          resumeOnReceiverDrain = true;
-          if (!ws._receiver._writableState.needDrain) ws._socket.resume();
-        }
+        if (ws.isPaused) ws.resume();
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
@@ -42599,19 +44066,63 @@ var require_stream4 = __commonJS({
   }
 });
 
+// ../../node_modules/ws/lib/subprotocol.js
+var require_subprotocol = __commonJS({
+  "../../node_modules/ws/lib/subprotocol.js"(exports2, module2) {
+    "use strict";
+    var { tokenChars } = require_validation();
+    function parse2(header) {
+      const protocols = /* @__PURE__ */ new Set();
+      let start = -1;
+      let end = -1;
+      let i = 0;
+      for (i; i < header.length; i++) {
+        const code = header.charCodeAt(i);
+        if (end === -1 && tokenChars[code] === 1) {
+          if (start === -1) start = i;
+        } else if (i !== 0 && (code === 32 || code === 9)) {
+          if (end === -1 && start !== -1) end = i;
+        } else if (code === 44) {
+          if (start === -1) {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+          if (end === -1) end = i;
+          const protocol2 = header.slice(start, end);
+          if (protocols.has(protocol2)) {
+            throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`);
+          }
+          protocols.add(protocol2);
+          start = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      }
+      if (start === -1 || end !== -1) {
+        throw new SyntaxError("Unexpected end of input");
+      }
+      const protocol = header.slice(start, i);
+      if (protocols.has(protocol)) {
+        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+      }
+      protocols.add(protocol);
+      return protocols;
+    }
+    module2.exports = { parse: parse2 };
+  }
+});
+
 // ../../node_modules/ws/lib/websocket-server.js
 var require_websocket_server = __commonJS({
   "../../node_modules/ws/lib/websocket-server.js"(exports2, module2) {
     "use strict";
     var EventEmitter2 = require("events");
     var http = require("http");
-    var https = require("https");
-    var net = require("net");
-    var tls = require("tls");
+    var { Duplex } = require("stream");
     var { createHash } = require("crypto");
+    var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
+    var subprotocol = require_subprotocol();
     var WebSocket = require_websocket();
-    var { format: format2, parse: parse2 } = require_extension();
     var { GUID, kWebSocket } = require_constants();
     var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
     var RUNNING = 0;
@@ -42622,6 +44133,11 @@ var require_websocket_server = __commonJS({
        * Create a `WebSocketServer` instance.
        *
        * @param {Object} options Configuration options
+       * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+       *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+       *     multiple times in the same tick
+       * @param {Boolean} [options.autoPong=true] Specifies whether or not to
+       *     automatically send a pong in response to a ping
        * @param {Number} [options.backlog=511] The maximum length of the queue of
        *     pending connections
        * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
@@ -42637,13 +44153,20 @@ var require_websocket_server = __commonJS({
        * @param {Number} [options.port] The port where to bind the server
        * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
        *     server to use
+       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+       *     not to skip UTF-8 validation for text and close messages
        * @param {Function} [options.verifyClient] A hook to reject connections
+       * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
+       *     class to use. It must be the `WebSocket` class or class that extends it
        * @param {Function} [callback] A listener for the `listening` event
        */
       constructor(options2, callback) {
         super();
         options2 = {
+          allowSynchronousEvents: true,
+          autoPong: true,
           maxPayload: 100 * 1024 * 1024,
+          skipUTF8Validation: false,
           perMessageDeflate: false,
           handleProtocols: null,
           clientTracking: true,
@@ -42655,6 +44178,7 @@ var require_websocket_server = __commonJS({
           host: null,
           path: null,
           port: null,
+          WebSocket,
           ...options2
         };
         if (options2.port == null && !options2.server && !options2.noServer || options2.port != null && (options2.server || options2.noServer) || options2.server && options2.noServer) {
@@ -42691,7 +44215,10 @@ var require_websocket_server = __commonJS({
           });
         }
         if (options2.perMessageDeflate === true) options2.perMessageDeflate = {};
-        if (options2.clientTracking) this.clients = /* @__PURE__ */ new Set();
+        if (options2.clientTracking) {
+          this.clients = /* @__PURE__ */ new Set();
+          this._shouldEmitClose = false;
+        }
         this.options = options2;
         this._state = RUNNING;
       }
@@ -42712,32 +44239,47 @@ var require_websocket_server = __commonJS({
         return this._server.address();
       }
       /**
-       * Close the server.
+       * Stop the server from accepting new connections and emit the `'close'` event
+       * when all existing connections are closed.
        *
-       * @param {Function} [cb] Callback
+       * @param {Function} [cb] A one-time listener for the `'close'` event
        * @public
        */
       close(cb) {
-        if (cb) this.once("close", cb);
         if (this._state === CLOSED) {
+          if (cb) {
+            this.once("close", () => {
+              cb(new Error("The server is not running"));
+            });
+          }
           process.nextTick(emitClose, this);
           return;
         }
+        if (cb) this.once("close", cb);
         if (this._state === CLOSING) return;
         this._state = CLOSING;
-        if (this.clients) {
-          for (const client of this.clients) client.terminate();
-        }
-        const server = this._server;
-        if (server) {
+        if (this.options.noServer || this.options.server) {
+          if (this._server) {
+            this._removeListeners();
+            this._removeListeners = this._server = null;
+          }
+          if (this.clients) {
+            if (!this.clients.size) {
+              process.nextTick(emitClose, this);
+            } else {
+              this._shouldEmitClose = true;
+            }
+          } else {
+            process.nextTick(emitClose, this);
+          }
+        } else {
+          const server = this._server;
           this._removeListeners();
           this._removeListeners = this._server = null;
-          if (this.options.port != null) {
-            server.close(emitClose.bind(void 0, this));
-            return;
-          }
+          server.close(() => {
+            emitClose(this);
+          });
         }
-        process.nextTick(emitClose, this);
       }
       /**
        * See if a given request should be handled by this server instance.
@@ -42758,35 +44300,71 @@ var require_websocket_server = __commonJS({
        * Handle a HTTP Upgrade request.
        *
        * @param {http.IncomingMessage} req The request object
-       * @param {(net.Socket|tls.Socket)} socket The network socket between the
-       *     server and client
+       * @param {Duplex} socket The network socket between the server and client
        * @param {Buffer} head The first packet of the upgraded stream
        * @param {Function} cb Callback
        * @public
        */
       handleUpgrade(req, socket, head, cb) {
         socket.on("error", socketOnError);
-        const key = req.headers["sec-websocket-key"] !== void 0 ? req.headers["sec-websocket-key"].trim() : false;
+        const key = req.headers["sec-websocket-key"];
         const upgrade = req.headers.upgrade;
         const version = +req.headers["sec-websocket-version"];
-        const extensions = {};
-        if (req.method !== "GET" || upgrade === void 0 || upgrade.toLowerCase() !== "websocket" || !key || !keyRegex.test(key) || version !== 8 && version !== 13 || !this.shouldHandle(req)) {
-          return abortHandshake(socket, 400);
+        if (req.method !== "GET") {
+          const message = "Invalid HTTP method";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+          return;
+        }
+        if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
+          const message = "Invalid Upgrade header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+          return;
         }
-        if (this.options.perMessageDeflate) {
+        if (key === void 0 || !keyRegex.test(key)) {
+          const message = "Missing or invalid Sec-WebSocket-Key header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+          return;
+        }
+        if (version !== 13 && version !== 8) {
+          const message = "Missing or invalid Sec-WebSocket-Version header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
+            "Sec-WebSocket-Version": "13, 8"
+          });
+          return;
+        }
+        if (!this.shouldHandle(req)) {
+          abortHandshake(socket, 400);
+          return;
+        }
+        const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
+        let protocols = /* @__PURE__ */ new Set();
+        if (secWebSocketProtocol !== void 0) {
+          try {
+            protocols = subprotocol.parse(secWebSocketProtocol);
+          } catch (err) {
+            const message = "Invalid Sec-WebSocket-Protocol header";
+            abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+            return;
+          }
+        }
+        const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
+        const extensions = {};
+        if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
           const perMessageDeflate = new PerMessageDeflate(
             this.options.perMessageDeflate,
             true,
             this.options.maxPayload
           );
           try {
-            const offers = parse2(req.headers["sec-websocket-extensions"]);
+            const offers = extension.parse(secWebSocketExtensions);
             if (offers[PerMessageDeflate.extensionName]) {
               perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
               extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
             }
           } catch (err) {
-            return abortHandshake(socket, 400);
+            const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
+            abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+            return;
           }
         }
         if (this.options.verifyClient) {
@@ -42800,28 +44378,36 @@ var require_websocket_server = __commonJS({
               if (!verified) {
                 return abortHandshake(socket, code || 401, message, headers);
               }
-              this.completeUpgrade(key, extensions, req, socket, head, cb);
+              this.completeUpgrade(
+                extensions,
+                key,
+                protocols,
+                req,
+                socket,
+                head,
+                cb
+              );
             });
             return;
           }
           if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
         }
-        this.completeUpgrade(key, extensions, req, socket, head, cb);
+        this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
       }
       /**
        * Upgrade the connection to WebSocket.
        *
-       * @param {String} key The value of the `Sec-WebSocket-Key` header
        * @param {Object} extensions The accepted extensions
+       * @param {String} key The value of the `Sec-WebSocket-Key` header
+       * @param {Set} protocols The subprotocols
        * @param {http.IncomingMessage} req The request object
-       * @param {(net.Socket|tls.Socket)} socket The network socket between the
-       *     server and client
+       * @param {Duplex} socket The network socket between the server and client
        * @param {Buffer} head The first packet of the upgraded stream
        * @param {Function} cb Callback
        * @throws {Error} If called more than once with the same socket
        * @private
        */
-      completeUpgrade(key, extensions, req, socket, head, cb) {
+      completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
         if (!socket.readable || !socket.writable) return socket.destroy();
         if (socket[kWebSocket]) {
           throw new Error(
@@ -42836,15 +44422,9 @@ var require_websocket_server = __commonJS({
           "Connection: Upgrade",
           `Sec-WebSocket-Accept: ${digest}`
         ];
-        const ws = new WebSocket(null);
-        let protocol = req.headers["sec-websocket-protocol"];
-        if (protocol) {
-          protocol = protocol.split(",").map(trim);
-          if (this.options.handleProtocols) {
-            protocol = this.options.handleProtocols(protocol, req);
-          } else {
-            protocol = protocol[0];
-          }
+        const ws = new this.options.WebSocket(null, void 0, this.options);
+        if (protocols.size) {
+          const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value;
           if (protocol) {
             headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
             ws._protocol = protocol;
@@ -42852,7 +44432,7 @@ var require_websocket_server = __commonJS({
         }
         if (extensions[PerMessageDeflate.extensionName]) {
           const params = extensions[PerMessageDeflate.extensionName].params;
-          const value = format2({
+          const value = extension.format({
             [PerMessageDeflate.extensionName]: [params]
           });
           headers.push(`Sec-WebSocket-Extensions: ${value}`);
@@ -42861,10 +44441,19 @@ var require_websocket_server = __commonJS({
         this.emit("headers", headers, req);
         socket.write(headers.concat("\r\n").join("\r\n"));
         socket.removeListener("error", socketOnError);
-        ws.setSocket(socket, head, this.options.maxPayload);
+        ws.setSocket(socket, head, {
+          allowSynchronousEvents: this.options.allowSynchronousEvents,
+          maxPayload: this.options.maxPayload,
+          skipUTF8Validation: this.options.skipUTF8Validation
+        });
         if (this.clients) {
           this.clients.add(ws);
-          ws.on("close", () => this.clients.delete(ws));
+          ws.on("close", () => {
+            this.clients.delete(ws);
+            if (this._shouldEmitClose && !this.clients.size) {
+              process.nextTick(emitClose, this);
+            }
+          });
         }
         cb(ws, req);
       }
@@ -42886,24 +44475,27 @@ var require_websocket_server = __commonJS({
       this.destroy();
     }
     function abortHandshake(socket, code, message, headers) {
-      if (socket.writable) {
-        message = message || http.STATUS_CODES[code];
-        headers = {
-          Connection: "close",
-          "Content-Type": "text/html",
-          "Content-Length": Buffer.byteLength(message),
-          ...headers
-        };
-        socket.write(
-          `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
+      message = message || http.STATUS_CODES[code];
+      headers = {
+        Connection: "close",
+        "Content-Type": "text/html",
+        "Content-Length": Buffer.byteLength(message),
+        ...headers
+      };
+      socket.once("finish", socket.destroy);
+      socket.end(
+        `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
 ` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
-        );
-      }
-      socket.removeListener("error", socketOnError);
-      socket.destroy();
+      );
     }
-    function trim(str) {
-      return str.trim();
+    function abortHandshakeOrEmitwsClientError(server, req, socket, code, message, headers) {
+      if (server.listenerCount("wsClientError")) {
+        const err = new Error(message);
+        Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+        server.emit("wsClientError", err, socket, req);
+      } else {
+        abortHandshake(socket, code, message, headers);
+      }
     }
   }
 });
@@ -42917,6 +44509,8 @@ var require_ws = __commonJS({
     WebSocket.Server = require_websocket_server();
     WebSocket.Receiver = require_receiver();
     WebSocket.Sender = require_sender();
+    WebSocket.WebSocket = WebSocket;
+    WebSocket.WebSocketServer = WebSocket.Server;
     module2.exports = WebSocket;
   }
 });
@@ -57816,7 +59410,7 @@ mime-types/index.js:
    *)
 
 axios/dist/node/axios.cjs:
-  (*! Axios v1.8.2 Copyright (c) 2025 Matt Zabriskie and contributors *)
+  (*! Axios v1.11.0 Copyright (c) 2025 Matt Zabriskie and contributors *)
 
 repeat-string/index.js:
   (*!