@effect-x/envault 0.1.0

package/dist/wrapper-BUyLZ9aM.js

@@ -0,0 +1,1606 @@
+import { n as e, r as t, t as n } from "./chunk-C-LSD6C2.js";
+//#region node_modules/ws/lib/constants.js
+var r = n(((e, t) => {
+	let n = [
+		"nodebuffer",
+		"arraybuffer",
+		"fragments"
+	], r = typeof Blob < "u";
+	r && n.push("blob"), t.exports = {
+		BINARY_TYPES: n,
+		CLOSE_TIMEOUT: 3e4,
+		EMPTY_BUFFER: Buffer.alloc(0),
+		GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
+		hasBlob: r,
+		kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
+		kListener: Symbol("kListener"),
+		kStatusCode: Symbol("status-code"),
+		kWebSocket: Symbol("websocket"),
+		NOOP: () => {}
+	};
+})), i = n(((t, n) => {
+	let { EMPTY_BUFFER: i } = r(), a = Buffer[Symbol.species];
+	function o(e, t) {
+		if (e.length === 0) return i;
+		if (e.length === 1) return e[0];
+		let n = Buffer.allocUnsafe(t), r = 0;
+		for (let t = 0; t < e.length; t++) {
+			let i = e[t];
+			n.set(i, r), r += i.length;
+		}
+		return r < t ? new a(n.buffer, n.byteOffset, r) : n;
+	}
+	function s(e, t, n, r, i) {
+		for (let a = 0; a < i; a++) n[r + a] = e[a] ^ t[a & 3];
+	}
+	function c(e, t) {
+		for (let n = 0; n < e.length; n++) e[n] ^= t[n & 3];
+	}
+	function l(e) {
+		return e.length === e.buffer.byteLength ? e.buffer : e.buffer.slice(e.byteOffset, e.byteOffset + e.length);
+	}
+	function u(e) {
+		if (u.readOnly = !0, Buffer.isBuffer(e)) return e;
+		let t;
+		return e instanceof ArrayBuffer ? t = new a(e) : ArrayBuffer.isView(e) ? t = new a(e.buffer, e.byteOffset, e.byteLength) : (t = Buffer.from(e), u.readOnly = !1), t;
+	}
+	if (n.exports = {
+		concat: o,
+		mask: s,
+		toArrayBuffer: l,
+		toBuffer: u,
+		unmask: c
+	}, !process.env.WS_NO_BUFFER_UTIL) try {
+		let t = e("bufferutil");
+		n.exports.mask = function(e, n, r, i, a) {
+			a < 48 ? s(e, n, r, i, a) : t.mask(e, n, r, i, a);
+		}, n.exports.unmask = function(e, n) {
+			e.length < 32 ? c(e, n) : t.unmask(e, n);
+		};
+	} catch {}
+})), a = n(((e, t) => {
+	let n = Symbol("kDone"), r = Symbol("kRun");
+	t.exports = class {
+		constructor(e) {
+			this[n] = () => {
+				this.pending--, this[r]();
+			}, this.concurrency = e || Infinity, this.jobs = [], this.pending = 0;
+		}
+		add(e) {
+			this.jobs.push(e), this[r]();
+		}
+		[r]() {
+			if (this.pending !== this.concurrency && this.jobs.length) {
+				let e = this.jobs.shift();
+				this.pending++, e(this[n]);
+			}
+		}
+	};
+})), o = n(((t, n) => {
+	let o = e("zlib"), s = i(), c = a(), { kStatusCode: l } = r(), u = Buffer[Symbol.species], d = Buffer.from([
+		0,
+		0,
+		255,
+		255
+	]), f = Symbol("permessage-deflate"), p = Symbol("total-length"), m = Symbol("callback"), h = Symbol("buffers"), g = Symbol("error"), _;
+	n.exports = class {
+		constructor(e) {
+			this._options = e || {}, this._threshold = this._options.threshold === void 0 ? 1024 : this._options.threshold, this._maxPayload = this._options.maxPayload | 0, this._isServer = !!this._options.isServer, this._deflate = null, this._inflate = null, this.params = null, _ ||= new c(this._options.concurrencyLimit === void 0 ? 10 : this._options.concurrencyLimit);
+		}
+		static get extensionName() {
+			return "permessage-deflate";
+		}
+		offer() {
+			let e = {};
+			return this._options.serverNoContextTakeover && (e.server_no_context_takeover = !0), this._options.clientNoContextTakeover && (e.client_no_context_takeover = !0), this._options.serverMaxWindowBits && (e.server_max_window_bits = this._options.serverMaxWindowBits), this._options.clientMaxWindowBits ? e.client_max_window_bits = this._options.clientMaxWindowBits : this._options.clientMaxWindowBits ?? (e.client_max_window_bits = !0), e;
+		}
+		accept(e) {
+			return e = this.normalizeParams(e), this.params = this._isServer ? this.acceptAsServer(e) : this.acceptAsClient(e), this.params;
+		}
+		cleanup() {
+			if (this._inflate &&= (this._inflate.close(), null), this._deflate) {
+				let e = this._deflate[m];
+				this._deflate.close(), this._deflate = null, e && e(Error("The deflate stream was closed while data was being processed"));
+			}
+		}
+		acceptAsServer(e) {
+			let t = this._options, n = e.find((e) => !(t.serverNoContextTakeover === !1 && e.server_no_context_takeover || e.server_max_window_bits && (t.serverMaxWindowBits === !1 || typeof t.serverMaxWindowBits == "number" && t.serverMaxWindowBits > e.server_max_window_bits) || typeof t.clientMaxWindowBits == "number" && !e.client_max_window_bits));
+			if (!n) throw Error("None of the extension offers can be accepted");
+			return t.serverNoContextTakeover && (n.server_no_context_takeover = !0), t.clientNoContextTakeover && (n.client_no_context_takeover = !0), typeof t.serverMaxWindowBits == "number" && (n.server_max_window_bits = t.serverMaxWindowBits), typeof t.clientMaxWindowBits == "number" ? n.client_max_window_bits = t.clientMaxWindowBits : (n.client_max_window_bits === !0 || t.clientMaxWindowBits === !1) && delete n.client_max_window_bits, n;
+		}
+		acceptAsClient(e) {
+			let t = e[0];
+			if (this._options.clientNoContextTakeover === !1 && t.client_no_context_takeover) throw Error("Unexpected parameter \"client_no_context_takeover\"");
+			if (!t.client_max_window_bits) typeof this._options.clientMaxWindowBits == "number" && (t.client_max_window_bits = this._options.clientMaxWindowBits);
+			else if (this._options.clientMaxWindowBits === !1 || typeof this._options.clientMaxWindowBits == "number" && t.client_max_window_bits > this._options.clientMaxWindowBits) throw Error("Unexpected or invalid parameter \"client_max_window_bits\"");
+			return t;
+		}
+		normalizeParams(e) {
+			return e.forEach((e) => {
+				Object.keys(e).forEach((t) => {
+					let n = e[t];
+					if (n.length > 1) throw Error(`Parameter "${t}" must have only a single value`);
+					if (n = n[0], t === "client_max_window_bits") {
+						if (n !== !0) {
+							let e = +n;
+							if (!Number.isInteger(e) || e < 8 || e > 15) throw TypeError(`Invalid value for parameter "${t}": ${n}`);
+							n = e;
+						} else if (!this._isServer) throw TypeError(`Invalid value for parameter "${t}": ${n}`);
+					} else if (t === "server_max_window_bits") {
+						let e = +n;
+						if (!Number.isInteger(e) || e < 8 || e > 15) throw TypeError(`Invalid value for parameter "${t}": ${n}`);
+						n = e;
+					} else if (t === "client_no_context_takeover" || t === "server_no_context_takeover") {
+						if (n !== !0) throw TypeError(`Invalid value for parameter "${t}": ${n}`);
+					} else throw Error(`Unknown parameter "${t}"`);
+					e[t] = n;
+				});
+			}), e;
+		}
+		decompress(e, t, n) {
+			_.add((r) => {
+				this._decompress(e, t, (e, t) => {
+					r(), n(e, t);
+				});
+			});
+		}
+		compress(e, t, n) {
+			_.add((r) => {
+				this._compress(e, t, (e, t) => {
+					r(), n(e, t);
+				});
+			});
+		}
+		_decompress(e, t, n) {
+			let r = this._isServer ? "client" : "server";
+			if (!this._inflate) {
+				let e = `${r}_max_window_bits`, t = typeof this.params[e] == "number" ? this.params[e] : o.Z_DEFAULT_WINDOWBITS;
+				this._inflate = o.createInflateRaw({
+					...this._options.zlibInflateOptions,
+					windowBits: t
+				}), this._inflate[f] = this, this._inflate[p] = 0, this._inflate[h] = [], this._inflate.on("error", b), this._inflate.on("data", y);
+			}
+			this._inflate[m] = n, this._inflate.write(e), t && this._inflate.write(d), this._inflate.flush(() => {
+				let e = this._inflate[g];
+				if (e) {
+					this._inflate.close(), this._inflate = null, n(e);
+					return;
+				}
+				let i = s.concat(this._inflate[h], this._inflate[p]);
+				this._inflate._readableState.endEmitted ? (this._inflate.close(), this._inflate = null) : (this._inflate[p] = 0, this._inflate[h] = [], t && this.params[`${r}_no_context_takeover`] && this._inflate.reset()), n(null, i);
+			});
+		}
+		_compress(e, t, n) {
+			let r = this._isServer ? "server" : "client";
+			if (!this._deflate) {
+				let e = `${r}_max_window_bits`, t = typeof this.params[e] == "number" ? this.params[e] : o.Z_DEFAULT_WINDOWBITS;
+				this._deflate = o.createDeflateRaw({
+					...this._options.zlibDeflateOptions,
+					windowBits: t
+				}), this._deflate[p] = 0, this._deflate[h] = [], this._deflate.on("data", v);
+			}
+			this._deflate[m] = n, this._deflate.write(e), this._deflate.flush(o.Z_SYNC_FLUSH, () => {
+				if (!this._deflate) return;
+				let e = s.concat(this._deflate[h], this._deflate[p]);
+				t && (e = new u(e.buffer, e.byteOffset, e.length - 4)), this._deflate[m] = null, this._deflate[p] = 0, this._deflate[h] = [], t && this.params[`${r}_no_context_takeover`] && this._deflate.reset(), n(null, e);
+			});
+		}
+	};
+	function v(e) {
+		this[h].push(e), this[p] += e.length;
+	}
+	function y(e) {
+		if (this[p] += e.length, this[f]._maxPayload < 1 || this[p] <= this[f]._maxPayload) {
+			this[h].push(e);
+			return;
+		}
+		this[g] = RangeError("Max payload size exceeded"), this[g].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH", this[g][l] = 1009, this.removeListener("data", y), this.reset();
+	}
+	function b(e) {
+		if (this[f]._inflate = null, this[g]) {
+			this[m](this[g]);
+			return;
+		}
+		e[l] = 1007, this[m](e);
+	}
+})), s = n(((t, n) => {
+	let { isUtf8: i } = e("buffer"), { hasBlob: a } = r(), o = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		1,
+		1,
+		0,
+		1,
+		1,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		1,
+		0,
+		1,
+		0
+	];
+	function s(e) {
+		return e >= 1e3 && e <= 1014 && e !== 1004 && e !== 1005 && e !== 1006 || e >= 3e3 && e <= 4999;
+	}
+	function c(e) {
+		let t = e.length, n = 0;
+		for (; n < t;) if (!(e[n] & 128)) n++;
+		else if ((e[n] & 224) == 192) {
+			if (n + 1 === t || (e[n + 1] & 192) != 128 || (e[n] & 254) == 192) return !1;
+			n += 2;
+		} else if ((e[n] & 240) == 224) {
+			if (n + 2 >= t || (e[n + 1] & 192) != 128 || (e[n + 2] & 192) != 128 || e[n] === 224 && (e[n + 1] & 224) == 128 || e[n] === 237 && (e[n + 1] & 224) == 160) return !1;
+			n += 3;
+		} else if ((e[n] & 248) == 240) {
+			if (n + 3 >= t || (e[n + 1] & 192) != 128 || (e[n + 2] & 192) != 128 || (e[n + 3] & 192) != 128 || e[n] === 240 && (e[n + 1] & 240) == 128 || e[n] === 244 && e[n + 1] > 143 || e[n] > 244) return !1;
+			n += 4;
+		} else return !1;
+		return !0;
+	}
+	function l(e) {
+		return a && typeof e == "object" && typeof e.arrayBuffer == "function" && typeof e.type == "string" && typeof e.stream == "function" && (e[Symbol.toStringTag] === "Blob" || e[Symbol.toStringTag] === "File");
+	}
+	if (n.exports = {
+		isBlob: l,
+		isValidStatusCode: s,
+		isValidUTF8: c,
+		tokenChars: o
+	}, i) n.exports.isValidUTF8 = function(e) {
+		return e.length < 24 ? c(e) : i(e);
+	};
+	else if (!process.env.WS_NO_UTF_8_VALIDATE) try {
+		let t = e("utf-8-validate");
+		n.exports.isValidUTF8 = function(e) {
+			return e.length < 32 ? c(e) : t(e);
+		};
+	} catch {}
+})), c = n(((t, n) => {
+	let { Writable: a } = e("stream"), c = o(), { BINARY_TYPES: l, EMPTY_BUFFER: u, kStatusCode: d, kWebSocket: f } = r(), { concat: p, toArrayBuffer: m, unmask: h } = i(), { isValidStatusCode: g, isValidUTF8: _ } = s(), v = Buffer[Symbol.species];
+	n.exports = class extends a {
+		constructor(e = {}) {
+			super(), this._allowSynchronousEvents = e.allowSynchronousEvents === void 0 ? !0 : e.allowSynchronousEvents, this._binaryType = e.binaryType || l[0], this._extensions = e.extensions || {}, this._isServer = !!e.isServer, this._maxPayload = e.maxPayload | 0, this._skipUTF8Validation = !!e.skipUTF8Validation, this[f] = void 0, this._bufferedBytes = 0, this._buffers = [], this._compressed = !1, this._payloadLength = 0, this._mask = void 0, this._fragmented = 0, this._masked = !1, this._fin = !1, this._opcode = 0, this._totalPayloadLength = 0, this._messageLength = 0, this._fragments = [], this._errored = !1, this._loop = !1, this._state = 0;
+		}
+		_write(e, t, n) {
+			if (this._opcode === 8 && this._state == 0) return n();
+			this._bufferedBytes += e.length, this._buffers.push(e), this.startLoop(n);
+		}
+		consume(e) {
+			if (this._bufferedBytes -= e, e === this._buffers[0].length) return this._buffers.shift();
+			if (e < this._buffers[0].length) {
+				let t = this._buffers[0];
+				return this._buffers[0] = new v(t.buffer, t.byteOffset + e, t.length - e), new v(t.buffer, t.byteOffset, e);
+			}
+			let t = Buffer.allocUnsafe(e);
+			do {
+				let n = this._buffers[0], r = t.length - e;
+				e >= n.length ? t.set(this._buffers.shift(), r) : (t.set(new Uint8Array(n.buffer, n.byteOffset, e), r), this._buffers[0] = new v(n.buffer, n.byteOffset + e, n.length - e)), e -= n.length;
+			} while (e > 0);
+			return t;
+		}
+		startLoop(e) {
+			this._loop = !0;
+			do
+				switch (this._state) {
+					case 0:
+						this.getInfo(e);
+						break;
+					case 1:
+						this.getPayloadLength16(e);
+						break;
+					case 2:
+						this.getPayloadLength64(e);
+						break;
+					case 3:
+						this.getMask();
+						break;
+					case 4:
+						this.getData(e);
+						break;
+					case 5:
+					case 6:
+						this._loop = !1;
+						return;
+				}
+			while (this._loop);
+			this._errored || e();
+		}
+		getInfo(e) {
+			if (this._bufferedBytes < 2) {
+				this._loop = !1;
+				return;
+			}
+			let t = this.consume(2);
+			if (t[0] & 48) {
+				e(this.createError(RangeError, "RSV2 and RSV3 must be clear", !0, 1002, "WS_ERR_UNEXPECTED_RSV_2_3"));
+				return;
+			}
+			let n = (t[0] & 64) == 64;
+			if (n && !this._extensions[c.extensionName]) {
+				e(this.createError(RangeError, "RSV1 must be clear", !0, 1002, "WS_ERR_UNEXPECTED_RSV_1"));
+				return;
+			}
+			if (this._fin = (t[0] & 128) == 128, this._opcode = t[0] & 15, this._payloadLength = t[1] & 127, this._opcode === 0) {
+				if (n) {
+					e(this.createError(RangeError, "RSV1 must be clear", !0, 1002, "WS_ERR_UNEXPECTED_RSV_1"));
+					return;
+				}
+				if (!this._fragmented) {
+					e(this.createError(RangeError, "invalid opcode 0", !0, 1002, "WS_ERR_INVALID_OPCODE"));
+					return;
+				}
+				this._opcode = this._fragmented;
+			} else if (this._opcode === 1 || this._opcode === 2) {
+				if (this._fragmented) {
+					e(this.createError(RangeError, `invalid opcode ${this._opcode}`, !0, 1002, "WS_ERR_INVALID_OPCODE"));
+					return;
+				}
+				this._compressed = n;
+			} else if (this._opcode > 7 && this._opcode < 11) {
+				if (!this._fin) {
+					e(this.createError(RangeError, "FIN must be set", !0, 1002, "WS_ERR_EXPECTED_FIN"));
+					return;
+				}
+				if (n) {
+					e(this.createError(RangeError, "RSV1 must be clear", !0, 1002, "WS_ERR_UNEXPECTED_RSV_1"));
+					return;
+				}
+				if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
+					e(this.createError(RangeError, `invalid payload length ${this._payloadLength}`, !0, 1002, "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"));
+					return;
+				}
+			} else {
+				e(this.createError(RangeError, `invalid opcode ${this._opcode}`, !0, 1002, "WS_ERR_INVALID_OPCODE"));
+				return;
+			}
+			if (!this._fin && !this._fragmented && (this._fragmented = this._opcode), this._masked = (t[1] & 128) == 128, this._isServer) {
+				if (!this._masked) {
+					e(this.createError(RangeError, "MASK must be set", !0, 1002, "WS_ERR_EXPECTED_MASK"));
+					return;
+				}
+			} else if (this._masked) {
+				e(this.createError(RangeError, "MASK must be clear", !0, 1002, "WS_ERR_UNEXPECTED_MASK"));
+				return;
+			}
+			this._payloadLength === 126 ? this._state = 1 : this._payloadLength === 127 ? this._state = 2 : this.haveLength(e);
+		}
+		getPayloadLength16(e) {
+			if (this._bufferedBytes < 2) {
+				this._loop = !1;
+				return;
+			}
+			this._payloadLength = this.consume(2).readUInt16BE(0), this.haveLength(e);
+		}
+		getPayloadLength64(e) {
+			if (this._bufferedBytes < 8) {
+				this._loop = !1;
+				return;
+			}
+			let t = this.consume(8), n = t.readUInt32BE(0);
+			if (n > 2 ** 21 - 1) {
+				e(this.createError(RangeError, "Unsupported WebSocket frame: payload length > 2^53 - 1", !1, 1009, "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"));
+				return;
+			}
+			this._payloadLength = n * 2 ** 32 + t.readUInt32BE(4), this.haveLength(e);
+		}
+		haveLength(e) {
+			if (this._payloadLength && this._opcode < 8 && (this._totalPayloadLength += this._payloadLength, this._totalPayloadLength > this._maxPayload && this._maxPayload > 0)) {
+				e(this.createError(RangeError, "Max payload size exceeded", !1, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"));
+				return;
+			}
+			this._masked ? this._state = 3 : this._state = 4;
+		}
+		getMask() {
+			if (this._bufferedBytes < 4) {
+				this._loop = !1;
+				return;
+			}
+			this._mask = this.consume(4), this._state = 4;
+		}
+		getData(e) {
+			let t = u;
+			if (this._payloadLength) {
+				if (this._bufferedBytes < this._payloadLength) {
+					this._loop = !1;
+					return;
+				}
+				t = this.consume(this._payloadLength), this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0 && h(t, this._mask);
+			}
+			if (this._opcode > 7) {
+				this.controlMessage(t, e);
+				return;
+			}
+			if (this._compressed) {
+				this._state = 5, this.decompress(t, e);
+				return;
+			}
+			t.length && (this._messageLength = this._totalPayloadLength, this._fragments.push(t)), this.dataMessage(e);
+		}
+		decompress(e, t) {
+			this._extensions[c.extensionName].decompress(e, this._fin, (e, n) => {
+				if (e) return t(e);
+				if (n.length) {
+					if (this._messageLength += n.length, this._messageLength > this._maxPayload && this._maxPayload > 0) {
+						t(this.createError(RangeError, "Max payload size exceeded", !1, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"));
+						return;
+					}
+					this._fragments.push(n);
+				}
+				this.dataMessage(t), this._state === 0 && this.startLoop(t);
+			});
+		}
+		dataMessage(e) {
+			if (!this._fin) {
+				this._state = 0;
+				return;
+			}
+			let t = this._messageLength, n = this._fragments;
+			if (this._totalPayloadLength = 0, this._messageLength = 0, this._fragmented = 0, this._fragments = [], this._opcode === 2) {
+				let r;
+				r = this._binaryType === "nodebuffer" ? p(n, t) : this._binaryType === "arraybuffer" ? m(p(n, t)) : this._binaryType === "blob" ? new Blob(n) : n, this._allowSynchronousEvents ? (this.emit("message", r, !0), this._state = 0) : (this._state = 6, setImmediate(() => {
+					this.emit("message", r, !0), this._state = 0, this.startLoop(e);
+				}));
+			} else {
+				let r = p(n, t);
+				if (!this._skipUTF8Validation && !_(r)) {
+					e(this.createError(Error, "invalid UTF-8 sequence", !0, 1007, "WS_ERR_INVALID_UTF8"));
+					return;
+				}
+				this._state === 5 || this._allowSynchronousEvents ? (this.emit("message", r, !1), this._state = 0) : (this._state = 6, setImmediate(() => {
+					this.emit("message", r, !1), this._state = 0, this.startLoop(e);
+				}));
+			}
+		}
+		controlMessage(e, t) {
+			if (this._opcode === 8) {
+				if (e.length === 0) this._loop = !1, this.emit("conclude", 1005, u), this.end();
+				else {
+					let n = e.readUInt16BE(0);
+					if (!g(n)) {
+						t(this.createError(RangeError, `invalid status code ${n}`, !0, 1002, "WS_ERR_INVALID_CLOSE_CODE"));
+						return;
+					}
+					let r = new v(e.buffer, e.byteOffset + 2, e.length - 2);
+					if (!this._skipUTF8Validation && !_(r)) {
+						t(this.createError(Error, "invalid UTF-8 sequence", !0, 1007, "WS_ERR_INVALID_UTF8"));
+						return;
+					}
+					this._loop = !1, this.emit("conclude", n, r), this.end();
+				}
+				this._state = 0;
+				return;
+			}
+			this._allowSynchronousEvents ? (this.emit(this._opcode === 9 ? "ping" : "pong", e), this._state = 0) : (this._state = 6, setImmediate(() => {
+				this.emit(this._opcode === 9 ? "ping" : "pong", e), this._state = 0, this.startLoop(t);
+			}));
+		}
+		createError(e, t, n, r, i) {
+			this._loop = !1, this._errored = !0;
+			let a = new e(n ? `Invalid WebSocket frame: ${t}` : t);
+			return Error.captureStackTrace(a, this.createError), a.code = i, a[d] = r, a;
+		}
+	};
+})), l = n(((t, n) => {
+	let { Duplex: a } = e("stream"), { randomFillSync: c } = e("crypto"), l = o(), { EMPTY_BUFFER: u, kWebSocket: d, NOOP: f } = r(), { isBlob: p, isValidStatusCode: m } = s(), { mask: h, toBuffer: g } = i(), _ = Symbol("kByteLength"), v = Buffer.alloc(4), y = 8 * 1024, b, x = y;
+	n.exports = class e {
+		constructor(e, t, n) {
+			this._extensions = t || {}, n && (this._generateMask = n, this._maskBuffer = Buffer.alloc(4)), this._socket = e, this._firstFragment = !0, this._compress = !1, this._bufferedBytes = 0, this._queue = [], this._state = 0, this.onerror = f, this[d] = void 0;
+		}
+		static frame(e, t) {
+			let n, r = !1, i = 2, a = !1;
+			t.mask && (n = t.maskBuffer || v, t.generateMask ? t.generateMask(n) : (x === y && (b === void 0 && (b = Buffer.alloc(y)), c(b, 0, y), x = 0), n[0] = b[x++], n[1] = b[x++], n[2] = b[x++], n[3] = b[x++]), a = (n[0] | n[1] | n[2] | n[3]) === 0, i = 6);
+			let o;
+			typeof e == "string" ? (!t.mask || a) && t[_] !== void 0 ? o = t[_] : (e = Buffer.from(e), o = e.length) : (o = e.length, r = t.mask && t.readOnly && !a);
+			let s = o;
+			o >= 65536 ? (i += 8, s = 127) : o > 125 && (i += 2, s = 126);
+			let l = Buffer.allocUnsafe(r ? o + i : i);
+			return l[0] = t.fin ? t.opcode | 128 : t.opcode, t.rsv1 && (l[0] |= 64), l[1] = s, s === 126 ? l.writeUInt16BE(o, 2) : s === 127 && (l[2] = l[3] = 0, l.writeUIntBE(o, 4, 6)), !t.mask || (l[1] |= 128, l[i - 4] = n[0], l[i - 3] = n[1], l[i - 2] = n[2], l[i - 1] = n[3], a) ? [l, e] : r ? (h(e, n, l, i, o), [l]) : (h(e, n, e, 0, o), [l, e]);
+		}
+		close(t, n, r, i) {
+			let a;
+			if (t === void 0) a = u;
+			else if (typeof t != "number" || !m(t)) throw TypeError("First argument must be a valid error code number");
+			else if (n === void 0 || !n.length) a = Buffer.allocUnsafe(2), a.writeUInt16BE(t, 0);
+			else {
+				let e = Buffer.byteLength(n);
+				if (e > 123) throw RangeError("The message must not be greater than 123 bytes");
+				a = Buffer.allocUnsafe(2 + e), a.writeUInt16BE(t, 0), typeof n == "string" ? a.write(n, 2) : a.set(n, 2);
+			}
+			let o = {
+				[_]: a.length,
+				fin: !0,
+				generateMask: this._generateMask,
+				mask: r,
+				maskBuffer: this._maskBuffer,
+				opcode: 8,
+				readOnly: !1,
+				rsv1: !1
+			};
+			this._state === 0 ? this.sendFrame(e.frame(a, o), i) : this.enqueue([
+				this.dispatch,
+				a,
+				!1,
+				o,
+				i
+			]);
+		}
+		ping(t, n, r) {
+			let i, a;
+			if (typeof t == "string" ? (i = Buffer.byteLength(t), a = !1) : p(t) ? (i = t.size, a = !1) : (t = g(t), i = t.length, a = g.readOnly), i > 125) throw RangeError("The data size must not be greater than 125 bytes");
+			let o = {
+				[_]: i,
+				fin: !0,
+				generateMask: this._generateMask,
+				mask: n,
+				maskBuffer: this._maskBuffer,
+				opcode: 9,
+				readOnly: a,
+				rsv1: !1
+			};
+			p(t) ? this._state === 0 ? this.getBlobData(t, !1, o, r) : this.enqueue([
+				this.getBlobData,
+				t,
+				!1,
+				o,
+				r
+			]) : this._state === 0 ? this.sendFrame(e.frame(t, o), r) : this.enqueue([
+				this.dispatch,
+				t,
+				!1,
+				o,
+				r
+			]);
+		}
+		pong(t, n, r) {
+			let i, a;
+			if (typeof t == "string" ? (i = Buffer.byteLength(t), a = !1) : p(t) ? (i = t.size, a = !1) : (t = g(t), i = t.length, a = g.readOnly), i > 125) throw RangeError("The data size must not be greater than 125 bytes");
+			let o = {
+				[_]: i,
+				fin: !0,
+				generateMask: this._generateMask,
+				mask: n,
+				maskBuffer: this._maskBuffer,
+				opcode: 10,
+				readOnly: a,
+				rsv1: !1
+			};
+			p(t) ? this._state === 0 ? this.getBlobData(t, !1, o, r) : this.enqueue([
+				this.getBlobData,
+				t,
+				!1,
+				o,
+				r
+			]) : this._state === 0 ? this.sendFrame(e.frame(t, o), r) : this.enqueue([
+				this.dispatch,
+				t,
+				!1,
+				o,
+				r
+			]);
+		}
+		send(e, t, n) {
+			let r = this._extensions[l.extensionName], i = t.binary ? 2 : 1, a = t.compress, o, s;
+			typeof e == "string" ? (o = Buffer.byteLength(e), s = !1) : p(e) ? (o = e.size, s = !1) : (e = g(e), o = e.length, s = g.readOnly), this._firstFragment ? (this._firstFragment = !1, a && r && r.params[r._isServer ? "server_no_context_takeover" : "client_no_context_takeover"] && (a = o >= r._threshold), this._compress = a) : (a = !1, i = 0), t.fin && (this._firstFragment = !0);
+			let c = {
+				[_]: o,
+				fin: t.fin,
+				generateMask: this._generateMask,
+				mask: t.mask,
+				maskBuffer: this._maskBuffer,
+				opcode: i,
+				readOnly: s,
+				rsv1: a
+			};
+			p(e) ? this._state === 0 ? this.getBlobData(e, this._compress, c, n) : this.enqueue([
+				this.getBlobData,
+				e,
+				this._compress,
+				c,
+				n
+			]) : this._state === 0 ? this.dispatch(e, this._compress, c, n) : this.enqueue([
+				this.dispatch,
+				e,
+				this._compress,
+				c,
+				n
+			]);
+		}
+		getBlobData(t, n, r, i) {
+			this._bufferedBytes += r[_], this._state = 2, t.arrayBuffer().then((t) => {
+				if (this._socket.destroyed) {
+					let e = Error("The socket was closed while the blob was being read");
+					process.nextTick(S, this, e, i);
+					return;
+				}
+				this._bufferedBytes -= r[_];
+				let a = g(t);
+				n ? this.dispatch(a, n, r, i) : (this._state = 0, this.sendFrame(e.frame(a, r), i), this.dequeue());
+			}).catch((e) => {
+				process.nextTick(C, this, e, i);
+			});
+		}
+		dispatch(t, n, r, i) {
+			if (!n) {
+				this.sendFrame(e.frame(t, r), i);
+				return;
+			}
+			let a = this._extensions[l.extensionName];
+			this._bufferedBytes += r[_], this._state = 1, a.compress(t, r.fin, (t, n) => {
+				if (this._socket.destroyed) {
+					let e = Error("The socket was closed while data was being compressed");
+					S(this, e, i);
+					return;
+				}
+				this._bufferedBytes -= r[_], this._state = 0, r.readOnly = !1, this.sendFrame(e.frame(n, r), i), this.dequeue();
+			});
+		}
+		dequeue() {
+			for (; this._state === 0 && this._queue.length;) {
+				let e = this._queue.shift();
+				this._bufferedBytes -= e[3][_], Reflect.apply(e[0], this, e.slice(1));
+			}
+		}
+		enqueue(e) {
+			this._bufferedBytes += e[3][_], this._queue.push(e);
+		}
+		sendFrame(e, t) {
+			e.length === 2 ? (this._socket.cork(), this._socket.write(e[0]), this._socket.write(e[1], t), this._socket.uncork()) : this._socket.write(e[0], t);
+		}
+	};
+	function S(e, t, n) {
+		typeof n == "function" && n(t);
+		for (let n = 0; n < e._queue.length; n++) {
+			let r = e._queue[n], i = r[r.length - 1];
+			typeof i == "function" && i(t);
+		}
+	}
+	function C(e, t, n) {
+		S(e, t, n), e.onerror(t);
+	}
+})), u = n(((e, t) => {
+	let { kForOnEventAttribute: n, kListener: i } = r(), a = Symbol("kCode"), o = Symbol("kData"), s = Symbol("kError"), c = Symbol("kMessage"), l = Symbol("kReason"), u = Symbol("kTarget"), d = Symbol("kType"), f = Symbol("kWasClean");
+	var p = class {
+		constructor(e) {
+			this[u] = null, this[d] = e;
+		}
+		get target() {
+			return this[u];
+		}
+		get type() {
+			return this[d];
+		}
+	};
+	Object.defineProperty(p.prototype, "target", { enumerable: !0 }), Object.defineProperty(p.prototype, "type", { enumerable: !0 });
+	var m = class extends p {
+		constructor(e, t = {}) {
+			super(e), this[a] = t.code === void 0 ? 0 : t.code, this[l] = t.reason === void 0 ? "" : t.reason, this[f] = t.wasClean === void 0 ? !1 : t.wasClean;
+		}
+		get code() {
+			return this[a];
+		}
+		get reason() {
+			return this[l];
+		}
+		get wasClean() {
+			return this[f];
+		}
+	};
+	Object.defineProperty(m.prototype, "code", { enumerable: !0 }), Object.defineProperty(m.prototype, "reason", { enumerable: !0 }), Object.defineProperty(m.prototype, "wasClean", { enumerable: !0 });
+	var h = class extends p {
+		constructor(e, t = {}) {
+			super(e), this[s] = t.error === void 0 ? null : t.error, this[c] = t.message === void 0 ? "" : t.message;
+		}
+		get error() {
+			return this[s];
+		}
+		get message() {
+			return this[c];
+		}
+	};
+	Object.defineProperty(h.prototype, "error", { enumerable: !0 }), Object.defineProperty(h.prototype, "message", { enumerable: !0 });
+	var g = class extends p {
+		constructor(e, t = {}) {
+			super(e), this[o] = t.data === void 0 ? null : t.data;
+		}
+		get data() {
+			return this[o];
+		}
+	};
+	Object.defineProperty(g.prototype, "data", { enumerable: !0 }), t.exports = {
+		CloseEvent: m,
+		ErrorEvent: h,
+		Event: p,
+		EventTarget: {
+			addEventListener(e, t, r = {}) {
+				for (let a of this.listeners(e)) if (!r[n] && a[i] === t && !a[n]) return;
+				let a;
+				if (e === "message") a = function(e, n) {
+					let r = new g("message", { data: n ? e : e.toString() });
+					r[u] = this, _(t, this, r);
+				};
+				else if (e === "close") a = function(e, n) {
+					let r = new m("close", {
+						code: e,
+						reason: n.toString(),
+						wasClean: this._closeFrameReceived && this._closeFrameSent
+					});
+					r[u] = this, _(t, this, r);
+				};
+				else if (e === "error") a = function(e) {
+					let n = new h("error", {
+						error: e,
+						message: e.message
+					});
+					n[u] = this, _(t, this, n);
+				};
+				else if (e === "open") a = function() {
+					let e = new p("open");
+					e[u] = this, _(t, this, e);
+				};
+				else return;
+				a[n] = !!r[n], a[i] = t, r.once ? this.once(e, a) : this.on(e, a);
+			},
+			removeEventListener(e, t) {
+				for (let r of this.listeners(e)) if (r[i] === t && !r[n]) {
+					this.removeListener(e, r);
+					break;
+				}
+			}
+		},
+		MessageEvent: g
+	};
+	function _(e, t, n) {
+		typeof e == "object" && e.handleEvent ? e.handleEvent.call(e, n) : e.call(t, n);
+	}
+})), d = n(((e, t) => {
+	let { tokenChars: n } = s();
+	function r(e, t, n) {
+		e[t] === void 0 ? e[t] = [n] : e[t].push(n);
+	}
+	function i(e) {
+		let t = Object.create(null), i = Object.create(null), a = !1, o = !1, s = !1, c, l, u = -1, d = -1, f = -1, p = 0;
+		for (; p < e.length; p++) if (d = e.charCodeAt(p), c === void 0) if (f === -1 && n[d] === 1) u === -1 && (u = p);
+		else if (p !== 0 && (d === 32 || d === 9)) f === -1 && u !== -1 && (f = p);
+		else if (d === 59 || d === 44) {
+			if (u === -1) throw SyntaxError(`Unexpected character at index ${p}`);
+			f === -1 && (f = p);
+			let n = e.slice(u, f);
+			d === 44 ? (r(t, n, i), i = Object.create(null)) : c = n, u = f = -1;
+		} else throw SyntaxError(`Unexpected character at index ${p}`);
+		else if (l === void 0) if (f === -1 && n[d] === 1) u === -1 && (u = p);
+		else if (d === 32 || d === 9) f === -1 && u !== -1 && (f = p);
+		else if (d === 59 || d === 44) {
+			if (u === -1) throw SyntaxError(`Unexpected character at index ${p}`);
+			f === -1 && (f = p), r(i, e.slice(u, f), !0), d === 44 && (r(t, c, i), i = Object.create(null), c = void 0), u = f = -1;
+		} else if (d === 61 && u !== -1 && f === -1) l = e.slice(u, p), u = f = -1;
+		else throw SyntaxError(`Unexpected character at index ${p}`);
+		else if (o) {
+			if (n[d] !== 1) throw SyntaxError(`Unexpected character at index ${p}`);
+			u === -1 ? u = p : a ||= !0, o = !1;
+		} else if (s) if (n[d] === 1) u === -1 && (u = p);
+		else if (d === 34 && u !== -1) s = !1, f = p;
+		else if (d === 92) o = !0;
+		else throw SyntaxError(`Unexpected character at index ${p}`);
+		else if (d === 34 && e.charCodeAt(p - 1) === 61) s = !0;
+		else if (f === -1 && n[d] === 1) u === -1 && (u = p);
+		else if (u !== -1 && (d === 32 || d === 9)) f === -1 && (f = p);
+		else if (d === 59 || d === 44) {
+			if (u === -1) throw SyntaxError(`Unexpected character at index ${p}`);
+			f === -1 && (f = p);
+			let n = e.slice(u, f);
+			a &&= (n = n.replace(/\\/g, ""), !1), r(i, l, n), d === 44 && (r(t, c, i), i = Object.create(null), c = void 0), l = void 0, u = f = -1;
+		} else throw SyntaxError(`Unexpected character at index ${p}`);
+		if (u === -1 || s || d === 32 || d === 9) throw SyntaxError("Unexpected end of input");
+		f === -1 && (f = p);
+		let m = e.slice(u, f);
+		return c === void 0 ? r(t, m, i) : (l === void 0 ? r(i, m, !0) : a ? r(i, l, m.replace(/\\/g, "")) : r(i, l, m), r(t, c, i)), t;
+	}
+	function a(e) {
+		return Object.keys(e).map((t) => {
+			let n = e[t];
+			return Array.isArray(n) || (n = [n]), n.map((e) => [t].concat(Object.keys(e).map((t) => {
+				let n = e[t];
+				return Array.isArray(n) || (n = [n]), n.map((e) => e === !0 ? t : `${t}=${e}`).join("; ");
+			})).join("; ")).join(", ");
+		}).join(", ");
+	}
+	t.exports = {
+		format: a,
+		parse: i
+	};
+})), f = n(((t, n) => {
+	let a = e("events"), f = e("https"), p = e("http"), m = e("net"), h = e("tls"), { randomBytes: g, createHash: _ } = e("crypto"), { Duplex: v, Readable: y } = e("stream"), { URL: b } = e("url"), x = o(), S = c(), C = l(), { isBlob: w } = s(), { BINARY_TYPES: T, CLOSE_TIMEOUT: E, EMPTY_BUFFER: D, GUID: O, kForOnEventAttribute: k, kListener: A, kStatusCode: j, kWebSocket: M, NOOP: N } = r(), { EventTarget: { addEventListener: ee, removeEventListener: te } } = u(), { format: P, parse: F } = d(), { toBuffer: I } = i(), L = Symbol("kAborted"), R = [8, 13], z = [
+		"CONNECTING",
+		"OPEN",
+		"CLOSING",
+		"CLOSED"
+	], B = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+	var V = class e extends a {
+		constructor(t, n, r) {
+			super(), this._binaryType = T[0], this._closeCode = 1006, this._closeFrameReceived = !1, this._closeFrameSent = !1, this._closeMessage = D, this._closeTimer = null, this._errorEmitted = !1, this._extensions = {}, this._paused = !1, this._protocol = "", this._readyState = e.CONNECTING, this._receiver = null, this._sender = null, this._socket = null, t === null ? (this._autoPong = r.autoPong, this._closeTimeout = r.closeTimeout, this._isServer = !0) : (this._bufferedAmount = 0, this._isServer = !1, this._redirects = 0, n === void 0 ? n = [] : Array.isArray(n) || (typeof n == "object" && n ? (r = n, n = []) : n = [n]), H(this, t, n, r));
+		}
+		get binaryType() {
+			return this._binaryType;
+		}
+		set binaryType(e) {
+			T.includes(e) && (this._binaryType = e, this._receiver && (this._receiver._binaryType = e));
+		}
+		get bufferedAmount() {
+			return this._socket ? this._socket._writableState.length + this._sender._bufferedBytes : this._bufferedAmount;
+		}
+		get extensions() {
+			return Object.keys(this._extensions).join();
+		}
+		get isPaused() {
+			return this._paused;
+		}
+		get onclose() {
+			return null;
+		}
+		get onerror() {
+			return null;
+		}
+		get onopen() {
+			return null;
+		}
+		get onmessage() {
+			return null;
+		}
+		get protocol() {
+			return this._protocol;
+		}
+		get readyState() {
+			return this._readyState;
+		}
+		get url() {
+			return this._url;
+		}
+		setSocket(t, n, r) {
+			let i = new S({
+				allowSynchronousEvents: r.allowSynchronousEvents,
+				binaryType: this.binaryType,
+				extensions: this._extensions,
+				isServer: this._isServer,
+				maxPayload: r.maxPayload,
+				skipUTF8Validation: r.skipUTF8Validation
+			}), a = new C(t, this._extensions, r.generateMask);
+			this._receiver = i, this._sender = a, this._socket = t, i[M] = this, a[M] = this, t[M] = this, i.on("conclude", re), i.on("drain", ie), i.on("error", ae), i.on("message", oe), i.on("ping", se), i.on("pong", ce), a.onerror = le, t.setTimeout && t.setTimeout(0), t.setNoDelay && t.setNoDelay(), n.length > 0 && t.unshift(n), t.on("close", X), t.on("data", Z), t.on("end", Q), t.on("error", $), this._readyState = e.OPEN, this.emit("open");
+		}
+		emitClose() {
+			if (!this._socket) {
+				this._readyState = e.CLOSED, this.emit("close", this._closeCode, this._closeMessage);
+				return;
+			}
+			this._extensions[x.extensionName] && this._extensions[x.extensionName].cleanup(), this._receiver.removeAllListeners(), this._readyState = e.CLOSED, this.emit("close", this._closeCode, this._closeMessage);
+		}
+		close(t, n) {
+			if (this.readyState !== e.CLOSED) {
+				if (this.readyState === e.CONNECTING) {
+					G(this, this._req, "WebSocket was closed before the connection was established");
+					return;
+				}
+				if (this.readyState === e.CLOSING) {
+					this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted) && this._socket.end();
+					return;
+				}
+				this._readyState = e.CLOSING, this._sender.close(t, n, !this._isServer, (e) => {
+					e || (this._closeFrameSent = !0, (this._closeFrameReceived || this._receiver._writableState.errorEmitted) && this._socket.end());
+				}), Y(this);
+			}
+		}
+		pause() {
+			this.readyState === e.CONNECTING || this.readyState === e.CLOSED || (this._paused = !0, this._socket.pause());
+		}
+		ping(t, n, r) {
+			if (this.readyState === e.CONNECTING) throw Error("WebSocket is not open: readyState 0 (CONNECTING)");
+			if (typeof t == "function" ? (r = t, t = n = void 0) : typeof n == "function" && (r = n, n = void 0), typeof t == "number" && (t = t.toString()), this.readyState !== e.OPEN) {
+				K(this, t, r);
+				return;
+			}
+			n === void 0 && (n = !this._isServer), this._sender.ping(t || D, n, r);
+		}
+		pong(t, n, r) {
+			if (this.readyState === e.CONNECTING) throw Error("WebSocket is not open: readyState 0 (CONNECTING)");
+			if (typeof t == "function" ? (r = t, t = n = void 0) : typeof n == "function" && (r = n, n = void 0), typeof t == "number" && (t = t.toString()), this.readyState !== e.OPEN) {
+				K(this, t, r);
+				return;
+			}
+			n === void 0 && (n = !this._isServer), this._sender.pong(t || D, n, r);
+		}
+		resume() {
+			this.readyState === e.CONNECTING || this.readyState === e.CLOSED || (this._paused = !1, this._receiver._writableState.needDrain || this._socket.resume());
+		}
+		send(t, n, r) {
+			if (this.readyState === e.CONNECTING) throw Error("WebSocket is not open: readyState 0 (CONNECTING)");
+			if (typeof n == "function" && (r = n, n = {}), typeof t == "number" && (t = t.toString()), this.readyState !== e.OPEN) {
+				K(this, t, r);
+				return;
+			}
+			let i = {
+				binary: typeof t != "string",
+				mask: !this._isServer,
+				compress: !0,
+				fin: !0,
+				...n
+			};
+			this._extensions[x.extensionName] || (i.compress = !1), this._sender.send(t || D, i, r);
+		}
+		terminate() {
+			if (this.readyState !== e.CLOSED) {
+				if (this.readyState === e.CONNECTING) {
+					G(this, this._req, "WebSocket was closed before the connection was established");
+					return;
+				}
+				this._socket && (this._readyState = e.CLOSING, this._socket.destroy());
+			}
+		}
+	};
+	Object.defineProperty(V, "CONNECTING", {
+		enumerable: !0,
+		value: z.indexOf("CONNECTING")
+	}), Object.defineProperty(V.prototype, "CONNECTING", {
+		enumerable: !0,
+		value: z.indexOf("CONNECTING")
+	}), Object.defineProperty(V, "OPEN", {
+		enumerable: !0,
+		value: z.indexOf("OPEN")
+	}), Object.defineProperty(V.prototype, "OPEN", {
+		enumerable: !0,
+		value: z.indexOf("OPEN")
+	}), Object.defineProperty(V, "CLOSING", {
+		enumerable: !0,
+		value: z.indexOf("CLOSING")
+	}), Object.defineProperty(V.prototype, "CLOSING", {
+		enumerable: !0,
+		value: z.indexOf("CLOSING")
+	}), Object.defineProperty(V, "CLOSED", {
+		enumerable: !0,
+		value: z.indexOf("CLOSED")
+	}), Object.defineProperty(V.prototype, "CLOSED", {
+		enumerable: !0,
+		value: z.indexOf("CLOSED")
+	}), [
+		"binaryType",
+		"bufferedAmount",
+		"extensions",
+		"isPaused",
+		"protocol",
+		"readyState",
+		"url"
+	].forEach((e) => {
+		Object.defineProperty(V.prototype, e, { enumerable: !0 });
+	}), [
+		"open",
+		"error",
+		"close",
+		"message"
+	].forEach((e) => {
+		Object.defineProperty(V.prototype, `on${e}`, {
+			enumerable: !0,
+			get() {
+				for (let t of this.listeners(e)) if (t[k]) return t[A];
+				return null;
+			},
+			set(t) {
+				for (let t of this.listeners(e)) if (t[k]) {
+					this.removeListener(e, t);
+					break;
+				}
+				typeof t == "function" && this.addEventListener(e, t, { [k]: !0 });
+			}
+		});
+	}), V.prototype.addEventListener = ee, V.prototype.removeEventListener = te, n.exports = V;
+	function H(e, t, n, r) {
+		let i = {
+			allowSynchronousEvents: !0,
+			autoPong: !0,
+			closeTimeout: E,
+			protocolVersion: R[1],
+			maxPayload: 100 * 1024 * 1024,
+			skipUTF8Validation: !1,
+			perMessageDeflate: !0,
+			followRedirects: !1,
+			maxRedirects: 10,
+			...r,
+			socketPath: void 0,
+			hostname: void 0,
+			protocol: void 0,
+			timeout: void 0,
+			method: "GET",
+			host: void 0,
+			path: void 0,
+			port: void 0
+		};
+		if (e._autoPong = i.autoPong, e._closeTimeout = i.closeTimeout, !R.includes(i.protocolVersion)) throw RangeError(`Unsupported protocol version: ${i.protocolVersion} (supported versions: ${R.join(", ")})`);
+		let a;
+		if (t instanceof b) a = t;
+		else try {
+			a = new b(t);
+		} catch {
+			throw SyntaxError(`Invalid URL: ${t}`);
+		}
+		a.protocol === "http:" ? a.protocol = "ws:" : a.protocol === "https:" && (a.protocol = "wss:"), e._url = a.href;
+		let o = a.protocol === "wss:", s = a.protocol === "ws+unix:", c;
+		if (a.protocol !== "ws:" && !o && !s ? c = "The URL's protocol must be one of \"ws:\", \"wss:\", \"http:\", \"https:\", or \"ws+unix:\"" : s && !a.pathname ? c = "The URL's pathname is empty" : a.hash && (c = "The URL contains a fragment identifier"), c) {
+			let t = SyntaxError(c);
+			if (e._redirects === 0) throw t;
+			U(e, t);
+			return;
+		}
+		let l = o ? 443 : 80, u = g(16).toString("base64"), d = o ? f.request : p.request, m = new Set(), h;
+		if (i.createConnection = i.createConnection || (o ? ne : W), i.defaultPort = i.defaultPort || l, i.port = a.port || l, i.host = a.hostname.startsWith("[") ? a.hostname.slice(1, -1) : a.hostname, i.headers = {
+			...i.headers,
+			"Sec-WebSocket-Version": i.protocolVersion,
+			"Sec-WebSocket-Key": u,
+			Connection: "Upgrade",
+			Upgrade: "websocket"
+		}, i.path = a.pathname + a.search, i.timeout = i.handshakeTimeout, i.perMessageDeflate && (h = new x({
+			...i.perMessageDeflate,
+			isServer: !1,
+			maxPayload: i.maxPayload
+		}), i.headers["Sec-WebSocket-Extensions"] = P({ [x.extensionName]: h.offer() })), n.length) {
+			for (let e of n) {
+				if (typeof e != "string" || !B.test(e) || m.has(e)) throw SyntaxError("An invalid or duplicated subprotocol was specified");
+				m.add(e);
+			}
+			i.headers["Sec-WebSocket-Protocol"] = n.join(",");
+		}
+		if (i.origin && (i.protocolVersion < 13 ? i.headers["Sec-WebSocket-Origin"] = i.origin : i.headers.Origin = i.origin), (a.username || a.password) && (i.auth = `${a.username}:${a.password}`), s) {
+			let e = i.path.split(":");
+			i.socketPath = e[0], i.path = e[1];
+		}
+		let v;
+		if (i.followRedirects) {
+			if (e._redirects === 0) {
+				e._originalIpc = s, e._originalSecure = o, e._originalHostOrSocketPath = s ? i.socketPath : a.host;
+				let t = r && r.headers;
+				if (r = {
+					...r,
+					headers: {}
+				}, t) for (let [e, n] of Object.entries(t)) r.headers[e.toLowerCase()] = n;
+			} else if (e.listenerCount("redirect") === 0) {
+				let t = s ? e._originalIpc ? i.socketPath === e._originalHostOrSocketPath : !1 : e._originalIpc ? !1 : a.host === e._originalHostOrSocketPath;
+				(!t || e._originalSecure && !o) && (delete i.headers.authorization, delete i.headers.cookie, t || delete i.headers.host, i.auth = void 0);
+			}
+			i.auth && !r.headers.authorization && (r.headers.authorization = "Basic " + Buffer.from(i.auth).toString("base64")), v = e._req = d(i), e._redirects && e.emit("redirect", e.url, v);
+		} else v = e._req = d(i);
+		i.timeout && v.on("timeout", () => {
+			G(e, v, "Opening handshake has timed out");
+		}), v.on("error", (t) => {
+			v === null || v[L] || (v = e._req = null, U(e, t));
+		}), v.on("response", (a) => {
+			let o = a.headers.location, s = a.statusCode;
+			if (o && i.followRedirects && s >= 300 && s < 400) {
+				if (++e._redirects > i.maxRedirects) {
+					G(e, v, "Maximum redirects exceeded");
+					return;
+				}
+				v.abort();
+				let a;
+				try {
+					a = new b(o, t);
+				} catch {
+					U(e, SyntaxError(`Invalid URL: ${o}`));
+					return;
+				}
+				H(e, a, n, r);
+			} else e.emit("unexpected-response", v, a) || G(e, v, `Unexpected server response: ${a.statusCode}`);
+		}), v.on("upgrade", (t, n, r) => {
+			if (e.emit("upgrade", t), e.readyState !== V.CONNECTING) return;
+			v = e._req = null;
+			let a = t.headers.upgrade;
+			if (a === void 0 || a.toLowerCase() !== "websocket") {
+				G(e, n, "Invalid Upgrade header");
+				return;
+			}
+			let o = _("sha1").update(u + O).digest("base64");
+			if (t.headers["sec-websocket-accept"] !== o) {
+				G(e, n, "Invalid Sec-WebSocket-Accept header");
+				return;
+			}
+			let s = t.headers["sec-websocket-protocol"], c;
+			if (s === void 0 ? m.size && (c = "Server sent no subprotocol") : m.size ? m.has(s) || (c = "Server sent an invalid subprotocol") : c = "Server sent a subprotocol but none was requested", c) {
+				G(e, n, c);
+				return;
+			}
+			s && (e._protocol = s);
+			let l = t.headers["sec-websocket-extensions"];
+			if (l !== void 0) {
+				if (!h) {
+					G(e, n, "Server sent a Sec-WebSocket-Extensions header but no extension was requested");
+					return;
+				}
+				let t;
+				try {
+					t = F(l);
+				} catch {
+					G(e, n, "Invalid Sec-WebSocket-Extensions header");
+					return;
+				}
+				let r = Object.keys(t);
+				if (r.length !== 1 || r[0] !== x.extensionName) {
+					G(e, n, "Server indicated an extension that was not requested");
+					return;
+				}
+				try {
+					h.accept(t[x.extensionName]);
+				} catch {
+					G(e, n, "Invalid Sec-WebSocket-Extensions header");
+					return;
+				}
+				e._extensions[x.extensionName] = h;
+			}
+			e.setSocket(n, r, {
+				allowSynchronousEvents: i.allowSynchronousEvents,
+				generateMask: i.generateMask,
+				maxPayload: i.maxPayload,
+				skipUTF8Validation: i.skipUTF8Validation
+			});
+		}), i.finishRequest ? i.finishRequest(v, e) : v.end();
+	}
+	function U(e, t) {
+		e._readyState = V.CLOSING, e._errorEmitted = !0, e.emit("error", t), e.emitClose();
+	}
+	function W(e) {
+		return e.path = e.socketPath, m.connect(e);
+	}
+	function ne(e) {
+		return e.path = void 0, !e.servername && e.servername !== "" && (e.servername = m.isIP(e.host) ? "" : e.host), h.connect(e);
+	}
+	function G(e, t, n) {
+		e._readyState = V.CLOSING;
+		let r = Error(n);
+		Error.captureStackTrace(r, G), t.setHeader ? (t[L] = !0, t.abort(), t.socket && !t.socket.destroyed && t.socket.destroy(), process.nextTick(U, e, r)) : (t.destroy(r), t.once("error", e.emit.bind(e, "error")), t.once("close", e.emitClose.bind(e)));
+	}
+	function K(e, t, n) {
+		if (t) {
+			let n = w(t) ? t.size : I(t).length;
+			e._socket ? e._sender._bufferedBytes += n : e._bufferedAmount += n;
+		}
+		if (n) {
+			let t = Error(`WebSocket is not open: readyState ${e.readyState} (${z[e.readyState]})`);
+			process.nextTick(n, t);
+		}
+	}
+	function re(e, t) {
+		let n = this[M];
+		n._closeFrameReceived = !0, n._closeMessage = t, n._closeCode = e, n._socket[M] !== void 0 && (n._socket.removeListener("data", Z), process.nextTick(J, n._socket), e === 1005 ? n.close() : n.close(e, t));
+	}
+	function ie() {
+		let e = this[M];
+		e.isPaused || e._socket.resume();
+	}
+	function ae(e) {
+		let t = this[M];
+		t._socket[M] !== void 0 && (t._socket.removeListener("data", Z), process.nextTick(J, t._socket), t.close(e[j])), t._errorEmitted || (t._errorEmitted = !0, t.emit("error", e));
+	}
+	function q() {
+		this[M].emitClose();
+	}
+	function oe(e, t) {
+		this[M].emit("message", e, t);
+	}
+	function se(e) {
+		let t = this[M];
+		t._autoPong && t.pong(e, !this._isServer, N), t.emit("ping", e);
+	}
+	function ce(e) {
+		this[M].emit("pong", e);
+	}
+	function J(e) {
+		e.resume();
+	}
+	function le(e) {
+		let t = this[M];
+		t.readyState !== V.CLOSED && (t.readyState === V.OPEN && (t._readyState = V.CLOSING, Y(t)), this._socket.end(), t._errorEmitted || (t._errorEmitted = !0, t.emit("error", e)));
+	}
+	function Y(e) {
+		e._closeTimer = setTimeout(e._socket.destroy.bind(e._socket), e._closeTimeout);
+	}
+	function X() {
+		let e = this[M];
+		if (this.removeListener("close", X), this.removeListener("data", Z), this.removeListener("end", Q), e._readyState = V.CLOSING, !this._readableState.endEmitted && !e._closeFrameReceived && !e._receiver._writableState.errorEmitted && this._readableState.length !== 0) {
+			let t = this.read(this._readableState.length);
+			e._receiver.write(t);
+		}
+		e._receiver.end(), this[M] = void 0, clearTimeout(e._closeTimer), e._receiver._writableState.finished || e._receiver._writableState.errorEmitted ? e.emitClose() : (e._receiver.on("error", q), e._receiver.on("finish", q));
+	}
+	function Z(e) {
+		this[M]._receiver.write(e) || this.pause();
+	}
+	function Q() {
+		let e = this[M];
+		e._readyState = V.CLOSING, e._receiver.end(), this.end();
+	}
+	function $() {
+		let e = this[M];
+		this.removeListener("error", $), this.on("error", N), e && (e._readyState = V.CLOSING, this.destroy());
+	}
+})), p = n(((t, n) => {
+	f();
+	let { Duplex: r } = e("stream");
+	function i(e) {
+		e.emit("close");
+	}
+	function a() {
+		!this.destroyed && this._writableState.finished && this.destroy();
+	}
+	function o(e) {
+		this.removeListener("error", o), this.destroy(), this.listenerCount("error") === 0 && this.emit("error", e);
+	}
+	function s(e, t) {
+		let n = !0, s = new r({
+			...t,
+			autoDestroy: !1,
+			emitClose: !1,
+			objectMode: !1,
+			writableObjectMode: !1
+		});
+		return e.on("message", function(t, n) {
+			let r = !n && s._readableState.objectMode ? t.toString() : t;
+			s.push(r) || e.pause();
+		}), e.once("error", function(e) {
+			s.destroyed || (n = !1, s.destroy(e));
+		}), e.once("close", function() {
+			s.destroyed || s.push(null);
+		}), s._destroy = function(t, r) {
+			if (e.readyState === e.CLOSED) {
+				r(t), process.nextTick(i, s);
+				return;
+			}
+			let a = !1;
+			e.once("error", function(e) {
+				a = !0, r(e);
+			}), e.once("close", function() {
+				a || r(t), process.nextTick(i, s);
+			}), n && e.terminate();
+		}, s._final = function(t) {
+			if (e.readyState === e.CONNECTING) {
+				e.once("open", function() {
+					s._final(t);
+				});
+				return;
+			}
+			e._socket !== null && (e._socket._writableState.finished ? (t(), s._readableState.endEmitted && s.destroy()) : (e._socket.once("finish", function() {
+				t();
+			}), e.close()));
+		}, s._read = function() {
+			e.isPaused && e.resume();
+		}, s._write = function(t, n, r) {
+			if (e.readyState === e.CONNECTING) {
+				e.once("open", function() {
+					s._write(t, n, r);
+				});
+				return;
+			}
+			e.send(t, r);
+		}, s.on("end", a), s.on("error", o), s;
+	}
+	n.exports = s;
+})), m = n(((e, t) => {
+	let { tokenChars: n } = s();
+	function r(e) {
+		let t = new Set(), r = -1, i = -1, a = 0;
+		for (; a < e.length; a++) {
+			let o = e.charCodeAt(a);
+			if (i === -1 && n[o] === 1) r === -1 && (r = a);
+			else if (a !== 0 && (o === 32 || o === 9)) i === -1 && r !== -1 && (i = a);
+			else if (o === 44) {
+				if (r === -1) throw SyntaxError(`Unexpected character at index ${a}`);
+				i === -1 && (i = a);
+				let n = e.slice(r, i);
+				if (t.has(n)) throw SyntaxError(`The "${n}" subprotocol is duplicated`);
+				t.add(n), r = i = -1;
+			} else throw SyntaxError(`Unexpected character at index ${a}`);
+		}
+		if (r === -1 || i !== -1) throw SyntaxError("Unexpected end of input");
+		let o = e.slice(r, a);
+		if (t.has(o)) throw SyntaxError(`The "${o}" subprotocol is duplicated`);
+		return t.add(o), t;
+	}
+	t.exports = { parse: r };
+})), h = n(((t, n) => {
+	let i = e("events"), a = e("http"), { Duplex: s } = e("stream"), { createHash: c } = e("crypto"), l = d(), u = o(), p = m(), h = f(), { CLOSE_TIMEOUT: g, GUID: _, kWebSocket: v } = r(), y = /^[+/0-9A-Za-z]{22}==$/;
+	n.exports = class extends i {
+		constructor(e, t) {
+			if (super(), e = {
+				allowSynchronousEvents: !0,
+				autoPong: !0,
+				maxPayload: 100 * 1024 * 1024,
+				skipUTF8Validation: !1,
+				perMessageDeflate: !1,
+				handleProtocols: null,
+				clientTracking: !0,
+				closeTimeout: g,
+				verifyClient: null,
+				noServer: !1,
+				backlog: null,
+				server: null,
+				host: null,
+				path: null,
+				port: null,
+				WebSocket: h,
+				...e
+			}, e.port == null && !e.server && !e.noServer || e.port != null && (e.server || e.noServer) || e.server && e.noServer) throw TypeError("One and only one of the \"port\", \"server\", or \"noServer\" options must be specified");
+			if (e.port == null ? e.server && (this._server = e.server) : (this._server = a.createServer((e, t) => {
+				let n = a.STATUS_CODES[426];
+				t.writeHead(426, {
+					"Content-Length": n.length,
+					"Content-Type": "text/plain"
+				}), t.end(n);
+			}), this._server.listen(e.port, e.host, e.backlog, t)), this._server) {
+				let e = this.emit.bind(this, "connection");
+				this._removeListeners = b(this._server, {
+					listening: this.emit.bind(this, "listening"),
+					error: this.emit.bind(this, "error"),
+					upgrade: (t, n, r) => {
+						this.handleUpgrade(t, n, r, e);
+					}
+				});
+			}
+			e.perMessageDeflate === !0 && (e.perMessageDeflate = {}), e.clientTracking && (this.clients = new Set(), this._shouldEmitClose = !1), this.options = e, this._state = 0;
+		}
+		address() {
+			if (this.options.noServer) throw Error("The server is operating in \"noServer\" mode");
+			return this._server ? this._server.address() : null;
+		}
+		close(e) {
+			if (this._state === 2) {
+				e && this.once("close", () => {
+					e(Error("The server is not running"));
+				}), process.nextTick(x, this);
+				return;
+			}
+			if (e && this.once("close", e), this._state !== 1) if (this._state = 1, this.options.noServer || this.options.server) this._server && (this._removeListeners(), this._removeListeners = this._server = null), this.clients && this.clients.size ? this._shouldEmitClose = !0 : process.nextTick(x, this);
+			else {
+				let e = this._server;
+				this._removeListeners(), this._removeListeners = this._server = null, e.close(() => {
+					x(this);
+				});
+			}
+		}
+		shouldHandle(e) {
+			if (this.options.path) {
+				let t = e.url.indexOf("?");
+				if ((t === -1 ? e.url : e.url.slice(0, t)) !== this.options.path) return !1;
+			}
+			return !0;
+		}
+		handleUpgrade(e, t, n, r) {
+			t.on("error", S);
+			let i = e.headers["sec-websocket-key"], a = e.headers.upgrade, o = +e.headers["sec-websocket-version"];
+			if (e.method !== "GET") {
+				w(this, e, t, 405, "Invalid HTTP method");
+				return;
+			}
+			if (a === void 0 || a.toLowerCase() !== "websocket") {
+				w(this, e, t, 400, "Invalid Upgrade header");
+				return;
+			}
+			if (i === void 0 || !y.test(i)) {
+				w(this, e, t, 400, "Missing or invalid Sec-WebSocket-Key header");
+				return;
+			}
+			if (o !== 13 && o !== 8) {
+				w(this, e, t, 400, "Missing or invalid Sec-WebSocket-Version header", { "Sec-WebSocket-Version": "13, 8" });
+				return;
+			}
+			if (!this.shouldHandle(e)) {
+				C(t, 400);
+				return;
+			}
+			let s = e.headers["sec-websocket-protocol"], c = new Set();
+			if (s !== void 0) try {
+				c = p.parse(s);
+			} catch {
+				w(this, e, t, 400, "Invalid Sec-WebSocket-Protocol header");
+				return;
+			}
+			let d = e.headers["sec-websocket-extensions"], f = {};
+			if (this.options.perMessageDeflate && d !== void 0) {
+				let n = new u({
+					...this.options.perMessageDeflate,
+					isServer: !0,
+					maxPayload: this.options.maxPayload
+				});
+				try {
+					let e = l.parse(d);
+					e[u.extensionName] && (n.accept(e[u.extensionName]), f[u.extensionName] = n);
+				} catch {
+					w(this, e, t, 400, "Invalid or unacceptable Sec-WebSocket-Extensions header");
+					return;
+				}
+			}
+			if (this.options.verifyClient) {
+				let a = {
+					origin: e.headers[`${o === 8 ? "sec-websocket-origin" : "origin"}`],
+					secure: !!(e.socket.authorized || e.socket.encrypted),
+					req: e
+				};
+				if (this.options.verifyClient.length === 2) {
+					this.options.verifyClient(a, (a, o, s, l) => {
+						if (!a) return C(t, o || 401, s, l);
+						this.completeUpgrade(f, i, c, e, t, n, r);
+					});
+					return;
+				}
+				if (!this.options.verifyClient(a)) return C(t, 401);
+			}
+			this.completeUpgrade(f, i, c, e, t, n, r);
+		}
+		completeUpgrade(e, t, n, r, i, a, o) {
+			if (!i.readable || !i.writable) return i.destroy();
+			if (i[v]) throw Error("server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration");
+			if (this._state > 0) return C(i, 503);
+			let s = [
+				"HTTP/1.1 101 Switching Protocols",
+				"Upgrade: websocket",
+				"Connection: Upgrade",
+				`Sec-WebSocket-Accept: ${c("sha1").update(t + _).digest("base64")}`
+			], d = new this.options.WebSocket(null, void 0, this.options);
+			if (n.size) {
+				let e = this.options.handleProtocols ? this.options.handleProtocols(n, r) : n.values().next().value;
+				e && (s.push(`Sec-WebSocket-Protocol: ${e}`), d._protocol = e);
+			}
+			if (e[u.extensionName]) {
+				let t = e[u.extensionName].params, n = l.format({ [u.extensionName]: [t] });
+				s.push(`Sec-WebSocket-Extensions: ${n}`), d._extensions = e;
+			}
+			this.emit("headers", s, r), i.write(s.concat("\r\n").join("\r\n")), i.removeListener("error", S), d.setSocket(i, a, {
+				allowSynchronousEvents: this.options.allowSynchronousEvents,
+				maxPayload: this.options.maxPayload,
+				skipUTF8Validation: this.options.skipUTF8Validation
+			}), this.clients && (this.clients.add(d), d.on("close", () => {
+				this.clients.delete(d), this._shouldEmitClose && !this.clients.size && process.nextTick(x, this);
+			})), o(d, r);
+		}
+	};
+	function b(e, t) {
+		for (let n of Object.keys(t)) e.on(n, t[n]);
+		return function() {
+			for (let n of Object.keys(t)) e.removeListener(n, t[n]);
+		};
+	}
+	function x(e) {
+		e._state = 2, e.emit("close");
+	}
+	function S() {
+		this.destroy();
+	}
+	function C(e, t, n, r) {
+		n ||= a.STATUS_CODES[t], r = {
+			Connection: "close",
+			"Content-Type": "text/html",
+			"Content-Length": Buffer.byteLength(n),
+			...r
+		}, e.once("finish", e.destroy), e.end(`HTTP/1.1 ${t} ${a.STATUS_CODES[t]}\r\n` + Object.keys(r).map((e) => `${e}: ${r[e]}`).join("\r\n") + "\r\n\r\n" + n);
+	}
+	function w(e, t, n, r, i, a) {
+		if (e.listenerCount("wsClientError")) {
+			let r = Error(i);
+			Error.captureStackTrace(r, w), e.emit("wsClientError", r, n, t);
+		} else C(n, r, i, a);
+	}
+}));
+p(), d(), o(), c(), l(), m();
+var g = t(f(), 1);
+h();
+var _ = g.default;
+//#endregion
+export { _ as default };
+
+//# sourceMappingURL=wrapper-BUyLZ9aM.js.map