@nsshunt/stsrunnerframework 2.0.21 → 2.0.23

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { ModelDelimeter, Sleep, defaultLogger, isNode } from "@nsshunt/stsutils";
 import { Gauge } from "@nsshunt/stsobservability";
+import { gzipSync, strToU8 } from "fflate";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -7,7 +8,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __commonJSMin$1 = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -1500,7 +1510,7 @@ var AbstractRunnerExecutionWorker = class {
 * - The broker itself does not interpret business meaning of unsolicited messages;
 *   those are delegated to a caller-supplied callback
 */
-var import_lodash_merge = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+var import_lodash_merge = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	/**
 	* Lodash (Custom Build) <https://lodash.com/>
 	* Build: `lodash modularize exports="npm" -o ./`
@@ -1958,7 +1968,8 @@ var import_lodash_merge = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin
 	* @param {Array} [entries] The key-value pairs to cache.
 	*/
 	function Stack(entries) {
-		this.size = (this.__data__ = new ListCache(entries)).size;
+		var data = this.__data__ = new ListCache(entries);
+		this.size = data.size;
 	}
 	/**
 	* Removes all key-value entries from the stack.
@@ -4871,7 +4882,10 @@ var WorkerRegistry = class {
 		if (worker) {
 			const runnersMap = worker.GetAllRunnersExMap();
 			if (runnersMap) {
-				if (runnersMap[runnerId]) delete runnersMap[runnerId];
+				if (runnersMap[runnerId]) {
+					delete runnersMap[runnerId];
+					this.options.logger.debug(`DeleteRunner(): RunnerId: [${runnerId}] has been removed from this workerId: [${workerId}], Remaining Runners: [${Object.keys(worker.GetAllRunnersExMap()).length}]`);
+				}
 			}
 		}
 	};
@@ -5847,7 +5861,7 @@ var WorkerCommandCoordinator = class {
 	* @returns Array of worker-level aggregated results.
 	*/
 	ExecuteWorkerCommands = async (workerIds, command, runnerOptions) => {
-		this.options.logger.debug(`_ProcessWorkerCommands: workerIds: [${workerIds}]  command: [${command}`);
+		this.options.logger.debug(`_ProcessWorkerCommands: workerIds: [${workerIds}] command: [${command}]`);
 		try {
 			/**
 			* Promise array holding each worker's command execution result.
@@ -6583,6 +6597,3924 @@ var STSWorkerManager = class {
 	};
 };
 //#endregion
-export { AbstractRunnerExecutionWorker, IRunnerState, IWorkerState, PublishMessageCommandsTestRunner, STSWorkerManager, eIWMessageCommands };
+//#region node_modules/@nsshunt/stssocketioutils/dist/tiny-emitter-DB59cw42.js
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var require_tiny_emitter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function E() {}
+	E.prototype = {
+		on: function(name, callback, ctx) {
+			var e = this.e || (this.e = {});
+			(e[name] || (e[name] = [])).push({
+				fn: callback,
+				ctx
+			});
+			return this;
+		},
+		once: function(name, callback, ctx) {
+			var self = this;
+			function listener() {
+				self.off(name, listener);
+				callback.apply(ctx, arguments);
+			}
+			listener._ = callback;
+			return this.on(name, listener, ctx);
+		},
+		emit: function(name) {
+			var data = [].slice.call(arguments, 1);
+			var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+			var i = 0;
+			var len = evtArr.length;
+			for (; i < len; i++) evtArr[i].fn.apply(evtArr[i].ctx, data);
+			return this;
+		},
+		off: function(name, callback) {
+			var e = this.e || (this.e = {});
+			var evts = e[name];
+			var liveEvents = [];
+			if (evts && callback) {
+				for (var i = 0, len = evts.length; i < len; i++) if (evts[i].fn !== callback && evts[i].fn._ !== callback) liveEvents.push(evts[i]);
+			}
+			liveEvents.length ? e[name] = liveEvents : delete e[name];
+			return this;
+		}
+	};
+	module.exports = E;
+	module.exports.TinyEmitter = E;
+}));
+//#endregion
+//#region node_modules/engine.io-parser/build/esm/commons.js
+var PACKET_TYPES = Object.create(null);
+PACKET_TYPES["open"] = "0";
+PACKET_TYPES["close"] = "1";
+PACKET_TYPES["ping"] = "2";
+PACKET_TYPES["pong"] = "3";
+PACKET_TYPES["message"] = "4";
+PACKET_TYPES["upgrade"] = "5";
+PACKET_TYPES["noop"] = "6";
+var PACKET_TYPES_REVERSE = Object.create(null);
+Object.keys(PACKET_TYPES).forEach((key) => {
+	PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
+});
+var ERROR_PACKET = {
+	type: "error",
+	data: "parser error"
+};
+//#endregion
+//#region node_modules/engine.io-parser/build/esm/encodePacket.browser.js
+var withNativeBlob$1 = typeof Blob === "function" || typeof Blob !== "undefined" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]";
+var withNativeArrayBuffer$2 = typeof ArrayBuffer === "function";
+var isView$1 = (obj) => {
+	return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj && obj.buffer instanceof ArrayBuffer;
+};
+var encodePacket = ({ type, data }, supportsBinary, callback) => {
+	if (withNativeBlob$1 && data instanceof Blob) if (supportsBinary) return callback(data);
+	else return encodeBlobAsBase64(data, callback);
+	else if (withNativeArrayBuffer$2 && (data instanceof ArrayBuffer || isView$1(data))) if (supportsBinary) return callback(data);
+	else return encodeBlobAsBase64(new Blob([data]), callback);
+	return callback(PACKET_TYPES[type] + (data || ""));
+};
+var encodeBlobAsBase64 = (data, callback) => {
+	const fileReader = new FileReader();
+	fileReader.onload = function() {
+		const content = fileReader.result.split(",")[1];
+		callback("b" + (content || ""));
+	};
+	return fileReader.readAsDataURL(data);
+};
+function toArray(data) {
+	if (data instanceof Uint8Array) return data;
+	else if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	else return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+var TEXT_ENCODER;
+function encodePacketToBinary(packet, callback) {
+	if (withNativeBlob$1 && packet.data instanceof Blob) return packet.data.arrayBuffer().then(toArray).then(callback);
+	else if (withNativeArrayBuffer$2 && (packet.data instanceof ArrayBuffer || isView$1(packet.data))) return callback(toArray(packet.data));
+	encodePacket(packet, false, (encoded) => {
+		if (!TEXT_ENCODER) TEXT_ENCODER = new TextEncoder();
+		callback(TEXT_ENCODER.encode(encoded));
+	});
+}
+//#endregion
+//#region node_modules/engine.io-parser/build/esm/contrib/base64-arraybuffer.js
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var lookup$1 = typeof Uint8Array === "undefined" ? [] : new Uint8Array(256);
+for (let i = 0; i < 64; i++) lookup$1[chars.charCodeAt(i)] = i;
+var decode$1 = (base64) => {
+	let bufferLength = base64.length * .75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
+	if (base64[base64.length - 1] === "=") {
+		bufferLength--;
+		if (base64[base64.length - 2] === "=") bufferLength--;
+	}
+	const arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
+	for (i = 0; i < len; i += 4) {
+		encoded1 = lookup$1[base64.charCodeAt(i)];
+		encoded2 = lookup$1[base64.charCodeAt(i + 1)];
+		encoded3 = lookup$1[base64.charCodeAt(i + 2)];
+		encoded4 = lookup$1[base64.charCodeAt(i + 3)];
+		bytes[p++] = encoded1 << 2 | encoded2 >> 4;
+		bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
+		bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
+	}
+	return arraybuffer;
+};
+//#endregion
+//#region node_modules/engine.io-parser/build/esm/decodePacket.browser.js
+var withNativeArrayBuffer$1 = typeof ArrayBuffer === "function";
+var decodePacket = (encodedPacket, binaryType) => {
+	if (typeof encodedPacket !== "string") return {
+		type: "message",
+		data: mapBinary(encodedPacket, binaryType)
+	};
+	const type = encodedPacket.charAt(0);
+	if (type === "b") return {
+		type: "message",
+		data: decodeBase64Packet(encodedPacket.substring(1), binaryType)
+	};
+	if (!PACKET_TYPES_REVERSE[type]) return ERROR_PACKET;
+	return encodedPacket.length > 1 ? {
+		type: PACKET_TYPES_REVERSE[type],
+		data: encodedPacket.substring(1)
+	} : { type: PACKET_TYPES_REVERSE[type] };
+};
+var decodeBase64Packet = (data, binaryType) => {
+	if (withNativeArrayBuffer$1) return mapBinary(decode$1(data), binaryType);
+	else return {
+		base64: true,
+		data
+	};
+};
+var mapBinary = (data, binaryType) => {
+	switch (binaryType) {
+		case "blob": if (data instanceof Blob) return data;
+		else return new Blob([data]);
+		default: if (data instanceof ArrayBuffer) return data;
+		else return data.buffer;
+	}
+};
+//#endregion
+//#region node_modules/engine.io-parser/build/esm/index.js
+var SEPARATOR = String.fromCharCode(30);
+var encodePayload = (packets, callback) => {
+	const length = packets.length;
+	const encodedPackets = new Array(length);
+	let count = 0;
+	packets.forEach((packet, i) => {
+		encodePacket(packet, false, (encodedPacket) => {
+			encodedPackets[i] = encodedPacket;
+			if (++count === length) callback(encodedPackets.join(SEPARATOR));
+		});
+	});
+};
+var decodePayload = (encodedPayload, binaryType) => {
+	const encodedPackets = encodedPayload.split(SEPARATOR);
+	const packets = [];
+	for (let i = 0; i < encodedPackets.length; i++) {
+		const decodedPacket = decodePacket(encodedPackets[i], binaryType);
+		packets.push(decodedPacket);
+		if (decodedPacket.type === "error") break;
+	}
+	return packets;
+};
+function createPacketEncoderStream() {
+	return new TransformStream({ transform(packet, controller) {
+		encodePacketToBinary(packet, (encodedPacket) => {
+			const payloadLength = encodedPacket.length;
+			let header;
+			if (payloadLength < 126) {
+				header = new Uint8Array(1);
+				new DataView(header.buffer).setUint8(0, payloadLength);
+			} else if (payloadLength < 65536) {
+				header = new Uint8Array(3);
+				const view = new DataView(header.buffer);
+				view.setUint8(0, 126);
+				view.setUint16(1, payloadLength);
+			} else {
+				header = new Uint8Array(9);
+				const view = new DataView(header.buffer);
+				view.setUint8(0, 127);
+				view.setBigUint64(1, BigInt(payloadLength));
+			}
+			if (packet.data && typeof packet.data !== "string") header[0] |= 128;
+			controller.enqueue(header);
+			controller.enqueue(encodedPacket);
+		});
+	} });
+}
+var TEXT_DECODER;
+function totalLength(chunks) {
+	return chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+}
+function concatChunks(chunks, size) {
+	if (chunks[0].length === size) return chunks.shift();
+	const buffer = new Uint8Array(size);
+	let j = 0;
+	for (let i = 0; i < size; i++) {
+		buffer[i] = chunks[0][j++];
+		if (j === chunks[0].length) {
+			chunks.shift();
+			j = 0;
+		}
+	}
+	if (chunks.length && j < chunks[0].length) chunks[0] = chunks[0].slice(j);
+	return buffer;
+}
+function createPacketDecoderStream(maxPayload, binaryType) {
+	if (!TEXT_DECODER) TEXT_DECODER = new TextDecoder();
+	const chunks = [];
+	let state = 0;
+	let expectedLength = -1;
+	let isBinary = false;
+	return new TransformStream({ transform(chunk, controller) {
+		chunks.push(chunk);
+		while (true) {
+			if (state === 0) {
+				if (totalLength(chunks) < 1) break;
+				const header = concatChunks(chunks, 1);
+				isBinary = (header[0] & 128) === 128;
+				expectedLength = header[0] & 127;
+				if (expectedLength < 126) state = 3;
+				else if (expectedLength === 126) state = 1;
+				else state = 2;
+			} else if (state === 1) {
+				if (totalLength(chunks) < 2) break;
+				const headerArray = concatChunks(chunks, 2);
+				expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);
+				state = 3;
+			} else if (state === 2) {
+				if (totalLength(chunks) < 8) break;
+				const headerArray = concatChunks(chunks, 8);
+				const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);
+				const n = view.getUint32(0);
+				if (n > Math.pow(2, 21) - 1) {
+					controller.enqueue(ERROR_PACKET);
+					break;
+				}
+				expectedLength = n * Math.pow(2, 32) + view.getUint32(4);
+				state = 3;
+			} else {
+				if (totalLength(chunks) < expectedLength) break;
+				const data = concatChunks(chunks, expectedLength);
+				controller.enqueue(decodePacket(isBinary ? data : TEXT_DECODER.decode(data), binaryType));
+				state = 0;
+			}
+			if (expectedLength === 0 || expectedLength > maxPayload) {
+				controller.enqueue(ERROR_PACKET);
+				break;
+			}
+		}
+	} });
+}
+//#endregion
+//#region node_modules/@socket.io/component-emitter/lib/esm/index.js
+/**
+* Initialize a new `Emitter`.
+*
+* @api public
+*/
+function Emitter(obj) {
+	if (obj) return mixin(obj);
+}
+/**
+* Mixin the emitter properties.
+*
+* @param {Object} obj
+* @return {Object}
+* @api private
+*/
+function mixin(obj) {
+	for (var key in Emitter.prototype) obj[key] = Emitter.prototype[key];
+	return obj;
+}
+/**
+* Listen on the given `event` with `fn`.
+*
+* @param {String} event
+* @param {Function} fn
+* @return {Emitter}
+* @api public
+*/
+Emitter.prototype.on = Emitter.prototype.addEventListener = function(event, fn) {
+	this._callbacks = this._callbacks || {};
+	(this._callbacks["$" + event] = this._callbacks["$" + event] || []).push(fn);
+	return this;
+};
+/**
+* Adds an `event` listener that will be invoked a single
+* time then automatically removed.
+*
+* @param {String} event
+* @param {Function} fn
+* @return {Emitter}
+* @api public
+*/
+Emitter.prototype.once = function(event, fn) {
+	function on() {
+		this.off(event, on);
+		fn.apply(this, arguments);
+	}
+	on.fn = fn;
+	this.on(event, on);
+	return this;
+};
+/**
+* Remove the given callback for `event` or all
+* registered callbacks.
+*
+* @param {String} event
+* @param {Function} fn
+* @return {Emitter}
+* @api public
+*/
+Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function(event, fn) {
+	this._callbacks = this._callbacks || {};
+	if (0 == arguments.length) {
+		this._callbacks = {};
+		return this;
+	}
+	var callbacks = this._callbacks["$" + event];
+	if (!callbacks) return this;
+	if (1 == arguments.length) {
+		delete this._callbacks["$" + event];
+		return this;
+	}
+	var cb;
+	for (var i = 0; i < callbacks.length; i++) {
+		cb = callbacks[i];
+		if (cb === fn || cb.fn === fn) {
+			callbacks.splice(i, 1);
+			break;
+		}
+	}
+	if (callbacks.length === 0) delete this._callbacks["$" + event];
+	return this;
+};
+/**
+* Emit `event` with the given args.
+*
+* @param {String} event
+* @param {Mixed} ...
+* @return {Emitter}
+*/
+Emitter.prototype.emit = function(event) {
+	this._callbacks = this._callbacks || {};
+	var args = new Array(arguments.length - 1), callbacks = this._callbacks["$" + event];
+	for (var i = 1; i < arguments.length; i++) args[i - 1] = arguments[i];
+	if (callbacks) {
+		callbacks = callbacks.slice(0);
+		for (var i = 0, len = callbacks.length; i < len; ++i) callbacks[i].apply(this, args);
+	}
+	return this;
+};
+Emitter.prototype.emitReserved = Emitter.prototype.emit;
+/**
+* Return array of callbacks for `event`.
+*
+* @param {String} event
+* @return {Array}
+* @api public
+*/
+Emitter.prototype.listeners = function(event) {
+	this._callbacks = this._callbacks || {};
+	return this._callbacks["$" + event] || [];
+};
+/**
+* Check if this emitter has `event` handlers.
+*
+* @param {String} event
+* @return {Boolean}
+* @api public
+*/
+Emitter.prototype.hasListeners = function(event) {
+	return !!this.listeners(event).length;
+};
+//#endregion
+//#region node_modules/engine.io-client/build/esm/globals.js
+var nextTick = (() => {
+	if (typeof Promise === "function" && typeof Promise.resolve === "function") return (cb) => Promise.resolve().then(cb);
+	else return (cb, setTimeoutFn) => setTimeoutFn(cb, 0);
+})();
+var globalThisShim = (() => {
+	if (typeof self !== "undefined") return self;
+	else if (typeof window !== "undefined") return window;
+	else return Function("return this")();
+})();
+var defaultBinaryType = "arraybuffer";
+function createCookieJar() {}
+//#endregion
+//#region node_modules/engine.io-client/build/esm/util.js
+function pick(obj, ...attr) {
+	return attr.reduce((acc, k) => {
+		if (obj.hasOwnProperty(k)) acc[k] = obj[k];
+		return acc;
+	}, {});
+}
+var NATIVE_SET_TIMEOUT = globalThisShim.setTimeout;
+var NATIVE_CLEAR_TIMEOUT = globalThisShim.clearTimeout;
+function installTimerFunctions(obj, opts) {
+	if (opts.useNativeTimers) {
+		obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThisShim);
+		obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThisShim);
+	} else {
+		obj.setTimeoutFn = globalThisShim.setTimeout.bind(globalThisShim);
+		obj.clearTimeoutFn = globalThisShim.clearTimeout.bind(globalThisShim);
+	}
+}
+var BASE64_OVERHEAD = 1.33;
+function byteLength(obj) {
+	if (typeof obj === "string") return utf8Length(obj);
+	return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);
+}
+function utf8Length(str) {
+	let c = 0, length = 0;
+	for (let i = 0, l = str.length; i < l; i++) {
+		c = str.charCodeAt(i);
+		if (c < 128) length += 1;
+		else if (c < 2048) length += 2;
+		else if (c < 55296 || c >= 57344) length += 3;
+		else {
+			i++;
+			length += 4;
+		}
+	}
+	return length;
+}
+/**
+* Generates a random 8-characters string.
+*/
+function randomString() {
+	return Date.now().toString(36).substring(3) + Math.random().toString(36).substring(2, 5);
+}
+//#endregion
+//#region node_modules/engine.io-client/build/esm/contrib/parseqs.js
+/**
+* Compiles a querystring
+* Returns string representation of the object
+*
+* @param {Object}
+* @api private
+*/
+function encode(obj) {
+	let str = "";
+	for (let i in obj) if (obj.hasOwnProperty(i)) {
+		if (str.length) str += "&";
+		str += encodeURIComponent(i) + "=" + encodeURIComponent(obj[i]);
+	}
+	return str;
+}
+/**
+* Parses a simple querystring into an object
+*
+* @param {String} qs
+* @api private
+*/
+function decode(qs) {
+	let qry = {};
+	let pairs = qs.split("&");
+	for (let i = 0, l = pairs.length; i < l; i++) {
+		let pair = pairs[i].split("=");
+		qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
+	}
+	return qry;
+}
+//#endregion
+//#region node_modules/engine.io-client/build/esm/transport.js
+var TransportError = class extends Error {
+	constructor(reason, description, context) {
+		super(reason);
+		this.description = description;
+		this.context = context;
+		this.type = "TransportError";
+	}
+};
+var Transport = class extends Emitter {
+	/**
+	* Transport abstract constructor.
+	*
+	* @param {Object} opts - options
+	* @protected
+	*/
+	constructor(opts) {
+		super();
+		this.writable = false;
+		installTimerFunctions(this, opts);
+		this.opts = opts;
+		this.query = opts.query;
+		this.socket = opts.socket;
+		this.supportsBinary = !opts.forceBase64;
+	}
+	/**
+	* Emits an error.
+	*
+	* @param {String} reason
+	* @param description
+	* @param context - the error context
+	* @return {Transport} for chaining
+	* @protected
+	*/
+	onError(reason, description, context) {
+		super.emitReserved("error", new TransportError(reason, description, context));
+		return this;
+	}
+	/**
+	* Opens the transport.
+	*/
+	open() {
+		this.readyState = "opening";
+		this.doOpen();
+		return this;
+	}
+	/**
+	* Closes the transport.
+	*/
+	close() {
+		if (this.readyState === "opening" || this.readyState === "open") {
+			this.doClose();
+			this.onClose();
+		}
+		return this;
+	}
+	/**
+	* Sends multiple packets.
+	*
+	* @param {Array} packets
+	*/
+	send(packets) {
+		if (this.readyState === "open") this.write(packets);
+	}
+	/**
+	* Called upon open
+	*
+	* @protected
+	*/
+	onOpen() {
+		this.readyState = "open";
+		this.writable = true;
+		super.emitReserved("open");
+	}
+	/**
+	* Called with data.
+	*
+	* @param {String} data
+	* @protected
+	*/
+	onData(data) {
+		const packet = decodePacket(data, this.socket.binaryType);
+		this.onPacket(packet);
+	}
+	/**
+	* Called with a decoded packet.
+	*
+	* @protected
+	*/
+	onPacket(packet) {
+		super.emitReserved("packet", packet);
+	}
+	/**
+	* Called upon close.
+	*
+	* @protected
+	*/
+	onClose(details) {
+		this.readyState = "closed";
+		super.emitReserved("close", details);
+	}
+	/**
+	* Pauses the transport, in order not to lose packets during an upgrade.
+	*
+	* @param onPause
+	*/
+	pause(onPause) {}
+	createUri(schema, query = {}) {
+		return schema + "://" + this._hostname() + this._port() + this.opts.path + this._query(query);
+	}
+	_hostname() {
+		const hostname = this.opts.hostname;
+		return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]";
+	}
+	_port() {
+		if (this.opts.port && (this.opts.secure && Number(this.opts.port) !== 443 || !this.opts.secure && Number(this.opts.port) !== 80)) return ":" + this.opts.port;
+		else return "";
+	}
+	_query(query) {
+		const encodedQuery = encode(query);
+		return encodedQuery.length ? "?" + encodedQuery : "";
+	}
+};
+//#endregion
+//#region node_modules/engine.io-client/build/esm/transports/polling.js
+var Polling = class extends Transport {
+	constructor() {
+		super(...arguments);
+		this._polling = false;
+	}
+	get name() {
+		return "polling";
+	}
+	/**
+	* Opens the socket (triggers polling). We write a PING message to determine
+	* when the transport is open.
+	*
+	* @protected
+	*/
+	doOpen() {
+		this._poll();
+	}
+	/**
+	* Pauses polling.
+	*
+	* @param {Function} onPause - callback upon buffers are flushed and transport is paused
+	* @package
+	*/
+	pause(onPause) {
+		this.readyState = "pausing";
+		const pause = () => {
+			this.readyState = "paused";
+			onPause();
+		};
+		if (this._polling || !this.writable) {
+			let total = 0;
+			if (this._polling) {
+				total++;
+				this.once("pollComplete", function() {
+					--total || pause();
+				});
+			}
+			if (!this.writable) {
+				total++;
+				this.once("drain", function() {
+					--total || pause();
+				});
+			}
+		} else pause();
+	}
+	/**
+	* Starts polling cycle.
+	*
+	* @private
+	*/
+	_poll() {
+		this._polling = true;
+		this.doPoll();
+		this.emitReserved("poll");
+	}
+	/**
+	* Overloads onData to detect payloads.
+	*
+	* @protected
+	*/
+	onData(data) {
+		const callback = (packet) => {
+			if ("opening" === this.readyState && packet.type === "open") this.onOpen();
+			if ("close" === packet.type) {
+				this.onClose({ description: "transport closed by the server" });
+				return false;
+			}
+			this.onPacket(packet);
+		};
+		decodePayload(data, this.socket.binaryType).forEach(callback);
+		if ("closed" !== this.readyState) {
+			this._polling = false;
+			this.emitReserved("pollComplete");
+			if ("open" === this.readyState) this._poll();
+		}
+	}
+	/**
+	* For polling, send a close packet.
+	*
+	* @protected
+	*/
+	doClose() {
+		const close = () => {
+			this.write([{ type: "close" }]);
+		};
+		if ("open" === this.readyState) close();
+		else this.once("open", close);
+	}
+	/**
+	* Writes a packets payload.
+	*
+	* @param {Array} packets - data packets
+	* @protected
+	*/
+	write(packets) {
+		this.writable = false;
+		encodePayload(packets, (data) => {
+			this.doWrite(data, () => {
+				this.writable = true;
+				this.emitReserved("drain");
+			});
+		});
+	}
+	/**
+	* Generates uri for connection.
+	*
+	* @private
+	*/
+	uri() {
+		const schema = this.opts.secure ? "https" : "http";
+		const query = this.query || {};
+		if (false !== this.opts.timestampRequests) query[this.opts.timestampParam] = randomString();
+		if (!this.supportsBinary && !query.sid) query.b64 = 1;
+		return this.createUri(schema, query);
+	}
+};
+//#endregion
+//#region node_modules/engine.io-client/build/esm/contrib/has-cors.js
+var value = false;
+try {
+	value = typeof XMLHttpRequest !== "undefined" && "withCredentials" in new XMLHttpRequest();
+} catch (err) {}
+var hasCORS = value;
+//#endregion
+//#region node_modules/engine.io-client/build/esm/transports/polling-xhr.js
+function empty() {}
+var BaseXHR = class extends Polling {
+	/**
+	* XHR Polling constructor.
+	*
+	* @param {Object} opts
+	* @package
+	*/
+	constructor(opts) {
+		super(opts);
+		if (typeof location !== "undefined") {
+			const isSSL = "https:" === location.protocol;
+			let port = location.port;
+			if (!port) port = isSSL ? "443" : "80";
+			this.xd = typeof location !== "undefined" && opts.hostname !== location.hostname || port !== opts.port;
+		}
+	}
+	/**
+	* Sends data.
+	*
+	* @param {String} data to send.
+	* @param {Function} called upon flush.
+	* @private
+	*/
+	doWrite(data, fn) {
+		const req = this.request({
+			method: "POST",
+			data
+		});
+		req.on("success", fn);
+		req.on("error", (xhrStatus, context) => {
+			this.onError("xhr post error", xhrStatus, context);
+		});
+	}
+	/**
+	* Starts a poll cycle.
+	*
+	* @private
+	*/
+	doPoll() {
+		const req = this.request();
+		req.on("data", this.onData.bind(this));
+		req.on("error", (xhrStatus, context) => {
+			this.onError("xhr poll error", xhrStatus, context);
+		});
+		this.pollXhr = req;
+	}
+};
+var Request = class Request extends Emitter {
+	/**
+	* Request constructor
+	*
+	* @param {Object} options
+	* @package
+	*/
+	constructor(createRequest, uri, opts) {
+		super();
+		this.createRequest = createRequest;
+		installTimerFunctions(this, opts);
+		this._opts = opts;
+		this._method = opts.method || "GET";
+		this._uri = uri;
+		this._data = void 0 !== opts.data ? opts.data : null;
+		this._create();
+	}
+	/**
+	* Creates the XHR object and sends the request.
+	*
+	* @private
+	*/
+	_create() {
+		var _a;
+		const opts = pick(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+		opts.xdomain = !!this._opts.xd;
+		const xhr = this._xhr = this.createRequest(opts);
+		try {
+			xhr.open(this._method, this._uri, true);
+			try {
+				if (this._opts.extraHeaders) {
+					xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);
+					for (let i in this._opts.extraHeaders) if (this._opts.extraHeaders.hasOwnProperty(i)) xhr.setRequestHeader(i, this._opts.extraHeaders[i]);
+				}
+			} catch (e) {}
+			if ("POST" === this._method) try {
+				xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
+			} catch (e) {}
+			try {
+				xhr.setRequestHeader("Accept", "*/*");
+			} catch (e) {}
+			(_a = this._opts.cookieJar) === null || _a === void 0 || _a.addCookies(xhr);
+			if ("withCredentials" in xhr) xhr.withCredentials = this._opts.withCredentials;
+			if (this._opts.requestTimeout) xhr.timeout = this._opts.requestTimeout;
+			xhr.onreadystatechange = () => {
+				var _a;
+				if (xhr.readyState === 3) (_a = this._opts.cookieJar) === null || _a === void 0 || _a.parseCookies(xhr.getResponseHeader("set-cookie"));
+				if (4 !== xhr.readyState) return;
+				if (200 === xhr.status || 1223 === xhr.status) this._onLoad();
+				else this.setTimeoutFn(() => {
+					this._onError(typeof xhr.status === "number" ? xhr.status : 0);
+				}, 0);
+			};
+			xhr.send(this._data);
+		} catch (e) {
+			this.setTimeoutFn(() => {
+				this._onError(e);
+			}, 0);
+			return;
+		}
+		if (typeof document !== "undefined") {
+			this._index = Request.requestsCount++;
+			Request.requests[this._index] = this;
+		}
+	}
+	/**
+	* Called upon error.
+	*
+	* @private
+	*/
+	_onError(err) {
+		this.emitReserved("error", err, this._xhr);
+		this._cleanup(true);
+	}
+	/**
+	* Cleans up house.
+	*
+	* @private
+	*/
+	_cleanup(fromError) {
+		if ("undefined" === typeof this._xhr || null === this._xhr) return;
+		this._xhr.onreadystatechange = empty;
+		if (fromError) try {
+			this._xhr.abort();
+		} catch (e) {}
+		if (typeof document !== "undefined") delete Request.requests[this._index];
+		this._xhr = null;
+	}
+	/**
+	* Called upon load.
+	*
+	* @private
+	*/
+	_onLoad() {
+		const data = this._xhr.responseText;
+		if (data !== null) {
+			this.emitReserved("data", data);
+			this.emitReserved("success");
+			this._cleanup();
+		}
+	}
+	/**
+	* Aborts the request.
+	*
+	* @package
+	*/
+	abort() {
+		this._cleanup();
+	}
+};
+Request.requestsCount = 0;
+Request.requests = {};
+/**
+* Aborts pending requests when unloading the window. This is needed to prevent
+* memory leaks (e.g. when using IE) and to ensure that no spurious error is
+* emitted.
+*/
+if (typeof document !== "undefined") {
+	if (typeof attachEvent === "function") attachEvent("onunload", unloadHandler);
+	else if (typeof addEventListener === "function") {
+		const terminationEvent = "onpagehide" in globalThisShim ? "pagehide" : "unload";
+		addEventListener(terminationEvent, unloadHandler, false);
+	}
+}
+function unloadHandler() {
+	for (let i in Request.requests) if (Request.requests.hasOwnProperty(i)) Request.requests[i].abort();
+}
+var hasXHR2 = (function() {
+	const xhr = newRequest({ xdomain: false });
+	return xhr && xhr.responseType !== null;
+})();
+/**
+* HTTP long-polling based on the built-in `XMLHttpRequest` object.
+*
+* Usage: browser
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest
+*/
+var XHR = class extends BaseXHR {
+	constructor(opts) {
+		super(opts);
+		const forceBase64 = opts && opts.forceBase64;
+		this.supportsBinary = hasXHR2 && !forceBase64;
+	}
+	request(opts = {}) {
+		Object.assign(opts, { xd: this.xd }, this.opts);
+		return new Request(newRequest, this.uri(), opts);
+	}
+};
+function newRequest(opts) {
+	const xdomain = opts.xdomain;
+	try {
+		if ("undefined" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) return new XMLHttpRequest();
+	} catch (e) {}
+	if (!xdomain) try {
+		return new globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+	} catch (e) {}
+}
+//#endregion
+//#region node_modules/engine.io-client/build/esm/transports/websocket.js
+var isReactNative = typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative";
+var BaseWS = class extends Transport {
+	get name() {
+		return "websocket";
+	}
+	doOpen() {
+		const uri = this.uri();
+		const protocols = this.opts.protocols;
+		const opts = isReactNative ? {} : pick(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
+		if (this.opts.extraHeaders) opts.headers = this.opts.extraHeaders;
+		try {
+			this.ws = this.createSocket(uri, protocols, opts);
+		} catch (err) {
+			return this.emitReserved("error", err);
+		}
+		this.ws.binaryType = this.socket.binaryType;
+		this.addEventListeners();
+	}
+	/**
+	* Adds event listeners to the socket
+	*
+	* @private
+	*/
+	addEventListeners() {
+		this.ws.onopen = () => {
+			if (this.opts.autoUnref) this.ws._socket.unref();
+			this.onOpen();
+		};
+		this.ws.onclose = (closeEvent) => this.onClose({
+			description: "websocket connection closed",
+			context: closeEvent
+		});
+		this.ws.onmessage = (ev) => this.onData(ev.data);
+		this.ws.onerror = (e) => this.onError("websocket error", e);
+	}
+	write(packets) {
+		this.writable = false;
+		for (let i = 0; i < packets.length; i++) {
+			const packet = packets[i];
+			const lastPacket = i === packets.length - 1;
+			encodePacket(packet, this.supportsBinary, (data) => {
+				try {
+					this.doWrite(packet, data);
+				} catch (e) {}
+				if (lastPacket) nextTick(() => {
+					this.writable = true;
+					this.emitReserved("drain");
+				}, this.setTimeoutFn);
+			});
+		}
+	}
+	doClose() {
+		if (typeof this.ws !== "undefined") {
+			this.ws.onerror = () => {};
+			this.ws.close();
+			this.ws = null;
+		}
+	}
+	/**
+	* Generates uri for connection.
+	*
+	* @private
+	*/
+	uri() {
+		const schema = this.opts.secure ? "wss" : "ws";
+		const query = this.query || {};
+		if (this.opts.timestampRequests) query[this.opts.timestampParam] = randomString();
+		if (!this.supportsBinary) query.b64 = 1;
+		return this.createUri(schema, query);
+	}
+};
+var WebSocketCtor = globalThisShim.WebSocket || globalThisShim.MozWebSocket;
+/**
+* WebSocket transport based on the built-in `WebSocket` object.
+*
+* Usage: browser, Node.js (since v21), Deno, Bun
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+* @see https://caniuse.com/mdn-api_websocket
+* @see https://nodejs.org/api/globals.html#websocket
+*/
+var WS = class extends BaseWS {
+	createSocket(uri, protocols, opts) {
+		return !isReactNative ? protocols ? new WebSocketCtor(uri, protocols) : new WebSocketCtor(uri) : new WebSocketCtor(uri, protocols, opts);
+	}
+	doWrite(_packet, data) {
+		this.ws.send(data);
+	}
+};
+//#endregion
+//#region node_modules/engine.io-client/build/esm/transports/webtransport.js
+/**
+* WebTransport transport based on the built-in `WebTransport` object.
+*
+* Usage: browser, Node.js (with the `@fails-components/webtransport` package)
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/WebTransport
+* @see https://caniuse.com/webtransport
+*/
+var WT = class extends Transport {
+	get name() {
+		return "webtransport";
+	}
+	doOpen() {
+		try {
+			this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
+		} catch (err) {
+			return this.emitReserved("error", err);
+		}
+		this._transport.closed.then(() => {
+			this.onClose();
+		}).catch((err) => {
+			this.onError("webtransport error", err);
+		});
+		this._transport.ready.then(() => {
+			this._transport.createBidirectionalStream().then((stream) => {
+				const decoderStream = createPacketDecoderStream(Number.MAX_SAFE_INTEGER, this.socket.binaryType);
+				const reader = stream.readable.pipeThrough(decoderStream).getReader();
+				const encoderStream = createPacketEncoderStream();
+				encoderStream.readable.pipeTo(stream.writable);
+				this._writer = encoderStream.writable.getWriter();
+				const read = () => {
+					reader.read().then(({ done, value }) => {
+						if (done) return;
+						this.onPacket(value);
+						read();
+					}).catch((err) => {});
+				};
+				read();
+				const packet = { type: "open" };
+				if (this.query.sid) packet.data = `{"sid":"${this.query.sid}"}`;
+				this._writer.write(packet).then(() => this.onOpen());
+			});
+		});
+	}
+	write(packets) {
+		this.writable = false;
+		for (let i = 0; i < packets.length; i++) {
+			const packet = packets[i];
+			const lastPacket = i === packets.length - 1;
+			this._writer.write(packet).then(() => {
+				if (lastPacket) nextTick(() => {
+					this.writable = true;
+					this.emitReserved("drain");
+				}, this.setTimeoutFn);
+			});
+		}
+	}
+	doClose() {
+		var _a;
+		(_a = this._transport) === null || _a === void 0 || _a.close();
+	}
+};
+//#endregion
+//#region node_modules/engine.io-client/build/esm/transports/index.js
+var transports = {
+	websocket: WS,
+	webtransport: WT,
+	polling: XHR
+};
+//#endregion
+//#region node_modules/engine.io-client/build/esm/contrib/parseuri.js
+/**
+* Parses a URI
+*
+* Note: we could also have used the built-in URL object, but it isn't supported on all platforms.
+*
+* See:
+* - https://developer.mozilla.org/en-US/docs/Web/API/URL
+* - https://caniuse.com/url
+* - https://www.rfc-editor.org/rfc/rfc3986#appendix-B
+*
+* History of the parse() method:
+* - first commit: https://github.com/socketio/socket.io-client/commit/4ee1d5d94b3906a9c052b459f1a818b15f38f91c
+* - export into its own module: https://github.com/socketio/engine.io-client/commit/de2c561e4564efeb78f1bdb1ba39ef81b2822cb3
+* - reimport: https://github.com/socketio/engine.io-client/commit/df32277c3f6d622eec5ed09f493cae3f3391d242
+*
+* @author Steven Levithan <stevenlevithan.com> (MIT license)
+* @api private
+*/
+var re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
+var parts = [
+	"source",
+	"protocol",
+	"authority",
+	"userInfo",
+	"user",
+	"password",
+	"host",
+	"port",
+	"relative",
+	"path",
+	"directory",
+	"file",
+	"query",
+	"anchor"
+];
+function parse(str) {
+	if (str.length > 8e3) throw "URI too long";
+	const src = str, b = str.indexOf("["), e = str.indexOf("]");
+	if (b != -1 && e != -1) str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ";") + str.substring(e, str.length);
+	let m = re.exec(str || ""), uri = {}, i = 14;
+	while (i--) uri[parts[i]] = m[i] || "";
+	if (b != -1 && e != -1) {
+		uri.source = src;
+		uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ":");
+		uri.authority = uri.authority.replace("[", "").replace("]", "").replace(/;/g, ":");
+		uri.ipv6uri = true;
+	}
+	uri.pathNames = pathNames(uri, uri["path"]);
+	uri.queryKey = queryKey(uri, uri["query"]);
+	return uri;
+}
+function pathNames(obj, path) {
+	const names = path.replace(/\/{2,9}/g, "/").split("/");
+	if (path.slice(0, 1) == "/" || path.length === 0) names.splice(0, 1);
+	if (path.slice(-1) == "/") names.splice(names.length - 1, 1);
+	return names;
+}
+function queryKey(uri, query) {
+	const data = {};
+	query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function($0, $1, $2) {
+		if ($1) data[$1] = $2;
+	});
+	return data;
+}
+//#endregion
+//#region node_modules/engine.io-client/build/esm/socket.js
+var withEventListeners = typeof addEventListener === "function" && typeof removeEventListener === "function";
+var OFFLINE_EVENT_LISTENERS = [];
+if (withEventListeners) addEventListener("offline", () => {
+	OFFLINE_EVENT_LISTENERS.forEach((listener) => listener());
+}, false);
+/**
+* This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
+* with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
+*
+* This class comes without upgrade mechanism, which means that it will keep the first low-level transport that
+* successfully establishes the connection.
+*
+* In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
+*
+* @example
+* import { SocketWithoutUpgrade, WebSocket } from "engine.io-client";
+*
+* const socket = new SocketWithoutUpgrade({
+*   transports: [WebSocket]
+* });
+*
+* socket.on("open", () => {
+*   socket.send("hello");
+* });
+*
+* @see SocketWithUpgrade
+* @see Socket
+*/
+var SocketWithoutUpgrade = class SocketWithoutUpgrade extends Emitter {
+	/**
+	* Socket constructor.
+	*
+	* @param {String|Object} uri - uri or options
+	* @param {Object} opts - options
+	*/
+	constructor(uri, opts) {
+		super();
+		this.binaryType = defaultBinaryType;
+		this.writeBuffer = [];
+		this._prevBufferLen = 0;
+		this._pingInterval = -1;
+		this._pingTimeout = -1;
+		this._maxPayload = -1;
+		/**
+		* The expiration timestamp of the {@link _pingTimeoutTimer} object is tracked, in case the timer is throttled and the
+		* callback is not fired on time. This can happen for example when a laptop is suspended or when a phone is locked.
+		*/
+		this._pingTimeoutTime = Infinity;
+		if (uri && "object" === typeof uri) {
+			opts = uri;
+			uri = null;
+		}
+		if (uri) {
+			const parsedUri = parse(uri);
+			opts.hostname = parsedUri.host;
+			opts.secure = parsedUri.protocol === "https" || parsedUri.protocol === "wss";
+			opts.port = parsedUri.port;
+			if (parsedUri.query) opts.query = parsedUri.query;
+		} else if (opts.host) opts.hostname = parse(opts.host).host;
+		installTimerFunctions(this, opts);
+		this.secure = null != opts.secure ? opts.secure : typeof location !== "undefined" && "https:" === location.protocol;
+		if (opts.hostname && !opts.port) opts.port = this.secure ? "443" : "80";
+		this.hostname = opts.hostname || (typeof location !== "undefined" ? location.hostname : "localhost");
+		this.port = opts.port || (typeof location !== "undefined" && location.port ? location.port : this.secure ? "443" : "80");
+		this.transports = [];
+		this._transportsByName = {};
+		opts.transports.forEach((t) => {
+			const transportName = t.prototype.name;
+			this.transports.push(transportName);
+			this._transportsByName[transportName] = t;
+		});
+		this.opts = Object.assign({
+			path: "/engine.io",
+			agent: false,
+			withCredentials: false,
+			upgrade: true,
+			timestampParam: "t",
+			rememberUpgrade: false,
+			addTrailingSlash: true,
+			rejectUnauthorized: true,
+			perMessageDeflate: { threshold: 1024 },
+			transportOptions: {},
+			closeOnBeforeunload: false
+		}, opts);
+		this.opts.path = this.opts.path.replace(/\/$/, "") + (this.opts.addTrailingSlash ? "/" : "");
+		if (typeof this.opts.query === "string") this.opts.query = decode(this.opts.query);
+		if (withEventListeners) {
+			if (this.opts.closeOnBeforeunload) {
+				this._beforeunloadEventListener = () => {
+					if (this.transport) {
+						this.transport.removeAllListeners();
+						this.transport.close();
+					}
+				};
+				addEventListener("beforeunload", this._beforeunloadEventListener, false);
+			}
+			if (this.hostname !== "localhost") {
+				this._offlineEventListener = () => {
+					this._onClose("transport close", { description: "network connection lost" });
+				};
+				OFFLINE_EVENT_LISTENERS.push(this._offlineEventListener);
+			}
+		}
+		if (this.opts.withCredentials) this._cookieJar = /* @__PURE__ */ createCookieJar();
+		this._open();
+	}
+	/**
+	* Creates transport of the given type.
+	*
+	* @param {String} name - transport name
+	* @return {Transport}
+	* @private
+	*/
+	createTransport(name) {
+		const query = Object.assign({}, this.opts.query);
+		query.EIO = 4;
+		query.transport = name;
+		if (this.id) query.sid = this.id;
+		const opts = Object.assign({}, this.opts, {
+			query,
+			socket: this,
+			hostname: this.hostname,
+			secure: this.secure,
+			port: this.port
+		}, this.opts.transportOptions[name]);
+		return new this._transportsByName[name](opts);
+	}
+	/**
+	* Initializes transport to use and starts probe.
+	*
+	* @private
+	*/
+	_open() {
+		if (this.transports.length === 0) {
+			this.setTimeoutFn(() => {
+				this.emitReserved("error", "No transports available");
+			}, 0);
+			return;
+		}
+		const transportName = this.opts.rememberUpgrade && SocketWithoutUpgrade.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1 ? "websocket" : this.transports[0];
+		this.readyState = "opening";
+		const transport = this.createTransport(transportName);
+		transport.open();
+		this.setTransport(transport);
+	}
+	/**
+	* Sets the current transport. Disables the existing one (if any).
+	*
+	* @private
+	*/
+	setTransport(transport) {
+		if (this.transport) this.transport.removeAllListeners();
+		this.transport = transport;
+		transport.on("drain", this._onDrain.bind(this)).on("packet", this._onPacket.bind(this)).on("error", this._onError.bind(this)).on("close", (reason) => this._onClose("transport close", reason));
+	}
+	/**
+	* Called when connection is deemed open.
+	*
+	* @private
+	*/
+	onOpen() {
+		this.readyState = "open";
+		SocketWithoutUpgrade.priorWebsocketSuccess = "websocket" === this.transport.name;
+		this.emitReserved("open");
+		this.flush();
+	}
+	/**
+	* Handles a packet.
+	*
+	* @private
+	*/
+	_onPacket(packet) {
+		if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
+			this.emitReserved("packet", packet);
+			this.emitReserved("heartbeat");
+			switch (packet.type) {
+				case "open":
+					this.onHandshake(JSON.parse(packet.data));
+					break;
+				case "ping":
+					this._sendPacket("pong");
+					this.emitReserved("ping");
+					this.emitReserved("pong");
+					this._resetPingTimeout();
+					break;
+				case "error":
+					const err = /* @__PURE__ */ new Error("server error");
+					err.code = packet.data;
+					this._onError(err);
+					break;
+				case "message":
+					this.emitReserved("data", packet.data);
+					this.emitReserved("message", packet.data);
+					break;
+			}
+		}
+	}
+	/**
+	* Called upon handshake completion.
+	*
+	* @param {Object} data - handshake obj
+	* @private
+	*/
+	onHandshake(data) {
+		this.emitReserved("handshake", data);
+		this.id = data.sid;
+		this.transport.query.sid = data.sid;
+		this._pingInterval = data.pingInterval;
+		this._pingTimeout = data.pingTimeout;
+		this._maxPayload = data.maxPayload;
+		this.onOpen();
+		if ("closed" === this.readyState) return;
+		this._resetPingTimeout();
+	}
+	/**
+	* Sets and resets ping timeout timer based on server pings.
+	*
+	* @private
+	*/
+	_resetPingTimeout() {
+		this.clearTimeoutFn(this._pingTimeoutTimer);
+		const delay = this._pingInterval + this._pingTimeout;
+		this._pingTimeoutTime = Date.now() + delay;
+		this._pingTimeoutTimer = this.setTimeoutFn(() => {
+			this._onClose("ping timeout");
+		}, delay);
+		if (this.opts.autoUnref) this._pingTimeoutTimer.unref();
+	}
+	/**
+	* Called on `drain` event
+	*
+	* @private
+	*/
+	_onDrain() {
+		this.writeBuffer.splice(0, this._prevBufferLen);
+		this._prevBufferLen = 0;
+		if (0 === this.writeBuffer.length) this.emitReserved("drain");
+		else this.flush();
+	}
+	/**
+	* Flush write buffers.
+	*
+	* @private
+	*/
+	flush() {
+		if ("closed" !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
+			const packets = this._getWritablePackets();
+			this.transport.send(packets);
+			this._prevBufferLen = packets.length;
+			this.emitReserved("flush");
+		}
+	}
+	/**
+	* Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP
+	* long-polling)
+	*
+	* @private
+	*/
+	_getWritablePackets() {
+		if (!(this._maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1)) return this.writeBuffer;
+		let payloadSize = 1;
+		for (let i = 0; i < this.writeBuffer.length; i++) {
+			const data = this.writeBuffer[i].data;
+			if (data) payloadSize += byteLength(data);
+			if (i > 0 && payloadSize > this._maxPayload) return this.writeBuffer.slice(0, i);
+			payloadSize += 2;
+		}
+		return this.writeBuffer;
+	}
+	/**
+	* Checks whether the heartbeat timer has expired but the socket has not yet been notified.
+	*
+	* Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the
+	* `write()` method then the message would not be buffered by the Socket.IO client.
+	*
+	* @return {boolean}
+	* @private
+	*/
+	_hasPingExpired() {
+		if (!this._pingTimeoutTime) return true;
+		const hasExpired = Date.now() > this._pingTimeoutTime;
+		if (hasExpired) {
+			this._pingTimeoutTime = 0;
+			nextTick(() => {
+				this._onClose("ping timeout");
+			}, this.setTimeoutFn);
+		}
+		return hasExpired;
+	}
+	/**
+	* Sends a message.
+	*
+	* @param {String} msg - message.
+	* @param {Object} options.
+	* @param {Function} fn - callback function.
+	* @return {Socket} for chaining.
+	*/
+	write(msg, options, fn) {
+		this._sendPacket("message", msg, options, fn);
+		return this;
+	}
+	/**
+	* Sends a message. Alias of {@link Socket#write}.
+	*
+	* @param {String} msg - message.
+	* @param {Object} options.
+	* @param {Function} fn - callback function.
+	* @return {Socket} for chaining.
+	*/
+	send(msg, options, fn) {
+		this._sendPacket("message", msg, options, fn);
+		return this;
+	}
+	/**
+	* Sends a packet.
+	*
+	* @param {String} type: packet type.
+	* @param {String} data.
+	* @param {Object} options.
+	* @param {Function} fn - callback function.
+	* @private
+	*/
+	_sendPacket(type, data, options, fn) {
+		if ("function" === typeof data) {
+			fn = data;
+			data = void 0;
+		}
+		if ("function" === typeof options) {
+			fn = options;
+			options = null;
+		}
+		if ("closing" === this.readyState || "closed" === this.readyState) return;
+		options = options || {};
+		options.compress = false !== options.compress;
+		const packet = {
+			type,
+			data,
+			options
+		};
+		this.emitReserved("packetCreate", packet);
+		this.writeBuffer.push(packet);
+		if (fn) this.once("flush", fn);
+		this.flush();
+	}
+	/**
+	* Closes the connection.
+	*/
+	close() {
+		const close = () => {
+			this._onClose("forced close");
+			this.transport.close();
+		};
+		const cleanupAndClose = () => {
+			this.off("upgrade", cleanupAndClose);
+			this.off("upgradeError", cleanupAndClose);
+			close();
+		};
+		const waitForUpgrade = () => {
+			this.once("upgrade", cleanupAndClose);
+			this.once("upgradeError", cleanupAndClose);
+		};
+		if ("opening" === this.readyState || "open" === this.readyState) {
+			this.readyState = "closing";
+			if (this.writeBuffer.length) this.once("drain", () => {
+				if (this.upgrading) waitForUpgrade();
+				else close();
+			});
+			else if (this.upgrading) waitForUpgrade();
+			else close();
+		}
+		return this;
+	}
+	/**
+	* Called upon transport error
+	*
+	* @private
+	*/
+	_onError(err) {
+		SocketWithoutUpgrade.priorWebsocketSuccess = false;
+		if (this.opts.tryAllTransports && this.transports.length > 1 && this.readyState === "opening") {
+			this.transports.shift();
+			return this._open();
+		}
+		this.emitReserved("error", err);
+		this._onClose("transport error", err);
+	}
+	/**
+	* Called upon transport close.
+	*
+	* @private
+	*/
+	_onClose(reason, description) {
+		if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
+			this.clearTimeoutFn(this._pingTimeoutTimer);
+			this.transport.removeAllListeners("close");
+			this.transport.close();
+			this.transport.removeAllListeners();
+			if (withEventListeners) {
+				if (this._beforeunloadEventListener) removeEventListener("beforeunload", this._beforeunloadEventListener, false);
+				if (this._offlineEventListener) {
+					const i = OFFLINE_EVENT_LISTENERS.indexOf(this._offlineEventListener);
+					if (i !== -1) OFFLINE_EVENT_LISTENERS.splice(i, 1);
+				}
+			}
+			this.readyState = "closed";
+			this.id = null;
+			this.emitReserved("close", reason, description);
+			this.writeBuffer = [];
+			this._prevBufferLen = 0;
+		}
+	}
+};
+SocketWithoutUpgrade.protocol = 4;
+/**
+* This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
+* with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
+*
+* This class comes with an upgrade mechanism, which means that once the connection is established with the first
+* low-level transport, it will try to upgrade to a better transport.
+*
+* In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
+*
+* @example
+* import { SocketWithUpgrade, WebSocket } from "engine.io-client";
+*
+* const socket = new SocketWithUpgrade({
+*   transports: [WebSocket]
+* });
+*
+* socket.on("open", () => {
+*   socket.send("hello");
+* });
+*
+* @see SocketWithoutUpgrade
+* @see Socket
+*/
+var SocketWithUpgrade = class extends SocketWithoutUpgrade {
+	constructor() {
+		super(...arguments);
+		this._upgrades = [];
+	}
+	onOpen() {
+		super.onOpen();
+		if ("open" === this.readyState && this.opts.upgrade) for (let i = 0; i < this._upgrades.length; i++) this._probe(this._upgrades[i]);
+	}
+	/**
+	* Probes a transport.
+	*
+	* @param {String} name - transport name
+	* @private
+	*/
+	_probe(name) {
+		let transport = this.createTransport(name);
+		let failed = false;
+		SocketWithoutUpgrade.priorWebsocketSuccess = false;
+		const onTransportOpen = () => {
+			if (failed) return;
+			transport.send([{
+				type: "ping",
+				data: "probe"
+			}]);
+			transport.once("packet", (msg) => {
+				if (failed) return;
+				if ("pong" === msg.type && "probe" === msg.data) {
+					this.upgrading = true;
+					this.emitReserved("upgrading", transport);
+					if (!transport) return;
+					SocketWithoutUpgrade.priorWebsocketSuccess = "websocket" === transport.name;
+					this.transport.pause(() => {
+						if (failed) return;
+						if ("closed" === this.readyState) return;
+						cleanup();
+						this.setTransport(transport);
+						transport.send([{ type: "upgrade" }]);
+						this.emitReserved("upgrade", transport);
+						transport = null;
+						this.upgrading = false;
+						this.flush();
+					});
+				} else {
+					const err = /* @__PURE__ */ new Error("probe error");
+					err.transport = transport.name;
+					this.emitReserved("upgradeError", err);
+				}
+			});
+		};
+		function freezeTransport() {
+			if (failed) return;
+			failed = true;
+			cleanup();
+			transport.close();
+			transport = null;
+		}
+		const onerror = (err) => {
+			const error = /* @__PURE__ */ new Error("probe error: " + err);
+			error.transport = transport.name;
+			freezeTransport();
+			this.emitReserved("upgradeError", error);
+		};
+		function onTransportClose() {
+			onerror("transport closed");
+		}
+		function onclose() {
+			onerror("socket closed");
+		}
+		function onupgrade(to) {
+			if (transport && to.name !== transport.name) freezeTransport();
+		}
+		const cleanup = () => {
+			transport.removeListener("open", onTransportOpen);
+			transport.removeListener("error", onerror);
+			transport.removeListener("close", onTransportClose);
+			this.off("close", onclose);
+			this.off("upgrading", onupgrade);
+		};
+		transport.once("open", onTransportOpen);
+		transport.once("error", onerror);
+		transport.once("close", onTransportClose);
+		this.once("close", onclose);
+		this.once("upgrading", onupgrade);
+		if (this._upgrades.indexOf("webtransport") !== -1 && name !== "webtransport") this.setTimeoutFn(() => {
+			if (!failed) transport.open();
+		}, 200);
+		else transport.open();
+	}
+	onHandshake(data) {
+		this._upgrades = this._filterUpgrades(data.upgrades);
+		super.onHandshake(data);
+	}
+	/**
+	* Filters upgrades, returning only those matching client transports.
+	*
+	* @param {Array} upgrades - server upgrades
+	* @private
+	*/
+	_filterUpgrades(upgrades) {
+		const filteredUpgrades = [];
+		for (let i = 0; i < upgrades.length; i++) if (~this.transports.indexOf(upgrades[i])) filteredUpgrades.push(upgrades[i]);
+		return filteredUpgrades;
+	}
+};
+/**
+* This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
+* with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
+*
+* This class comes with an upgrade mechanism, which means that once the connection is established with the first
+* low-level transport, it will try to upgrade to a better transport.
+*
+* @example
+* import { Socket } from "engine.io-client";
+*
+* const socket = new Socket();
+*
+* socket.on("open", () => {
+*   socket.send("hello");
+* });
+*
+* @see SocketWithoutUpgrade
+* @see SocketWithUpgrade
+*/
+var Socket$1 = class extends SocketWithUpgrade {
+	constructor(uri, opts = {}) {
+		const o = typeof uri === "object" ? uri : opts;
+		if (!o.transports || o.transports && typeof o.transports[0] === "string") o.transports = (o.transports || [
+			"polling",
+			"websocket",
+			"webtransport"
+		]).map((transportName) => transports[transportName]).filter((t) => !!t);
+		super(uri, o);
+	}
+};
+Socket$1.protocol;
+//#endregion
+//#region node_modules/socket.io-client/build/esm/url.js
+/**
+* URL parser.
+*
+* @param uri - url
+* @param path - the request path of the connection
+* @param loc - An object meant to mimic window.location.
+*        Defaults to window.location.
+* @public
+*/
+function url(uri, path = "", loc) {
+	let obj = uri;
+	loc = loc || typeof location !== "undefined" && location;
+	if (null == uri) uri = loc.protocol + "//" + loc.host;
+	if (typeof uri === "string") {
+		if ("/" === uri.charAt(0)) if ("/" === uri.charAt(1)) uri = loc.protocol + uri;
+		else uri = loc.host + uri;
+		if (!/^(https?|wss?):\/\//.test(uri)) if ("undefined" !== typeof loc) uri = loc.protocol + "//" + uri;
+		else uri = "https://" + uri;
+		obj = parse(uri);
+	}
+	if (!obj.port) {
+		if (/^(http|ws)$/.test(obj.protocol)) obj.port = "80";
+		else if (/^(http|ws)s$/.test(obj.protocol)) obj.port = "443";
+	}
+	obj.path = obj.path || "/";
+	const host = obj.host.indexOf(":") !== -1 ? "[" + obj.host + "]" : obj.host;
+	obj.id = obj.protocol + "://" + host + ":" + obj.port + path;
+	obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port);
+	return obj;
+}
+//#endregion
+//#region node_modules/socket.io-parser/build/esm/is-binary.js
+var withNativeArrayBuffer = typeof ArrayBuffer === "function";
+var isView = (obj) => {
+	return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer;
+};
+var toString = Object.prototype.toString;
+var withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && toString.call(Blob) === "[object BlobConstructor]";
+var withNativeFile = typeof File === "function" || typeof File !== "undefined" && toString.call(File) === "[object FileConstructor]";
+/**
+* Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File.
+*
+* @private
+*/
+function isBinary(obj) {
+	return withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj)) || withNativeBlob && obj instanceof Blob || withNativeFile && obj instanceof File;
+}
+function hasBinary(obj, toJSON) {
+	if (!obj || typeof obj !== "object") return false;
+	if (Array.isArray(obj)) {
+		for (let i = 0, l = obj.length; i < l; i++) if (hasBinary(obj[i])) return true;
+		return false;
+	}
+	if (isBinary(obj)) return true;
+	if (obj.toJSON && typeof obj.toJSON === "function" && arguments.length === 1) return hasBinary(obj.toJSON(), true);
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) return true;
+	return false;
+}
+//#endregion
+//#region node_modules/socket.io-parser/build/esm/binary.js
+/**
+* Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.
+*
+* @param {Object} packet - socket.io event packet
+* @return {Object} with deconstructed packet and list of buffers
+* @public
+*/
+function deconstructPacket(packet) {
+	const buffers = [];
+	const packetData = packet.data;
+	const pack = packet;
+	pack.data = _deconstructPacket(packetData, buffers);
+	pack.attachments = buffers.length;
+	return {
+		packet: pack,
+		buffers
+	};
+}
+function _deconstructPacket(data, buffers) {
+	if (!data) return data;
+	if (isBinary(data)) {
+		const placeholder = {
+			_placeholder: true,
+			num: buffers.length
+		};
+		buffers.push(data);
+		return placeholder;
+	} else if (Array.isArray(data)) {
+		const newData = new Array(data.length);
+		for (let i = 0; i < data.length; i++) newData[i] = _deconstructPacket(data[i], buffers);
+		return newData;
+	} else if (typeof data === "object" && !(data instanceof Date)) {
+		const newData = {};
+		for (const key in data) if (Object.prototype.hasOwnProperty.call(data, key)) newData[key] = _deconstructPacket(data[key], buffers);
+		return newData;
+	}
+	return data;
+}
+/**
+* Reconstructs a binary packet from its placeholder packet and buffers
+*
+* @param {Object} packet - event packet with placeholders
+* @param {Array} buffers - binary buffers to put in placeholder positions
+* @return {Object} reconstructed packet
+* @public
+*/
+function reconstructPacket(packet, buffers) {
+	packet.data = _reconstructPacket(packet.data, buffers);
+	delete packet.attachments;
+	return packet;
+}
+function _reconstructPacket(data, buffers) {
+	if (!data) return data;
+	if (data && data._placeholder === true) if (typeof data.num === "number" && data.num >= 0 && data.num < buffers.length) return buffers[data.num];
+	else throw new Error("illegal attachments");
+	else if (Array.isArray(data)) for (let i = 0; i < data.length; i++) data[i] = _reconstructPacket(data[i], buffers);
+	else if (typeof data === "object") {
+		for (const key in data) if (Object.prototype.hasOwnProperty.call(data, key)) data[key] = _reconstructPacket(data[key], buffers);
+	}
+	return data;
+}
+//#endregion
+//#region node_modules/socket.io-parser/build/esm/index.js
+var esm_exports = /* @__PURE__ */ __exportAll({
+	Decoder: () => Decoder,
+	Encoder: () => Encoder,
+	PacketType: () => PacketType,
+	isPacketValid: () => isPacketValid,
+	protocol: () => 5
+});
+/**
+* These strings must not be used as event names, as they have a special meaning.
+*/
+var RESERVED_EVENTS$1 = [
+	"connect",
+	"connect_error",
+	"disconnect",
+	"disconnecting",
+	"newListener",
+	"removeListener"
+];
+var PacketType;
+(function(PacketType) {
+	PacketType[PacketType["CONNECT"] = 0] = "CONNECT";
+	PacketType[PacketType["DISCONNECT"] = 1] = "DISCONNECT";
+	PacketType[PacketType["EVENT"] = 2] = "EVENT";
+	PacketType[PacketType["ACK"] = 3] = "ACK";
+	PacketType[PacketType["CONNECT_ERROR"] = 4] = "CONNECT_ERROR";
+	PacketType[PacketType["BINARY_EVENT"] = 5] = "BINARY_EVENT";
+	PacketType[PacketType["BINARY_ACK"] = 6] = "BINARY_ACK";
+})(PacketType || (PacketType = {}));
+/**
+* A socket.io Encoder instance
+*/
+var Encoder = class {
+	/**
+	* Encoder constructor
+	*
+	* @param {function} replacer - custom replacer to pass down to JSON.parse
+	*/
+	constructor(replacer) {
+		this.replacer = replacer;
+	}
+	/**
+	* Encode a packet as a single string if non-binary, or as a
+	* buffer sequence, depending on packet type.
+	*
+	* @param {Object} obj - packet object
+	*/
+	encode(obj) {
+		if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
+			if (hasBinary(obj)) return this.encodeAsBinary({
+				type: obj.type === PacketType.EVENT ? PacketType.BINARY_EVENT : PacketType.BINARY_ACK,
+				nsp: obj.nsp,
+				data: obj.data,
+				id: obj.id
+			});
+		}
+		return [this.encodeAsString(obj)];
+	}
+	/**
+	* Encode packet as string.
+	*/
+	encodeAsString(obj) {
+		let str = "" + obj.type;
+		if (obj.type === PacketType.BINARY_EVENT || obj.type === PacketType.BINARY_ACK) str += obj.attachments + "-";
+		if (obj.nsp && "/" !== obj.nsp) str += obj.nsp + ",";
+		if (null != obj.id) str += obj.id;
+		if (null != obj.data) str += JSON.stringify(obj.data, this.replacer);
+		return str;
+	}
+	/**
+	* Encode packet as 'buffer sequence' by removing blobs, and
+	* deconstructing packet into object with placeholders and
+	* a list of buffers.
+	*/
+	encodeAsBinary(obj) {
+		const deconstruction = deconstructPacket(obj);
+		const pack = this.encodeAsString(deconstruction.packet);
+		const buffers = deconstruction.buffers;
+		buffers.unshift(pack);
+		return buffers;
+	}
+};
+/**
+* A socket.io Decoder instance
+*
+* @return {Object} decoder
+*/
+var Decoder = class Decoder extends Emitter {
+	/**
+	* Decoder constructor
+	*/
+	constructor(opts) {
+		super();
+		this.opts = Object.assign({
+			reviver: void 0,
+			maxAttachments: 10
+		}, typeof opts === "function" ? { reviver: opts } : opts);
+	}
+	/**
+	* Decodes an encoded packet string into packet JSON.
+	*
+	* @param {String} obj - encoded packet
+	*/
+	add(obj) {
+		let packet;
+		if (typeof obj === "string") {
+			if (this.reconstructor) throw new Error("got plaintext data when reconstructing a packet");
+			packet = this.decodeString(obj);
+			const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;
+			if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {
+				packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;
+				this.reconstructor = new BinaryReconstructor(packet);
+				if (packet.attachments === 0) super.emitReserved("decoded", packet);
+			} else super.emitReserved("decoded", packet);
+		} else if (isBinary(obj) || obj.base64) if (!this.reconstructor) throw new Error("got binary data when not reconstructing a packet");
+		else {
+			packet = this.reconstructor.takeBinaryData(obj);
+			if (packet) {
+				this.reconstructor = null;
+				super.emitReserved("decoded", packet);
+			}
+		}
+		else throw new Error("Unknown type: " + obj);
+	}
+	/**
+	* Decode a packet String (JSON data)
+	*
+	* @param {String} str
+	* @return {Object} packet
+	*/
+	decodeString(str) {
+		let i = 0;
+		const p = { type: Number(str.charAt(0)) };
+		if (PacketType[p.type] === void 0) throw new Error("unknown packet type " + p.type);
+		if (p.type === PacketType.BINARY_EVENT || p.type === PacketType.BINARY_ACK) {
+			const start = i + 1;
+			while (str.charAt(++i) !== "-" && i != str.length);
+			const buf = str.substring(start, i);
+			if (buf != Number(buf) || str.charAt(i) !== "-") throw new Error("Illegal attachments");
+			const n = Number(buf);
+			if (!isInteger(n) || n < 0) throw new Error("Illegal attachments");
+			else if (n > this.opts.maxAttachments) throw new Error("too many attachments");
+			p.attachments = n;
+		}
+		if ("/" === str.charAt(i + 1)) {
+			const start = i + 1;
+			while (++i) {
+				if ("," === str.charAt(i)) break;
+				if (i === str.length) break;
+			}
+			p.nsp = str.substring(start, i);
+		} else p.nsp = "/";
+		const next = str.charAt(i + 1);
+		if ("" !== next && Number(next) == next) {
+			const start = i + 1;
+			while (++i) {
+				const c = str.charAt(i);
+				if (null == c || Number(c) != c) {
+					--i;
+					break;
+				}
+				if (i === str.length) break;
+			}
+			p.id = Number(str.substring(start, i + 1));
+		}
+		if (str.charAt(++i)) {
+			const payload = this.tryParse(str.substr(i));
+			if (Decoder.isPayloadValid(p.type, payload)) p.data = payload;
+			else throw new Error("invalid payload");
+		}
+		return p;
+	}
+	tryParse(str) {
+		try {
+			return JSON.parse(str, this.opts.reviver);
+		} catch (e) {
+			return false;
+		}
+	}
+	static isPayloadValid(type, payload) {
+		switch (type) {
+			case PacketType.CONNECT: return isObject(payload);
+			case PacketType.DISCONNECT: return payload === void 0;
+			case PacketType.CONNECT_ERROR: return typeof payload === "string" || isObject(payload);
+			case PacketType.EVENT:
+			case PacketType.BINARY_EVENT: return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS$1.indexOf(payload[0]) === -1);
+			case PacketType.ACK:
+			case PacketType.BINARY_ACK: return Array.isArray(payload);
+		}
+	}
+	/**
+	* Deallocates a parser's resources
+	*/
+	destroy() {
+		if (this.reconstructor) {
+			this.reconstructor.finishedReconstruction();
+			this.reconstructor = null;
+		}
+	}
+};
+/**
+* A manager of a binary event's 'buffer sequence'. Should
+* be constructed whenever a packet of type BINARY_EVENT is
+* decoded.
+*
+* @param {Object} packet
+* @return {BinaryReconstructor} initialized reconstructor
+*/
+var BinaryReconstructor = class {
+	constructor(packet) {
+		this.packet = packet;
+		this.buffers = [];
+		this.reconPack = packet;
+	}
+	/**
+	* Method to be called when binary data received from connection
+	* after a BINARY_EVENT packet.
+	*
+	* @param {Buffer | ArrayBuffer} binData - the raw binary data received
+	* @return {null | Object} returns null if more binary data is expected or
+	*   a reconstructed packet object if all buffers have been received.
+	*/
+	takeBinaryData(binData) {
+		this.buffers.push(binData);
+		if (this.buffers.length === this.reconPack.attachments) {
+			const packet = reconstructPacket(this.reconPack, this.buffers);
+			this.finishedReconstruction();
+			return packet;
+		}
+		return null;
+	}
+	/**
+	* Cleans up binary packet reconstruction variables.
+	*/
+	finishedReconstruction() {
+		this.reconPack = null;
+		this.buffers = [];
+	}
+};
+function isNamespaceValid(nsp) {
+	return typeof nsp === "string";
+}
+var isInteger = Number.isInteger || function(value) {
+	return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
+};
+function isAckIdValid(id) {
+	return id === void 0 || isInteger(id);
+}
+function isObject(value) {
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isDataValid(type, payload) {
+	switch (type) {
+		case PacketType.CONNECT: return payload === void 0 || isObject(payload);
+		case PacketType.DISCONNECT: return payload === void 0;
+		case PacketType.EVENT: return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS$1.indexOf(payload[0]) === -1);
+		case PacketType.ACK: return Array.isArray(payload);
+		case PacketType.CONNECT_ERROR: return typeof payload === "string" || isObject(payload);
+		default: return false;
+	}
+}
+function isPacketValid(packet) {
+	return isNamespaceValid(packet.nsp) && isAckIdValid(packet.id) && isDataValid(packet.type, packet.data);
+}
+//#endregion
+//#region node_modules/socket.io-client/build/esm/on.js
+function on(obj, ev, fn) {
+	obj.on(ev, fn);
+	return function subDestroy() {
+		obj.off(ev, fn);
+	};
+}
+//#endregion
+//#region node_modules/socket.io-client/build/esm/socket.js
+/**
+* Internal events.
+* These events can't be emitted by the user.
+*/
+var RESERVED_EVENTS = Object.freeze({
+	connect: 1,
+	connect_error: 1,
+	disconnect: 1,
+	disconnecting: 1,
+	newListener: 1,
+	removeListener: 1
+});
+/**
+* A Socket is the fundamental class for interacting with the server.
+*
+* A Socket belongs to a certain Namespace (by default /) and uses an underlying {@link Manager} to communicate.
+*
+* @example
+* const socket = io();
+*
+* socket.on("connect", () => {
+*   console.log("connected");
+* });
+*
+* // send an event to the server
+* socket.emit("foo", "bar");
+*
+* socket.on("foobar", () => {
+*   // an event was received from the server
+* });
+*
+* // upon disconnection
+* socket.on("disconnect", (reason) => {
+*   console.log(`disconnected due to ${reason}`);
+* });
+*/
+var Socket = class extends Emitter {
+	/**
+	* `Socket` constructor.
+	*/
+	constructor(io, nsp, opts) {
+		super();
+		/**
+		* Whether the socket is currently connected to the server.
+		*
+		* @example
+		* const socket = io();
+		*
+		* socket.on("connect", () => {
+		*   console.log(socket.connected); // true
+		* });
+		*
+		* socket.on("disconnect", () => {
+		*   console.log(socket.connected); // false
+		* });
+		*/
+		this.connected = false;
+		/**
+		* Whether the connection state was recovered after a temporary disconnection. In that case, any missed packets will
+		* be transmitted by the server.
+		*/
+		this.recovered = false;
+		/**
+		* Buffer for packets received before the CONNECT packet
+		*/
+		this.receiveBuffer = [];
+		/**
+		* Buffer for packets that will be sent once the socket is connected
+		*/
+		this.sendBuffer = [];
+		/**
+		* The queue of packets to be sent with retry in case of failure.
+		*
+		* Packets are sent one by one, each waiting for the server acknowledgement, in order to guarantee the delivery order.
+		* @private
+		*/
+		this._queue = [];
+		/**
+		* A sequence to generate the ID of the {@link QueuedPacket}.
+		* @private
+		*/
+		this._queueSeq = 0;
+		this.ids = 0;
+		/**
+		* A map containing acknowledgement handlers.
+		*
+		* The `withError` attribute is used to differentiate handlers that accept an error as first argument:
+		*
+		* - `socket.emit("test", (err, value) => { ... })` with `ackTimeout` option
+		* - `socket.timeout(5000).emit("test", (err, value) => { ... })`
+		* - `const value = await socket.emitWithAck("test")`
+		*
+		* From those that don't:
+		*
+		* - `socket.emit("test", (value) => { ... });`
+		*
+		* In the first case, the handlers will be called with an error when:
+		*
+		* - the timeout is reached
+		* - the socket gets disconnected
+		*
+		* In the second case, the handlers will be simply discarded upon disconnection, since the client will never receive
+		* an acknowledgement from the server.
+		*
+		* @private
+		*/
+		this.acks = {};
+		this.flags = {};
+		this.io = io;
+		this.nsp = nsp;
+		if (opts && opts.auth) this.auth = opts.auth;
+		this._opts = Object.assign({}, opts);
+		if (this.io._autoConnect) this.open();
+	}
+	/**
+	* Whether the socket is currently disconnected
+	*
+	* @example
+	* const socket = io();
+	*
+	* socket.on("connect", () => {
+	*   console.log(socket.disconnected); // false
+	* });
+	*
+	* socket.on("disconnect", () => {
+	*   console.log(socket.disconnected); // true
+	* });
+	*/
+	get disconnected() {
+		return !this.connected;
+	}
+	/**
+	* Subscribe to open, close and packet events
+	*
+	* @private
+	*/
+	subEvents() {
+		if (this.subs) return;
+		const io = this.io;
+		this.subs = [
+			on(io, "open", this.onopen.bind(this)),
+			on(io, "packet", this.onpacket.bind(this)),
+			on(io, "error", this.onerror.bind(this)),
+			on(io, "close", this.onclose.bind(this))
+		];
+	}
+	/**
+	* Whether the Socket will try to reconnect when its Manager connects or reconnects.
+	*
+	* @example
+	* const socket = io();
+	*
+	* console.log(socket.active); // true
+	*
+	* socket.on("disconnect", (reason) => {
+	*   if (reason === "io server disconnect") {
+	*     // the disconnection was initiated by the server, you need to manually reconnect
+	*     console.log(socket.active); // false
+	*   }
+	*   // else the socket will automatically try to reconnect
+	*   console.log(socket.active); // true
+	* });
+	*/
+	get active() {
+		return !!this.subs;
+	}
+	/**
+	* "Opens" the socket.
+	*
+	* @example
+	* const socket = io({
+	*   autoConnect: false
+	* });
+	*
+	* socket.connect();
+	*/
+	connect() {
+		if (this.connected) return this;
+		this.subEvents();
+		if (!this.io["_reconnecting"]) this.io.open();
+		if ("open" === this.io._readyState) this.onopen();
+		return this;
+	}
+	/**
+	* Alias for {@link connect()}.
+	*/
+	open() {
+		return this.connect();
+	}
+	/**
+	* Sends a `message` event.
+	*
+	* This method mimics the WebSocket.send() method.
+	*
+	* @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+	*
+	* @example
+	* socket.send("hello");
+	*
+	* // this is equivalent to
+	* socket.emit("message", "hello");
+	*
+	* @return self
+	*/
+	send(...args) {
+		args.unshift("message");
+		this.emit.apply(this, args);
+		return this;
+	}
+	/**
+	* Override `emit`.
+	* If the event is in `events`, it's emitted normally.
+	*
+	* @example
+	* socket.emit("hello", "world");
+	*
+	* // all serializable datastructures are supported (no need to call JSON.stringify)
+	* socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
+	*
+	* // with an acknowledgement from the server
+	* socket.emit("hello", "world", (val) => {
+	*   // ...
+	* });
+	*
+	* @return self
+	*/
+	emit(ev, ...args) {
+		var _a, _b, _c;
+		if (RESERVED_EVENTS.hasOwnProperty(ev)) throw new Error("\"" + ev.toString() + "\" is a reserved event name");
+		args.unshift(ev);
+		if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {
+			this._addToQueue(args);
+			return this;
+		}
+		const packet = {
+			type: PacketType.EVENT,
+			data: args
+		};
+		packet.options = {};
+		packet.options.compress = this.flags.compress !== false;
+		if ("function" === typeof args[args.length - 1]) {
+			const id = this.ids++;
+			const ack = args.pop();
+			this._registerAckCallback(id, ack);
+			packet.id = id;
+		}
+		const isTransportWritable = (_b = (_a = this.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.writable;
+		const isConnected = this.connected && !((_c = this.io.engine) === null || _c === void 0 ? void 0 : _c._hasPingExpired());
+		if (this.flags.volatile && !isTransportWritable) {} else if (isConnected) {
+			this.notifyOutgoingListeners(packet);
+			this.packet(packet);
+		} else this.sendBuffer.push(packet);
+		this.flags = {};
+		return this;
+	}
+	/**
+	* @private
+	*/
+	_registerAckCallback(id, ack) {
+		var _a;
+		const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;
+		if (timeout === void 0) {
+			this.acks[id] = ack;
+			return;
+		}
+		const timer = this.io.setTimeoutFn(() => {
+			delete this.acks[id];
+			for (let i = 0; i < this.sendBuffer.length; i++) if (this.sendBuffer[i].id === id) this.sendBuffer.splice(i, 1);
+			ack.call(this, /* @__PURE__ */ new Error("operation has timed out"));
+		}, timeout);
+		const fn = (...args) => {
+			this.io.clearTimeoutFn(timer);
+			ack.apply(this, args);
+		};
+		fn.withError = true;
+		this.acks[id] = fn;
+	}
+	/**
+	* Emits an event and waits for an acknowledgement
+	*
+	* @example
+	* // without timeout
+	* const response = await socket.emitWithAck("hello", "world");
+	*
+	* // with a specific timeout
+	* try {
+	*   const response = await socket.timeout(1000).emitWithAck("hello", "world");
+	* } catch (err) {
+	*   // the server did not acknowledge the event in the given delay
+	* }
+	*
+	* @return a Promise that will be fulfilled when the server acknowledges the event
+	*/
+	emitWithAck(ev, ...args) {
+		return new Promise((resolve, reject) => {
+			const fn = (arg1, arg2) => {
+				return arg1 ? reject(arg1) : resolve(arg2);
+			};
+			fn.withError = true;
+			args.push(fn);
+			this.emit(ev, ...args);
+		});
+	}
+	/**
+	* Add the packet to the queue.
+	* @param args
+	* @private
+	*/
+	_addToQueue(args) {
+		let ack;
+		if (typeof args[args.length - 1] === "function") ack = args.pop();
+		const packet = {
+			id: this._queueSeq++,
+			tryCount: 0,
+			pending: false,
+			args,
+			flags: Object.assign({ fromQueue: true }, this.flags)
+		};
+		args.push((err, ...responseArgs) => {
+			if (packet !== this._queue[0]) {}
+			if (err !== null) {
+				if (packet.tryCount > this._opts.retries) {
+					this._queue.shift();
+					if (ack) ack(err);
+				}
+			} else {
+				this._queue.shift();
+				if (ack) ack(null, ...responseArgs);
+			}
+			packet.pending = false;
+			return this._drainQueue();
+		});
+		this._queue.push(packet);
+		this._drainQueue();
+	}
+	/**
+	* Send the first packet of the queue, and wait for an acknowledgement from the server.
+	* @param force - whether to resend a packet that has not been acknowledged yet
+	*
+	* @private
+	*/
+	_drainQueue(force = false) {
+		if (!this.connected || this._queue.length === 0) return;
+		const packet = this._queue[0];
+		if (packet.pending && !force) return;
+		packet.pending = true;
+		packet.tryCount++;
+		this.flags = packet.flags;
+		this.emit.apply(this, packet.args);
+	}
+	/**
+	* Sends a packet.
+	*
+	* @param packet
+	* @private
+	*/
+	packet(packet) {
+		packet.nsp = this.nsp;
+		this.io._packet(packet);
+	}
+	/**
+	* Called upon engine `open`.
+	*
+	* @private
+	*/
+	onopen() {
+		if (typeof this.auth == "function") this.auth((data) => {
+			this._sendConnectPacket(data);
+		});
+		else this._sendConnectPacket(this.auth);
+	}
+	/**
+	* Sends a CONNECT packet to initiate the Socket.IO session.
+	*
+	* @param data
+	* @private
+	*/
+	_sendConnectPacket(data) {
+		this.packet({
+			type: PacketType.CONNECT,
+			data: this._pid ? Object.assign({
+				pid: this._pid,
+				offset: this._lastOffset
+			}, data) : data
+		});
+	}
+	/**
+	* Called upon engine or manager `error`.
+	*
+	* @param err
+	* @private
+	*/
+	onerror(err) {
+		if (!this.connected) this.emitReserved("connect_error", err);
+	}
+	/**
+	* Called upon engine `close`.
+	*
+	* @param reason
+	* @param description
+	* @private
+	*/
+	onclose(reason, description) {
+		this.connected = false;
+		delete this.id;
+		this.emitReserved("disconnect", reason, description);
+		this._clearAcks();
+	}
+	/**
+	* Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from
+	* the server.
+	*
+	* @private
+	*/
+	_clearAcks() {
+		Object.keys(this.acks).forEach((id) => {
+			if (!this.sendBuffer.some((packet) => String(packet.id) === id)) {
+				const ack = this.acks[id];
+				delete this.acks[id];
+				if (ack.withError) ack.call(this, /* @__PURE__ */ new Error("socket has been disconnected"));
+			}
+		});
+	}
+	/**
+	* Called with socket packet.
+	*
+	* @param packet
+	* @private
+	*/
+	onpacket(packet) {
+		if (!(packet.nsp === this.nsp)) return;
+		switch (packet.type) {
+			case PacketType.CONNECT:
+				if (packet.data && packet.data.sid) this.onconnect(packet.data.sid, packet.data.pid);
+				else this.emitReserved("connect_error", /* @__PURE__ */ new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
+				break;
+			case PacketType.EVENT:
+			case PacketType.BINARY_EVENT:
+				this.onevent(packet);
+				break;
+			case PacketType.ACK:
+			case PacketType.BINARY_ACK:
+				this.onack(packet);
+				break;
+			case PacketType.DISCONNECT:
+				this.ondisconnect();
+				break;
+			case PacketType.CONNECT_ERROR:
+				this.destroy();
+				const err = new Error(packet.data.message);
+				err.data = packet.data.data;
+				this.emitReserved("connect_error", err);
+				break;
+		}
+	}
+	/**
+	* Called upon a server event.
+	*
+	* @param packet
+	* @private
+	*/
+	onevent(packet) {
+		const args = packet.data || [];
+		if (null != packet.id) args.push(this.ack(packet.id));
+		if (this.connected) this.emitEvent(args);
+		else this.receiveBuffer.push(Object.freeze(args));
+	}
+	emitEvent(args) {
+		if (this._anyListeners && this._anyListeners.length) {
+			const listeners = this._anyListeners.slice();
+			for (const listener of listeners) listener.apply(this, args);
+		}
+		super.emit.apply(this, args);
+		if (this._pid && args.length && typeof args[args.length - 1] === "string") this._lastOffset = args[args.length - 1];
+	}
+	/**
+	* Produces an ack callback to emit with an event.
+	*
+	* @private
+	*/
+	ack(id) {
+		const self = this;
+		let sent = false;
+		return function(...args) {
+			if (sent) return;
+			sent = true;
+			self.packet({
+				type: PacketType.ACK,
+				id,
+				data: args
+			});
+		};
+	}
+	/**
+	* Called upon a server acknowledgement.
+	*
+	* @param packet
+	* @private
+	*/
+	onack(packet) {
+		const ack = this.acks[packet.id];
+		if (typeof ack !== "function") return;
+		delete this.acks[packet.id];
+		if (ack.withError) packet.data.unshift(null);
+		ack.apply(this, packet.data);
+	}
+	/**
+	* Called upon server connect.
+	*
+	* @private
+	*/
+	onconnect(id, pid) {
+		this.id = id;
+		this.recovered = pid && this._pid === pid;
+		this._pid = pid;
+		this.connected = true;
+		this.emitBuffered();
+		this._drainQueue(true);
+		this.emitReserved("connect");
+	}
+	/**
+	* Emit buffered events (received and emitted).
+	*
+	* @private
+	*/
+	emitBuffered() {
+		this.receiveBuffer.forEach((args) => this.emitEvent(args));
+		this.receiveBuffer = [];
+		this.sendBuffer.forEach((packet) => {
+			this.notifyOutgoingListeners(packet);
+			this.packet(packet);
+		});
+		this.sendBuffer = [];
+	}
+	/**
+	* Called upon server disconnect.
+	*
+	* @private
+	*/
+	ondisconnect() {
+		this.destroy();
+		this.onclose("io server disconnect");
+	}
+	/**
+	* Called upon forced client/server side disconnections,
+	* this method ensures the manager stops tracking us and
+	* that reconnections don't get triggered for this.
+	*
+	* @private
+	*/
+	destroy() {
+		if (this.subs) {
+			this.subs.forEach((subDestroy) => subDestroy());
+			this.subs = void 0;
+		}
+		this.io["_destroy"](this);
+	}
+	/**
+	* Disconnects the socket manually. In that case, the socket will not try to reconnect.
+	*
+	* If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
+	*
+	* @example
+	* const socket = io();
+	*
+	* socket.on("disconnect", (reason) => {
+	*   // console.log(reason); prints "io client disconnect"
+	* });
+	*
+	* socket.disconnect();
+	*
+	* @return self
+	*/
+	disconnect() {
+		if (this.connected) this.packet({ type: PacketType.DISCONNECT });
+		this.destroy();
+		if (this.connected) this.onclose("io client disconnect");
+		return this;
+	}
+	/**
+	* Alias for {@link disconnect()}.
+	*
+	* @return self
+	*/
+	close() {
+		return this.disconnect();
+	}
+	/**
+	* Sets the compress flag.
+	*
+	* @example
+	* socket.compress(false).emit("hello");
+	*
+	* @param compress - if `true`, compresses the sending data
+	* @return self
+	*/
+	compress(compress) {
+		this.flags.compress = compress;
+		return this;
+	}
+	/**
+	* Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
+	* ready to send messages.
+	*
+	* @example
+	* socket.volatile.emit("hello"); // the server may or may not receive it
+	*
+	* @returns self
+	*/
+	get volatile() {
+		this.flags.volatile = true;
+		return this;
+	}
+	/**
+	* Sets a modifier for a subsequent event emission that the callback will be called with an error when the
+	* given number of milliseconds have elapsed without an acknowledgement from the server:
+	*
+	* @example
+	* socket.timeout(5000).emit("my-event", (err) => {
+	*   if (err) {
+	*     // the server did not acknowledge the event in the given delay
+	*   }
+	* });
+	*
+	* @returns self
+	*/
+	timeout(timeout) {
+		this.flags.timeout = timeout;
+		return this;
+	}
+	/**
+	* Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+	* callback.
+	*
+	* @example
+	* socket.onAny((event, ...args) => {
+	*   console.log(`got ${event}`);
+	* });
+	*
+	* @param listener
+	*/
+	onAny(listener) {
+		this._anyListeners = this._anyListeners || [];
+		this._anyListeners.push(listener);
+		return this;
+	}
+	/**
+	* Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+	* callback. The listener is added to the beginning of the listeners array.
+	*
+	* @example
+	* socket.prependAny((event, ...args) => {
+	*   console.log(`got event ${event}`);
+	* });
+	*
+	* @param listener
+	*/
+	prependAny(listener) {
+		this._anyListeners = this._anyListeners || [];
+		this._anyListeners.unshift(listener);
+		return this;
+	}
+	/**
+	* Removes the listener that will be fired when any event is emitted.
+	*
+	* @example
+	* const catchAllListener = (event, ...args) => {
+	*   console.log(`got event ${event}`);
+	* }
+	*
+	* socket.onAny(catchAllListener);
+	*
+	* // remove a specific listener
+	* socket.offAny(catchAllListener);
+	*
+	* // or remove all listeners
+	* socket.offAny();
+	*
+	* @param listener
+	*/
+	offAny(listener) {
+		if (!this._anyListeners) return this;
+		if (listener) {
+			const listeners = this._anyListeners;
+			for (let i = 0; i < listeners.length; i++) if (listener === listeners[i]) {
+				listeners.splice(i, 1);
+				return this;
+			}
+		} else this._anyListeners = [];
+		return this;
+	}
+	/**
+	* Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+	* e.g. to remove listeners.
+	*/
+	listenersAny() {
+		return this._anyListeners || [];
+	}
+	/**
+	* Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+	* callback.
+	*
+	* Note: acknowledgements sent to the server are not included.
+	*
+	* @example
+	* socket.onAnyOutgoing((event, ...args) => {
+	*   console.log(`sent event ${event}`);
+	* });
+	*
+	* @param listener
+	*/
+	onAnyOutgoing(listener) {
+		this._anyOutgoingListeners = this._anyOutgoingListeners || [];
+		this._anyOutgoingListeners.push(listener);
+		return this;
+	}
+	/**
+	* Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+	* callback. The listener is added to the beginning of the listeners array.
+	*
+	* Note: acknowledgements sent to the server are not included.
+	*
+	* @example
+	* socket.prependAnyOutgoing((event, ...args) => {
+	*   console.log(`sent event ${event}`);
+	* });
+	*
+	* @param listener
+	*/
+	prependAnyOutgoing(listener) {
+		this._anyOutgoingListeners = this._anyOutgoingListeners || [];
+		this._anyOutgoingListeners.unshift(listener);
+		return this;
+	}
+	/**
+	* Removes the listener that will be fired when any event is emitted.
+	*
+	* @example
+	* const catchAllListener = (event, ...args) => {
+	*   console.log(`sent event ${event}`);
+	* }
+	*
+	* socket.onAnyOutgoing(catchAllListener);
+	*
+	* // remove a specific listener
+	* socket.offAnyOutgoing(catchAllListener);
+	*
+	* // or remove all listeners
+	* socket.offAnyOutgoing();
+	*
+	* @param [listener] - the catch-all listener (optional)
+	*/
+	offAnyOutgoing(listener) {
+		if (!this._anyOutgoingListeners) return this;
+		if (listener) {
+			const listeners = this._anyOutgoingListeners;
+			for (let i = 0; i < listeners.length; i++) if (listener === listeners[i]) {
+				listeners.splice(i, 1);
+				return this;
+			}
+		} else this._anyOutgoingListeners = [];
+		return this;
+	}
+	/**
+	* Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+	* e.g. to remove listeners.
+	*/
+	listenersAnyOutgoing() {
+		return this._anyOutgoingListeners || [];
+	}
+	/**
+	* Notify the listeners for each packet sent
+	*
+	* @param packet
+	*
+	* @private
+	*/
+	notifyOutgoingListeners(packet) {
+		if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
+			const listeners = this._anyOutgoingListeners.slice();
+			for (const listener of listeners) listener.apply(this, packet.data);
+		}
+	}
+};
+//#endregion
+//#region node_modules/socket.io-client/build/esm/contrib/backo2.js
+/**
+* Initialize backoff timer with `opts`.
+*
+* - `min` initial timeout in milliseconds [100]
+* - `max` max timeout [10000]
+* - `jitter` [0]
+* - `factor` [2]
+*
+* @param {Object} opts
+* @api public
+*/
+function Backoff(opts) {
+	opts = opts || {};
+	this.ms = opts.min || 100;
+	this.max = opts.max || 1e4;
+	this.factor = opts.factor || 2;
+	this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
+	this.attempts = 0;
+}
+/**
+* Return the backoff duration.
+*
+* @return {Number}
+* @api public
+*/
+Backoff.prototype.duration = function() {
+	var ms = this.ms * Math.pow(this.factor, this.attempts++);
+	if (this.jitter) {
+		var rand = Math.random();
+		var deviation = Math.floor(rand * this.jitter * ms);
+		ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
+	}
+	return Math.min(ms, this.max) | 0;
+};
+/**
+* Reset the number of attempts.
+*
+* @api public
+*/
+Backoff.prototype.reset = function() {
+	this.attempts = 0;
+};
+/**
+* Set the minimum duration
+*
+* @api public
+*/
+Backoff.prototype.setMin = function(min) {
+	this.ms = min;
+};
+/**
+* Set the maximum duration
+*
+* @api public
+*/
+Backoff.prototype.setMax = function(max) {
+	this.max = max;
+};
+/**
+* Set the jitter
+*
+* @api public
+*/
+Backoff.prototype.setJitter = function(jitter) {
+	this.jitter = jitter;
+};
+//#endregion
+//#region node_modules/socket.io-client/build/esm/manager.js
+var Manager = class extends Emitter {
+	constructor(uri, opts) {
+		var _a;
+		super();
+		this.nsps = {};
+		this.subs = [];
+		if (uri && "object" === typeof uri) {
+			opts = uri;
+			uri = void 0;
+		}
+		opts = opts || {};
+		opts.path = opts.path || "/socket.io";
+		this.opts = opts;
+		installTimerFunctions(this, opts);
+		this.reconnection(opts.reconnection !== false);
+		this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
+		this.reconnectionDelay(opts.reconnectionDelay || 1e3);
+		this.reconnectionDelayMax(opts.reconnectionDelayMax || 5e3);
+		this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : .5);
+		this.backoff = new Backoff({
+			min: this.reconnectionDelay(),
+			max: this.reconnectionDelayMax(),
+			jitter: this.randomizationFactor()
+		});
+		this.timeout(null == opts.timeout ? 2e4 : opts.timeout);
+		this._readyState = "closed";
+		this.uri = uri;
+		const _parser = opts.parser || esm_exports;
+		this.encoder = new _parser.Encoder();
+		this.decoder = new _parser.Decoder();
+		this._autoConnect = opts.autoConnect !== false;
+		if (this._autoConnect) this.open();
+	}
+	reconnection(v) {
+		if (!arguments.length) return this._reconnection;
+		this._reconnection = !!v;
+		if (!v) this.skipReconnect = true;
+		return this;
+	}
+	reconnectionAttempts(v) {
+		if (v === void 0) return this._reconnectionAttempts;
+		this._reconnectionAttempts = v;
+		return this;
+	}
+	reconnectionDelay(v) {
+		var _a;
+		if (v === void 0) return this._reconnectionDelay;
+		this._reconnectionDelay = v;
+		(_a = this.backoff) === null || _a === void 0 || _a.setMin(v);
+		return this;
+	}
+	randomizationFactor(v) {
+		var _a;
+		if (v === void 0) return this._randomizationFactor;
+		this._randomizationFactor = v;
+		(_a = this.backoff) === null || _a === void 0 || _a.setJitter(v);
+		return this;
+	}
+	reconnectionDelayMax(v) {
+		var _a;
+		if (v === void 0) return this._reconnectionDelayMax;
+		this._reconnectionDelayMax = v;
+		(_a = this.backoff) === null || _a === void 0 || _a.setMax(v);
+		return this;
+	}
+	timeout(v) {
+		if (!arguments.length) return this._timeout;
+		this._timeout = v;
+		return this;
+	}
+	/**
+	* Starts trying to reconnect if reconnection is enabled and we have not
+	* started reconnecting yet
+	*
+	* @private
+	*/
+	maybeReconnectOnOpen() {
+		if (!this._reconnecting && this._reconnection && this.backoff.attempts === 0) this.reconnect();
+	}
+	/**
+	* Sets the current transport `socket`.
+	*
+	* @param {Function} fn - optional, callback
+	* @return self
+	* @public
+	*/
+	open(fn) {
+		if (~this._readyState.indexOf("open")) return this;
+		this.engine = new Socket$1(this.uri, this.opts);
+		const socket = this.engine;
+		const self = this;
+		this._readyState = "opening";
+		this.skipReconnect = false;
+		const openSubDestroy = on(socket, "open", function() {
+			self.onopen();
+			fn && fn();
+		});
+		const onError = (err) => {
+			this.cleanup();
+			this._readyState = "closed";
+			this.emitReserved("error", err);
+			if (fn) fn(err);
+			else this.maybeReconnectOnOpen();
+		};
+		const errorSub = on(socket, "error", onError);
+		if (false !== this._timeout) {
+			const timeout = this._timeout;
+			const timer = this.setTimeoutFn(() => {
+				openSubDestroy();
+				onError(/* @__PURE__ */ new Error("timeout"));
+				socket.close();
+			}, timeout);
+			if (this.opts.autoUnref) timer.unref();
+			this.subs.push(() => {
+				this.clearTimeoutFn(timer);
+			});
+		}
+		this.subs.push(openSubDestroy);
+		this.subs.push(errorSub);
+		return this;
+	}
+	/**
+	* Alias for open()
+	*
+	* @return self
+	* @public
+	*/
+	connect(fn) {
+		return this.open(fn);
+	}
+	/**
+	* Called upon transport open.
+	*
+	* @private
+	*/
+	onopen() {
+		this.cleanup();
+		this._readyState = "open";
+		this.emitReserved("open");
+		const socket = this.engine;
+		this.subs.push(on(socket, "ping", this.onping.bind(this)), on(socket, "data", this.ondata.bind(this)), on(socket, "error", this.onerror.bind(this)), on(socket, "close", this.onclose.bind(this)), on(this.decoder, "decoded", this.ondecoded.bind(this)));
+	}
+	/**
+	* Called upon a ping.
+	*
+	* @private
+	*/
+	onping() {
+		this.emitReserved("ping");
+	}
+	/**
+	* Called with data.
+	*
+	* @private
+	*/
+	ondata(data) {
+		try {
+			this.decoder.add(data);
+		} catch (e) {
+			this.onclose("parse error", e);
+		}
+	}
+	/**
+	* Called when parser fully decodes a packet.
+	*
+	* @private
+	*/
+	ondecoded(packet) {
+		nextTick(() => {
+			this.emitReserved("packet", packet);
+		}, this.setTimeoutFn);
+	}
+	/**
+	* Called upon socket error.
+	*
+	* @private
+	*/
+	onerror(err) {
+		this.emitReserved("error", err);
+	}
+	/**
+	* Creates a new socket for the given `nsp`.
+	*
+	* @return {Socket}
+	* @public
+	*/
+	socket(nsp, opts) {
+		let socket = this.nsps[nsp];
+		if (!socket) {
+			socket = new Socket(this, nsp, opts);
+			this.nsps[nsp] = socket;
+		} else if (this._autoConnect && !socket.active) socket.connect();
+		return socket;
+	}
+	/**
+	* Called upon a socket close.
+	*
+	* @param socket
+	* @private
+	*/
+	_destroy(socket) {
+		const nsps = Object.keys(this.nsps);
+		for (const nsp of nsps) if (this.nsps[nsp].active) return;
+		this._close();
+	}
+	/**
+	* Writes a packet.
+	*
+	* @param packet
+	* @private
+	*/
+	_packet(packet) {
+		const encodedPackets = this.encoder.encode(packet);
+		for (let i = 0; i < encodedPackets.length; i++) this.engine.write(encodedPackets[i], packet.options);
+	}
+	/**
+	* Clean up transport subscriptions and packet buffer.
+	*
+	* @private
+	*/
+	cleanup() {
+		this.subs.forEach((subDestroy) => subDestroy());
+		this.subs.length = 0;
+		this.decoder.destroy();
+	}
+	/**
+	* Close the current socket.
+	*
+	* @private
+	*/
+	_close() {
+		this.skipReconnect = true;
+		this._reconnecting = false;
+		this.onclose("forced close");
+	}
+	/**
+	* Alias for close()
+	*
+	* @private
+	*/
+	disconnect() {
+		return this._close();
+	}
+	/**
+	* Called when:
+	*
+	* - the low-level engine is closed
+	* - the parser encountered a badly formatted packet
+	* - all sockets are disconnected
+	*
+	* @private
+	*/
+	onclose(reason, description) {
+		var _a;
+		this.cleanup();
+		(_a = this.engine) === null || _a === void 0 || _a.close();
+		this.backoff.reset();
+		this._readyState = "closed";
+		this.emitReserved("close", reason, description);
+		if (this._reconnection && !this.skipReconnect) this.reconnect();
+	}
+	/**
+	* Attempt a reconnection.
+	*
+	* @private
+	*/
+	reconnect() {
+		if (this._reconnecting || this.skipReconnect) return this;
+		const self = this;
+		if (this.backoff.attempts >= this._reconnectionAttempts) {
+			this.backoff.reset();
+			this.emitReserved("reconnect_failed");
+			this._reconnecting = false;
+		} else {
+			const delay = this.backoff.duration();
+			this._reconnecting = true;
+			const timer = this.setTimeoutFn(() => {
+				if (self.skipReconnect) return;
+				this.emitReserved("reconnect_attempt", self.backoff.attempts);
+				if (self.skipReconnect) return;
+				self.open((err) => {
+					if (err) {
+						self._reconnecting = false;
+						self.reconnect();
+						this.emitReserved("reconnect_error", err);
+					} else self.onreconnect();
+				});
+			}, delay);
+			if (this.opts.autoUnref) timer.unref();
+			this.subs.push(() => {
+				this.clearTimeoutFn(timer);
+			});
+		}
+	}
+	/**
+	* Called upon successful reconnect.
+	*
+	* @private
+	*/
+	onreconnect() {
+		const attempt = this.backoff.attempts;
+		this._reconnecting = false;
+		this.backoff.reset();
+		this.emitReserved("reconnect", attempt);
+	}
+};
+//#endregion
+//#region node_modules/socket.io-client/build/esm/index.js
+/**
+* Managers cache.
+*/
+var cache = {};
+function lookup(uri, opts) {
+	if (typeof uri === "object") {
+		opts = uri;
+		uri = void 0;
+	}
+	opts = opts || {};
+	const parsed = url(uri, opts.path || "/socket.io");
+	const source = parsed.source;
+	const id = parsed.id;
+	const path = parsed.path;
+	const sameNamespace = cache[id] && path in cache[id]["nsps"];
+	const newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
+	let io;
+	if (newConnection) io = new Manager(source, opts);
+	else {
+		if (!cache[id]) cache[id] = new Manager(source, opts);
+		io = cache[id];
+	}
+	if (parsed.query && !opts.query) opts.query = parsed.queryKey;
+	return io.socket(parsed.path, opts);
+}
+Object.assign(lookup, {
+	Manager,
+	Socket,
+	io: lookup,
+	connect: lookup
+});
+//#endregion
+//#region node_modules/@nsshunt/stssocketioutils/dist/index.mjs
+var import_tiny_emitter = require_tiny_emitter();
+var SocketIoClient = class extends import_tiny_emitter.TinyEmitter {
+	#agentManager;
+	#logger;
+	#name;
+	#address;
+	#socketIoCustomPath;
+	#authToken;
+	#socket;
+	#reconnectTimeout = 2e3;
+	constructor(name) {
+		super();
+		this.#name = name;
+	}
+	get logPrefix() {
+		return `SocketIoClient[${this.#name}]:`;
+	}
+	LogDebugMessage(message) {
+		if (this.#logger) this.#logger.debug(`${this.logPrefix}${message}`);
+	}
+	LogErrorMessage(message) {
+		if (this.#logger) this.#logger.error(`${this.logPrefix}${message}`);
+	}
+	LogWarningMessage(message) {
+		if (this.#logger) this.#logger.warn(`${this.logPrefix}${message}`);
+	}
+	get name() {
+		return this.#name;
+	}
+	get reconnectTimeout() {
+		return this.#reconnectTimeout;
+	}
+	get agentManager() {
+		return this.#agentManager;
+	}
+	get logger() {
+		return this.#logger;
+	}
+	get address() {
+		return this.#address;
+	}
+	get authToken() {
+		return this.#authToken;
+	}
+	get socketIoCustomPath() {
+		return this.#socketIoCustomPath;
+	}
+	get socket() {
+		return this.#socket;
+	}
+	WithAddress(address) {
+		this.#address = address;
+		return this;
+	}
+	WithAuthToken(authToken) {
+		this.#authToken = authToken;
+		return this;
+	}
+	WithSocketIoCustomPath(socketIoCustomPath) {
+		this.#socketIoCustomPath = socketIoCustomPath;
+		return this;
+	}
+	WithLogger(logger) {
+		this.#logger = logger;
+		return this;
+	}
+	WithAgentManager(agentManager) {
+		this.#agentManager = agentManager;
+		return this;
+	}
+	WithReconnectTimeout(reconnectTimeout) {
+		this.#reconnectTimeout = reconnectTimeout;
+		return this;
+	}
+	SetupSocket() {
+		if (!this.#address) throw new Error(`SocketIoClientHelper:SetupSocket(): Error: [address not provided]`);
+		this.#EstablishSocketConnect();
+		return this;
+	}
+	EngineError(error) {}
+	EngineReconnectError(error) {}
+	EngineConnectError(error) {}
+	EngineReconnect(attempt) {}
+	#EstablishSocketConnect() {
+		if (this.#socket !== void 0) {
+			if (this.#socket.connected === true) this.#socket.disconnect();
+			this.#socket = void 0;
+			if (isNode) setTimeout(() => this.#EstablishSocketConnect(), this.#reconnectTimeout).unref();
+			else setTimeout(() => this.#EstablishSocketConnect(), this.#reconnectTimeout);
+			return;
+		}
+		let socketOptions;
+		if (isNode) {
+			socketOptions = { transports: ["websocket"] };
+			if (this.#agentManager) {
+				if (!this.#address) throw new Error(`SocketIoClient:SetupSocket(): Error: [address not provided when using agentManager]`);
+				socketOptions.agent = this.#agentManager.GetAgent(this.#address);
+			}
+		} else socketOptions = { transports: ["websocket"] };
+		if (this.#authToken) socketOptions.auth = (cb) => {
+			cb({ token: this.#authToken });
+		};
+		if (this.#socketIoCustomPath && this.#socketIoCustomPath.localeCompare("") !== 0) socketOptions.path = this.#socketIoCustomPath;
+		this.#socket = lookup(this.#address, socketOptions);
+		this.#socket.io.on("error", (err) => {
+			this.LogErrorMessage(`socketDetail.socket.io.on('error'): [${err}] Address: [${this.#address}]`);
+			this.EngineError(err);
+		});
+		this.#socket.io.on("reconnect_error", (err) => {
+			this.LogErrorMessage(`socketDetail.socket.io.on('reconnect_error'): [${err}] Address: [${this.#address}]`);
+			this.EngineReconnectError(err);
+		});
+		this.#socket.on("connect_error", (err) => {
+			this.LogErrorMessage(`socketDetail.socket.on('connect_error'): [${err}] Address: [${this.#address}]`);
+			this.EngineConnectError(err);
+		});
+		this.#socket.io.on("reconnect", (attempt) => {
+			this.LogErrorMessage(`socketDetail.socket.io.on('reconnect'): Number: [${attempt}] Address: [${this.#address}]`);
+			this.EngineReconnect(attempt);
+		});
+		this.#socket.on("connect", () => {
+			if (this.#socket) {
+				this.LogDebugMessage(`Socket: [${this.#socket.id}]: connected, Address: [${this.#address}]`);
+				setTimeout(() => {
+					this.SocketConnect(this.#socket);
+				}, 0);
+				this.SetupSocketEvents(this.#socket);
+			} else {
+				const errorMessage = "Could not get socket object from socket.io, Address: [${socketDetail.address}]";
+				this.LogErrorMessage(errorMessage);
+				this.SocketConnectError(new Error(errorMessage));
+			}
+		});
+		this.#socket.on("disconnect", (reason) => {
+			this.LogDebugMessage("socket disconnect: " + reason);
+			this.SocketDisconnect(reason);
+			switch (reason) {
+				case "io server disconnect":
+					this.LogDebugMessage("The server disconnected using disconnectSockets, i.e. normal safe shutdown from explicit disconnection by the server.");
+					this.LogDebugMessage("The connection will be re-established when the server becomes available.");
+					this.#socket = void 0;
+					if (isNode) {
+						if (this.#agentManager) this.#agentManager.ResetAgent();
+						setTimeout(() => this.#EstablishSocketConnect(), this.#reconnectTimeout).unref();
+					} else setTimeout(() => this.#EstablishSocketConnect(), this.#reconnectTimeout);
+					break;
+				case "io client disconnect":
+					this.LogDebugMessage("The client disconnected using disconnectSockets, i.e. normal safe disconnection from explicit disconnection by the client.");
+					this.LogDebugMessage("The connection will not be re-established automatically.");
+					break;
+				case "transport close":
+				case "ping timeout":
+				case "transport error":
+					this.LogDebugMessage(`Server unexpectedly disconnected. Reason: [${reason}]`);
+					this.LogDebugMessage("The connection will be re-established when the server becomes available.");
+					if (this.#socket) this.#socket.disconnect();
+					this.#socket = void 0;
+					if (isNode) {
+						if (this.#agentManager) this.#agentManager?.ResetAgent();
+						setTimeout(() => this.#EstablishSocketConnect(), this.#reconnectTimeout).unref();
+					} else setTimeout(() => this.#EstablishSocketConnect(), this.#reconnectTimeout);
+					break;
+			}
+		});
+	}
+};
+//#endregion
+//#region src/wsevents.ts
+var IEventReturnValueBaseType = /* @__PURE__ */ function(IEventReturnValueBaseType) {
+	IEventReturnValueBaseType["serviceDetails"] = "serviceDetails";
+	IEventReturnValueBaseType["workers"] = "workers";
+	IEventReturnValueBaseType["archiveList"] = "archiveList";
+	IEventReturnValueBaseType["runner"] = "runner";
+	IEventReturnValueBaseType["worker"] = "worker";
+	IEventReturnValueBaseType["executeWorkerActionResult"] = "executeWorkerActionResult";
+	IEventReturnValueBaseType["executeRunnerActionResult"] = "executeRunnerActionResult";
+	return IEventReturnValueBaseType;
+}({});
+var IEventRequestCommand = /* @__PURE__ */ function(IEventRequestCommand) {
+	IEventRequestCommand["AddRunner"] = "AddRunner";
+	IEventRequestCommand["AddRunnerToWorker"] = "AddRunnerToWorker";
+	IEventRequestCommand["AddWorker"] = "AddWorker";
+	IEventRequestCommand["GetService"] = "GetService";
+	IEventRequestCommand["GetWorkers"] = "GetWorkers";
+	IEventRequestCommand["GetWorkersSmall"] = "GetWorkersSmall";
+	IEventRequestCommand["GetArchiveList"] = "GetArchiveList";
+	IEventRequestCommand["StartWorkers"] = "StartWorkers";
+	IEventRequestCommand["StopWorkers"] = "StopWorkers";
+	IEventRequestCommand["PauseWorkers"] = "PauseWorkers";
+	IEventRequestCommand["ResumeWorkers"] = "ResumeWorkers";
+	IEventRequestCommand["ExecuteWorkers"] = "ExecuteWorkers";
+	IEventRequestCommand["ResetWorkers"] = "ResetWorkers";
+	IEventRequestCommand["TerminateWorkers"] = "TerminateWorkers";
+	IEventRequestCommand["UpdateWorkers"] = "UpdateWorkers";
+	IEventRequestCommand["StartRunners"] = "StartRunners";
+	IEventRequestCommand["StopRunners"] = "StopRunners";
+	IEventRequestCommand["PauseRunners"] = "PauseRunners";
+	IEventRequestCommand["ResumeRunners"] = "ResumeRunners";
+	IEventRequestCommand["ExecuteRunners"] = "ExecuteRunners";
+	IEventRequestCommand["ResetRunners"] = "ResetRunners";
+	IEventRequestCommand["TerminateRunners"] = "TerminateRunners";
+	IEventRequestCommand["UpdateRunners"] = "UpdateRunners";
+	return IEventRequestCommand;
+}({});
+//#endregion
+//#region src/workerManagerProxy.ts
+var WorkerManagerProxy = class extends SocketIoClient {
+	_options;
+	_id = globalThis.crypto.randomUUID();
+	_clientName = "";
+	_wm;
+	#debug = (message) => this._options.logger.debug(message);
+	#error = (error) => this._options.logger.error(error);
+	#info = (message) => this._options.logger.info(message);
+	constructor(options) {
+		super(options.name);
+		this._options = options;
+		this._clientName = options.name;
+		this._wm = this._options.CreateSTSWorkerManager();
+		this.#info(chalk.yellow(`Worker Manager ID: [${this._wm.id}]`));
+		this._Start();
+	}
+	get workerManager() {
+		return this._wm;
+	}
+	get id() {
+		return this._id;
+	}
+	SocketConnectError(error) {}
+	SocketDisconnect(reason) {}
+	SocketConnect(socket) {
+		this._OnSocketConnected(socket, this.name, []);
+	}
+	SocketError(error) {
+		this.#error(`${this.name}: SetupClientSideSocket call back: [${error}]`);
+	}
+	SetupSocketEvents(socket) {
+		this._RegisterSocketEvents(socket, this.name);
+	}
+	_GetKeyPayloadData = (eventRequestCommand, eventReturnValueBaseType) => {
+		return {
+			id: this._id,
+			workerManagerId: this._wm.id,
+			name: this._options.name,
+			eventRequestCommand,
+			type: eventReturnValueBaseType
+		};
+	};
+	_LogPayloadEventRetVal = (retVal) => {
+		return retVal;
+	};
+	_Start = async () => {
+		this._EmitEvent("Starting", {});
+		this.WithAddress(this._options.ststccendpoint).WithLogger(defaultLogger).WithSocketIoCustomPath("");
+		if (this._options.agentManager) this.WithAgentManager(this._options.agentManager);
+		this.#info(chalk.yellow(`STS Test Runner Service Instance.`));
+		this.#info(chalk.yellow(`This service instance emulates instances of the ststestrunnernode service.`));
+		this.#info(chalk.yellow(`Service Instance ID: [${this._id}]`));
+		this.#info(chalk.yellow(`Service Instance Name: [${this._options.name}]`));
+		this.#info(chalk.yellow(`Options: [${JSON.stringify(this._options)}]`));
+		this.SetupSocket();
+		const start = async () => {
+			for (let i = 0; i < this._options.workers; i++) await this._AddWorker({
+				tags: [""],
+				userData: {},
+				mocked: false,
+				hostName: "host01",
+				agentId: "agent01",
+				userAgent: globalThis.crypto.randomUUID(),
+				logLevel: 4
+			});
+			this._EmitEvent("Started", {});
+		};
+		await start();
+	};
+	Stop = async () => {
+		this._EmitEvent("Stopping ...", {});
+		this.#debug(chalk.magenta(`Stop(): Stopping Service.`));
+		await this._wm.TerminateWorkers([]);
+		this.#debug(`Stop(): Workers terminated`);
+		if (this.socket) {
+			this.#debug(`Stop(): Going to disconnect socket ...`);
+			this.socket.disconnect();
+			this.#debug(`Stop(): Socket disconnected.`);
+		}
+		this.#debug(`Stop(): Sleeping (500ms) ...`);
+		await Sleep(500);
+		this.#debug(chalk.magenta(`Stop(): Service Stopped.`));
+		this._EmitEvent("Stopped", {});
+	};
+	_GetService = async () => {
+		const raw = this._EmitEvent("GetService", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.GetService, IEventReturnValueBaseType.serviceDetails),
+			serviceDetails: await this._options.GetServiceDetails()
+		}));
+		raw.serviceDetails = gzipSync(strToU8(JSON.stringify(raw.serviceDetails)));
+		return raw;
+	};
+	_GetServiceNoZip = async () => {
+		return this._EmitEvent("GetService", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.GetService, IEventReturnValueBaseType.serviceDetails),
+			serviceDetails: await this._options.GetServiceDetails()
+		}));
+	};
+	_EmitStateChange = (runnerEx) => {
+		this.#debug(chalk.rgb(10, 50, 200)(`WorkerManagerProxy:_EmitStateChange():  ==>>  Runner State Change: WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}] State: [${runnerEx.state}]`));
+		const stateChangeRetVal = {
+			eventRequestCommand: "StateChange",
+			type: IEventReturnValueBaseType.runner,
+			workerManagerId: this._wm.id,
+			id: this._id,
+			name: this._options.name,
+			runner: runnerEx.toRunner()
+		};
+		this._EmitEvent(`StateChange`, stateChangeRetVal);
+		this.socket?.emit("StateChange", stateChangeRetVal);
+	};
+	_EmitTelemetry = (runnerEx) => {
+		this.#debug(chalk.rgb(10, 50, 200)(`WorkerManagerProxy:_EmitTelemetry():  ==>>  WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}] State: [${runnerEx.state}]`));
+		const telemetryRetVal = {
+			eventRequestCommand: "StateChange",
+			type: IEventReturnValueBaseType.runner,
+			workerManagerId: this._wm.id,
+			id: this._id,
+			name: this._options.name,
+			runner: runnerEx.toRunner()
+		};
+		this._EmitEvent(`Telemetry`, telemetryRetVal);
+		this.socket?.emit("Telemetry", telemetryRetVal);
+	};
+	_SetupRunnerEventHandlers = (runnerEx) => {
+		runnerEx.on("StateChange", this._EmitStateChange);
+		runnerEx.on("Telemetry", this._EmitTelemetry);
+	};
+	_OnSocketConnected = (socket, clientName, joinRooms) => {
+		this.#debug(chalk.green(`${this._id} ${clientName}: --> connected`));
+		this._EmitEvent("SocketConnected", {
+			id: this._id,
+			clientName,
+			joinRooms: [
+				...joinRooms,
+				"ststrnservices",
+				this._id
+			]
+		});
+		if (joinRooms.length > 0) socket.emit("__STSjoinRoom", joinRooms);
+		socket.emit("__STSjoinRoom", ["ststrnservices"]).emit("__STSjoinRoom", [this._id]);
+	};
+	_AddWorker = async (options) => {
+		const workerEx = await this._wm.AddWorker(options);
+		if (workerEx) return this._EmitEvent("AddWorker", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.AddWorker, IEventReturnValueBaseType.worker),
+			worker: workerEx.toWorker()
+		}));
+		else return this._EmitEvent("AddWorker", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.AddWorker, IEventReturnValueBaseType.worker),
+			worker: {}
+		}));
+	};
+	_GetArchiveList = async (runnerSearchFilters) => {
+		const raw = this._EmitEvent("GetArchiveList", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.GetArchiveList, IEventReturnValueBaseType.archiveList),
+			archiveList: await this._wm.GetArchiveList(runnerSearchFilters)
+		}));
+		raw.archiveList = gzipSync(strToU8(JSON.stringify(raw.archiveList)));
+		return raw;
+	};
+	_GetArchiveListNoZip = async (runnerSearchFilters) => {
+		return this._EmitEvent("GetArchiveList", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.GetArchiveList, IEventReturnValueBaseType.archiveList),
+			archiveList: await this._wm.GetArchiveList(runnerSearchFilters)
+		}));
+	};
+	_GetWorkers = async () => {
+		const raw = this._EmitEvent("GetWorkers", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.GetWorkers, IEventReturnValueBaseType.workers),
+			workers: await this._wm.GetWorkers()
+		}));
+		raw.workers = gzipSync(strToU8(JSON.stringify(raw.workers)));
+		return raw;
+	};
+	_GetWorkersNoZip = async () => {
+		return this._EmitEvent("GetWorkers", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.GetWorkers, IEventReturnValueBaseType.workers),
+			workers: await this._wm.GetWorkers()
+		}));
+	};
+	_GetWorkersSmall = async (states) => {
+		const raw = this._EmitEvent("GetWorkersSmall", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.GetWorkersSmall, IEventReturnValueBaseType.workers),
+			workerCores: await this._wm.GetWorkersCore(states)
+		}));
+		raw.workers = gzipSync(strToU8(JSON.stringify(raw.workers)));
+		return raw;
+	};
+	_GetWorkersSmallNoZip = async (states) => {
+		return this._EmitEvent("GetWorkersSmall", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.GetWorkersSmall, IEventReturnValueBaseType.workers),
+			workerCores: await this._wm.GetWorkersCore(states)
+		}));
+	};
+	_StartWorkers = async (workerIds) => {
+		return this._EmitEvent("StartWorkers", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.StartWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
+			executeWorkerActionResult: await this._wm.StartWorkers(workerIds)
+		}));
+	};
+	_StopWorkers = async (workerIds) => {
+		return this._EmitEvent("StopWorkers", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.StopWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
+			executeWorkerActionResult: await this._wm.StopWorkers(workerIds)
+		}));
+	};
+	_PauseWorkers = async (workerIds) => {
+		return this._EmitEvent("PauseWorkers", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.PauseWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
+			executeWorkerActionResult: await this._wm.PauseWorkers(workerIds)
+		}));
+	};
+	_ResumeWorkers = async (workerIds) => {
+		return this._EmitEvent("ResumeWorkers", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.ResumeWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
+			executeWorkerActionResult: await this._wm.ResumeWorkers(workerIds)
+		}));
+	};
+	_ExecuteWorkers = async (workerIds) => {
+		return this._EmitEvent("ExecuteWorkers", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.ExecuteWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
+			executeWorkerActionResult: await this._wm.ExecuteWorkers(workerIds)
+		}));
+	};
+	_ResetWorkers = async (workerIds) => {
+		return this._EmitEvent("ResetWorkers", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.ResetWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
+			executeWorkerActionResult: await this._wm.ResetWorkers(workerIds)
+		}));
+	};
+	_TerminateWorkers = async (workerIds) => {
+		return this._EmitEvent("TerminateWorkers", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.TerminateWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
+			executeWorkerActionResult: await this._wm.TerminateWorkers(workerIds)
+		}));
+	};
+	_UpdateWorkers = async (workerIds, options) => {
+		return this._EmitEvent("UpdateWorkers", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.UpdateWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
+			executeWorkerActionResult: await this._wm.UpdateWorkers(workerIds, options)
+		}));
+	};
+	_StopRunners = async (workerId, runnerIds) => {
+		return this._EmitEvent("StopRunners", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.StopRunners, IEventReturnValueBaseType.executeRunnerActionResult),
+			executeRunnerActionResult: await this._wm.StopRunners(workerId, runnerIds)
+		}));
+	};
+	_StartRunners = async (workerId, runnerIds) => {
+		return this._EmitEvent("StartRunners", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.StartRunners, IEventReturnValueBaseType.executeRunnerActionResult),
+			executeRunnerActionResult: await this._wm.StartRunners(workerId, runnerIds)
+		}));
+	};
+	_PauseRunners = async (workerId, runnerIds) => {
+		return this._EmitEvent("PauseRunners", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.PauseRunners, IEventReturnValueBaseType.executeRunnerActionResult),
+			executeRunnerActionResult: await this._wm.PauseRunners(workerId, runnerIds)
+		}));
+	};
+	_ResumeRunners = async (workerId, runnerIds) => {
+		return this._EmitEvent("ResumeRunners", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.ResumeRunners, IEventReturnValueBaseType.executeRunnerActionResult),
+			executeRunnerActionResult: await this._wm.ResumeRunners(workerId, runnerIds)
+		}));
+	};
+	_ExecuteRunners = async (workerId, runnerIds) => {
+		return this._EmitEvent("ExecuteRunners", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.ExecuteRunners, IEventReturnValueBaseType.executeRunnerActionResult),
+			executeRunnerActionResult: await this._wm.ExecuteRunners(workerId, runnerIds)
+		}));
+	};
+	_ResetRunners = async (workerId, runnerIds) => {
+		return this._EmitEvent("ResetRunners", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.ResetRunners, IEventReturnValueBaseType.executeRunnerActionResult),
+			executeRunnerActionResult: await this._wm.ResetRunners(workerId, runnerIds)
+		}));
+	};
+	_TerminateRunners = async (workerId, runnerIds) => {
+		return this._EmitEvent("TerminateRunners", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.TerminateRunners, IEventReturnValueBaseType.executeRunnerActionResult),
+			executeRunnerActionResult: await this._wm.TerminateRunners(workerId, runnerIds)
+		}));
+	};
+	_UpdateRunners = async (workerId, runnerIds, options) => {
+		return this._EmitEvent("UpdateRunners", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.UpdateRunners, IEventReturnValueBaseType.executeRunnerActionResult),
+			executeRunnerActionResult: await this._wm.UpdateRunners(workerId, runnerIds, options)
+		}));
+	};
+	_AddRunner = async (options) => {
+		this.#debug(chalk.yellow(`${this._id} ${this._clientName}:  --> AddRunner: [${JSON.stringify(options)}]`));
+		const runnerEx = await this._wm.AddRunner(options);
+		let runner = {};
+		if (runnerEx) {
+			this._SetupRunnerEventHandlers(runnerEx);
+			this.#debug(chalk.yellow(`${this._clientName}: AddRunner: WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}]`));
+			runner = runnerEx.toRunner();
+		}
+		return this._EmitEvent(IEventRequestCommand.AddRunner, this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.AddRunner, IEventReturnValueBaseType.runner),
+			runner
+		}));
+	};
+	_AddRunnerToWorkerByWorkerId = async (workerId, options) => {
+		this.#debug(chalk.yellow(`${this._id} ${this._clientName}:  --> AddRunner: [${JSON.stringify(options)}]`));
+		const runnerEx = await this._wm.AddRunnerToWorkerByWorkerId(workerId, options);
+		let runner = {};
+		if (runnerEx) {
+			this._SetupRunnerEventHandlers(runnerEx);
+			this.#debug(chalk.yellow(`${this._clientName}: AddRunnerToWorker: WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}]`));
+			runner = runnerEx.toRunner();
+		}
+		return this._EmitEvent(IEventRequestCommand.AddRunnerToWorker, this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.AddRunnerToWorker, IEventReturnValueBaseType.runner),
+			runner
+		}));
+	};
+	_RegisterSocketEvents = (socket, clientName) => {
+		`${this._id}${clientName}`;
+		const handlers = this._GetSocketEventHandlers(socket, clientName);
+		for (const [event, handler] of Object.entries(handlers)) {
+			const wrappedHandler = async (...args) => {
+				return handler(...args);
+			};
+			socket.on(event, wrappedHandler);
+		}
+	};
+	_EmitEvent = (eventName, data) => {
+		this.emit(eventName, data);
+		return data;
+	};
+	_GetSocketEventHandlers = (socket, clientName) => {
+		const logPrefix = `${this._id} ${clientName}:`;
+		return {
+			"disconnect": (reason) => {
+				this._EmitEvent("disconnect", reason);
+				this.#error(`#disconnect(): [${reason}]`);
+			},
+			"connect_error": (error) => {
+				this._EmitEvent("connect_error", error);
+				if (!socket.active) this.#error(error.message);
+			},
+			"error": (error) => {
+				this._EmitEvent("error", error);
+				this.#error(`#GetSocketEventHandlers(): [${error}]`);
+			},
+			"__STSdisconnect": (reason) => {
+				this._EmitEvent("__STSdisconnect", reason);
+				this.#debug(chalk.magenta(`${logPrefix}: [${socket.id}] [${reason}]`));
+				this.Stop();
+			},
+			"GetService": async (cb) => cb(await this._GetService()),
+			"GetWorkers": async (cb) => cb(await this._GetWorkers()),
+			"GetWorkersSmall": async (states, cb) => cb(await this._GetWorkersSmall(states)),
+			"GetArchiveList": async (runnerSearchFilters, cb) => cb(await this._GetArchiveList(runnerSearchFilters)),
+			"AddRunner": async (options, cb) => cb(await this._AddRunner(options)),
+			"AddRunnerToWorkerByWorkerId": async (workerId, options, cb) => cb(await this._AddRunnerToWorkerByWorkerId(workerId, options)),
+			"AddWorker": async (options, cb) => cb(await this._AddWorker(options)),
+			"StartWorkers": async (workerIds, cb) => cb(await this._StartWorkers(workerIds)),
+			"StopWorkers": async (workerIds, cb) => cb(await this._StopWorkers(workerIds)),
+			"PauseWorkers": async (workerIds, cb) => cb(await this._PauseWorkers(workerIds)),
+			"ResumeWorkers": async (workerIds, cb) => cb(await this._ResumeWorkers(workerIds)),
+			"ExecuteWorkers": async (workerIds, cb) => cb(await this._ExecuteWorkers(workerIds)),
+			"ResetWorkers": async (workerIds, cb) => cb(await this._ResetWorkers(workerIds)),
+			"TerminateWorkers": async (workerIds, cb) => cb(await this._TerminateWorkers(workerIds)),
+			"UpdateWorkers": async (workerIds, options, cb) => cb(await this._UpdateWorkers(workerIds, options)),
+			"StartRunners": async (workerId, runnerIds, cb) => cb(await this._StartRunners(workerId, runnerIds)),
+			"StopRunners": async (workerId, runnerIds, cb) => cb(await this._StopRunners(workerId, runnerIds)),
+			"PauseRunners": async (workerId, runnerIds, cb) => cb(await this._PauseRunners(workerId, runnerIds)),
+			"ResumeRunners": async (workerId, runnerIds, cb) => cb(await this._ResumeRunners(workerId, runnerIds)),
+			"ExecuteRunners": async (workerId, runnerIds, cb) => cb(await this._ExecuteRunners(workerId, runnerIds)),
+			"ResetRunners": async (workerId, runnerIds, cb) => cb(await this._ResetRunners(workerId, runnerIds)),
+			"TerminateRunners": async (workerId, runnerIds, cb) => cb(await this._TerminateRunners(workerId, runnerIds)),
+			"UpdateRunners": async (workerId, runnerIds, options, cb) => cb(await this._UpdateRunners(workerId, runnerIds, options))
+		};
+	};
+};
+//#endregion
+export { AbstractRunnerExecutionWorker, IEventRequestCommand, IEventReturnValueBaseType, IRunnerState, IWorkerState, PublishMessageCommandsTestRunner, STSWorkerManager, WorkerManagerProxy, eIWMessageCommands };
 
 //# sourceMappingURL=index.mjs.map