@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/client-DXBLHk7K.cjs

@@ -0,0 +1,808 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
+const require__polyfill_node_process = require("./_polyfill-node.process-rf9LjCyG.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+let node_url = require("node:url");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs);
+let node_vm = require("node:vm");
+node_vm = require_rolldown_runtime.__toESM(node_vm);
+let node_worker_threads = require("node:worker_threads");
+node_worker_threads = require_rolldown_runtime.__toESM(node_worker_threads);
+//#region ../../node_modules/web-worker/src/node/index.js
+/**
+* Copyright 2020 Google LLC
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+require__polyfill_node_process.init__polyfill_node_process();
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+require__polyfill_node_process.init__polyfill_global_this();
+const WORKER = Symbol.for("worker");
+const EVENTS = Symbol.for("events");
+var EventTarget = class {
+	constructor() {
+		Object.defineProperty(this, EVENTS, { value: /* @__PURE__ */ new Map() });
+	}
+	dispatchEvent(event) {
+		event.target = event.currentTarget = this;
+		if (this["on" + event.type]) try {
+			this["on" + event.type](event);
+		} catch (err) {
+			console.error(err);
+		}
+		const list = this[EVENTS].get(event.type);
+		if (list == null) return;
+		list.forEach((handler) => {
+			try {
+				handler.call(this, event);
+			} catch (err) {
+				console.error(err);
+			}
+		});
+	}
+	addEventListener(type, fn) {
+		let events = this[EVENTS].get(type);
+		if (!events) this[EVENTS].set(type, events = []);
+		events.push(fn);
+	}
+	removeEventListener(type, fn) {
+		let events = this[EVENTS].get(type);
+		if (events) {
+			const index = events.indexOf(fn);
+			if (index !== -1) events.splice(index, 1);
+		}
+	}
+};
+function Event(type, target) {
+	this.type = type;
+	this.timeStamp = Date.now();
+	this.target = this.currentTarget = this.data = null;
+}
+var node_default = typeof Worker === "function" ? Worker : node_worker_threads.default.isMainThread ? mainThread() : workerThread();
+const baseUrl = (0, node_url.pathToFileURL)(require__polyfill_node_process.browser$1.cwd() + "/");
+function mainThread() {
+	/**
+	* A web-compatible Worker implementation atop Node's worker_threads.
+	*  - uses DOM-style events (Event.data, Event.type, etc)
+	*  - supports event handler properties (worker.onmessage)
+	*  - Worker() constructor accepts a module URL
+	*  - accepts the {type:'module'} option
+	*  - emulates WorkerGlobalScope within the worker
+	* @param {string} url  The URL or module specifier to load
+	* @param {object} [options]  Worker construction options
+	* @param {string} [options.name]  Available as `self.name` within the Worker
+	* @param {string} [options.type="classic"]  Pass "module" to create a Module Worker.
+	*/
+	class Worker extends EventTarget {
+		constructor(url, options) {
+			super();
+			const { name, type } = options || {};
+			url += "";
+			let mod;
+			if (/^data:/.test(url)) mod = url;
+			else mod = (0, node_url.fileURLToPath)(new node_url.URL(url, baseUrl));
+			const worker = new node_worker_threads.default.Worker((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href), { workerData: {
+				mod,
+				name,
+				type
+			} });
+			Object.defineProperty(this, WORKER, { value: worker });
+			worker.on("message", (data) => {
+				const event = new Event("message");
+				event.data = data;
+				this.dispatchEvent(event);
+			});
+			worker.on("error", (error) => {
+				error.type = "error";
+				this.dispatchEvent(error);
+			});
+			worker.on("exit", () => {
+				this.dispatchEvent(new Event("close"));
+			});
+		}
+		postMessage(data, transferList) {
+			this[WORKER].postMessage(data, transferList);
+		}
+		terminate() {
+			this[WORKER].terminate();
+		}
+	}
+	Worker.prototype.onmessage = Worker.prototype.onerror = Worker.prototype.onclose = null;
+	return Worker;
+}
+function workerThread() {
+	if (typeof require__polyfill_node_process._polyfill_global_this_default.WorkerGlobalScope === "function") return;
+	let { mod, name, type } = node_worker_threads.default.workerData;
+	if (!mod) return mainThread();
+	const self = require__polyfill_node_process._polyfill_global_this_default.self = require__polyfill_node_process._polyfill_global_this_default;
+	let q = [];
+	function flush() {
+		const buffered = q;
+		q = null;
+		buffered.forEach((event) => {
+			self.dispatchEvent(event);
+		});
+	}
+	node_worker_threads.default.parentPort.on("message", (data) => {
+		const event = new Event("message");
+		event.data = data;
+		if (q == null) self.dispatchEvent(event);
+		else q.push(event);
+	});
+	node_worker_threads.default.parentPort.on("error", (err) => {
+		err.type = "Error";
+		self.dispatchEvent(err);
+	});
+	class WorkerGlobalScope extends EventTarget {
+		postMessage(data, transferList) {
+			node_worker_threads.default.parentPort.postMessage(data, transferList);
+		}
+		close() {
+			require__polyfill_node_process.browser$1.exit();
+		}
+		importScripts() {
+			for (let i = 0; i < arguments.length; i++) {
+				const url = arguments[i];
+				let code;
+				if (/^data:/.test(url)) code = parseDataUrl(url).data;
+				else code = node_fs.default.readFileSync(new node_url.URL(node_path.default.posix.normalize(url), (0, node_url.pathToFileURL)(mod)), "utf-8");
+				node_vm.default.runInThisContext(code, { filename: url });
+			}
+		}
+	}
+	let proto = Object.getPrototypeOf(require__polyfill_node_process._polyfill_global_this_default);
+	delete proto.constructor;
+	Object.defineProperties(WorkerGlobalScope.prototype, proto);
+	proto = Object.setPrototypeOf(require__polyfill_node_process._polyfill_global_this_default, new WorkerGlobalScope());
+	[
+		"postMessage",
+		"addEventListener",
+		"removeEventListener",
+		"dispatchEvent"
+	].forEach((fn) => {
+		proto[fn] = proto[fn].bind(require__polyfill_node_process._polyfill_global_this_default);
+	});
+	require__polyfill_node_process._polyfill_global_this_default.name = name;
+	require__polyfill_node_process._polyfill_global_this_default.WorkerGlobalScope = WorkerGlobalScope;
+	const isDataUrl = /^data:/.test(mod);
+	if (type === "module") (isDataUrl ? import(mod) : import((0, node_url.pathToFileURL)(mod))).catch((err) => {
+		if (isDataUrl && err.message === "Not supported") {
+			console.warn("Worker(): Importing data: URLs requires Node 12.10+. Falling back to classic worker.");
+			return evaluateDataUrl(mod, name);
+		}
+		console.error(err);
+	}).then(flush);
+	else {
+		try {
+			if (/^data:/.test(mod)) evaluateDataUrl(mod, name);
+			else require__polyfill_node_process._polyfill_global_this_default.importScripts(mod);
+		} catch (err) {
+			console.error(err);
+		}
+		Promise.resolve().then(flush);
+	}
+}
+function evaluateDataUrl(url, name) {
+	const { data } = parseDataUrl(url);
+	return node_vm.default.runInThisContext(data, { filename: "worker.<" + (name || "data:") + ">" });
+}
+function parseDataUrl(url) {
+	let [m, type, encoding, data] = url.match(/^data: *([^;,]*)(?: *; *([^,]*))? *,(.*)$/) || [];
+	if (!m) throw Error("Invalid Data URL.");
+	data = decodeURIComponent(data);
+	if (encoding) switch (encoding.toLowerCase()) {
+		case "base64":
+			data = require__polyfill_buffer_patch.import_buffer.Buffer.from(data, "base64").toString();
+			break;
+		default: throw Error("Unknown Data URL encoding \"" + encoding + "\"");
+	}
+	return {
+		type,
+		data
+	};
+}
+//#endregion
+//#region ../../node_modules/graphql-http/lib/utils.mjs
+/** @private */
+function isObject$1(val) {
+	return typeof val === "object" && val !== null;
+}
+//#endregion
+//#region ../../node_modules/graphql-http/lib/client.mjs
+/**
+*
+* client
+*
+*/
+/**
+* Creates a disposable GraphQL over HTTP client to transmit
+* GraphQL operation results.
+*
+* @category Client
+*/
+function createClient$1(options) {
+	const { credentials = "same-origin", referrer, referrerPolicy, shouldRetry = () => false } = options;
+	const fetchFn = options.fetchFn || fetch;
+	const AbortControllerImpl = options.abortControllerImpl || AbortController;
+	const client = (() => {
+		let disposed = false;
+		const listeners = [];
+		return {
+			get disposed() {
+				return disposed;
+			},
+			onDispose(cb) {
+				if (disposed) {
+					setTimeout(() => cb(), 0);
+					return () => {};
+				}
+				listeners.push(cb);
+				return () => {
+					listeners.splice(listeners.indexOf(cb), 1);
+				};
+			},
+			dispose() {
+				if (disposed) return;
+				disposed = true;
+				for (const listener of [...listeners]) listener();
+			}
+		};
+	})();
+	return {
+		subscribe(request, sink) {
+			if (client.disposed) throw new Error("Client has been disposed");
+			const control = new AbortControllerImpl();
+			const unlisten = client.onDispose(() => {
+				unlisten();
+				control.abort();
+			});
+			(async () => {
+				var _a;
+				let retryingErr = null, retries = 0;
+				for (;;) {
+					if (retryingErr) {
+						const should = await shouldRetry(retryingErr, retries);
+						if (control.signal.aborted) return;
+						if (!should) throw retryingErr;
+						retries++;
+					}
+					try {
+						const url = typeof options.url === "function" ? await options.url(request) : options.url;
+						if (control.signal.aborted) return;
+						const headers = typeof options.headers === "function" ? await options.headers() : (_a = options.headers) !== null && _a !== void 0 ? _a : {};
+						if (control.signal.aborted) return;
+						let res;
+						try {
+							res = await fetchFn(url, {
+								signal: control.signal,
+								method: "POST",
+								headers: Object.assign(Object.assign({}, headers), {
+									"content-type": "application/json; charset=utf-8",
+									accept: "application/graphql-response+json, application/json"
+								}),
+								credentials,
+								referrer,
+								referrerPolicy,
+								body: JSON.stringify(request)
+							});
+						} catch (err) {
+							throw new NetworkError(err);
+						}
+						if (!res.ok) throw new NetworkError(res);
+						if (!res.body) throw new Error("Missing response body");
+						const contentType = res.headers.get("content-type");
+						if (!contentType) throw new Error("Missing response content-type");
+						if (!contentType.includes("application/graphql-response+json") && !contentType.includes("application/json")) throw new Error(`Unsupported response content-type ${contentType}`);
+						const result = await res.json();
+						sink.next(result);
+						return control.abort();
+					} catch (err) {
+						if (control.signal.aborted) return;
+						if (!(err instanceof NetworkError)) throw err;
+						retryingErr = err;
+					}
+				}
+			})().then(() => sink.complete()).catch((err) => sink.error(err));
+			return () => control.abort();
+		},
+		dispose() {
+			client.dispose();
+		}
+	};
+}
+/**
+* A network error caused by the client or an unexpected response from the server.
+*
+* To avoid bundling DOM typings (because the client can run in Node env too),
+* you should supply the `Response` generic depending on your Fetch implementation.
+*
+* @category Client
+*/
+var NetworkError = class extends Error {
+	constructor(msgOrErrOrResponse) {
+		let message, response;
+		if (isResponseLike(msgOrErrOrResponse)) {
+			response = msgOrErrOrResponse;
+			message = "Server responded with " + msgOrErrOrResponse.status + ": " + msgOrErrOrResponse.statusText;
+		} else if (msgOrErrOrResponse instanceof Error) message = msgOrErrOrResponse.message;
+		else message = String(msgOrErrOrResponse);
+		super(message);
+		this.name = this.constructor.name;
+		this.response = response;
+	}
+};
+function isResponseLike(val) {
+	return isObject$1(val) && typeof val["ok"] === "boolean" && typeof val["status"] === "number" && typeof val["statusText"] === "string";
+}
+//#endregion
+//#region ../../node_modules/graphql-ws/dist/common-CGW11Fyb.js
+function extendedTypeof(val) {
+	if (val === null) return "null";
+	if (Array.isArray(val)) return "array";
+	return typeof val;
+}
+function isObject(val) {
+	return extendedTypeof(val) === "object";
+}
+function areGraphQLFormattedErrors(obj) {
+	return Array.isArray(obj) && obj.length > 0 && obj.every((ob) => "message" in ob);
+}
+function limitCloseReason(reason, whenTooLong) {
+	return reason.length < 124 ? reason : whenTooLong;
+}
+var CloseCode = /* @__PURE__ */ ((CloseCode2) => {
+	CloseCode2[CloseCode2["InternalServerError"] = 4500] = "InternalServerError";
+	CloseCode2[CloseCode2["InternalClientError"] = 4005] = "InternalClientError";
+	CloseCode2[CloseCode2["BadRequest"] = 4400] = "BadRequest";
+	CloseCode2[CloseCode2["BadResponse"] = 4004] = "BadResponse";
+	CloseCode2[CloseCode2["Unauthorized"] = 4401] = "Unauthorized";
+	CloseCode2[CloseCode2["Forbidden"] = 4403] = "Forbidden";
+	CloseCode2[CloseCode2["SubprotocolNotAcceptable"] = 4406] = "SubprotocolNotAcceptable";
+	CloseCode2[CloseCode2["ConnectionInitialisationTimeout"] = 4408] = "ConnectionInitialisationTimeout";
+	CloseCode2[CloseCode2["ConnectionAcknowledgementTimeout"] = 4504] = "ConnectionAcknowledgementTimeout";
+	CloseCode2[CloseCode2["SubscriberAlreadyExists"] = 4409] = "SubscriberAlreadyExists";
+	CloseCode2[CloseCode2["TooManyInitialisationRequests"] = 4429] = "TooManyInitialisationRequests";
+	return CloseCode2;
+})(CloseCode || {});
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+	MessageType2["ConnectionInit"] = "connection_init";
+	MessageType2["ConnectionAck"] = "connection_ack";
+	MessageType2["Ping"] = "ping";
+	MessageType2["Pong"] = "pong";
+	MessageType2["Subscribe"] = "subscribe";
+	MessageType2["Next"] = "next";
+	MessageType2["Error"] = "error";
+	MessageType2["Complete"] = "complete";
+	return MessageType2;
+})(MessageType || {});
+function validateMessage(val) {
+	if (!isObject(val)) throw new Error(`Message is expected to be an object, but got ${extendedTypeof(val)}`);
+	if (!val.type) throw new Error(`Message is missing the 'type' property`);
+	if (typeof val.type !== "string") throw new Error(`Message is expects the 'type' property to be a string, but got ${extendedTypeof(val.type)}`);
+	switch (val.type) {
+		case "connection_init":
+		case "connection_ack":
+		case "ping":
+		case "pong":
+			if (val.payload != null && !isObject(val.payload)) throw new Error(`"${val.type}" message expects the 'payload' property to be an object or nullish or missing, but got "${val.payload}"`);
+			break;
+		case "subscribe":
+			if (typeof val.id !== "string") throw new Error(`"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(val.id)}`);
+			if (!val.id) throw new Error(`"${val.type}" message requires a non-empty 'id' property`);
+			if (!isObject(val.payload)) throw new Error(`"${val.type}" message expects the 'payload' property to be an object, but got ${extendedTypeof(val.payload)}`);
+			if (typeof val.payload.query !== "string") throw new Error(`"${val.type}" message payload expects the 'query' property to be a string, but got ${extendedTypeof(val.payload.query)}`);
+			if (val.payload.variables != null && !isObject(val.payload.variables)) throw new Error(`"${val.type}" message payload expects the 'variables' property to be a an object or nullish or missing, but got ${extendedTypeof(val.payload.variables)}`);
+			if (val.payload.operationName != null && extendedTypeof(val.payload.operationName) !== "string") throw new Error(`"${val.type}" message payload expects the 'operationName' property to be a string or nullish or missing, but got ${extendedTypeof(val.payload.operationName)}`);
+			if (val.payload.extensions != null && !isObject(val.payload.extensions)) throw new Error(`"${val.type}" message payload expects the 'extensions' property to be a an object or nullish or missing, but got ${extendedTypeof(val.payload.extensions)}`);
+			break;
+		case "next":
+			if (typeof val.id !== "string") throw new Error(`"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(val.id)}`);
+			if (!val.id) throw new Error(`"${val.type}" message requires a non-empty 'id' property`);
+			if (!isObject(val.payload)) throw new Error(`"${val.type}" message expects the 'payload' property to be an object, but got ${extendedTypeof(val.payload)}`);
+			break;
+		case "error":
+			if (typeof val.id !== "string") throw new Error(`"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(val.id)}`);
+			if (!val.id) throw new Error(`"${val.type}" message requires a non-empty 'id' property`);
+			if (!areGraphQLFormattedErrors(val.payload)) throw new Error(`"${val.type}" message expects the 'payload' property to be an array of GraphQL errors, but got ${JSON.stringify(val.payload)}`);
+			break;
+		case "complete":
+			if (typeof val.id !== "string") throw new Error(`"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(val.id)}`);
+			if (!val.id) throw new Error(`"${val.type}" message requires a non-empty 'id' property`);
+			break;
+		default: throw new Error(`Invalid message 'type' property "${val.type}"`);
+	}
+	return val;
+}
+function parseMessage(data, reviver) {
+	return validateMessage(typeof data === "string" ? JSON.parse(data, reviver) : data);
+}
+function stringifyMessage(msg, replacer) {
+	validateMessage(msg);
+	return JSON.stringify(msg, replacer);
+}
+//#endregion
+//#region ../../node_modules/graphql-ws/dist/client.js
+require__polyfill_node_process.init__polyfill_global_this();
+function createClient(options) {
+	const { url, connectionParams, lazy = true, onNonLazyError = console.error, lazyCloseTimeout: lazyCloseTimeoutMs = 0, keepAlive = 0, disablePong, connectionAckWaitTimeout = 0, retryAttempts = 5, retryWait = async function randomisedExponentialBackoff(retries2) {
+		const retryDelaySeconds = Math.pow(2, retries2);
+		await new Promise((resolve) => setTimeout(resolve, retryDelaySeconds * 1e3 + Math.floor(Math.random() * 2700 + 300)));
+	}, shouldRetry = isLikeCloseEvent, on, webSocketImpl, generateID = function generateUUID() {
+		return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+			const r = Math.random() * 16 | 0;
+			return (c == "x" ? r : r & 3 | 8).toString(16);
+		});
+	}, jsonMessageReplacer: replacer, jsonMessageReviver: reviver } = options;
+	let ws;
+	if (webSocketImpl) {
+		if (!isWebSocket(webSocketImpl)) throw new Error("Invalid WebSocket implementation provided");
+		ws = webSocketImpl;
+	} else if (typeof WebSocket !== "undefined") ws = WebSocket;
+	else if (typeof require__polyfill_node_process._polyfill_global_this_default !== "undefined") ws = require__polyfill_node_process._polyfill_global_this_default.WebSocket || require__polyfill_node_process._polyfill_global_this_default.MozWebSocket;
+	else if (typeof window !== "undefined") ws = window.WebSocket || window.MozWebSocket;
+	if (!ws) throw new Error("WebSocket implementation missing; on Node you can `import WebSocket from 'ws';` and pass `webSocketImpl: WebSocket` to `createClient`");
+	const WebSocketImpl = ws;
+	const emitter = (() => {
+		const message = /* @__PURE__ */ (() => {
+			const listeners2 = {};
+			return {
+				on(id, listener) {
+					listeners2[id] = listener;
+					return () => {
+						delete listeners2[id];
+					};
+				},
+				emit(message2) {
+					if ("id" in message2) listeners2[message2.id]?.(message2);
+				}
+			};
+		})();
+		const listeners = {
+			connecting: on?.connecting ? [on.connecting] : [],
+			opened: on?.opened ? [on.opened] : [],
+			connected: on?.connected ? [on.connected] : [],
+			ping: on?.ping ? [on.ping] : [],
+			pong: on?.pong ? [on.pong] : [],
+			message: on?.message ? [message.emit, on.message] : [message.emit],
+			closed: on?.closed ? [on.closed] : [],
+			error: on?.error ? [on.error] : []
+		};
+		return {
+			onMessage: message.on,
+			on(event, listener) {
+				const l = listeners[event];
+				l.push(listener);
+				return () => {
+					const i = l.indexOf(listener);
+					if (i > -1) l.splice(i, 1);
+				};
+			},
+			emit(event, ...args) {
+				for (const listener of [...listeners[event]]) listener(...args);
+			}
+		};
+	})();
+	function errorOrClosed(cb) {
+		const listening = [emitter.on("error", (err) => {
+			listening.forEach((unlisten) => unlisten());
+			cb(err);
+		}), emitter.on("closed", (event) => {
+			listening.forEach((unlisten) => unlisten());
+			cb(event);
+		})];
+	}
+	let connecting, locks = 0, lazyCloseTimeout, retrying = false, retries = 0, disposed = false;
+	async function connect() {
+		clearTimeout(lazyCloseTimeout);
+		const [socket, throwOnClose] = await (connecting ?? (connecting = new Promise((connected, denied) => (async () => {
+			if (retrying) {
+				await retryWait(retries);
+				if (!locks) {
+					connecting = void 0;
+					return denied({
+						code: 1e3,
+						reason: "All Subscriptions Gone"
+					});
+				}
+				retries++;
+			}
+			emitter.emit("connecting", retrying);
+			const socket2 = new WebSocketImpl(typeof url === "function" ? await url() : url, "graphql-transport-ws");
+			let connectionAckTimeout, queuedPing;
+			function enqueuePing() {
+				if (isFinite(keepAlive) && keepAlive > 0) {
+					clearTimeout(queuedPing);
+					queuedPing = setTimeout(() => {
+						if (socket2.readyState === WebSocketImpl.OPEN) {
+							socket2.send(stringifyMessage({ type: MessageType.Ping }));
+							emitter.emit("ping", false, void 0);
+						}
+					}, keepAlive);
+				}
+			}
+			errorOrClosed((errOrEvent) => {
+				connecting = void 0;
+				clearTimeout(connectionAckTimeout);
+				clearTimeout(queuedPing);
+				denied(errOrEvent);
+				if (errOrEvent instanceof TerminatedCloseEvent) {
+					socket2.close(4499, "Terminated");
+					socket2.onerror = null;
+					socket2.onclose = null;
+				}
+			});
+			socket2.onerror = (err) => emitter.emit("error", err);
+			socket2.onclose = (event) => emitter.emit("closed", event);
+			socket2.onopen = async () => {
+				try {
+					emitter.emit("opened", socket2);
+					const payload = typeof connectionParams === "function" ? await connectionParams() : connectionParams;
+					if (socket2.readyState !== WebSocketImpl.OPEN) return;
+					socket2.send(stringifyMessage(payload ? {
+						type: MessageType.ConnectionInit,
+						payload
+					} : { type: MessageType.ConnectionInit }, replacer));
+					if (isFinite(connectionAckWaitTimeout) && connectionAckWaitTimeout > 0) connectionAckTimeout = setTimeout(() => {
+						socket2.close(CloseCode.ConnectionAcknowledgementTimeout, "Connection acknowledgement timeout");
+					}, connectionAckWaitTimeout);
+					enqueuePing();
+				} catch (err) {
+					emitter.emit("error", err);
+					socket2.close(CloseCode.InternalClientError, limitCloseReason(err instanceof Error ? err.message : String(err), "Internal client error"));
+				}
+			};
+			let acknowledged = false;
+			socket2.onmessage = ({ data }) => {
+				try {
+					const message = parseMessage(data, reviver);
+					emitter.emit("message", message);
+					if (message.type === "ping" || message.type === "pong") {
+						emitter.emit(message.type, true, message.payload);
+						if (message.type === "pong") enqueuePing();
+						else if (!disablePong) {
+							socket2.send(stringifyMessage(message.payload ? {
+								type: MessageType.Pong,
+								payload: message.payload
+							} : { type: MessageType.Pong }));
+							emitter.emit("pong", false, message.payload);
+						}
+						return;
+					}
+					if (acknowledged) return;
+					if (message.type !== MessageType.ConnectionAck) throw new Error(`First message cannot be of type ${message.type}`);
+					clearTimeout(connectionAckTimeout);
+					acknowledged = true;
+					emitter.emit("connected", socket2, message.payload, retrying);
+					retrying = false;
+					retries = 0;
+					connected([socket2, new Promise((_, reject) => errorOrClosed(reject))]);
+				} catch (err) {
+					socket2.onmessage = null;
+					emitter.emit("error", err);
+					socket2.close(CloseCode.BadResponse, limitCloseReason(err instanceof Error ? err.message : String(err), "Bad response"));
+				}
+			};
+		})())));
+		if (socket.readyState === WebSocketImpl.CLOSING) await throwOnClose;
+		let release = () => {};
+		const released = new Promise((resolve) => release = resolve);
+		return [
+			socket,
+			release,
+			Promise.race([released.then(() => {
+				if (!locks) {
+					const complete = () => socket.close(1e3, "Normal Closure");
+					if (isFinite(lazyCloseTimeoutMs) && lazyCloseTimeoutMs > 0) lazyCloseTimeout = setTimeout(() => {
+						if (socket.readyState === WebSocketImpl.OPEN) complete();
+					}, lazyCloseTimeoutMs);
+					else complete();
+				}
+			}), throwOnClose])
+		];
+	}
+	function shouldRetryConnectOrThrow(errOrCloseEvent) {
+		if (isLikeCloseEvent(errOrCloseEvent) && (isFatalInternalCloseCode(errOrCloseEvent.code) || [
+			CloseCode.InternalServerError,
+			CloseCode.InternalClientError,
+			CloseCode.BadRequest,
+			CloseCode.BadResponse,
+			CloseCode.Unauthorized,
+			CloseCode.SubprotocolNotAcceptable,
+			CloseCode.SubscriberAlreadyExists,
+			CloseCode.TooManyInitialisationRequests
+		].includes(errOrCloseEvent.code))) throw errOrCloseEvent;
+		if (disposed) return false;
+		if (isLikeCloseEvent(errOrCloseEvent) && errOrCloseEvent.code === 1e3) return locks > 0;
+		if (!retryAttempts || retries >= retryAttempts) throw errOrCloseEvent;
+		if (!shouldRetry(errOrCloseEvent)) throw errOrCloseEvent;
+		return retrying = true;
+	}
+	if (!lazy) (async () => {
+		locks++;
+		for (;;) try {
+			const [, , throwOnClose] = await connect();
+			await throwOnClose;
+		} catch (errOrCloseEvent) {
+			try {
+				if (!shouldRetryConnectOrThrow(errOrCloseEvent)) return;
+			} catch (errOrCloseEvent2) {
+				return onNonLazyError?.(errOrCloseEvent2);
+			}
+		}
+	})();
+	function subscribe(payload, sink) {
+		const id = generateID(payload);
+		let done = false, errored = false, releaser = () => {
+			locks--;
+			done = true;
+		};
+		(async () => {
+			locks++;
+			for (;;) try {
+				const [socket, release, waitForReleaseOrThrowOnClose] = await connect();
+				if (done) return release();
+				const unlisten = emitter.onMessage(id, (message) => {
+					switch (message.type) {
+						case MessageType.Next:
+							sink.next(message.payload);
+							return;
+						case MessageType.Error:
+							errored = true, done = true;
+							sink.error(message.payload);
+							releaser();
+							return;
+						case MessageType.Complete:
+							done = true;
+							releaser();
+							return;
+					}
+				});
+				socket.send(stringifyMessage({
+					id,
+					type: MessageType.Subscribe,
+					payload
+				}, replacer));
+				releaser = () => {
+					if (!done && socket.readyState === WebSocketImpl.OPEN) socket.send(stringifyMessage({
+						id,
+						type: MessageType.Complete
+					}, replacer));
+					locks--;
+					done = true;
+					release();
+				};
+				await waitForReleaseOrThrowOnClose.finally(unlisten);
+				return;
+			} catch (errOrCloseEvent) {
+				if (!shouldRetryConnectOrThrow(errOrCloseEvent)) return;
+			}
+		})().then(() => {
+			if (!errored) sink.complete();
+		}).catch((err) => {
+			sink.error(err);
+		});
+		return () => {
+			if (!done) releaser();
+		};
+	}
+	return {
+		on: emitter.on,
+		subscribe,
+		iterate(request) {
+			const pending = [];
+			const deferred = {
+				done: false,
+				error: null,
+				resolve: () => {}
+			};
+			const dispose = subscribe(request, {
+				next(val) {
+					pending.push(val);
+					deferred.resolve();
+				},
+				error(err) {
+					deferred.done = true;
+					deferred.error = err;
+					deferred.resolve();
+				},
+				complete() {
+					deferred.done = true;
+					deferred.resolve();
+				}
+			});
+			const iterator = async function* iterator2() {
+				for (;;) {
+					if (!pending.length) await new Promise((resolve) => deferred.resolve = resolve);
+					while (pending.length) yield pending.shift();
+					if (deferred.error) throw deferred.error;
+					if (deferred.done) return;
+				}
+			}();
+			iterator.throw = async (err) => {
+				if (!deferred.done) {
+					deferred.done = true;
+					deferred.error = err;
+					deferred.resolve();
+				}
+				return {
+					done: true,
+					value: void 0
+				};
+			};
+			iterator.return = async () => {
+				dispose();
+				return {
+					done: true,
+					value: void 0
+				};
+			};
+			return iterator;
+		},
+		async dispose() {
+			disposed = true;
+			if (connecting) {
+				const [socket] = await connecting;
+				socket.close(1e3, "Normal Closure");
+			}
+		},
+		terminate() {
+			if (connecting) emitter.emit("closed", new TerminatedCloseEvent());
+		}
+	};
+}
+var TerminatedCloseEvent = class extends Error {
+	name = "TerminatedCloseEvent";
+	message = "4499: Terminated";
+	code = 4499;
+	reason = "Terminated";
+	wasClean = false;
+};
+function isLikeCloseEvent(val) {
+	return isObject(val) && "code" in val && "reason" in val;
+}
+function isFatalInternalCloseCode(code) {
+	if ([
+		1e3,
+		1001,
+		1006,
+		1005,
+		1012,
+		1013,
+		1014
+	].includes(code)) return false;
+	return code >= 1e3 && code <= 1999;
+}
+function isWebSocket(val) {
+	return typeof val === "function" && "constructor" in val && "CLOSED" in val && "CLOSING" in val && "CONNECTING" in val && "OPEN" in val;
+}
+//#endregion
+Object.defineProperty(exports, "createClient", {
+	enumerable: true,
+	get: function() {
+		return createClient;
+	}
+});
+Object.defineProperty(exports, "createClient$1", {
+	enumerable: true,
+	get: function() {
+		return createClient$1;
+	}
+});
+Object.defineProperty(exports, "node_default", {
+	enumerable: true,
+	get: function() {
+		return node_default;
+	}
+});