@fire-spark/realtime 0.0.1

package/dist/index.js

@@ -0,0 +1,4096 @@
+import { isStorefrontNotFound, services, storefrontJson } from "@fire-spark/core";
+//#region ../../node_modules/.pnpm/@supabase+realtime-js@2.100.1/node_modules/@supabase/realtime-js/dist/module/lib/websocket-factory.js
+/**
+* Utilities for creating WebSocket instances across runtimes.
+*/
+var WebSocketFactory = class {
+	/**
+	* Static-only utility – prevent instantiation.
+	*/
+	constructor() {}
+	static detectEnvironment() {
+		var _a;
+		if (typeof WebSocket !== "undefined") return {
+			type: "native",
+			constructor: WebSocket
+		};
+		if (typeof globalThis !== "undefined" && typeof globalThis.WebSocket !== "undefined") return {
+			type: "native",
+			constructor: globalThis.WebSocket
+		};
+		if (typeof global !== "undefined" && typeof global.WebSocket !== "undefined") return {
+			type: "native",
+			constructor: global.WebSocket
+		};
+		if (typeof globalThis !== "undefined" && typeof globalThis.WebSocketPair !== "undefined" && typeof globalThis.WebSocket === "undefined") return {
+			type: "cloudflare",
+			error: "Cloudflare Workers detected. WebSocket clients are not supported in Cloudflare Workers.",
+			workaround: "Use Cloudflare Workers WebSocket API for server-side WebSocket handling, or deploy to a different runtime."
+		};
+		if (typeof globalThis !== "undefined" && globalThis.EdgeRuntime || typeof navigator !== "undefined" && ((_a = navigator.userAgent) === null || _a === void 0 ? void 0 : _a.includes("Vercel-Edge"))) return {
+			type: "unsupported",
+			error: "Edge runtime detected (Vercel Edge/Netlify Edge). WebSockets are not supported in edge functions.",
+			workaround: "Use serverless functions or a different deployment target for WebSocket functionality."
+		};
+		const _process = globalThis["process"];
+		if (_process) {
+			const processVersions = _process["versions"];
+			if (processVersions && processVersions["node"]) {
+				const versionString = processVersions["node"];
+				const nodeVersion = parseInt(versionString.replace(/^v/, "").split(".")[0]);
+				if (nodeVersion >= 22) {
+					if (typeof globalThis.WebSocket !== "undefined") return {
+						type: "native",
+						constructor: globalThis.WebSocket
+					};
+					return {
+						type: "unsupported",
+						error: `Node.js ${nodeVersion} detected but native WebSocket not found.`,
+						workaround: "Provide a WebSocket implementation via the transport option."
+					};
+				}
+				return {
+					type: "unsupported",
+					error: `Node.js ${nodeVersion} detected without native WebSocket support.`,
+					workaround: "For Node.js < 22, install \"ws\" package and provide it via the transport option:\nimport ws from \"ws\"\nnew RealtimeClient(url, { transport: ws })"
+				};
+			}
+		}
+		return {
+			type: "unsupported",
+			error: "Unknown JavaScript runtime without WebSocket support.",
+			workaround: "Ensure you're running in a supported environment (browser, Node.js, Deno) or provide a custom WebSocket implementation."
+		};
+	}
+	/**
+	* Returns the best available WebSocket constructor for the current runtime.
+	*
+	* @category Realtime
+	*
+	* @example Example with error handling
+	* ```ts
+	* try {
+	*   const WS = WebSocketFactory.getWebSocketConstructor()
+	*   const socket = new WS('wss://example.com/socket')
+	* } catch (error) {
+	*   console.error('WebSocket not available in this environment.', error)
+	* }
+	* ```
+	*/
+	static getWebSocketConstructor() {
+		const env = this.detectEnvironment();
+		if (env.constructor) return env.constructor;
+		let errorMessage = env.error || "WebSocket not supported in this environment.";
+		if (env.workaround) errorMessage += `\n\nSuggested solution: ${env.workaround}`;
+		throw new Error(errorMessage);
+	}
+	/**
+	* Detects whether the runtime can establish WebSocket connections.
+	*
+	* @category Realtime
+	*
+	* @example Example in a Node.js script
+	* ```ts
+	* if (!WebSocketFactory.isWebSocketSupported()) {
+	*   console.error('WebSockets are required for this script.')
+	*   process.exitCode = 1
+	* }
+	* ```
+	*/
+	static isWebSocketSupported() {
+		try {
+			const env = this.detectEnvironment();
+			return env.type === "native" || env.type === "ws";
+		} catch (_a) {
+			return false;
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@supabase+realtime-js@2.100.1/node_modules/@supabase/realtime-js/dist/module/lib/constants.js
+const DEFAULT_VERSION = `realtime-js/2.100.1`;
+const VSN_1_0_0 = "1.0.0";
+const VSN_2_0_0 = "2.0.0";
+const DEFAULT_VSN$1 = VSN_2_0_0;
+const DEFAULT_TIMEOUT$1 = 1e4;
+const CHANNEL_STATES$1 = {
+	closed: "closed",
+	errored: "errored",
+	joined: "joined",
+	joining: "joining",
+	leaving: "leaving"
+};
+const CHANNEL_EVENTS$1 = {
+	close: "phx_close",
+	error: "phx_error",
+	join: "phx_join",
+	reply: "phx_reply",
+	leave: "phx_leave",
+	access_token: "access_token"
+};
+const CONNECTION_STATE = {
+	connecting: "connecting",
+	open: "open",
+	closing: "closing",
+	closed: "closed"
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@supabase+realtime-js@2.100.1/node_modules/@supabase/realtime-js/dist/module/lib/serializer.js
+var Serializer = class {
+	constructor(allowedMetadataKeys) {
+		this.HEADER_LENGTH = 1;
+		this.USER_BROADCAST_PUSH_META_LENGTH = 6;
+		this.KINDS = {
+			userBroadcastPush: 3,
+			userBroadcast: 4
+		};
+		this.BINARY_ENCODING = 0;
+		this.JSON_ENCODING = 1;
+		this.BROADCAST_EVENT = "broadcast";
+		this.allowedMetadataKeys = [];
+		this.allowedMetadataKeys = allowedMetadataKeys !== null && allowedMetadataKeys !== void 0 ? allowedMetadataKeys : [];
+	}
+	encode(msg, callback) {
+		if (msg.event === this.BROADCAST_EVENT && !(msg.payload instanceof ArrayBuffer) && typeof msg.payload.event === "string") return callback(this._binaryEncodeUserBroadcastPush(msg));
+		let payload = [
+			msg.join_ref,
+			msg.ref,
+			msg.topic,
+			msg.event,
+			msg.payload
+		];
+		return callback(JSON.stringify(payload));
+	}
+	_binaryEncodeUserBroadcastPush(message) {
+		var _a;
+		if (this._isArrayBuffer((_a = message.payload) === null || _a === void 0 ? void 0 : _a.payload)) return this._encodeBinaryUserBroadcastPush(message);
+		else return this._encodeJsonUserBroadcastPush(message);
+	}
+	_encodeBinaryUserBroadcastPush(message) {
+		var _a, _b;
+		const userPayload = (_b = (_a = message.payload) === null || _a === void 0 ? void 0 : _a.payload) !== null && _b !== void 0 ? _b : /* @__PURE__ */ new ArrayBuffer(0);
+		return this._encodeUserBroadcastPush(message, this.BINARY_ENCODING, userPayload);
+	}
+	_encodeJsonUserBroadcastPush(message) {
+		var _a, _b;
+		const userPayload = (_b = (_a = message.payload) === null || _a === void 0 ? void 0 : _a.payload) !== null && _b !== void 0 ? _b : {};
+		const encodedUserPayload = new TextEncoder().encode(JSON.stringify(userPayload)).buffer;
+		return this._encodeUserBroadcastPush(message, this.JSON_ENCODING, encodedUserPayload);
+	}
+	_encodeUserBroadcastPush(message, encodingType, encodedPayload) {
+		var _a, _b;
+		const topic = message.topic;
+		const ref = (_a = message.ref) !== null && _a !== void 0 ? _a : "";
+		const joinRef = (_b = message.join_ref) !== null && _b !== void 0 ? _b : "";
+		const userEvent = message.payload.event;
+		const rest = this.allowedMetadataKeys ? this._pick(message.payload, this.allowedMetadataKeys) : {};
+		const metadata = Object.keys(rest).length === 0 ? "" : JSON.stringify(rest);
+		if (joinRef.length > 255) throw new Error(`joinRef length ${joinRef.length} exceeds maximum of 255`);
+		if (ref.length > 255) throw new Error(`ref length ${ref.length} exceeds maximum of 255`);
+		if (topic.length > 255) throw new Error(`topic length ${topic.length} exceeds maximum of 255`);
+		if (userEvent.length > 255) throw new Error(`userEvent length ${userEvent.length} exceeds maximum of 255`);
+		if (metadata.length > 255) throw new Error(`metadata length ${metadata.length} exceeds maximum of 255`);
+		const metaLength = this.USER_BROADCAST_PUSH_META_LENGTH + joinRef.length + ref.length + topic.length + userEvent.length + metadata.length;
+		const header = new ArrayBuffer(this.HEADER_LENGTH + metaLength);
+		let view = new DataView(header);
+		let offset = 0;
+		view.setUint8(offset++, this.KINDS.userBroadcastPush);
+		view.setUint8(offset++, joinRef.length);
+		view.setUint8(offset++, ref.length);
+		view.setUint8(offset++, topic.length);
+		view.setUint8(offset++, userEvent.length);
+		view.setUint8(offset++, metadata.length);
+		view.setUint8(offset++, encodingType);
+		Array.from(joinRef, (char) => view.setUint8(offset++, char.charCodeAt(0)));
+		Array.from(ref, (char) => view.setUint8(offset++, char.charCodeAt(0)));
+		Array.from(topic, (char) => view.setUint8(offset++, char.charCodeAt(0)));
+		Array.from(userEvent, (char) => view.setUint8(offset++, char.charCodeAt(0)));
+		Array.from(metadata, (char) => view.setUint8(offset++, char.charCodeAt(0)));
+		var combined = new Uint8Array(header.byteLength + encodedPayload.byteLength);
+		combined.set(new Uint8Array(header), 0);
+		combined.set(new Uint8Array(encodedPayload), header.byteLength);
+		return combined.buffer;
+	}
+	decode(rawPayload, callback) {
+		if (this._isArrayBuffer(rawPayload)) return callback(this._binaryDecode(rawPayload));
+		if (typeof rawPayload === "string") {
+			const [join_ref, ref, topic, event, payload] = JSON.parse(rawPayload);
+			return callback({
+				join_ref,
+				ref,
+				topic,
+				event,
+				payload
+			});
+		}
+		return callback({});
+	}
+	_binaryDecode(buffer) {
+		const view = new DataView(buffer);
+		const kind = view.getUint8(0);
+		const decoder = new TextDecoder();
+		switch (kind) {
+			case this.KINDS.userBroadcast: return this._decodeUserBroadcast(buffer, view, decoder);
+		}
+	}
+	_decodeUserBroadcast(buffer, view, decoder) {
+		const topicSize = view.getUint8(1);
+		const userEventSize = view.getUint8(2);
+		const metadataSize = view.getUint8(3);
+		const payloadEncoding = view.getUint8(4);
+		let offset = this.HEADER_LENGTH + 4;
+		const topic = decoder.decode(buffer.slice(offset, offset + topicSize));
+		offset = offset + topicSize;
+		const userEvent = decoder.decode(buffer.slice(offset, offset + userEventSize));
+		offset = offset + userEventSize;
+		const metadata = decoder.decode(buffer.slice(offset, offset + metadataSize));
+		offset = offset + metadataSize;
+		const payload = buffer.slice(offset, buffer.byteLength);
+		const parsedPayload = payloadEncoding === this.JSON_ENCODING ? JSON.parse(decoder.decode(payload)) : payload;
+		const data = {
+			type: this.BROADCAST_EVENT,
+			event: userEvent,
+			payload: parsedPayload
+		};
+		if (metadataSize > 0) data["meta"] = JSON.parse(metadata);
+		return {
+			join_ref: null,
+			ref: null,
+			topic,
+			event: this.BROADCAST_EVENT,
+			payload: data
+		};
+	}
+	_isArrayBuffer(buffer) {
+		var _a;
+		return buffer instanceof ArrayBuffer || ((_a = buffer === null || buffer === void 0 ? void 0 : buffer.constructor) === null || _a === void 0 ? void 0 : _a.name) === "ArrayBuffer";
+	}
+	_pick(obj, keys) {
+		if (!obj || typeof obj !== "object") return {};
+		return Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)));
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@supabase+realtime-js@2.100.1/node_modules/@supabase/realtime-js/dist/module/lib/transformers.js
+/**
+* Helpers to convert the change Payload into native JS types.
+*/
+var PostgresTypes;
+(function(PostgresTypes) {
+	PostgresTypes["abstime"] = "abstime";
+	PostgresTypes["bool"] = "bool";
+	PostgresTypes["date"] = "date";
+	PostgresTypes["daterange"] = "daterange";
+	PostgresTypes["float4"] = "float4";
+	PostgresTypes["float8"] = "float8";
+	PostgresTypes["int2"] = "int2";
+	PostgresTypes["int4"] = "int4";
+	PostgresTypes["int4range"] = "int4range";
+	PostgresTypes["int8"] = "int8";
+	PostgresTypes["int8range"] = "int8range";
+	PostgresTypes["json"] = "json";
+	PostgresTypes["jsonb"] = "jsonb";
+	PostgresTypes["money"] = "money";
+	PostgresTypes["numeric"] = "numeric";
+	PostgresTypes["oid"] = "oid";
+	PostgresTypes["reltime"] = "reltime";
+	PostgresTypes["text"] = "text";
+	PostgresTypes["time"] = "time";
+	PostgresTypes["timestamp"] = "timestamp";
+	PostgresTypes["timestamptz"] = "timestamptz";
+	PostgresTypes["timetz"] = "timetz";
+	PostgresTypes["tsrange"] = "tsrange";
+	PostgresTypes["tstzrange"] = "tstzrange";
+})(PostgresTypes || (PostgresTypes = {}));
+/**
+* Takes an array of columns and an object of string values then converts each string value
+* to its mapped type.
+*
+* @param {{name: String, type: String}[]} columns
+* @param {Object} record
+* @param {Object} options The map of various options that can be applied to the mapper
+* @param {Array} options.skipTypes The array of types that should not be converted
+*
+* @example convertChangeData([{name: 'first_name', type: 'text'}, {name: 'age', type: 'int4'}], {first_name: 'Paul', age:'33'}, {})
+* //=>{ first_name: 'Paul', age: 33 }
+*/
+const convertChangeData = (columns, record, options = {}) => {
+	var _a;
+	const skipTypes = (_a = options.skipTypes) !== null && _a !== void 0 ? _a : [];
+	if (!record) return {};
+	return Object.keys(record).reduce((acc, rec_key) => {
+		acc[rec_key] = convertColumn(rec_key, columns, record, skipTypes);
+		return acc;
+	}, {});
+};
+/**
+* Converts the value of an individual column.
+*
+* @param {String} columnName The column that you want to convert
+* @param {{name: String, type: String}[]} columns All of the columns
+* @param {Object} record The map of string values
+* @param {Array} skipTypes An array of types that should not be converted
+* @return {object} Useless information
+*
+* @example convertColumn('age', [{name: 'first_name', type: 'text'}, {name: 'age', type: 'int4'}], {first_name: 'Paul', age: '33'}, [])
+* //=> 33
+* @example convertColumn('age', [{name: 'first_name', type: 'text'}, {name: 'age', type: 'int4'}], {first_name: 'Paul', age: '33'}, ['int4'])
+* //=> "33"
+*/
+const convertColumn = (columnName, columns, record, skipTypes) => {
+	const column = columns.find((x) => x.name === columnName);
+	const colType = column === null || column === void 0 ? void 0 : column.type;
+	const value = record[columnName];
+	if (colType && !skipTypes.includes(colType)) return convertCell(colType, value);
+	return noop(value);
+};
+/**
+* If the value of the cell is `null`, returns null.
+* Otherwise converts the string value to the correct type.
+* @param {String} type A postgres column type
+* @param {String} value The cell value
+*
+* @example convertCell('bool', 't')
+* //=> true
+* @example convertCell('int8', '10')
+* //=> 10
+* @example convertCell('_int4', '{1,2,3,4}')
+* //=> [1,2,3,4]
+*/
+const convertCell = (type, value) => {
+	if (type.charAt(0) === "_") {
+		const dataType = type.slice(1, type.length);
+		return toArray(value, dataType);
+	}
+	switch (type) {
+		case PostgresTypes.bool: return toBoolean(value);
+		case PostgresTypes.float4:
+		case PostgresTypes.float8:
+		case PostgresTypes.int2:
+		case PostgresTypes.int4:
+		case PostgresTypes.int8:
+		case PostgresTypes.numeric:
+		case PostgresTypes.oid: return toNumber(value);
+		case PostgresTypes.json:
+		case PostgresTypes.jsonb: return toJson(value);
+		case PostgresTypes.timestamp: return toTimestampString(value);
+		case PostgresTypes.abstime:
+		case PostgresTypes.date:
+		case PostgresTypes.daterange:
+		case PostgresTypes.int4range:
+		case PostgresTypes.int8range:
+		case PostgresTypes.money:
+		case PostgresTypes.reltime:
+		case PostgresTypes.text:
+		case PostgresTypes.time:
+		case PostgresTypes.timestamptz:
+		case PostgresTypes.timetz:
+		case PostgresTypes.tsrange:
+		case PostgresTypes.tstzrange: return noop(value);
+		default: return noop(value);
+	}
+};
+const noop = (value) => {
+	return value;
+};
+const toBoolean = (value) => {
+	switch (value) {
+		case "t": return true;
+		case "f": return false;
+		default: return value;
+	}
+};
+const toNumber = (value) => {
+	if (typeof value === "string") {
+		const parsedValue = parseFloat(value);
+		if (!Number.isNaN(parsedValue)) return parsedValue;
+	}
+	return value;
+};
+const toJson = (value) => {
+	if (typeof value === "string") try {
+		return JSON.parse(value);
+	} catch (_a) {
+		return value;
+	}
+	return value;
+};
+/**
+* Converts a Postgres Array into a native JS array
+*
+* @example toArray('{}', 'int4')
+* //=> []
+* @example toArray('{"[2021-01-01,2021-12-31)","(2021-01-01,2021-12-32]"}', 'daterange')
+* //=> ['[2021-01-01,2021-12-31)', '(2021-01-01,2021-12-32]']
+* @example toArray([1,2,3,4], 'int4')
+* //=> [1,2,3,4]
+*/
+const toArray = (value, type) => {
+	if (typeof value !== "string") return value;
+	const lastIdx = value.length - 1;
+	const closeBrace = value[lastIdx];
+	if (value[0] === "{" && closeBrace === "}") {
+		let arr;
+		const valTrim = value.slice(1, lastIdx);
+		try {
+			arr = JSON.parse("[" + valTrim + "]");
+		} catch (_) {
+			arr = valTrim ? valTrim.split(",") : [];
+		}
+		return arr.map((val) => convertCell(type, val));
+	}
+	return value;
+};
+/**
+* Fixes timestamp to be ISO-8601. Swaps the space between the date and time for a 'T'
+* See https://github.com/supabase/supabase/issues/18
+*
+* @example toTimestampString('2019-09-10 00:00:00')
+* //=> '2019-09-10T00:00:00'
+*/
+const toTimestampString = (value) => {
+	if (typeof value === "string") return value.replace(" ", "T");
+	return value;
+};
+const httpEndpointURL = (socketUrl) => {
+	const wsUrl = new URL(socketUrl);
+	wsUrl.protocol = wsUrl.protocol.replace(/^ws/i, "http");
+	wsUrl.pathname = wsUrl.pathname.replace(/\/+$/, "").replace(/\/socket\/websocket$/i, "").replace(/\/socket$/i, "").replace(/\/websocket$/i, "");
+	if (wsUrl.pathname === "" || wsUrl.pathname === "/") wsUrl.pathname = "/api/broadcast";
+	else wsUrl.pathname = wsUrl.pathname + "/api/broadcast";
+	return wsUrl.href;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@supabase+phoenix@0.4.0/node_modules/@supabase/phoenix/priv/static/phoenix.mjs
+var closure = (value) => {
+	if (typeof value === "function") return value;
+	else {
+		let closure2 = function() {
+			return value;
+		};
+		return closure2;
+	}
+};
+var globalSelf = typeof self !== "undefined" ? self : null;
+var phxWindow = typeof window !== "undefined" ? window : null;
+var global$1 = globalSelf || phxWindow || globalThis;
+var DEFAULT_VSN = "2.0.0";
+var DEFAULT_TIMEOUT = 1e4;
+var WS_CLOSE_NORMAL = 1e3;
+var SOCKET_STATES = (
+/** @type {const} */
+{
+	connecting: 0,
+	open: 1,
+	closing: 2,
+	closed: 3
+});
+var CHANNEL_STATES = (
+/** @type {const} */
+{
+	closed: "closed",
+	errored: "errored",
+	joined: "joined",
+	joining: "joining",
+	leaving: "leaving"
+});
+var CHANNEL_EVENTS = (
+/** @type {const} */
+{
+	close: "phx_close",
+	error: "phx_error",
+	join: "phx_join",
+	reply: "phx_reply",
+	leave: "phx_leave"
+});
+var TRANSPORTS = (
+/** @type {const} */
+{
+	longpoll: "longpoll",
+	websocket: "websocket"
+});
+var XHR_STATES = (
+/** @type {const} */
+{ complete: 4 });
+var AUTH_TOKEN_PREFIX = "base64url.bearer.phx.";
+var Push = class {
+	/**
+	* Initializes the Push
+	* @param {Channel} channel - The Channel
+	* @param {ChannelEvent} event - The event, for example `"phx_join"`
+	* @param {() => Record<string, unknown>} payload - The payload, for example `{user_id: 123}`
+	* @param {number} timeout - The push timeout in milliseconds
+	*/
+	constructor(channel, event, payload, timeout) {
+		this.channel = channel;
+		this.event = event;
+		this.payload = payload || function() {
+			return {};
+		};
+		this.receivedResp = null;
+		this.timeout = timeout;
+		this.timeoutTimer = null;
+		this.recHooks = [];
+		this.sent = false;
+		this.ref = void 0;
+	}
+	/**
+	*
+	* @param {number} timeout
+	*/
+	resend(timeout) {
+		this.timeout = timeout;
+		this.reset();
+		this.send();
+	}
+	/**
+	*
+	*/
+	send() {
+		if (this.hasReceived("timeout")) return;
+		this.startTimeout();
+		this.sent = true;
+		this.channel.socket.push({
+			topic: this.channel.topic,
+			event: this.event,
+			payload: this.payload(),
+			ref: this.ref,
+			join_ref: this.channel.joinRef()
+		});
+	}
+	/**
+	*
+	* @param {string} status
+	* @param {(response: any) => void} callback
+	*/
+	receive(status, callback) {
+		if (this.hasReceived(status)) callback(this.receivedResp.response);
+		this.recHooks.push({
+			status,
+			callback
+		});
+		return this;
+	}
+	reset() {
+		this.cancelRefEvent();
+		this.ref = null;
+		this.refEvent = null;
+		this.receivedResp = null;
+		this.sent = false;
+	}
+	destroy() {
+		this.cancelRefEvent();
+		this.cancelTimeout();
+	}
+	/**
+	* @private
+	*/
+	matchReceive({ status, response, _ref }) {
+		this.recHooks.filter((h) => h.status === status).forEach((h) => h.callback(response));
+	}
+	/**
+	* @private
+	*/
+	cancelRefEvent() {
+		if (!this.refEvent) return;
+		this.channel.off(this.refEvent);
+	}
+	cancelTimeout() {
+		clearTimeout(this.timeoutTimer);
+		this.timeoutTimer = null;
+	}
+	startTimeout() {
+		if (this.timeoutTimer) this.cancelTimeout();
+		this.ref = this.channel.socket.makeRef();
+		this.refEvent = this.channel.replyEventName(this.ref);
+		this.channel.on(this.refEvent, (payload) => {
+			this.cancelRefEvent();
+			this.cancelTimeout();
+			this.receivedResp = payload;
+			this.matchReceive(payload);
+		});
+		this.timeoutTimer = setTimeout(() => {
+			this.trigger("timeout", {});
+		}, this.timeout);
+	}
+	/**
+	* @private
+	*/
+	hasReceived(status) {
+		return this.receivedResp && this.receivedResp.status === status;
+	}
+	trigger(status, response) {
+		this.channel.trigger(this.refEvent, {
+			status,
+			response
+		});
+	}
+};
+var Timer = class {
+	/**
+	* @param {() => void} callback
+	* @param {(tries: number) => number} timerCalc
+	*/
+	constructor(callback, timerCalc) {
+		this.callback = callback;
+		this.timerCalc = timerCalc;
+		this.timer = void 0;
+		this.tries = 0;
+	}
+	reset() {
+		this.tries = 0;
+		clearTimeout(this.timer);
+	}
+	/**
+	* Cancels any previous scheduleTimeout and schedules callback
+	*/
+	scheduleTimeout() {
+		clearTimeout(this.timer);
+		this.timer = setTimeout(() => {
+			this.tries = this.tries + 1;
+			this.callback();
+		}, this.timerCalc(this.tries + 1));
+	}
+};
+var Channel = class {
+	/**
+	* @param {string} topic
+	* @param {Params | (() => Params)} params
+	* @param {Socket} socket
+	*/
+	constructor(topic, params, socket) {
+		this.state = CHANNEL_STATES.closed;
+		this.topic = topic;
+		this.params = closure(params || {});
+		this.socket = socket;
+		this.bindings = [];
+		this.bindingRef = 0;
+		this.timeout = this.socket.timeout;
+		this.joinedOnce = false;
+		this.joinPush = new Push(this, CHANNEL_EVENTS.join, this.params, this.timeout);
+		this.pushBuffer = [];
+		this.stateChangeRefs = [];
+		this.rejoinTimer = new Timer(() => {
+			if (this.socket.isConnected()) this.rejoin();
+		}, this.socket.rejoinAfterMs);
+		this.stateChangeRefs.push(this.socket.onError(() => this.rejoinTimer.reset()));
+		this.stateChangeRefs.push(this.socket.onOpen(() => {
+			this.rejoinTimer.reset();
+			if (this.isErrored()) this.rejoin();
+		}));
+		this.joinPush.receive("ok", () => {
+			this.state = CHANNEL_STATES.joined;
+			this.rejoinTimer.reset();
+			this.pushBuffer.forEach((pushEvent) => pushEvent.send());
+			this.pushBuffer = [];
+		});
+		this.joinPush.receive("error", (reason) => {
+			this.state = CHANNEL_STATES.errored;
+			if (this.socket.hasLogger()) this.socket.log("channel", `error ${this.topic}`, reason);
+			if (this.socket.isConnected()) this.rejoinTimer.scheduleTimeout();
+		});
+		this.onClose(() => {
+			this.rejoinTimer.reset();
+			if (this.socket.hasLogger()) this.socket.log("channel", `close ${this.topic}`);
+			this.state = CHANNEL_STATES.closed;
+			this.socket.remove(this);
+		});
+		this.onError((reason) => {
+			if (this.socket.hasLogger()) this.socket.log("channel", `error ${this.topic}`, reason);
+			if (this.isJoining()) this.joinPush.reset();
+			this.state = CHANNEL_STATES.errored;
+			if (this.socket.isConnected()) this.rejoinTimer.scheduleTimeout();
+		});
+		this.joinPush.receive("timeout", () => {
+			if (this.socket.hasLogger()) this.socket.log("channel", `timeout ${this.topic}`, this.joinPush.timeout);
+			new Push(this, CHANNEL_EVENTS.leave, closure({}), this.timeout).send();
+			this.state = CHANNEL_STATES.errored;
+			this.joinPush.reset();
+			if (this.socket.isConnected()) this.rejoinTimer.scheduleTimeout();
+		});
+		this.on(CHANNEL_EVENTS.reply, (payload, ref) => {
+			this.trigger(this.replyEventName(ref), payload);
+		});
+	}
+	/**
+	* Join the channel
+	* @param {number} timeout
+	* @returns {Push}
+	*/
+	join(timeout = this.timeout) {
+		if (this.joinedOnce) throw new Error("tried to join multiple times. 'join' can only be called a single time per channel instance");
+		else {
+			this.timeout = timeout;
+			this.joinedOnce = true;
+			this.rejoin();
+			return this.joinPush;
+		}
+	}
+	/**
+	* Teardown the channel.
+	*
+	* Destroys and stops related timers.
+	*/
+	teardown() {
+		this.pushBuffer.forEach((push) => push.destroy());
+		this.pushBuffer = [];
+		this.rejoinTimer.reset();
+		this.joinPush.destroy();
+		this.state = CHANNEL_STATES.closed;
+		this.bindings = [];
+	}
+	/**
+	* Hook into channel close
+	* @param {ChannelBindingCallback} callback
+	*/
+	onClose(callback) {
+		this.on(CHANNEL_EVENTS.close, callback);
+	}
+	/**
+	* Hook into channel errors
+	* @param {ChannelOnErrorCallback} callback
+	* @return {number}
+	*/
+	onError(callback) {
+		return this.on(CHANNEL_EVENTS.error, (reason) => callback(reason));
+	}
+	/**
+	* Subscribes on channel events
+	*
+	* Subscription returns a ref counter, which can be used later to
+	* unsubscribe the exact event listener
+	*
+	* @example
+	* const ref1 = channel.on("event", do_stuff)
+	* const ref2 = channel.on("event", do_other_stuff)
+	* channel.off("event", ref1)
+	* // Since unsubscription, do_stuff won't fire,
+	* // while do_other_stuff will keep firing on the "event"
+	*
+	* @param {string} event
+	* @param {ChannelBindingCallback} callback
+	* @returns {number} ref
+	*/
+	on(event, callback) {
+		let ref = this.bindingRef++;
+		this.bindings.push({
+			event,
+			ref,
+			callback
+		});
+		return ref;
+	}
+	/**
+	* Unsubscribes off of channel events
+	*
+	* Use the ref returned from a channel.on() to unsubscribe one
+	* handler, or pass nothing for the ref to unsubscribe all
+	* handlers for the given event.
+	*
+	* @example
+	* // Unsubscribe the do_stuff handler
+	* const ref1 = channel.on("event", do_stuff)
+	* channel.off("event", ref1)
+	*
+	* // Unsubscribe all handlers from event
+	* channel.off("event")
+	*
+	* @param {string} event
+	* @param {number} [ref]
+	*/
+	off(event, ref) {
+		this.bindings = this.bindings.filter((bind) => {
+			return !(bind.event === event && (typeof ref === "undefined" || ref === bind.ref));
+		});
+	}
+	/**
+	* @private
+	*/
+	canPush() {
+		return this.socket.isConnected() && this.isJoined();
+	}
+	/**
+	* Sends a message `event` to phoenix with the payload `payload`.
+	* Phoenix receives this in the `handle_in(event, payload, socket)`
+	* function. if phoenix replies or it times out (default 10000ms),
+	* then optionally the reply can be received.
+	*
+	* @example
+	* channel.push("event")
+	*   .receive("ok", payload => console.log("phoenix replied:", payload))
+	*   .receive("error", err => console.log("phoenix errored", err))
+	*   .receive("timeout", () => console.log("timed out pushing"))
+	* @param {string} event
+	* @param {Object} payload
+	* @param {number} [timeout]
+	* @returns {Push}
+	*/
+	push(event, payload, timeout = this.timeout) {
+		payload = payload || {};
+		if (!this.joinedOnce) throw new Error(`tried to push '${event}' to '${this.topic}' before joining. Use channel.join() before pushing events`);
+		let pushEvent = new Push(this, event, function() {
+			return payload;
+		}, timeout);
+		if (this.canPush()) pushEvent.send();
+		else {
+			pushEvent.startTimeout();
+			this.pushBuffer.push(pushEvent);
+		}
+		return pushEvent;
+	}
+	/** Leaves the channel
+	*
+	* Unsubscribes from server events, and
+	* instructs channel to terminate on server
+	*
+	* Triggers onClose() hooks
+	*
+	* To receive leave acknowledgements, use the `receive`
+	* hook to bind to the server ack, ie:
+	*
+	* @example
+	* channel.leave().receive("ok", () => alert("left!") )
+	*
+	* @param {number} timeout
+	* @returns {Push}
+	*/
+	leave(timeout = this.timeout) {
+		this.rejoinTimer.reset();
+		this.joinPush.cancelTimeout();
+		this.state = CHANNEL_STATES.leaving;
+		let onClose = () => {
+			if (this.socket.hasLogger()) this.socket.log("channel", `leave ${this.topic}`);
+			this.trigger(CHANNEL_EVENTS.close, "leave");
+		};
+		let leavePush = new Push(this, CHANNEL_EVENTS.leave, closure({}), timeout);
+		leavePush.receive("ok", () => onClose()).receive("timeout", () => onClose());
+		leavePush.send();
+		if (!this.canPush()) leavePush.trigger("ok", {});
+		return leavePush;
+	}
+	/**
+	* Overridable message hook
+	*
+	* Receives all events for specialized message handling
+	* before dispatching to the channel callbacks.
+	*
+	* Must return the payload, modified or unmodified
+	* @type{ChannelOnMessage}
+	*/
+	onMessage(_event, payload, _ref) {
+		return payload;
+	}
+	/**
+	* Overridable filter hook
+	*
+	* If this function returns `true`, `binding`'s callback will be called.
+	*
+	* @type{ChannelFilterBindings}
+	*/
+	filterBindings(_binding, _payload, _ref) {
+		return true;
+	}
+	isMember(topic, event, payload, joinRef) {
+		if (this.topic !== topic) return false;
+		if (joinRef && joinRef !== this.joinRef()) {
+			if (this.socket.hasLogger()) this.socket.log("channel", "dropping outdated message", {
+				topic,
+				event,
+				payload,
+				joinRef
+			});
+			return false;
+		} else return true;
+	}
+	joinRef() {
+		return this.joinPush.ref;
+	}
+	/**
+	* @private
+	*/
+	rejoin(timeout = this.timeout) {
+		if (this.isLeaving()) return;
+		this.socket.leaveOpenTopic(this.topic);
+		this.state = CHANNEL_STATES.joining;
+		this.joinPush.resend(timeout);
+	}
+	/**
+	* @param {string} event
+	* @param {unknown} [payload]
+	* @param {?string} [ref]
+	* @param {?string} [joinRef]
+	*/
+	trigger(event, payload, ref, joinRef) {
+		let handledPayload = this.onMessage(event, payload, ref, joinRef);
+		if (payload && !handledPayload) throw new Error("channel onMessage callbacks must return the payload, modified or unmodified");
+		let eventBindings = this.bindings.filter((bind) => bind.event === event && this.filterBindings(bind, payload, ref));
+		for (let i = 0; i < eventBindings.length; i++) eventBindings[i].callback(handledPayload, ref, joinRef || this.joinRef());
+	}
+	/**
+	* @param {string} ref
+	*/
+	replyEventName(ref) {
+		return `chan_reply_${ref}`;
+	}
+	isClosed() {
+		return this.state === CHANNEL_STATES.closed;
+	}
+	isErrored() {
+		return this.state === CHANNEL_STATES.errored;
+	}
+	isJoined() {
+		return this.state === CHANNEL_STATES.joined;
+	}
+	isJoining() {
+		return this.state === CHANNEL_STATES.joining;
+	}
+	isLeaving() {
+		return this.state === CHANNEL_STATES.leaving;
+	}
+};
+var Ajax = class {
+	static request(method, endPoint, headers, body, timeout, ontimeout, callback) {
+		if (global$1.XDomainRequest) {
+			let req = new global$1.XDomainRequest();
+			return this.xdomainRequest(req, method, endPoint, body, timeout, ontimeout, callback);
+		} else if (global$1.XMLHttpRequest) {
+			let req = new global$1.XMLHttpRequest();
+			return this.xhrRequest(req, method, endPoint, headers, body, timeout, ontimeout, callback);
+		} else if (global$1.fetch && global$1.AbortController) return this.fetchRequest(method, endPoint, headers, body, timeout, ontimeout, callback);
+		else throw new Error("No suitable XMLHttpRequest implementation found");
+	}
+	static fetchRequest(method, endPoint, headers, body, timeout, ontimeout, callback) {
+		let options = {
+			method,
+			headers,
+			body
+		};
+		let controller = null;
+		if (timeout) {
+			controller = new AbortController();
+			setTimeout(() => controller.abort(), timeout);
+			options.signal = controller.signal;
+		}
+		global$1.fetch(endPoint, options).then((response) => response.text()).then((data) => this.parseJSON(data)).then((data) => callback && callback(data)).catch((err) => {
+			if (err.name === "AbortError" && ontimeout) ontimeout();
+			else callback && callback(null);
+		});
+		return controller;
+	}
+	static xdomainRequest(req, method, endPoint, body, timeout, ontimeout, callback) {
+		req.timeout = timeout;
+		req.open(method, endPoint);
+		req.onload = () => {
+			let response = this.parseJSON(req.responseText);
+			callback && callback(response);
+		};
+		if (ontimeout) req.ontimeout = ontimeout;
+		req.onprogress = () => {};
+		req.send(body);
+		return req;
+	}
+	static xhrRequest(req, method, endPoint, headers, body, timeout, ontimeout, callback) {
+		req.open(method, endPoint, true);
+		req.timeout = timeout;
+		for (let [key, value] of Object.entries(headers)) req.setRequestHeader(key, value);
+		req.onerror = () => callback && callback(null);
+		req.onreadystatechange = () => {
+			if (req.readyState === XHR_STATES.complete && callback) callback(this.parseJSON(req.responseText));
+		};
+		if (ontimeout) req.ontimeout = ontimeout;
+		req.send(body);
+		return req;
+	}
+	static parseJSON(resp) {
+		if (!resp || resp === "") return null;
+		try {
+			return JSON.parse(resp);
+		} catch {
+			console && console.log("failed to parse JSON response", resp);
+			return null;
+		}
+	}
+	static serialize(obj, parentKey) {
+		let queryStr = [];
+		for (var key in obj) {
+			if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+			let paramKey = parentKey ? `${parentKey}[${key}]` : key;
+			let paramVal = obj[key];
+			if (typeof paramVal === "object") queryStr.push(this.serialize(paramVal, paramKey));
+			else queryStr.push(encodeURIComponent(paramKey) + "=" + encodeURIComponent(paramVal));
+		}
+		return queryStr.join("&");
+	}
+	static appendParams(url, params) {
+		if (Object.keys(params).length === 0) return url;
+		return `${url}${url.match(/\?/) ? "&" : "?"}${this.serialize(params)}`;
+	}
+};
+var arrayBufferToBase64 = (buffer) => {
+	let binary = "";
+	let bytes = new Uint8Array(buffer);
+	let len = bytes.byteLength;
+	for (let i = 0; i < len; i++) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary);
+};
+var LongPoll = class {
+	constructor(endPoint, protocols) {
+		if (protocols && protocols.length === 2 && protocols[1].startsWith(AUTH_TOKEN_PREFIX)) this.authToken = atob(protocols[1].slice(AUTH_TOKEN_PREFIX.length));
+		this.endPoint = null;
+		this.token = null;
+		this.skipHeartbeat = true;
+		this.reqs = /* @__PURE__ */ new Set();
+		this.awaitingBatchAck = false;
+		this.currentBatch = null;
+		this.currentBatchTimer = null;
+		this.batchBuffer = [];
+		this.onopen = function() {};
+		this.onerror = function() {};
+		this.onmessage = function() {};
+		this.onclose = function() {};
+		this.pollEndpoint = this.normalizeEndpoint(endPoint);
+		this.readyState = SOCKET_STATES.connecting;
+		setTimeout(() => this.poll(), 0);
+	}
+	normalizeEndpoint(endPoint) {
+		return endPoint.replace("ws://", "http://").replace("wss://", "https://").replace(new RegExp("(.*)/" + TRANSPORTS.websocket), "$1/" + TRANSPORTS.longpoll);
+	}
+	endpointURL() {
+		return Ajax.appendParams(this.pollEndpoint, { token: this.token });
+	}
+	closeAndRetry(code, reason, wasClean) {
+		this.close(code, reason, wasClean);
+		this.readyState = SOCKET_STATES.connecting;
+	}
+	ontimeout() {
+		this.onerror("timeout");
+		this.closeAndRetry(1005, "timeout", false);
+	}
+	isActive() {
+		return this.readyState === SOCKET_STATES.open || this.readyState === SOCKET_STATES.connecting;
+	}
+	poll() {
+		const headers = { "Accept": "application/json" };
+		if (this.authToken) headers["X-Phoenix-AuthToken"] = this.authToken;
+		this.ajax("GET", headers, null, () => this.ontimeout(), (resp) => {
+			if (resp) {
+				var { status, token, messages } = resp;
+				if (status === 410 && this.token !== null) {
+					this.onerror(410);
+					this.closeAndRetry(3410, "session_gone", false);
+					return;
+				}
+				this.token = token;
+			} else status = 0;
+			switch (status) {
+				case 200:
+					messages.forEach((msg) => {
+						setTimeout(() => this.onmessage({ data: msg }), 0);
+					});
+					this.poll();
+					break;
+				case 204:
+					this.poll();
+					break;
+				case 410:
+					this.readyState = SOCKET_STATES.open;
+					this.onopen({});
+					this.poll();
+					break;
+				case 403:
+					this.onerror(403);
+					this.close(1008, "forbidden", false);
+					break;
+				case 0:
+				case 500:
+					this.onerror(500);
+					this.closeAndRetry(1011, "internal server error", 500);
+					break;
+				default: throw new Error(`unhandled poll status ${status}`);
+			}
+		});
+	}
+	send(body) {
+		if (typeof body !== "string") body = arrayBufferToBase64(body);
+		if (this.currentBatch) this.currentBatch.push(body);
+		else if (this.awaitingBatchAck) this.batchBuffer.push(body);
+		else {
+			this.currentBatch = [body];
+			this.currentBatchTimer = setTimeout(() => {
+				this.batchSend(this.currentBatch);
+				this.currentBatch = null;
+			}, 0);
+		}
+	}
+	batchSend(messages) {
+		this.awaitingBatchAck = true;
+		this.ajax("POST", { "Content-Type": "application/x-ndjson" }, messages.join("\n"), () => this.onerror("timeout"), (resp) => {
+			this.awaitingBatchAck = false;
+			if (!resp || resp.status !== 200) {
+				this.onerror(resp && resp.status);
+				this.closeAndRetry(1011, "internal server error", false);
+			} else if (this.batchBuffer.length > 0) {
+				this.batchSend(this.batchBuffer);
+				this.batchBuffer = [];
+			}
+		});
+	}
+	close(code, reason, wasClean) {
+		for (let req of this.reqs) req.abort();
+		this.readyState = SOCKET_STATES.closed;
+		let opts = Object.assign({
+			code: 1e3,
+			reason: void 0,
+			wasClean: true
+		}, {
+			code,
+			reason,
+			wasClean
+		});
+		this.batchBuffer = [];
+		clearTimeout(this.currentBatchTimer);
+		this.currentBatchTimer = null;
+		if (typeof CloseEvent !== "undefined") this.onclose(new CloseEvent("close", opts));
+		else this.onclose(opts);
+	}
+	ajax(method, headers, body, onCallerTimeout, callback) {
+		let req;
+		let ontimeout = () => {
+			this.reqs.delete(req);
+			onCallerTimeout();
+		};
+		req = Ajax.request(method, this.endpointURL(), headers, body, this.timeout, ontimeout, (resp) => {
+			this.reqs.delete(req);
+			if (this.isActive()) callback(resp);
+		});
+		this.reqs.add(req);
+	}
+};
+var Presence = class _Presence {
+	/**
+	* Initializes the Presence
+	* @param {Channel} channel - The Channel
+	* @param {PresenceOptions} [opts] - The options, for example `{events: {state: "state", diff: "diff"}}`
+	*/
+	constructor(channel, opts = {}) {
+		let events = opts.events || {
+			state: "presence_state",
+			diff: "presence_diff"
+		};
+		this.state = {};
+		this.pendingDiffs = [];
+		this.channel = channel;
+		this.joinRef = null;
+		this.caller = {
+			onJoin: function() {},
+			onLeave: function() {},
+			onSync: function() {}
+		};
+		this.channel.on(events.state, (newState) => {
+			let { onJoin, onLeave, onSync } = this.caller;
+			this.joinRef = this.channel.joinRef();
+			this.state = _Presence.syncState(this.state, newState, onJoin, onLeave);
+			this.pendingDiffs.forEach((diff) => {
+				this.state = _Presence.syncDiff(this.state, diff, onJoin, onLeave);
+			});
+			this.pendingDiffs = [];
+			onSync();
+		});
+		this.channel.on(events.diff, (diff) => {
+			let { onJoin, onLeave, onSync } = this.caller;
+			if (this.inPendingSyncState()) this.pendingDiffs.push(diff);
+			else {
+				this.state = _Presence.syncDiff(this.state, diff, onJoin, onLeave);
+				onSync();
+			}
+		});
+	}
+	/**
+	* @param {PresenceOnJoin} callback
+	*/
+	onJoin(callback) {
+		this.caller.onJoin = callback;
+	}
+	/**
+	* @param {PresenceOnLeave} callback
+	*/
+	onLeave(callback) {
+		this.caller.onLeave = callback;
+	}
+	/**
+	* @param {PresenceOnSync} callback
+	*/
+	onSync(callback) {
+		this.caller.onSync = callback;
+	}
+	/**
+	* Returns the array of presences, with selected metadata.
+	*
+	* @template [T=PresenceState]
+	* @param {((key: string, obj: PresenceState) => T)} [by]
+	*
+	* @returns {T[]}
+	*/
+	list(by) {
+		return _Presence.list(this.state, by);
+	}
+	inPendingSyncState() {
+		return !this.joinRef || this.joinRef !== this.channel.joinRef();
+	}
+	/**
+	* Used to sync the list of presences on the server
+	* with the client's state. An optional `onJoin` and `onLeave` callback can
+	* be provided to react to changes in the client's local presences across
+	* disconnects and reconnects with the server.
+	*
+	* @param {Record<string, PresenceState>} currentState
+	* @param {Record<string, PresenceState>} newState
+	* @param {PresenceOnJoin} onJoin
+	* @param {PresenceOnLeave} onLeave
+	*
+	* @returns {Record<string, PresenceState>}
+	*/
+	static syncState(currentState, newState, onJoin, onLeave) {
+		let state = this.clone(currentState);
+		let joins = {};
+		let leaves = {};
+		this.map(state, (key, presence) => {
+			if (!newState[key]) leaves[key] = presence;
+		});
+		this.map(newState, (key, newPresence) => {
+			let currentPresence = state[key];
+			if (currentPresence) {
+				let newRefs = newPresence.metas.map((m) => m.phx_ref);
+				let curRefs = currentPresence.metas.map((m) => m.phx_ref);
+				let joinedMetas = newPresence.metas.filter((m) => curRefs.indexOf(m.phx_ref) < 0);
+				let leftMetas = currentPresence.metas.filter((m) => newRefs.indexOf(m.phx_ref) < 0);
+				if (joinedMetas.length > 0) {
+					joins[key] = newPresence;
+					joins[key].metas = joinedMetas;
+				}
+				if (leftMetas.length > 0) {
+					leaves[key] = this.clone(currentPresence);
+					leaves[key].metas = leftMetas;
+				}
+			} else joins[key] = newPresence;
+		});
+		return this.syncDiff(state, {
+			joins,
+			leaves
+		}, onJoin, onLeave);
+	}
+	/**
+	*
+	* Used to sync a diff of presence join and leave
+	* events from the server, as they happen. Like `syncState`, `syncDiff`
+	* accepts optional `onJoin` and `onLeave` callbacks to react to a user
+	* joining or leaving from a device.
+	*
+	* @param {Record<string, PresenceState>} state
+	* @param {PresenceDiff} diff
+	* @param {PresenceOnJoin} onJoin
+	* @param {PresenceOnLeave} onLeave
+	*
+	* @returns {Record<string, PresenceState>}
+	*/
+	static syncDiff(state, diff, onJoin, onLeave) {
+		let { joins, leaves } = this.clone(diff);
+		if (!onJoin) onJoin = function() {};
+		if (!onLeave) onLeave = function() {};
+		this.map(joins, (key, newPresence) => {
+			let currentPresence = state[key];
+			state[key] = this.clone(newPresence);
+			if (currentPresence) {
+				let joinedRefs = state[key].metas.map((m) => m.phx_ref);
+				let curMetas = currentPresence.metas.filter((m) => joinedRefs.indexOf(m.phx_ref) < 0);
+				state[key].metas.unshift(...curMetas);
+			}
+			onJoin(key, currentPresence, newPresence);
+		});
+		this.map(leaves, (key, leftPresence) => {
+			let currentPresence = state[key];
+			if (!currentPresence) return;
+			let refsToRemove = leftPresence.metas.map((m) => m.phx_ref);
+			currentPresence.metas = currentPresence.metas.filter((p) => {
+				return refsToRemove.indexOf(p.phx_ref) < 0;
+			});
+			onLeave(key, currentPresence, leftPresence);
+			if (currentPresence.metas.length === 0) delete state[key];
+		});
+		return state;
+	}
+	/**
+	* Returns the array of presences, with selected metadata.
+	*
+	* @template [T=PresenceState]
+	* @param {Record<string, PresenceState>} presences
+	* @param {((key: string, obj: PresenceState) => T)} [chooser]
+	*
+	* @returns {T[]}
+	*/
+	static list(presences, chooser) {
+		if (!chooser) chooser = function(key, pres) {
+			return pres;
+		};
+		return this.map(presences, (key, presence) => {
+			return chooser(key, presence);
+		});
+	}
+	/**
+	* @template T
+	* @param {Record<string, PresenceState>} obj
+	* @param {(key: string, obj: PresenceState) => T} func
+	*/
+	static map(obj, func) {
+		return Object.getOwnPropertyNames(obj).map((key) => func(key, obj[key]));
+	}
+	/**
+	* @template T
+	* @param {T} obj
+	* @returns {T}
+	*/
+	static clone(obj) {
+		return JSON.parse(JSON.stringify(obj));
+	}
+};
+var serializer_default = {
+	HEADER_LENGTH: 1,
+	META_LENGTH: 4,
+	KINDS: {
+		push: 0,
+		reply: 1,
+		broadcast: 2
+	},
+	/**
+	* @template T
+	* @param {Message<Record<string, any>>} msg
+	* @param {(msg: ArrayBuffer | string) => T} callback
+	* @returns {T}
+	*/
+	encode(msg, callback) {
+		if (msg.payload.constructor === ArrayBuffer) return callback(this.binaryEncode(msg));
+		else {
+			let payload = [
+				msg.join_ref,
+				msg.ref,
+				msg.topic,
+				msg.event,
+				msg.payload
+			];
+			return callback(JSON.stringify(payload));
+		}
+	},
+	/**
+	* @template T
+	* @param {ArrayBuffer | string} rawPayload
+	* @param {(msg: Message<unknown>) => T} callback
+	* @returns {T}
+	*/
+	decode(rawPayload, callback) {
+		if (rawPayload.constructor === ArrayBuffer) return callback(this.binaryDecode(rawPayload));
+		else {
+			let [join_ref, ref, topic, event, payload] = JSON.parse(rawPayload);
+			return callback({
+				join_ref,
+				ref,
+				topic,
+				event,
+				payload
+			});
+		}
+	},
+	/** @private */
+	binaryEncode(message) {
+		let { join_ref, ref, event, topic, payload } = message;
+		let metaLength = this.META_LENGTH + join_ref.length + ref.length + topic.length + event.length;
+		let header = new ArrayBuffer(this.HEADER_LENGTH + metaLength);
+		let view = new DataView(header);
+		let offset = 0;
+		view.setUint8(offset++, this.KINDS.push);
+		view.setUint8(offset++, join_ref.length);
+		view.setUint8(offset++, ref.length);
+		view.setUint8(offset++, topic.length);
+		view.setUint8(offset++, event.length);
+		Array.from(join_ref, (char) => view.setUint8(offset++, char.charCodeAt(0)));
+		Array.from(ref, (char) => view.setUint8(offset++, char.charCodeAt(0)));
+		Array.from(topic, (char) => view.setUint8(offset++, char.charCodeAt(0)));
+		Array.from(event, (char) => view.setUint8(offset++, char.charCodeAt(0)));
+		var combined = new Uint8Array(header.byteLength + payload.byteLength);
+		combined.set(new Uint8Array(header), 0);
+		combined.set(new Uint8Array(payload), header.byteLength);
+		return combined.buffer;
+	},
+	/**
+	* @private
+	*/
+	binaryDecode(buffer) {
+		let view = new DataView(buffer);
+		let kind = view.getUint8(0);
+		let decoder = new TextDecoder();
+		switch (kind) {
+			case this.KINDS.push: return this.decodePush(buffer, view, decoder);
+			case this.KINDS.reply: return this.decodeReply(buffer, view, decoder);
+			case this.KINDS.broadcast: return this.decodeBroadcast(buffer, view, decoder);
+		}
+	},
+	/** @private */
+	decodePush(buffer, view, decoder) {
+		let joinRefSize = view.getUint8(1);
+		let topicSize = view.getUint8(2);
+		let eventSize = view.getUint8(3);
+		let offset = this.HEADER_LENGTH + this.META_LENGTH - 1;
+		let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize));
+		offset = offset + joinRefSize;
+		let topic = decoder.decode(buffer.slice(offset, offset + topicSize));
+		offset = offset + topicSize;
+		let event = decoder.decode(buffer.slice(offset, offset + eventSize));
+		offset = offset + eventSize;
+		return {
+			join_ref: joinRef,
+			ref: null,
+			topic,
+			event,
+			payload: buffer.slice(offset, buffer.byteLength)
+		};
+	},
+	/** @private */
+	decodeReply(buffer, view, decoder) {
+		let joinRefSize = view.getUint8(1);
+		let refSize = view.getUint8(2);
+		let topicSize = view.getUint8(3);
+		let eventSize = view.getUint8(4);
+		let offset = this.HEADER_LENGTH + this.META_LENGTH;
+		let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize));
+		offset = offset + joinRefSize;
+		let ref = decoder.decode(buffer.slice(offset, offset + refSize));
+		offset = offset + refSize;
+		let topic = decoder.decode(buffer.slice(offset, offset + topicSize));
+		offset = offset + topicSize;
+		let event = decoder.decode(buffer.slice(offset, offset + eventSize));
+		offset = offset + eventSize;
+		let payload = {
+			status: event,
+			response: buffer.slice(offset, buffer.byteLength)
+		};
+		return {
+			join_ref: joinRef,
+			ref,
+			topic,
+			event: CHANNEL_EVENTS.reply,
+			payload
+		};
+	},
+	/** @private */
+	decodeBroadcast(buffer, view, decoder) {
+		let topicSize = view.getUint8(1);
+		let eventSize = view.getUint8(2);
+		let offset = this.HEADER_LENGTH + 2;
+		let topic = decoder.decode(buffer.slice(offset, offset + topicSize));
+		offset = offset + topicSize;
+		let event = decoder.decode(buffer.slice(offset, offset + eventSize));
+		offset = offset + eventSize;
+		return {
+			join_ref: null,
+			ref: null,
+			topic,
+			event,
+			payload: buffer.slice(offset, buffer.byteLength)
+		};
+	}
+};
+var Socket = class {
+	/** Initializes the Socket *
+	*
+	* For IE8 support use an ES5-shim (https://github.com/es-shims/es5-shim)
+	*
+	* @constructor
+	* @param {string} endPoint - The string WebSocket endpoint, ie, `"ws://example.com/socket"`,
+	*                                               `"wss://example.com"`
+	*                                               `"/socket"` (inherited host & protocol)
+	* @param {SocketOptions} [opts] - Optional configuration
+	*/
+	constructor(endPoint, opts = {}) {
+		this.stateChangeCallbacks = {
+			open: [],
+			close: [],
+			error: [],
+			message: []
+		};
+		this.channels = [];
+		this.sendBuffer = [];
+		this.ref = 0;
+		this.fallbackRef = null;
+		this.timeout = opts.timeout || DEFAULT_TIMEOUT;
+		this.transport = opts.transport || global$1.WebSocket || LongPoll;
+		this.conn = void 0;
+		this.primaryPassedHealthCheck = false;
+		this.longPollFallbackMs = opts.longPollFallbackMs;
+		this.fallbackTimer = null;
+		this.sessionStore = opts.sessionStorage || global$1 && global$1.sessionStorage;
+		this.establishedConnections = 0;
+		this.defaultEncoder = serializer_default.encode.bind(serializer_default);
+		this.defaultDecoder = serializer_default.decode.bind(serializer_default);
+		this.closeWasClean = true;
+		this.disconnecting = false;
+		this.binaryType = opts.binaryType || "arraybuffer";
+		this.connectClock = 1;
+		this.pageHidden = false;
+		this.encode = void 0;
+		this.decode = void 0;
+		if (this.transport !== LongPoll) {
+			this.encode = opts.encode || this.defaultEncoder;
+			this.decode = opts.decode || this.defaultDecoder;
+		} else {
+			this.encode = this.defaultEncoder;
+			this.decode = this.defaultDecoder;
+		}
+		let awaitingConnectionOnPageShow = null;
+		if (phxWindow && phxWindow.addEventListener) {
+			phxWindow.addEventListener("pagehide", (_e) => {
+				if (this.conn) {
+					this.disconnect();
+					awaitingConnectionOnPageShow = this.connectClock;
+				}
+			});
+			phxWindow.addEventListener("pageshow", (_e) => {
+				if (awaitingConnectionOnPageShow === this.connectClock) {
+					awaitingConnectionOnPageShow = null;
+					this.connect();
+				}
+			});
+			phxWindow.addEventListener("visibilitychange", () => {
+				if (document.visibilityState === "hidden") this.pageHidden = true;
+				else {
+					this.pageHidden = false;
+					if (!this.isConnected() && !this.closeWasClean) this.teardown(() => this.connect());
+				}
+			});
+		}
+		this.heartbeatIntervalMs = opts.heartbeatIntervalMs || 3e4;
+		this.autoSendHeartbeat = opts.autoSendHeartbeat ?? true;
+		this.heartbeatCallback = opts.heartbeatCallback ?? (() => {});
+		this.rejoinAfterMs = (tries) => {
+			if (opts.rejoinAfterMs) return opts.rejoinAfterMs(tries);
+			else return [
+				1e3,
+				2e3,
+				5e3
+			][tries - 1] || 1e4;
+		};
+		this.reconnectAfterMs = (tries) => {
+			if (opts.reconnectAfterMs) return opts.reconnectAfterMs(tries);
+			else return [
+				10,
+				50,
+				100,
+				150,
+				200,
+				250,
+				500,
+				1e3,
+				2e3
+			][tries - 1] || 5e3;
+		};
+		this.logger = opts.logger || null;
+		if (!this.logger && opts.debug) this.logger = (kind, msg, data) => {
+			console.log(`${kind}: ${msg}`, data);
+		};
+		this.longpollerTimeout = opts.longpollerTimeout || 2e4;
+		this.params = closure(opts.params || {});
+		this.endPoint = `${endPoint}/${TRANSPORTS.websocket}`;
+		this.vsn = opts.vsn || DEFAULT_VSN;
+		this.heartbeatTimeoutTimer = null;
+		this.heartbeatTimer = null;
+		this.heartbeatSentAt = null;
+		this.pendingHeartbeatRef = null;
+		this.reconnectTimer = new Timer(() => {
+			if (this.pageHidden) {
+				this.log("Not reconnecting as page is hidden!");
+				this.teardown();
+				return;
+			}
+			this.teardown(async () => {
+				if (opts.beforeReconnect) await opts.beforeReconnect();
+				this.connect();
+			});
+		}, this.reconnectAfterMs);
+		this.authToken = opts.authToken;
+	}
+	/**
+	* Returns the LongPoll transport reference
+	*/
+	getLongPollTransport() {
+		return LongPoll;
+	}
+	/**
+	* Disconnects and replaces the active transport
+	*
+	* @param {SocketTransport} newTransport - The new transport class to instantiate
+	*
+	*/
+	replaceTransport(newTransport) {
+		this.connectClock++;
+		this.closeWasClean = true;
+		clearTimeout(this.fallbackTimer);
+		this.reconnectTimer.reset();
+		if (this.conn) {
+			this.conn.close();
+			this.conn = null;
+		}
+		this.transport = newTransport;
+	}
+	/**
+	* Returns the socket protocol
+	*
+	* @returns {"wss" | "ws"}
+	*/
+	protocol() {
+		return location.protocol.match(/^https/) ? "wss" : "ws";
+	}
+	/**
+	* The fully qualified socket url
+	*
+	* @returns {string}
+	*/
+	endPointURL() {
+		let uri = Ajax.appendParams(Ajax.appendParams(this.endPoint, this.params()), { vsn: this.vsn });
+		if (uri.charAt(0) !== "/") return uri;
+		if (uri.charAt(1) === "/") return `${this.protocol()}:${uri}`;
+		return `${this.protocol()}://${location.host}${uri}`;
+	}
+	/**
+	* Disconnects the socket
+	*
+	* See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes for valid status codes.
+	*
+	* @param {() => void} [callback] - Optional callback which is called after socket is disconnected.
+	* @param {number} [code] - A status code for disconnection (Optional).
+	* @param {string} [reason] - A textual description of the reason to disconnect. (Optional)
+	*/
+	disconnect(callback, code, reason) {
+		this.connectClock++;
+		this.disconnecting = true;
+		this.closeWasClean = true;
+		clearTimeout(this.fallbackTimer);
+		this.reconnectTimer.reset();
+		this.teardown(() => {
+			this.disconnecting = false;
+			callback && callback();
+		}, code, reason);
+	}
+	/**
+	* @param {Params} [params] - [DEPRECATED] The params to send when connecting, for example `{user_id: userToken}`
+	*
+	* Passing params to connect is deprecated; pass them in the Socket constructor instead:
+	* `new Socket("/socket", {params: {user_id: userToken}})`.
+	*/
+	connect(params) {
+		if (params) {
+			console && console.log("passing params to connect is deprecated. Instead pass :params to the Socket constructor");
+			this.params = closure(params);
+		}
+		if (this.conn && !this.disconnecting) return;
+		if (this.longPollFallbackMs && this.transport !== LongPoll) this.connectWithFallback(LongPoll, this.longPollFallbackMs);
+		else this.transportConnect();
+	}
+	/**
+	* Logs the message. Override `this.logger` for specialized logging. noops by default
+	* @param {string} kind
+	* @param {string} msg
+	* @param {Object} data
+	*/
+	log(kind, msg, data) {
+		this.logger && this.logger(kind, msg, data);
+	}
+	/**
+	* Returns true if a logger has been set on this socket.
+	*/
+	hasLogger() {
+		return this.logger !== null;
+	}
+	/**
+	* Registers callbacks for connection open events
+	*
+	* @example socket.onOpen(function(){ console.info("the socket was opened") })
+	*
+	* @param {SocketOnOpen} callback
+	*/
+	onOpen(callback) {
+		let ref = this.makeRef();
+		this.stateChangeCallbacks.open.push([ref, callback]);
+		return ref;
+	}
+	/**
+	* Registers callbacks for connection close events
+	* @param {SocketOnClose} callback
+	* @returns {string}
+	*/
+	onClose(callback) {
+		let ref = this.makeRef();
+		this.stateChangeCallbacks.close.push([ref, callback]);
+		return ref;
+	}
+	/**
+	* Registers callbacks for connection error events
+	*
+	* @example socket.onError(function(error){ alert("An error occurred") })
+	*
+	* @param {SocketOnError} callback
+	* @returns {string}
+	*/
+	onError(callback) {
+		let ref = this.makeRef();
+		this.stateChangeCallbacks.error.push([ref, callback]);
+		return ref;
+	}
+	/**
+	* Registers callbacks for connection message events
+	* @param {SocketOnMessage} callback
+	* @returns {string}
+	*/
+	onMessage(callback) {
+		let ref = this.makeRef();
+		this.stateChangeCallbacks.message.push([ref, callback]);
+		return ref;
+	}
+	/**
+	* Sets a callback that receives lifecycle events for internal heartbeat messages.
+	* Useful for instrumenting connection health (e.g. sent/ok/timeout/disconnected).
+	* @param {HeartbeatCallback} callback
+	*/
+	onHeartbeat(callback) {
+		this.heartbeatCallback = callback;
+	}
+	/**
+	* Pings the server and invokes the callback with the RTT in milliseconds
+	* @param {(timeDelta: number) => void} callback
+	*
+	* Returns true if the ping was pushed or false if unable to be pushed.
+	*/
+	ping(callback) {
+		if (!this.isConnected()) return false;
+		let ref = this.makeRef();
+		let startTime = Date.now();
+		this.push({
+			topic: "phoenix",
+			event: "heartbeat",
+			payload: {},
+			ref
+		});
+		let onMsgRef = this.onMessage((msg) => {
+			if (msg.ref === ref) {
+				this.off([onMsgRef]);
+				callback(Date.now() - startTime);
+			}
+		});
+		return true;
+	}
+	/**
+	* @private
+	*
+	* @param {Function}
+	*/
+	transportName(transport) {
+		switch (transport) {
+			case LongPoll: return "LongPoll";
+			default: return transport.name;
+		}
+	}
+	/**
+	* @private
+	*/
+	transportConnect() {
+		this.connectClock++;
+		this.closeWasClean = false;
+		let protocols = void 0;
+		if (this.authToken) protocols = ["phoenix", `${AUTH_TOKEN_PREFIX}${btoa(this.authToken).replace(/=/g, "")}`];
+		this.conn = new this.transport(this.endPointURL(), protocols);
+		this.conn.binaryType = this.binaryType;
+		this.conn.timeout = this.longpollerTimeout;
+		this.conn.onopen = () => this.onConnOpen();
+		this.conn.onerror = (error) => this.onConnError(error);
+		this.conn.onmessage = (event) => this.onConnMessage(event);
+		this.conn.onclose = (event) => this.onConnClose(event);
+	}
+	getSession(key) {
+		return this.sessionStore && this.sessionStore.getItem(key);
+	}
+	storeSession(key, val) {
+		this.sessionStore && this.sessionStore.setItem(key, val);
+	}
+	connectWithFallback(fallbackTransport, fallbackThreshold = 2500) {
+		clearTimeout(this.fallbackTimer);
+		let established = false;
+		let primaryTransport = true;
+		let openRef, errorRef;
+		let fallbackTransportName = this.transportName(fallbackTransport);
+		let fallback = (reason) => {
+			this.log("transport", `falling back to ${fallbackTransportName}...`, reason);
+			this.off([openRef, errorRef]);
+			primaryTransport = false;
+			this.replaceTransport(fallbackTransport);
+			this.transportConnect();
+		};
+		if (this.getSession(`phx:fallback:${fallbackTransportName}`)) return fallback("memorized");
+		this.fallbackTimer = setTimeout(fallback, fallbackThreshold);
+		errorRef = this.onError((reason) => {
+			this.log("transport", "error", reason);
+			if (primaryTransport && !established) {
+				clearTimeout(this.fallbackTimer);
+				fallback(reason);
+			}
+		});
+		if (this.fallbackRef) this.off([this.fallbackRef]);
+		this.fallbackRef = this.onOpen(() => {
+			established = true;
+			if (!primaryTransport) {
+				let fallbackTransportName2 = this.transportName(fallbackTransport);
+				if (!this.primaryPassedHealthCheck) this.storeSession(`phx:fallback:${fallbackTransportName2}`, "true");
+				return this.log("transport", `established ${fallbackTransportName2} fallback`);
+			}
+			clearTimeout(this.fallbackTimer);
+			this.fallbackTimer = setTimeout(fallback, fallbackThreshold);
+			this.ping((rtt) => {
+				this.log("transport", "connected to primary after", rtt);
+				this.primaryPassedHealthCheck = true;
+				clearTimeout(this.fallbackTimer);
+			});
+		});
+		this.transportConnect();
+	}
+	clearHeartbeats() {
+		clearTimeout(this.heartbeatTimer);
+		clearTimeout(this.heartbeatTimeoutTimer);
+	}
+	onConnOpen() {
+		if (this.hasLogger()) this.log("transport", `connected to ${this.endPointURL()}`);
+		this.closeWasClean = false;
+		this.disconnecting = false;
+		this.establishedConnections++;
+		this.flushSendBuffer();
+		this.reconnectTimer.reset();
+		if (this.autoSendHeartbeat) this.resetHeartbeat();
+		this.triggerStateCallbacks("open");
+	}
+	/**
+	* @private
+	*/
+	heartbeatTimeout() {
+		if (this.pendingHeartbeatRef) {
+			this.pendingHeartbeatRef = null;
+			this.heartbeatSentAt = null;
+			if (this.hasLogger()) this.log("transport", "heartbeat timeout. Attempting to re-establish connection");
+			try {
+				this.heartbeatCallback("timeout");
+			} catch (e) {
+				this.log("error", "error in heartbeat callback", e);
+			}
+			this.triggerChanError();
+			this.closeWasClean = false;
+			this.teardown(() => this.reconnectTimer.scheduleTimeout(), WS_CLOSE_NORMAL, "heartbeat timeout");
+		}
+	}
+	resetHeartbeat() {
+		if (this.conn && this.conn.skipHeartbeat) return;
+		this.pendingHeartbeatRef = null;
+		this.clearHeartbeats();
+		this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs);
+	}
+	teardown(callback, code, reason) {
+		if (!this.conn) return callback && callback();
+		const connToClose = this.conn;
+		this.waitForBufferDone(connToClose, () => {
+			if (code) connToClose.close(code, reason || "");
+			else connToClose.close();
+			this.waitForSocketClosed(connToClose, () => {
+				if (this.conn === connToClose) {
+					this.conn.onopen = function() {};
+					this.conn.onerror = function() {};
+					this.conn.onmessage = function() {};
+					this.conn.onclose = function() {};
+					this.conn = null;
+				}
+				callback && callback();
+			});
+		});
+	}
+	waitForBufferDone(conn, callback, tries = 1) {
+		if (tries === 5 || !conn.bufferedAmount) {
+			callback();
+			return;
+		}
+		setTimeout(() => {
+			this.waitForBufferDone(conn, callback, tries + 1);
+		}, 150 * tries);
+	}
+	waitForSocketClosed(conn, callback, tries = 1) {
+		if (tries === 5 || conn.readyState === SOCKET_STATES.closed) {
+			callback();
+			return;
+		}
+		setTimeout(() => {
+			this.waitForSocketClosed(conn, callback, tries + 1);
+		}, 150 * tries);
+	}
+	/**
+	* @param {CloseEvent} event
+	*/
+	onConnClose(event) {
+		if (this.conn) this.conn.onclose = () => {};
+		if (this.hasLogger()) this.log("transport", "close", event);
+		this.triggerChanError();
+		this.clearHeartbeats();
+		if (!this.closeWasClean) this.reconnectTimer.scheduleTimeout();
+		this.triggerStateCallbacks("close", event);
+	}
+	/**
+	* @private
+	* @param {Event} error
+	*/
+	onConnError(error) {
+		if (this.hasLogger()) this.log("transport", error);
+		let transportBefore = this.transport;
+		let establishedBefore = this.establishedConnections;
+		this.triggerStateCallbacks("error", error, transportBefore, establishedBefore);
+		if (transportBefore === this.transport || establishedBefore > 0) this.triggerChanError();
+	}
+	/**
+	* @private
+	*/
+	triggerChanError() {
+		this.channels.forEach((channel) => {
+			if (!(channel.isErrored() || channel.isLeaving() || channel.isClosed())) channel.trigger(CHANNEL_EVENTS.error);
+		});
+	}
+	/**
+	* @returns {string}
+	*/
+	connectionState() {
+		switch (this.conn && this.conn.readyState) {
+			case SOCKET_STATES.connecting: return "connecting";
+			case SOCKET_STATES.open: return "open";
+			case SOCKET_STATES.closing: return "closing";
+			default: return "closed";
+		}
+	}
+	/**
+	* @returns {boolean}
+	*/
+	isConnected() {
+		return this.connectionState() === "open";
+	}
+	/**
+	*
+	* @param {Channel} channel
+	*/
+	remove(channel) {
+		this.off(channel.stateChangeRefs);
+		this.channels = this.channels.filter((c) => c !== channel);
+	}
+	/**
+	* Removes `onOpen`, `onClose`, `onError,` and `onMessage` registrations.
+	*
+	* @param {string[]} refs - list of refs returned by calls to
+	*                 `onOpen`, `onClose`, `onError,` and `onMessage`
+	*/
+	off(refs) {
+		for (let key in this.stateChangeCallbacks) this.stateChangeCallbacks[key] = this.stateChangeCallbacks[key].filter(([ref]) => {
+			return refs.indexOf(ref) === -1;
+		});
+	}
+	/**
+	* Initiates a new channel for the given topic
+	*
+	* @param {string} topic
+	* @param {Params | (() => Params)} [chanParams]- Parameters for the channel
+	* @returns {Channel}
+	*/
+	channel(topic, chanParams = {}) {
+		let chan = new Channel(topic, chanParams, this);
+		this.channels.push(chan);
+		return chan;
+	}
+	/**
+	* @param {Message<Record<string, any>>} data
+	*/
+	push(data) {
+		if (this.hasLogger()) {
+			let { topic, event, payload, ref, join_ref } = data;
+			this.log("push", `${topic} ${event} (${join_ref}, ${ref})`, payload);
+		}
+		if (this.isConnected()) this.encode(data, (result) => this.conn.send(result));
+		else this.sendBuffer.push(() => this.encode(data, (result) => this.conn.send(result)));
+	}
+	/**
+	* Return the next message ref, accounting for overflows
+	* @returns {string}
+	*/
+	makeRef() {
+		let newRef = this.ref + 1;
+		if (newRef === this.ref) this.ref = 0;
+		else this.ref = newRef;
+		return this.ref.toString();
+	}
+	sendHeartbeat() {
+		if (!this.isConnected()) {
+			try {
+				this.heartbeatCallback("disconnected");
+			} catch (e) {
+				this.log("error", "error in heartbeat callback", e);
+			}
+			return;
+		}
+		if (this.pendingHeartbeatRef) {
+			this.heartbeatTimeout();
+			return;
+		}
+		this.pendingHeartbeatRef = this.makeRef();
+		this.heartbeatSentAt = Date.now();
+		this.push({
+			topic: "phoenix",
+			event: "heartbeat",
+			payload: {},
+			ref: this.pendingHeartbeatRef
+		});
+		try {
+			this.heartbeatCallback("sent");
+		} catch (e) {
+			this.log("error", "error in heartbeat callback", e);
+		}
+		this.heartbeatTimeoutTimer = setTimeout(() => this.heartbeatTimeout(), this.heartbeatIntervalMs);
+	}
+	flushSendBuffer() {
+		if (this.isConnected() && this.sendBuffer.length > 0) {
+			this.sendBuffer.forEach((callback) => callback());
+			this.sendBuffer = [];
+		}
+	}
+	/**
+	* @param {MessageEvent<any>} rawMessage
+	*/
+	onConnMessage(rawMessage) {
+		this.decode(rawMessage.data, (msg) => {
+			let { topic, event, payload, ref, join_ref } = msg;
+			if (ref && ref === this.pendingHeartbeatRef) {
+				const latency = this.heartbeatSentAt ? Date.now() - this.heartbeatSentAt : void 0;
+				this.clearHeartbeats();
+				try {
+					this.heartbeatCallback(payload.status === "ok" ? "ok" : "error", latency);
+				} catch (e) {
+					this.log("error", "error in heartbeat callback", e);
+				}
+				this.pendingHeartbeatRef = null;
+				this.heartbeatSentAt = null;
+				if (this.autoSendHeartbeat) this.heartbeatTimer = setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs);
+			}
+			if (this.hasLogger()) this.log("receive", `${payload.status || ""} ${topic} ${event} ${ref && "(" + ref + ")" || ""}`.trim(), payload);
+			for (let i = 0; i < this.channels.length; i++) {
+				const channel = this.channels[i];
+				if (!channel.isMember(topic, event, payload, join_ref)) continue;
+				channel.trigger(event, payload, ref, join_ref);
+			}
+			this.triggerStateCallbacks("message", msg);
+		});
+	}
+	/**
+	* @private
+	* @template {keyof SocketStateChangeCallbacks} K
+	* @param {K} event
+	* @param {...Parameters<SocketStateChangeCallbacks[K][number][1]>} args
+	* @returns {void}
+	*/
+	triggerStateCallbacks(event, ...args) {
+		try {
+			this.stateChangeCallbacks[event].forEach(([_, callback]) => {
+				try {
+					callback(...args);
+				} catch (e) {
+					this.log("error", `error in ${event} callback`, e);
+				}
+			});
+		} catch (e) {
+			this.log("error", `error triggering ${event} callbacks`, e);
+		}
+	}
+	leaveOpenTopic(topic) {
+		let dupChannel = this.channels.find((c) => c.topic === topic && (c.isJoined() || c.isJoining()));
+		if (dupChannel) {
+			if (this.hasLogger()) this.log("transport", `leaving duplicate topic "${topic}"`);
+			dupChannel.leave();
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@supabase+realtime-js@2.100.1/node_modules/@supabase/realtime-js/dist/module/phoenix/presenceAdapter.js
+var PresenceAdapter = class PresenceAdapter {
+	constructor(channel, opts) {
+		const phoenixOptions = phoenixPresenceOptions(opts);
+		this.presence = new Presence(channel.getChannel(), phoenixOptions);
+		this.presence.onJoin((key, currentPresence, newPresence) => {
+			const onJoinPayload = PresenceAdapter.onJoinPayload(key, currentPresence, newPresence);
+			channel.getChannel().trigger("presence", onJoinPayload);
+		});
+		this.presence.onLeave((key, currentPresence, leftPresence) => {
+			const onLeavePayload = PresenceAdapter.onLeavePayload(key, currentPresence, leftPresence);
+			channel.getChannel().trigger("presence", onLeavePayload);
+		});
+		this.presence.onSync(() => {
+			channel.getChannel().trigger("presence", { event: "sync" });
+		});
+	}
+	get state() {
+		return PresenceAdapter.transformState(this.presence.state);
+	}
+	/**
+	* @private
+	* Remove 'metas' key
+	* Change 'phx_ref' to 'presence_ref'
+	* Remove 'phx_ref' and 'phx_ref_prev'
+	*
+	* @example Transform state
+	* // returns {
+	*  abc123: [
+	*    { presence_ref: '2', user_id: 1 },
+	*    { presence_ref: '3', user_id: 2 }
+	*  ]
+	* }
+	* RealtimePresence.transformState({
+	*  abc123: {
+	*    metas: [
+	*      { phx_ref: '2', phx_ref_prev: '1' user_id: 1 },
+	*      { phx_ref: '3', user_id: 2 }
+	*    ]
+	*  }
+	* })
+	*
+	*/
+	static transformState(state) {
+		state = cloneState(state);
+		return Object.getOwnPropertyNames(state).reduce((newState, key) => {
+			const presences = state[key];
+			newState[key] = transformState(presences);
+			return newState;
+		}, {});
+	}
+	static onJoinPayload(key, currentPresence, newPresence) {
+		return {
+			event: "join",
+			key,
+			currentPresences: parseCurrentPresences(currentPresence),
+			newPresences: transformState(newPresence)
+		};
+	}
+	static onLeavePayload(key, currentPresence, leftPresence) {
+		return {
+			event: "leave",
+			key,
+			currentPresences: parseCurrentPresences(currentPresence),
+			leftPresences: transformState(leftPresence)
+		};
+	}
+};
+function transformState(presences) {
+	return presences.metas.map((presence) => {
+		presence["presence_ref"] = presence["phx_ref"];
+		delete presence["phx_ref"];
+		delete presence["phx_ref_prev"];
+		return presence;
+	});
+}
+function cloneState(state) {
+	return JSON.parse(JSON.stringify(state));
+}
+function phoenixPresenceOptions(opts) {
+	return (opts === null || opts === void 0 ? void 0 : opts.events) && { events: opts.events };
+}
+function parseCurrentPresences(currentPresences) {
+	return (currentPresences === null || currentPresences === void 0 ? void 0 : currentPresences.metas) ? transformState(currentPresences) : [];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@supabase+realtime-js@2.100.1/node_modules/@supabase/realtime-js/dist/module/RealtimePresence.js
+var REALTIME_PRESENCE_LISTEN_EVENTS;
+(function(REALTIME_PRESENCE_LISTEN_EVENTS) {
+	REALTIME_PRESENCE_LISTEN_EVENTS["SYNC"] = "sync";
+	REALTIME_PRESENCE_LISTEN_EVENTS["JOIN"] = "join";
+	REALTIME_PRESENCE_LISTEN_EVENTS["LEAVE"] = "leave";
+})(REALTIME_PRESENCE_LISTEN_EVENTS || (REALTIME_PRESENCE_LISTEN_EVENTS = {}));
+var RealtimePresence = class {
+	get state() {
+		return this.presenceAdapter.state;
+	}
+	/**
+	* Creates a Presence helper that keeps the local presence state in sync with the server.
+	*
+	* @param channel - The realtime channel to bind to.
+	* @param opts - Optional custom event names, e.g. `{ events: { state: 'state', diff: 'diff' } }`.
+	*
+	* @category Realtime
+	*
+	* @example Example for a presence channel
+	* ```ts
+	* const presence = new RealtimePresence(channel)
+	*
+	* channel.on('presence', ({ event, key }) => {
+	*   console.log(`Presence ${event} on ${key}`)
+	* })
+	* ```
+	*/
+	constructor(channel, opts) {
+		this.channel = channel;
+		this.presenceAdapter = new PresenceAdapter(this.channel.channelAdapter, opts);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@supabase+realtime-js@2.100.1/node_modules/@supabase/realtime-js/dist/module/phoenix/channelAdapter.js
+var ChannelAdapter = class {
+	constructor(socket, topic, params) {
+		const phoenixParams = phoenixChannelParams(params);
+		this.channel = socket.getSocket().channel(topic, phoenixParams);
+		this.socket = socket;
+	}
+	get state() {
+		return this.channel.state;
+	}
+	set state(state) {
+		this.channel.state = state;
+	}
+	get joinedOnce() {
+		return this.channel.joinedOnce;
+	}
+	get joinPush() {
+		return this.channel.joinPush;
+	}
+	get rejoinTimer() {
+		return this.channel.rejoinTimer;
+	}
+	on(event, callback) {
+		return this.channel.on(event, callback);
+	}
+	off(event, refNumber) {
+		this.channel.off(event, refNumber);
+	}
+	subscribe(timeout) {
+		return this.channel.join(timeout);
+	}
+	unsubscribe(timeout) {
+		return this.channel.leave(timeout);
+	}
+	teardown() {
+		this.channel.teardown();
+	}
+	onClose(callback) {
+		this.channel.onClose(callback);
+	}
+	onError(callback) {
+		return this.channel.onError(callback);
+	}
+	push(event, payload, timeout) {
+		let push;
+		try {
+			push = this.channel.push(event, payload, timeout);
+		} catch (error) {
+			throw `tried to push '${event}' to '${this.channel.topic}' before joining. Use channel.subscribe() before pushing events`;
+		}
+		if (this.channel.pushBuffer.length > 100) {
+			const removedPush = this.channel.pushBuffer.shift();
+			removedPush.cancelTimeout();
+			this.socket.log("channel", `discarded push due to buffer overflow: ${removedPush.event}`, removedPush.payload());
+		}
+		return push;
+	}
+	updateJoinPayload(payload) {
+		const oldPayload = this.channel.joinPush.payload();
+		this.channel.joinPush.payload = () => Object.assign(Object.assign({}, oldPayload), payload);
+	}
+	canPush() {
+		return this.socket.isConnected() && this.state === CHANNEL_STATES$1.joined;
+	}
+	isJoined() {
+		return this.state === CHANNEL_STATES$1.joined;
+	}
+	isJoining() {
+		return this.state === CHANNEL_STATES$1.joining;
+	}
+	isClosed() {
+		return this.state === CHANNEL_STATES$1.closed;
+	}
+	isLeaving() {
+		return this.state === CHANNEL_STATES$1.leaving;
+	}
+	updateFilterBindings(filterBindings) {
+		this.channel.filterBindings = filterBindings;
+	}
+	updatePayloadTransform(callback) {
+		this.channel.onMessage = callback;
+	}
+	/**
+	* @internal
+	*/
+	getChannel() {
+		return this.channel;
+	}
+};
+function phoenixChannelParams(options) {
+	return { config: Object.assign({
+		broadcast: {
+			ack: false,
+			self: false
+		},
+		presence: {
+			key: "",
+			enabled: false
+		},
+		private: false
+	}, options.config) };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@supabase+realtime-js@2.100.1/node_modules/@supabase/realtime-js/dist/module/RealtimeChannel.js
+var REALTIME_POSTGRES_CHANGES_LISTEN_EVENT;
+(function(REALTIME_POSTGRES_CHANGES_LISTEN_EVENT) {
+	REALTIME_POSTGRES_CHANGES_LISTEN_EVENT["ALL"] = "*";
+	REALTIME_POSTGRES_CHANGES_LISTEN_EVENT["INSERT"] = "INSERT";
+	REALTIME_POSTGRES_CHANGES_LISTEN_EVENT["UPDATE"] = "UPDATE";
+	REALTIME_POSTGRES_CHANGES_LISTEN_EVENT["DELETE"] = "DELETE";
+})(REALTIME_POSTGRES_CHANGES_LISTEN_EVENT || (REALTIME_POSTGRES_CHANGES_LISTEN_EVENT = {}));
+var REALTIME_LISTEN_TYPES;
+(function(REALTIME_LISTEN_TYPES) {
+	REALTIME_LISTEN_TYPES["BROADCAST"] = "broadcast";
+	REALTIME_LISTEN_TYPES["PRESENCE"] = "presence";
+	REALTIME_LISTEN_TYPES["POSTGRES_CHANGES"] = "postgres_changes";
+	REALTIME_LISTEN_TYPES["SYSTEM"] = "system";
+})(REALTIME_LISTEN_TYPES || (REALTIME_LISTEN_TYPES = {}));
+var REALTIME_SUBSCRIBE_STATES;
+(function(REALTIME_SUBSCRIBE_STATES) {
+	REALTIME_SUBSCRIBE_STATES["SUBSCRIBED"] = "SUBSCRIBED";
+	REALTIME_SUBSCRIBE_STATES["TIMED_OUT"] = "TIMED_OUT";
+	REALTIME_SUBSCRIBE_STATES["CLOSED"] = "CLOSED";
+	REALTIME_SUBSCRIBE_STATES["CHANNEL_ERROR"] = "CHANNEL_ERROR";
+})(REALTIME_SUBSCRIBE_STATES || (REALTIME_SUBSCRIBE_STATES = {}));
+/** A channel is the basic building block of Realtime
+* and narrows the scope of data flow to subscribed clients.
+* You can think of a channel as a chatroom where participants are able to see who's online
+* and send and receive messages.
+*/
+var RealtimeChannel = class RealtimeChannel {
+	get state() {
+		return this.channelAdapter.state;
+	}
+	set state(state) {
+		this.channelAdapter.state = state;
+	}
+	get joinedOnce() {
+		return this.channelAdapter.joinedOnce;
+	}
+	get timeout() {
+		return this.socket.timeout;
+	}
+	get joinPush() {
+		return this.channelAdapter.joinPush;
+	}
+	get rejoinTimer() {
+		return this.channelAdapter.rejoinTimer;
+	}
+	/**
+	* Creates a channel that can broadcast messages, sync presence, and listen to Postgres changes.
+	*
+	* The topic determines which realtime stream you are subscribing to. Config options let you
+	* enable acknowledgement for broadcasts, presence tracking, or private channels.
+	*
+	* @category Realtime
+	*
+	* @example Example for a public channel
+	* ```ts
+	* import RealtimeClient from '@supabase/realtime-js'
+	*
+	* const client = new RealtimeClient('https://xyzcompany.supabase.co/realtime/v1', {
+	*   params: { apikey: 'public-anon-key' },
+	* })
+	* const channel = new RealtimeChannel('realtime:public:messages', { config: {} }, client)
+	* ```
+	*/
+	constructor(topic, params = { config: {} }, socket) {
+		var _a, _b;
+		this.topic = topic;
+		this.params = params;
+		this.socket = socket;
+		this.bindings = {};
+		this.subTopic = topic.replace(/^realtime:/i, "");
+		this.params.config = Object.assign({
+			broadcast: {
+				ack: false,
+				self: false
+			},
+			presence: {
+				key: "",
+				enabled: false
+			},
+			private: false
+		}, params.config);
+		this.channelAdapter = new ChannelAdapter(this.socket.socketAdapter, topic, this.params);
+		this.presence = new RealtimePresence(this);
+		this._onClose(() => {
+			this.socket._remove(this);
+		});
+		this._updateFilterTransform();
+		this.broadcastEndpointURL = httpEndpointURL(this.socket.socketAdapter.endPointURL());
+		this.private = this.params.config.private || false;
+		if (!this.private && ((_b = (_a = this.params.config) === null || _a === void 0 ? void 0 : _a.broadcast) === null || _b === void 0 ? void 0 : _b.replay)) throw `tried to use replay on public channel '${this.topic}'. It must be a private channel.`;
+	}
+	/**
+	* Subscribe registers your client with the server
+	* @category Realtime
+	*/
+	subscribe(callback, timeout = this.timeout) {
+		var _a, _b, _c;
+		if (!this.socket.isConnected()) this.socket.connect();
+		if (this.channelAdapter.isClosed()) {
+			const { config: { broadcast, presence, private: isPrivate } } = this.params;
+			const postgres_changes = (_b = (_a = this.bindings.postgres_changes) === null || _a === void 0 ? void 0 : _a.map((r) => r.filter)) !== null && _b !== void 0 ? _b : [];
+			const presence_enabled = !!this.bindings[REALTIME_LISTEN_TYPES.PRESENCE] && this.bindings[REALTIME_LISTEN_TYPES.PRESENCE].length > 0 || ((_c = this.params.config.presence) === null || _c === void 0 ? void 0 : _c.enabled) === true;
+			const accessTokenPayload = {};
+			const config = {
+				broadcast,
+				presence: Object.assign(Object.assign({}, presence), { enabled: presence_enabled }),
+				postgres_changes,
+				private: isPrivate
+			};
+			if (this.socket.accessTokenValue) accessTokenPayload.access_token = this.socket.accessTokenValue;
+			this._onError((reason) => {
+				callback === null || callback === void 0 || callback(REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR, reason);
+			});
+			this._onClose(() => callback === null || callback === void 0 ? void 0 : callback(REALTIME_SUBSCRIBE_STATES.CLOSED));
+			this.updateJoinPayload(Object.assign({ config }, accessTokenPayload));
+			this._updateFilterMessage();
+			this.channelAdapter.subscribe(timeout).receive("ok", async ({ postgres_changes }) => {
+				if (!this.socket._isManualToken()) this.socket.setAuth();
+				if (postgres_changes === void 0) {
+					callback === null || callback === void 0 || callback(REALTIME_SUBSCRIBE_STATES.SUBSCRIBED);
+					return;
+				}
+				this._updatePostgresBindings(postgres_changes, callback);
+			}).receive("error", (error) => {
+				this.state = CHANNEL_STATES$1.errored;
+				callback === null || callback === void 0 || callback(REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR, new Error(JSON.stringify(Object.values(error).join(", ") || "error")));
+			}).receive("timeout", () => {
+				callback === null || callback === void 0 || callback(REALTIME_SUBSCRIBE_STATES.TIMED_OUT);
+			});
+		}
+		return this;
+	}
+	_updatePostgresBindings(postgres_changes, callback) {
+		var _a;
+		const clientPostgresBindings = this.bindings.postgres_changes;
+		const bindingsLen = (_a = clientPostgresBindings === null || clientPostgresBindings === void 0 ? void 0 : clientPostgresBindings.length) !== null && _a !== void 0 ? _a : 0;
+		const newPostgresBindings = [];
+		for (let i = 0; i < bindingsLen; i++) {
+			const clientPostgresBinding = clientPostgresBindings[i];
+			const { filter: { event, schema, table, filter } } = clientPostgresBinding;
+			const serverPostgresFilter = postgres_changes && postgres_changes[i];
+			if (serverPostgresFilter && serverPostgresFilter.event === event && RealtimeChannel.isFilterValueEqual(serverPostgresFilter.schema, schema) && RealtimeChannel.isFilterValueEqual(serverPostgresFilter.table, table) && RealtimeChannel.isFilterValueEqual(serverPostgresFilter.filter, filter)) newPostgresBindings.push(Object.assign(Object.assign({}, clientPostgresBinding), { id: serverPostgresFilter.id }));
+			else {
+				this.unsubscribe();
+				this.state = CHANNEL_STATES$1.errored;
+				callback === null || callback === void 0 || callback(REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR, /* @__PURE__ */ new Error("mismatch between server and client bindings for postgres changes"));
+				return;
+			}
+		}
+		this.bindings.postgres_changes = newPostgresBindings;
+		if (this.state != CHANNEL_STATES$1.errored && callback) callback(REALTIME_SUBSCRIBE_STATES.SUBSCRIBED);
+	}
+	/**
+	* Returns the current presence state for this channel.
+	*
+	* The shape is a map keyed by presence key (for example a user id) where each entry contains the
+	* tracked metadata for that user.
+	*
+	* @category Realtime
+	*/
+	presenceState() {
+		return this.presence.state;
+	}
+	/**
+	* Sends the supplied payload to the presence tracker so other subscribers can see that this
+	* client is online. Use `untrack` to stop broadcasting presence for the same key.
+	*
+	* @category Realtime
+	*/
+	async track(payload, opts = {}) {
+		return await this.send({
+			type: "presence",
+			event: "track",
+			payload
+		}, opts.timeout || this.timeout);
+	}
+	/**
+	* Removes the current presence state for this client.
+	*
+	* @category Realtime
+	*/
+	async untrack(opts = {}) {
+		return await this.send({
+			type: "presence",
+			event: "untrack"
+		}, opts);
+	}
+	/**
+	* Listen to realtime events on this channel.
+	* @category Realtime
+	*
+	* @remarks
+	* - By default, Broadcast and Presence are enabled for all projects.
+	* - By default, listening to database changes is disabled for new projects due to database performance and security concerns. You can turn it on by managing Realtime's [replication](/docs/guides/api#realtime-api-overview).
+	* - You can receive the "previous" data for updates and deletes by setting the table's `REPLICA IDENTITY` to `FULL` (e.g., `ALTER TABLE your_table REPLICA IDENTITY FULL;`).
+	* - Row level security is not applied to delete statements. When RLS is enabled and replica identity is set to full, only the primary key is sent to clients.
+	*
+	* @example Listen to broadcast messages
+	* ```js
+	* const channel = supabase.channel("room1")
+	*
+	* channel.on("broadcast", { event: "cursor-pos" }, (payload) => {
+	*   console.log("Cursor position received!", payload);
+	* }).subscribe((status) => {
+	*   if (status === "SUBSCRIBED") {
+	*     channel.send({
+	*       type: "broadcast",
+	*       event: "cursor-pos",
+	*       payload: { x: Math.random(), y: Math.random() },
+	*     });
+	*   }
+	* });
+	* ```
+	*
+	* @example Listen to presence sync
+	* ```js
+	* const channel = supabase.channel('room1')
+	* channel
+	*   .on('presence', { event: 'sync' }, () => {
+	*     console.log('Synced presence state: ', channel.presenceState())
+	*   })
+	*   .subscribe(async (status) => {
+	*     if (status === 'SUBSCRIBED') {
+	*       await channel.track({ online_at: new Date().toISOString() })
+	*     }
+	*   })
+	* ```
+	*
+	* @example Listen to presence join
+	* ```js
+	* const channel = supabase.channel('room1')
+	* channel
+	*   .on('presence', { event: 'join' }, ({ newPresences }) => {
+	*     console.log('Newly joined presences: ', newPresences)
+	*   })
+	*   .subscribe(async (status) => {
+	*     if (status === 'SUBSCRIBED') {
+	*       await channel.track({ online_at: new Date().toISOString() })
+	*     }
+	*   })
+	* ```
+	*
+	* @example Listen to presence leave
+	* ```js
+	* const channel = supabase.channel('room1')
+	* channel
+	*   .on('presence', { event: 'leave' }, ({ leftPresences }) => {
+	*     console.log('Newly left presences: ', leftPresences)
+	*   })
+	*   .subscribe(async (status) => {
+	*     if (status === 'SUBSCRIBED') {
+	*       await channel.track({ online_at: new Date().toISOString() })
+	*       await channel.untrack()
+	*     }
+	*   })
+	* ```
+	*
+	* @example Listen to all database changes
+	* ```js
+	* supabase
+	*   .channel('room1')
+	*   .on('postgres_changes', { event: '*', schema: '*' }, payload => {
+	*     console.log('Change received!', payload)
+	*   })
+	*   .subscribe()
+	* ```
+	*
+	* @example Listen to a specific table
+	* ```js
+	* supabase
+	*   .channel('room1')
+	*   .on('postgres_changes', { event: '*', schema: 'public', table: 'countries' }, payload => {
+	*     console.log('Change received!', payload)
+	*   })
+	*   .subscribe()
+	* ```
+	*
+	* @example Listen to inserts
+	* ```js
+	* supabase
+	*   .channel('room1')
+	*   .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'countries' }, payload => {
+	*     console.log('Change received!', payload)
+	*   })
+	*   .subscribe()
+	* ```
+	*
+	* @exampleDescription Listen to updates
+	* By default, Supabase will send only the updated record. If you want to receive the previous values as well you can
+	* enable full replication for the table you are listening to:
+	*
+	* ```sql
+	* alter table "your_table" replica identity full;
+	* ```
+	*
+	* @example Listen to updates
+	* ```js
+	* supabase
+	*   .channel('room1')
+	*   .on('postgres_changes', { event: 'UPDATE', schema: 'public', table: 'countries' }, payload => {
+	*     console.log('Change received!', payload)
+	*   })
+	*   .subscribe()
+	* ```
+	*
+	* @exampleDescription Listen to deletes
+	* By default, Supabase does not send deleted records. If you want to receive the deleted record you can
+	* enable full replication for the table you are listening to:
+	*
+	* ```sql
+	* alter table "your_table" replica identity full;
+	* ```
+	*
+	* @example Listen to deletes
+	* ```js
+	* supabase
+	*   .channel('room1')
+	*   .on('postgres_changes', { event: 'DELETE', schema: 'public', table: 'countries' }, payload => {
+	*     console.log('Change received!', payload)
+	*   })
+	*   .subscribe()
+	* ```
+	*
+	* @exampleDescription Listen to multiple events
+	* You can chain listeners if you want to listen to multiple events for each table.
+	*
+	* @example Listen to multiple events
+	* ```js
+	* supabase
+	*   .channel('room1')
+	*   .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'countries' }, handleRecordInserted)
+	*   .on('postgres_changes', { event: 'DELETE', schema: 'public', table: 'countries' }, handleRecordDeleted)
+	*   .subscribe()
+	* ```
+	*
+	* @exampleDescription Listen to row level changes
+	* You can listen to individual rows using the format `{table}:{col}=eq.{val}` - where `{col}` is the column name, and `{val}` is the value which you want to match.
+	*
+	* @example Listen to row level changes
+	* ```js
+	* supabase
+	*   .channel('room1')
+	*   .on('postgres_changes', { event: 'UPDATE', schema: 'public', table: 'countries', filter: 'id=eq.200' }, handleRecordUpdated)
+	*   .subscribe()
+	* ```
+	*/
+	on(type, filter, callback) {
+		if (this.channelAdapter.isJoined() && type === REALTIME_LISTEN_TYPES.PRESENCE) {
+			this.socket.log("channel", `cannot add presence callbacks for ${this.topic} after joining.`);
+			throw new Error("cannot add presence callbacks after joining a channel");
+		}
+		return this._on(type, filter, callback);
+	}
+	/**
+	* Sends a broadcast message explicitly via REST API.
+	*
+	* This method always uses the REST API endpoint regardless of WebSocket connection state.
+	* Useful when you want to guarantee REST delivery or when gradually migrating from implicit REST fallback.
+	*
+	* @param event The name of the broadcast event
+	* @param payload Payload to be sent (required)
+	* @param opts Options including timeout
+	* @returns Promise resolving to object with success status, and error details if failed
+	*
+	* @category Realtime
+	*/
+	async httpSend(event, payload, opts = {}) {
+		var _a;
+		if (payload === void 0 || payload === null) return Promise.reject("Payload is required for httpSend()");
+		const headers = {
+			apikey: this.socket.apiKey ? this.socket.apiKey : "",
+			"Content-Type": "application/json"
+		};
+		if (this.socket.accessTokenValue) headers["Authorization"] = `Bearer ${this.socket.accessTokenValue}`;
+		const options = {
+			method: "POST",
+			headers,
+			body: JSON.stringify({ messages: [{
+				topic: this.subTopic,
+				event,
+				payload,
+				private: this.private
+			}] })
+		};
+		const response = await this._fetchWithTimeout(this.broadcastEndpointURL, options, (_a = opts.timeout) !== null && _a !== void 0 ? _a : this.timeout);
+		if (response.status === 202) return { success: true };
+		let errorMessage = response.statusText;
+		try {
+			const errorBody = await response.json();
+			errorMessage = errorBody.error || errorBody.message || errorMessage;
+		} catch (_b) {}
+		return Promise.reject(new Error(errorMessage));
+	}
+	/**
+	* Sends a message into the channel.
+	*
+	* @param args Arguments to send to channel
+	* @param args.type The type of event to send
+	* @param args.event The name of the event being sent
+	* @param args.payload Payload to be sent
+	* @param opts Options to be used during the send process
+	*
+	* @category Realtime
+	*
+	* @remarks
+	* - When using REST you don't need to subscribe to the channel
+	* - REST calls are only available from 2.37.0 onwards
+	*
+	* @example Send a message via websocket
+	* ```js
+	* const channel = supabase.channel('room1')
+	*
+	* channel.subscribe((status) => {
+	*   if (status === 'SUBSCRIBED') {
+	*     channel.send({
+	*       type: 'broadcast',
+	*       event: 'cursor-pos',
+	*       payload: { x: Math.random(), y: Math.random() },
+	*     })
+	*   }
+	* })
+	* ```
+	*
+	* @exampleResponse Send a message via websocket
+	* ```js
+	* ok | timed out | error
+	* ```
+	*
+	* @example Send a message via REST
+	* ```js
+	* supabase
+	*   .channel('room1')
+	*   .httpSend('cursor-pos', { x: Math.random(), y: Math.random() })
+	* ```
+	*/
+	async send(args, opts = {}) {
+		var _a, _b;
+		if (!this.channelAdapter.canPush() && args.type === "broadcast") {
+			console.warn("Realtime send() is automatically falling back to REST API. This behavior will be deprecated in the future. Please use httpSend() explicitly for REST delivery.");
+			const { event, payload: endpoint_payload } = args;
+			const headers = {
+				apikey: this.socket.apiKey ? this.socket.apiKey : "",
+				"Content-Type": "application/json"
+			};
+			if (this.socket.accessTokenValue) headers["Authorization"] = `Bearer ${this.socket.accessTokenValue}`;
+			const options = {
+				method: "POST",
+				headers,
+				body: JSON.stringify({ messages: [{
+					topic: this.subTopic,
+					event,
+					payload: endpoint_payload,
+					private: this.private
+				}] })
+			};
+			try {
+				const response = await this._fetchWithTimeout(this.broadcastEndpointURL, options, (_a = opts.timeout) !== null && _a !== void 0 ? _a : this.timeout);
+				await ((_b = response.body) === null || _b === void 0 ? void 0 : _b.cancel());
+				return response.ok ? "ok" : "error";
+			} catch (error) {
+				if (error.name === "AbortError") return "timed out";
+				else return "error";
+			}
+		} else return new Promise((resolve) => {
+			var _a, _b, _c;
+			const push = this.channelAdapter.push(args.type, args, opts.timeout || this.timeout);
+			if (args.type === "broadcast" && !((_c = (_b = (_a = this.params) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.broadcast) === null || _c === void 0 ? void 0 : _c.ack)) resolve("ok");
+			push.receive("ok", () => resolve("ok"));
+			push.receive("error", () => resolve("error"));
+			push.receive("timeout", () => resolve("timed out"));
+		});
+	}
+	/**
+	* Updates the payload that will be sent the next time the channel joins (reconnects).
+	* Useful for rotating access tokens or updating config without re-creating the channel.
+	*
+	* @category Realtime
+	*/
+	updateJoinPayload(payload) {
+		this.channelAdapter.updateJoinPayload(payload);
+	}
+	/**
+	* Leaves the channel.
+	*
+	* Unsubscribes from server events, and instructs channel to terminate on server.
+	* Triggers onClose() hooks.
+	*
+	* To receive leave acknowledgements, use the a `receive` hook to bind to the server ack, ie:
+	* channel.unsubscribe().receive("ok", () => alert("left!") )
+	*
+	* @category Realtime
+	*/
+	async unsubscribe(timeout = this.timeout) {
+		return new Promise((resolve) => {
+			this.channelAdapter.unsubscribe(timeout).receive("ok", () => resolve("ok")).receive("timeout", () => resolve("timed out")).receive("error", () => resolve("error"));
+		});
+	}
+	/**
+	* Destroys and stops related timers.
+	*
+	* @category Realtime
+	*/
+	teardown() {
+		this.channelAdapter.teardown();
+	}
+	/** @internal */
+	async _fetchWithTimeout(url, options, timeout) {
+		const controller = new AbortController();
+		const id = setTimeout(() => controller.abort(), timeout);
+		const response = await this.socket.fetch(url, Object.assign(Object.assign({}, options), { signal: controller.signal }));
+		clearTimeout(id);
+		return response;
+	}
+	/** @internal */
+	_on(type, filter, callback) {
+		const typeLower = type.toLocaleLowerCase();
+		const binding = {
+			type: typeLower,
+			filter,
+			callback,
+			ref: this.channelAdapter.on(type, callback)
+		};
+		if (this.bindings[typeLower]) this.bindings[typeLower].push(binding);
+		else this.bindings[typeLower] = [binding];
+		this._updateFilterMessage();
+		return this;
+	}
+	/**
+	* Registers a callback that will be executed when the channel closes.
+	*
+	* @internal
+	*/
+	_onClose(callback) {
+		this.channelAdapter.onClose(callback);
+	}
+	/**
+	* Registers a callback that will be executed when the channel encounteres an error.
+	*
+	* @internal
+	*/
+	_onError(callback) {
+		this.channelAdapter.onError(callback);
+	}
+	/** @internal */
+	_updateFilterMessage() {
+		this.channelAdapter.updateFilterBindings((binding, payload, ref) => {
+			var _a, _b, _c, _d, _e, _f, _g;
+			const typeLower = binding.event.toLocaleLowerCase();
+			if (this._notThisChannelEvent(typeLower, ref)) return false;
+			const bind = (_a = this.bindings[typeLower]) === null || _a === void 0 ? void 0 : _a.find((bind) => bind.ref === binding.ref);
+			if (!bind) return true;
+			if ([
+				"broadcast",
+				"presence",
+				"postgres_changes"
+			].includes(typeLower)) if ("id" in bind) {
+				const bindId = bind.id;
+				const bindEvent = (_b = bind.filter) === null || _b === void 0 ? void 0 : _b.event;
+				return bindId && ((_c = payload.ids) === null || _c === void 0 ? void 0 : _c.includes(bindId)) && (bindEvent === "*" || (bindEvent === null || bindEvent === void 0 ? void 0 : bindEvent.toLocaleLowerCase()) === ((_d = payload.data) === null || _d === void 0 ? void 0 : _d.type.toLocaleLowerCase()));
+			} else {
+				const bindEvent = (_f = (_e = bind === null || bind === void 0 ? void 0 : bind.filter) === null || _e === void 0 ? void 0 : _e.event) === null || _f === void 0 ? void 0 : _f.toLocaleLowerCase();
+				return bindEvent === "*" || bindEvent === ((_g = payload === null || payload === void 0 ? void 0 : payload.event) === null || _g === void 0 ? void 0 : _g.toLocaleLowerCase());
+			}
+			else return bind.type.toLocaleLowerCase() === typeLower;
+		});
+	}
+	/** @internal */
+	_notThisChannelEvent(event, ref) {
+		const { close, error, leave, join } = CHANNEL_EVENTS$1;
+		return ref && [
+			close,
+			error,
+			leave,
+			join
+		].includes(event) && ref !== this.joinPush.ref;
+	}
+	/** @internal */
+	_updateFilterTransform() {
+		this.channelAdapter.updatePayloadTransform((event, payload, ref) => {
+			if (typeof payload === "object" && "ids" in payload) {
+				const postgresChanges = payload.data;
+				const { schema, table, commit_timestamp, type, errors } = postgresChanges;
+				return Object.assign(Object.assign({}, {
+					schema,
+					table,
+					commit_timestamp,
+					eventType: type,
+					new: {},
+					old: {},
+					errors
+				}), this._getPayloadRecords(postgresChanges));
+			}
+			return payload;
+		});
+	}
+	/**
+	* Compares two optional filter values for equality.
+	* Treats undefined, null, and empty string as equivalent empty values.
+	* @internal
+	*/
+	static isFilterValueEqual(serverValue, clientValue) {
+		return (serverValue !== null && serverValue !== void 0 ? serverValue : void 0) === (clientValue !== null && clientValue !== void 0 ? clientValue : void 0);
+	}
+	/** @internal */
+	_getPayloadRecords(payload) {
+		const records = {
+			new: {},
+			old: {}
+		};
+		if (payload.type === "INSERT" || payload.type === "UPDATE") records.new = convertChangeData(payload.columns, payload.record);
+		if (payload.type === "UPDATE" || payload.type === "DELETE") records.old = convertChangeData(payload.columns, payload.old_record);
+		return records;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@supabase+realtime-js@2.100.1/node_modules/@supabase/realtime-js/dist/module/phoenix/socketAdapter.js
+var SocketAdapter = class {
+	constructor(endPoint, options) {
+		this.socket = new Socket(endPoint, options);
+	}
+	get timeout() {
+		return this.socket.timeout;
+	}
+	get endPoint() {
+		return this.socket.endPoint;
+	}
+	get transport() {
+		return this.socket.transport;
+	}
+	get heartbeatIntervalMs() {
+		return this.socket.heartbeatIntervalMs;
+	}
+	get heartbeatCallback() {
+		return this.socket.heartbeatCallback;
+	}
+	set heartbeatCallback(callback) {
+		this.socket.heartbeatCallback = callback;
+	}
+	get heartbeatTimer() {
+		return this.socket.heartbeatTimer;
+	}
+	get pendingHeartbeatRef() {
+		return this.socket.pendingHeartbeatRef;
+	}
+	get reconnectTimer() {
+		return this.socket.reconnectTimer;
+	}
+	get vsn() {
+		return this.socket.vsn;
+	}
+	get encode() {
+		return this.socket.encode;
+	}
+	get decode() {
+		return this.socket.decode;
+	}
+	get reconnectAfterMs() {
+		return this.socket.reconnectAfterMs;
+	}
+	get sendBuffer() {
+		return this.socket.sendBuffer;
+	}
+	get stateChangeCallbacks() {
+		return this.socket.stateChangeCallbacks;
+	}
+	connect() {
+		this.socket.connect();
+	}
+	disconnect(callback, code, reason, timeout = 1e4) {
+		return new Promise((resolve) => {
+			setTimeout(() => resolve("timeout"), timeout);
+			this.socket.disconnect(() => {
+				callback();
+				resolve("ok");
+			}, code, reason);
+		});
+	}
+	push(data) {
+		this.socket.push(data);
+	}
+	log(kind, msg, data) {
+		this.socket.log(kind, msg, data);
+	}
+	makeRef() {
+		return this.socket.makeRef();
+	}
+	onOpen(callback) {
+		this.socket.onOpen(callback);
+	}
+	onClose(callback) {
+		this.socket.onClose(callback);
+	}
+	onError(callback) {
+		this.socket.onError(callback);
+	}
+	onMessage(callback) {
+		this.socket.onMessage(callback);
+	}
+	isConnected() {
+		return this.socket.isConnected();
+	}
+	isConnecting() {
+		return this.socket.connectionState() == CONNECTION_STATE.connecting;
+	}
+	isDisconnecting() {
+		return this.socket.connectionState() == CONNECTION_STATE.closing;
+	}
+	connectionState() {
+		return this.socket.connectionState();
+	}
+	endPointURL() {
+		return this.socket.endPointURL();
+	}
+	sendHeartbeat() {
+		this.socket.sendHeartbeat();
+	}
+	/**
+	* @internal
+	*/
+	getSocket() {
+		return this.socket;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@supabase+realtime-js@2.100.1/node_modules/@supabase/realtime-js/dist/module/RealtimeClient.js
+const CONNECTION_TIMEOUTS = {
+	HEARTBEAT_INTERVAL: 25e3,
+	RECONNECT_DELAY: 10,
+	HEARTBEAT_TIMEOUT_FALLBACK: 100
+};
+const RECONNECT_INTERVALS = [
+	1e3,
+	2e3,
+	5e3,
+	1e4
+];
+const DEFAULT_RECONNECT_FALLBACK = 1e4;
+const WORKER_SCRIPT = `
+  addEventListener("message", (e) => {
+    if (e.data.event === "start") {
+      setInterval(() => postMessage({ event: "keepAlive" }), e.data.interval);
+    }
+  });`;
+var RealtimeClient = class {
+	get endPoint() {
+		return this.socketAdapter.endPoint;
+	}
+	get timeout() {
+		return this.socketAdapter.timeout;
+	}
+	get transport() {
+		return this.socketAdapter.transport;
+	}
+	get heartbeatCallback() {
+		return this.socketAdapter.heartbeatCallback;
+	}
+	get heartbeatIntervalMs() {
+		return this.socketAdapter.heartbeatIntervalMs;
+	}
+	get heartbeatTimer() {
+		if (this.worker) return this._workerHeartbeatTimer;
+		return this.socketAdapter.heartbeatTimer;
+	}
+	get pendingHeartbeatRef() {
+		if (this.worker) return this._pendingWorkerHeartbeatRef;
+		return this.socketAdapter.pendingHeartbeatRef;
+	}
+	get reconnectTimer() {
+		return this.socketAdapter.reconnectTimer;
+	}
+	get vsn() {
+		return this.socketAdapter.vsn;
+	}
+	get encode() {
+		return this.socketAdapter.encode;
+	}
+	get decode() {
+		return this.socketAdapter.decode;
+	}
+	get reconnectAfterMs() {
+		return this.socketAdapter.reconnectAfterMs;
+	}
+	get sendBuffer() {
+		return this.socketAdapter.sendBuffer;
+	}
+	get stateChangeCallbacks() {
+		return this.socketAdapter.stateChangeCallbacks;
+	}
+	/**
+	* Initializes the Socket.
+	*
+	* @param endPoint The string WebSocket endpoint, ie, "ws://example.com/socket", "wss://example.com", "/socket" (inherited host & protocol)
+	* @param httpEndpoint The string HTTP endpoint, ie, "https://example.com", "/" (inherited host & protocol)
+	* @param options.transport The Websocket Transport, for example WebSocket. This can be a custom implementation
+	* @param options.timeout The default timeout in milliseconds to trigger push timeouts.
+	* @param options.params The optional params to pass when connecting.
+	* @param options.headers Deprecated: headers cannot be set on websocket connections and this option will be removed in the future.
+	* @param options.heartbeatIntervalMs The millisec interval to send a heartbeat message.
+	* @param options.heartbeatCallback The optional function to handle heartbeat status and latency.
+	* @param options.logger The optional function for specialized logging, ie: logger: (kind, msg, data) => { console.log(`${kind}: ${msg}`, data) }
+	* @param options.logLevel Sets the log level for Realtime
+	* @param options.encode The function to encode outgoing messages. Defaults to JSON: (payload, callback) => callback(JSON.stringify(payload))
+	* @param options.decode The function to decode incoming messages. Defaults to Serializer's decode.
+	* @param options.reconnectAfterMs he optional function that returns the millsec reconnect interval. Defaults to stepped backoff off.
+	* @param options.worker Use Web Worker to set a side flow. Defaults to false.
+	* @param options.workerUrl The URL of the worker script. Defaults to https://realtime.supabase.com/worker.js that includes a heartbeat event call to keep the connection alive.
+	* @param options.vsn The protocol version to use when connecting. Supported versions are "1.0.0" and "2.0.0". Defaults to "2.0.0".
+	*
+	* @category Realtime
+	*
+	* @example Example for a public channel
+	* ```ts
+	* import RealtimeClient from '@supabase/realtime-js'
+	*
+	* const client = new RealtimeClient('https://xyzcompany.supabase.co/realtime/v1', {
+	*   params: { apikey: 'public-anon-key' },
+	* })
+	* client.connect()
+	* ```
+	*/
+	constructor(endPoint, options) {
+		var _a;
+		this.channels = new Array();
+		this.accessTokenValue = null;
+		this.accessToken = null;
+		this.apiKey = null;
+		this.httpEndpoint = "";
+		/** @deprecated headers cannot be set on websocket connections */
+		this.headers = {};
+		this.params = {};
+		this.ref = 0;
+		this.serializer = new Serializer();
+		this._manuallySetToken = false;
+		this._authPromise = null;
+		this._workerHeartbeatTimer = void 0;
+		this._pendingWorkerHeartbeatRef = null;
+		/**
+		* Use either custom fetch, if provided, or default fetch to make HTTP requests
+		*
+		* @internal
+		*/
+		this._resolveFetch = (customFetch) => {
+			if (customFetch) return (...args) => customFetch(...args);
+			return (...args) => fetch(...args);
+		};
+		if (!((_a = options === null || options === void 0 ? void 0 : options.params) === null || _a === void 0 ? void 0 : _a.apikey)) throw new Error("API key is required to connect to Realtime");
+		this.apiKey = options.params.apikey;
+		const socketAdapterOptions = this._initializeOptions(options);
+		this.socketAdapter = new SocketAdapter(endPoint, socketAdapterOptions);
+		this.httpEndpoint = httpEndpointURL(endPoint);
+		this.fetch = this._resolveFetch(options === null || options === void 0 ? void 0 : options.fetch);
+	}
+	/**
+	* Connects the socket, unless already connected.
+	*
+	* @category Realtime
+	*/
+	connect() {
+		if (this.isConnecting() || this.isDisconnecting() || this.isConnected()) return;
+		if (this.accessToken && !this._authPromise) this._setAuthSafely("connect");
+		this._setupConnectionHandlers();
+		try {
+			this.socketAdapter.connect();
+		} catch (error) {
+			const errorMessage = error.message;
+			if (errorMessage.includes("Node.js")) throw new Error(`${errorMessage}\n\nTo use Realtime in Node.js, you need to provide a WebSocket implementation:
+
+Option 1: Use Node.js 22+ which has native WebSocket support
+Option 2: Install and provide the "ws" package:
+
+  npm install ws
+
+  import ws from "ws"
+  const client = new RealtimeClient(url, {
+    ...options,
+    transport: ws
+  })`);
+			throw new Error(`WebSocket not available: ${errorMessage}`);
+		}
+		this._handleNodeJsRaceCondition();
+	}
+	/**
+	* Returns the URL of the websocket.
+	* @returns string The URL of the websocket.
+	*
+	* @category Realtime
+	*/
+	endpointURL() {
+		return this.socketAdapter.endPointURL();
+	}
+	/**
+	* Disconnects the socket.
+	*
+	* @param code A numeric status code to send on disconnect.
+	* @param reason A custom reason for the disconnect.
+	*
+	* @category Realtime
+	*/
+	async disconnect(code, reason) {
+		if (this.isDisconnecting()) return "ok";
+		return await this.socketAdapter.disconnect(() => {
+			clearInterval(this._workerHeartbeatTimer);
+			this._terminateWorker();
+		}, code, reason);
+	}
+	/**
+	* Returns all created channels
+	*
+	* @category Realtime
+	*/
+	getChannels() {
+		return this.channels;
+	}
+	/**
+	* Unsubscribes, removes and tears down a single channel
+	* @param channel A RealtimeChannel instance
+	*
+	* @category Realtime
+	*/
+	async removeChannel(channel) {
+		const status = await channel.unsubscribe();
+		if (status === "ok") channel.teardown();
+		if (this.channels.length === 0) this.disconnect();
+		return status;
+	}
+	/**
+	* Unsubscribes, removes and tears down all channels
+	*
+	* @category Realtime
+	*/
+	async removeAllChannels() {
+		const promises = this.channels.map(async (channel) => {
+			const result = await channel.unsubscribe();
+			channel.teardown();
+			return result;
+		});
+		const result = await Promise.all(promises);
+		this.disconnect();
+		return result;
+	}
+	/**
+	* Logs the message.
+	*
+	* For customized logging, `this.logger` can be overridden in Client constructor.
+	*
+	* @category Realtime
+	*/
+	log(kind, msg, data) {
+		this.socketAdapter.log(kind, msg, data);
+	}
+	/**
+	* Returns the current state of the socket.
+	*
+	* @category Realtime
+	*/
+	connectionState() {
+		return this.socketAdapter.connectionState() || CONNECTION_STATE.closed;
+	}
+	/**
+	* Returns `true` is the connection is open.
+	*
+	* @category Realtime
+	*/
+	isConnected() {
+		return this.socketAdapter.isConnected();
+	}
+	/**
+	* Returns `true` if the connection is currently connecting.
+	*
+	* @category Realtime
+	*/
+	isConnecting() {
+		return this.socketAdapter.isConnecting();
+	}
+	/**
+	* Returns `true` if the connection is currently disconnecting.
+	*
+	* @category Realtime
+	*/
+	isDisconnecting() {
+		return this.socketAdapter.isDisconnecting();
+	}
+	/**
+	* Creates (or reuses) a {@link RealtimeChannel} for the provided topic.
+	*
+	* Topics are automatically prefixed with `realtime:` to match the Realtime service.
+	* If a channel with the same topic already exists it will be returned instead of creating
+	* a duplicate connection.
+	*
+	* @category Realtime
+	*/
+	channel(topic, params = { config: {} }) {
+		const realtimeTopic = `realtime:${topic}`;
+		const exists = this.getChannels().find((c) => c.topic === realtimeTopic);
+		if (!exists) {
+			const chan = new RealtimeChannel(`realtime:${topic}`, params, this);
+			this.channels.push(chan);
+			return chan;
+		} else return exists;
+	}
+	/**
+	* Push out a message if the socket is connected.
+	*
+	* If the socket is not connected, the message gets enqueued within a local buffer, and sent out when a connection is next established.
+	*
+	* @category Realtime
+	*/
+	push(data) {
+		this.socketAdapter.push(data);
+	}
+	/**
+	* Sets the JWT access token used for channel subscription authorization and Realtime RLS.
+	*
+	* If param is null it will use the `accessToken` callback function or the token set on the client.
+	*
+	* On callback used, it will set the value of the token internal to the client.
+	*
+	* When a token is explicitly provided, it will be preserved across channel operations
+	* (including removeChannel and resubscribe). The `accessToken` callback will not be
+	* invoked until `setAuth()` is called without arguments.
+	*
+	* @param token A JWT string to override the token set on the client.
+	*
+	* @example Setting the authorization header
+	* // Use a manual token (preserved across resubscribes, ignores accessToken callback)
+	* client.realtime.setAuth('my-custom-jwt')
+	*
+	* // Switch back to using the accessToken callback
+	* client.realtime.setAuth()
+	*
+	* @category Realtime
+	*/
+	async setAuth(token = null) {
+		this._authPromise = this._performAuth(token);
+		try {
+			await this._authPromise;
+		} finally {
+			this._authPromise = null;
+		}
+	}
+	/**
+	* Returns true if the current access token was explicitly set via setAuth(token),
+	* false if it was obtained via the accessToken callback.
+	* @internal
+	*/
+	_isManualToken() {
+		return this._manuallySetToken;
+	}
+	/**
+	* Sends a heartbeat message if the socket is connected.
+	*
+	* @category Realtime
+	*/
+	async sendHeartbeat() {
+		this.socketAdapter.sendHeartbeat();
+	}
+	/**
+	* Sets a callback that receives lifecycle events for internal heartbeat messages.
+	* Useful for instrumenting connection health (e.g. sent/ok/timeout/disconnected).
+	*
+	* @category Realtime
+	*/
+	onHeartbeat(callback) {
+		this.socketAdapter.heartbeatCallback = this._wrapHeartbeatCallback(callback);
+	}
+	/**
+	* Return the next message ref, accounting for overflows
+	*
+	* @internal
+	*/
+	_makeRef() {
+		return this.socketAdapter.makeRef();
+	}
+	/**
+	* Removes a channel from RealtimeClient
+	*
+	* @param channel An open subscription.
+	*
+	* @internal
+	*/
+	_remove(channel) {
+		this.channels = this.channels.filter((c) => c.topic !== channel.topic);
+	}
+	/**
+	* Perform the actual auth operation
+	* @internal
+	*/
+	async _performAuth(token = null) {
+		let tokenToSend;
+		let isManualToken = false;
+		if (token) {
+			tokenToSend = token;
+			isManualToken = true;
+		} else if (this.accessToken) try {
+			tokenToSend = await this.accessToken();
+		} catch (e) {
+			this.log("error", "Error fetching access token from callback", e);
+			tokenToSend = this.accessTokenValue;
+		}
+		else tokenToSend = this.accessTokenValue;
+		if (isManualToken) this._manuallySetToken = true;
+		else if (this.accessToken) this._manuallySetToken = false;
+		if (this.accessTokenValue != tokenToSend) {
+			this.accessTokenValue = tokenToSend;
+			this.channels.forEach((channel) => {
+				const payload = {
+					access_token: tokenToSend,
+					version: DEFAULT_VERSION
+				};
+				tokenToSend && channel.updateJoinPayload(payload);
+				if (channel.joinedOnce && channel.channelAdapter.isJoined()) channel.channelAdapter.push(CHANNEL_EVENTS$1.access_token, { access_token: tokenToSend });
+			});
+		}
+	}
+	/**
+	* Wait for any in-flight auth operations to complete
+	* @internal
+	*/
+	async _waitForAuthIfNeeded() {
+		if (this._authPromise) await this._authPromise;
+	}
+	/**
+	* Safely call setAuth with standardized error handling
+	* @internal
+	*/
+	_setAuthSafely(context = "general") {
+		if (!this._isManualToken()) this.setAuth().catch((e) => {
+			this.log("error", `Error setting auth in ${context}`, e);
+		});
+	}
+	/** @internal */
+	_setupConnectionHandlers() {
+		this.socketAdapter.onOpen(() => {
+			(this._authPromise || (this.accessToken && !this.accessTokenValue ? this.setAuth() : Promise.resolve())).catch((e) => {
+				this.log("error", "error waiting for auth on connect", e);
+			});
+			if (this.worker && !this.workerRef) this._startWorkerHeartbeat();
+		});
+		this.socketAdapter.onClose(() => {
+			if (this.worker && this.workerRef) this._terminateWorker();
+		});
+		this.socketAdapter.onMessage((message) => {
+			if (message.ref && message.ref === this._pendingWorkerHeartbeatRef) this._pendingWorkerHeartbeatRef = null;
+		});
+	}
+	/** @internal */
+	_handleNodeJsRaceCondition() {
+		if (this.socketAdapter.isConnected()) this.socketAdapter.getSocket().onConnOpen();
+	}
+	/** @internal */
+	_wrapHeartbeatCallback(heartbeatCallback) {
+		return (status, latency) => {
+			if (status == "sent") this._setAuthSafely();
+			if (heartbeatCallback) heartbeatCallback(status, latency);
+		};
+	}
+	/** @internal */
+	_startWorkerHeartbeat() {
+		if (this.workerUrl) this.log("worker", `starting worker for from ${this.workerUrl}`);
+		else this.log("worker", `starting default worker`);
+		const objectUrl = this._workerObjectUrl(this.workerUrl);
+		this.workerRef = new Worker(objectUrl);
+		this.workerRef.onerror = (error) => {
+			this.log("worker", "worker error", error.message);
+			this._terminateWorker();
+			this.disconnect();
+		};
+		this.workerRef.onmessage = (event) => {
+			if (event.data.event === "keepAlive") this.sendHeartbeat();
+		};
+		this.workerRef.postMessage({
+			event: "start",
+			interval: this.heartbeatIntervalMs
+		});
+	}
+	/**
+	* Terminate the Web Worker and clear the reference
+	* @internal
+	*/
+	_terminateWorker() {
+		if (this.workerRef) {
+			this.log("worker", "terminating worker");
+			this.workerRef.terminate();
+			this.workerRef = void 0;
+		}
+	}
+	/** @internal */
+	_workerObjectUrl(url) {
+		let result_url;
+		if (url) result_url = url;
+		else {
+			const blob = new Blob([WORKER_SCRIPT], { type: "application/javascript" });
+			result_url = URL.createObjectURL(blob);
+		}
+		return result_url;
+	}
+	/**
+	* Initialize socket options with defaults
+	* @internal
+	*/
+	_initializeOptions(options) {
+		var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+		this.worker = (_a = options === null || options === void 0 ? void 0 : options.worker) !== null && _a !== void 0 ? _a : false;
+		this.accessToken = (_b = options === null || options === void 0 ? void 0 : options.accessToken) !== null && _b !== void 0 ? _b : null;
+		const result = {};
+		result.timeout = (_c = options === null || options === void 0 ? void 0 : options.timeout) !== null && _c !== void 0 ? _c : DEFAULT_TIMEOUT$1;
+		result.heartbeatIntervalMs = (_d = options === null || options === void 0 ? void 0 : options.heartbeatIntervalMs) !== null && _d !== void 0 ? _d : CONNECTION_TIMEOUTS.HEARTBEAT_INTERVAL;
+		result.transport = (_e = options === null || options === void 0 ? void 0 : options.transport) !== null && _e !== void 0 ? _e : WebSocketFactory.getWebSocketConstructor();
+		result.params = options === null || options === void 0 ? void 0 : options.params;
+		result.logger = options === null || options === void 0 ? void 0 : options.logger;
+		result.heartbeatCallback = this._wrapHeartbeatCallback(options === null || options === void 0 ? void 0 : options.heartbeatCallback);
+		result.reconnectAfterMs = (_f = options === null || options === void 0 ? void 0 : options.reconnectAfterMs) !== null && _f !== void 0 ? _f : ((tries) => {
+			return RECONNECT_INTERVALS[tries - 1] || DEFAULT_RECONNECT_FALLBACK;
+		});
+		let defaultEncode;
+		let defaultDecode;
+		const vsn = (_g = options === null || options === void 0 ? void 0 : options.vsn) !== null && _g !== void 0 ? _g : DEFAULT_VSN$1;
+		switch (vsn) {
+			case VSN_1_0_0:
+				defaultEncode = (payload, callback) => {
+					return callback(JSON.stringify(payload));
+				};
+				defaultDecode = (payload, callback) => {
+					return callback(JSON.parse(payload));
+				};
+				break;
+			case VSN_2_0_0:
+				defaultEncode = this.serializer.encode.bind(this.serializer);
+				defaultDecode = this.serializer.decode.bind(this.serializer);
+				break;
+			default: throw new Error(`Unsupported serializer version: ${result.vsn}`);
+		}
+		result.vsn = vsn;
+		result.encode = (_h = options === null || options === void 0 ? void 0 : options.encode) !== null && _h !== void 0 ? _h : defaultEncode;
+		result.decode = (_j = options === null || options === void 0 ? void 0 : options.decode) !== null && _j !== void 0 ? _j : defaultDecode;
+		result.beforeReconnect = this._reconnectAuth.bind(this);
+		if ((options === null || options === void 0 ? void 0 : options.logLevel) || (options === null || options === void 0 ? void 0 : options.log_level)) {
+			this.logLevel = options.logLevel || options.log_level;
+			result.params = Object.assign(Object.assign({}, result.params), { log_level: this.logLevel });
+		}
+		if (this.worker) {
+			if (typeof window !== "undefined" && !window.Worker) throw new Error("Web Worker is not supported");
+			this.workerUrl = options === null || options === void 0 ? void 0 : options.workerUrl;
+			result.autoSendHeartbeat = !this.worker;
+		}
+		return result;
+	}
+	/** @internal */
+	async _reconnectAuth() {
+		await this._waitForAuthIfNeeded();
+		if (!this.isConnected()) this.connect();
+	}
+};
+//#endregion
+//#region src/client.ts
+const createRealtimeSocket = (url, key) => {
+	return new RealtimeClient(`${url.replace(/\/$/, "")}/realtime/v1`, { params: { apikey: key } });
+};
+//#endregion
+//#region src/listen.types.ts
+const MENU_CHANGED_EVENT = "menu.changed";
+const AVAILABILITY_CHANGED_EVENT = "availability.changed";
+const ORDER_CHANGED_EVENT = "order.changed";
+const KIOSK_CONFIG_CHANGED_EVENT = "kiosk.config.changed";
+const KIOSK_COMMAND_EVENT = "kiosk.command";
+const CMS_CHANGED_EVENT = "cms.changed";
+const PAYMENTS_CHANGED_EVENT = "payments.changed";
+const FULFILLMENTS_CHANGED_EVENT = "fulfillments.changed";
+const REALTIME_REFRESH_MS = 27e4;
+//#endregion
+//#region src/scope.ts
+const ANY = "__ANY__";
+const fieldOverlaps = (published, listener) => {
+	if (!published || published === ANY) return true;
+	if (!listener || listener === ANY) return true;
+	return published === listener;
+};
+const menuScopeOverlaps = (published, listener = {}) => {
+	if (!fieldOverlaps(published.fulfillment_id, listener.fulfillment_id)) return false;
+	if (!fieldOverlaps(published.store_id, listener.store_id)) return false;
+	if (!fieldOverlaps(published.channel_id, listener.channel_id)) return false;
+	if (!fieldOverlaps(published.brand_id, listener.brand_id)) return false;
+	return true;
+};
+//#endregion
+//#region src/token.ts
+const fetchRealtimeToken = (scope = {}, options) => {
+	return storefrontJson(...[
+		"/api/storefront/v1/realtime/token",
+		{
+			method: "POST",
+			body: JSON.stringify(scope)
+		},
+		options
+	]);
+};
+//#endregion
+//#region src/listen.ts
+const SCOPE_KEYS = [
+	"fulfillment_id",
+	"store_id",
+	"channel_id",
+	"brand_id"
+];
+const isMenuChangedPayload = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const rec = value;
+	for (const key of SCOPE_KEYS) {
+		if (rec[key] === void 0) continue;
+		if (typeof rec[key] !== "string") return false;
+	}
+	return true;
+};
+const isWorkspaceChangedPayload = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const rec = value;
+	if (rec.merchant_id === void 0) return true;
+	return typeof rec.merchant_id === "string";
+};
+const bindWorkspaceEvent = (channel, event, handler) => {
+	if (!handler) return;
+	channel.on("broadcast", { event }, (msg) => {
+		const { payload } = msg;
+		if (!isWorkspaceChangedPayload(payload)) return;
+		handler(payload);
+	});
+};
+const bindStorefrontEvents = (socket, topic, options) => {
+	const { menuChanged, availabilityChanged } = options.on;
+	const { paymentsChanged, fulfillmentsChanged } = options.on;
+	if (!Object.values(options.on).some(Boolean)) return null;
+	const channel = socket.channel(topic, { config: { private: true } });
+	if (menuChanged) channel.on("broadcast", { event: MENU_CHANGED_EVENT }, (msg) => {
+		const { payload } = msg;
+		if (!isMenuChangedPayload(payload)) return;
+		if (!menuScopeOverlaps(payload, options.scope)) return;
+		menuChanged(payload);
+	});
+	bindWorkspaceEvent(channel, AVAILABILITY_CHANGED_EVENT, availabilityChanged);
+	bindWorkspaceEvent(channel, PAYMENTS_CHANGED_EVENT, paymentsChanged);
+	bindWorkspaceEvent(channel, FULFILLMENTS_CHANGED_EVENT, fulfillmentsChanged);
+	channel.subscribe((status, err) => {
+		if (status !== "CHANNEL_ERROR" && status !== "TIMED_OUT") return;
+		const detail = err instanceof Error ? err.message : status;
+		console.error("[realtime] subscribe failed", detail);
+	});
+	return channel;
+};
+const listen = (options, deps = {}) => {
+	const createClient = deps.createClient ?? createRealtimeSocket;
+	const setIntervalFn = deps.setIntervalFn ?? setInterval;
+	const clearIntervalFn = deps.clearIntervalFn ?? clearInterval;
+	let stopped = false;
+	let socket = null;
+	let channel = null;
+	let refreshId = null;
+	const http = {
+		baseUrl: options.baseUrl,
+		accessToken: options.accessToken,
+		fetchImpl: options.fetchImpl
+	};
+	const teardown = () => {
+		if (refreshId !== null) clearIntervalFn(refreshId);
+		refreshId = null;
+		channel?.unsubscribe();
+		channel = null;
+		socket?.disconnect();
+		socket = null;
+	};
+	const applyToken = async (existing) => {
+		const token = await fetchRealtimeToken(options.scope, http);
+		if (stopped) return null;
+		if (existing) {
+			await existing.setAuth(token.access_token);
+			return existing;
+		}
+		const next = createClient(token.url, token.key);
+		await next.setAuth(token.access_token);
+		if (stopped) {
+			next.disconnect();
+			return null;
+		}
+		next.connect();
+		if (stopped) {
+			next.disconnect();
+			return null;
+		}
+		channel = bindStorefrontEvents(next, token.topic, options);
+		return next;
+	};
+	const start = async () => {
+		socket = await applyToken();
+		if (stopped) {
+			teardown();
+			return;
+		}
+		if (!socket) return;
+		refreshId = setIntervalFn(() => {
+			if (!socket) return;
+			applyToken(socket).catch((error) => {
+				const message = error instanceof Error ? error.message : String(error);
+				console.error("[realtime] token refresh failed", message);
+			});
+		}, REALTIME_REFRESH_MS);
+		if (stopped) teardown();
+	};
+	start().catch((error) => {
+		if (stopped) return;
+		const message = error instanceof Error ? error.message : String(error);
+		console.error("[realtime] listen failed", message);
+	});
+	return () => {
+		stopped = true;
+		teardown();
+	};
+};
+//#endregion
+//#region src/listenKiosk.ts
+const isConfigPayload = (value) => {
+	if (!value || typeof value !== "object") return false;
+	return typeof value.device_uid === "string";
+};
+const COMMAND_TYPES = {
+	refresh_cache: true,
+	unlink: true,
+	reload: true,
+	check_ota: true
+};
+const isCommandPayload = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const rec = value;
+	if (typeof rec.type !== "string") return false;
+	if (!(rec.type in COMMAND_TYPES)) return false;
+	if (rec.device_uid === void 0) return true;
+	return typeof rec.device_uid === "string";
+};
+const isCmsPayload = (value) => {
+	if (!value || typeof value !== "object") return false;
+	return typeof value.name === "string";
+};
+const cmsBlockTopic = (workspaceTopic, name) => {
+	return `${workspaceTopic}:cms:${name}`;
+};
+const subscribeLogged = (channel) => {
+	channel.subscribe((status, err) => {
+		if (status !== "CHANNEL_ERROR" && status !== "TIMED_OUT") return;
+		const detail = err instanceof Error ? err.message : status;
+		console.error("[realtime] kiosk subscribe failed", detail);
+	});
+	return channel;
+};
+const bindCmsEvents = (socket, token, options) => {
+	const onCmsChanged = options.on.cmsChanged;
+	const names = [...new Set(options.cmsBlocks ?? [])];
+	if (!onCmsChanged) return [];
+	return names.map((name) => {
+		const topic = cmsBlockTopic(token.workspace_topic, name);
+		const channel = socket.channel(topic, { config: { private: true } });
+		channel.on("broadcast", { event: CMS_CHANGED_EVENT }, (msg) => {
+			const { payload } = msg;
+			if (!isCmsPayload(payload)) return;
+			onCmsChanged(payload);
+		});
+		return subscribeLogged(channel);
+	});
+};
+const bindKioskEvents = (socket, topic, options) => {
+	const onConfigChanged = options.on.configChanged;
+	const onCommand = options.on.command;
+	if (!onConfigChanged && !onCommand) return null;
+	const channel = socket.channel(topic, { config: { private: true } });
+	if (onConfigChanged) {
+		const event = KIOSK_CONFIG_CHANGED_EVENT;
+		channel.on("broadcast", { event }, (msg) => {
+			const { payload } = msg;
+			if (!isConfigPayload(payload)) return;
+			onConfigChanged(payload);
+		});
+	}
+	if (onCommand) channel.on("broadcast", { event: KIOSK_COMMAND_EVENT }, (msg) => {
+		const { payload } = msg;
+		if (!isCommandPayload(payload)) return;
+		onCommand(payload);
+	});
+	return subscribeLogged(channel);
+};
+const listenKiosk = (options, deps = {}) => {
+	const createClient = deps.createClient ?? createRealtimeSocket;
+	const setIntervalFn = deps.setIntervalFn ?? setInterval;
+	const clearIntervalFn = deps.clearIntervalFn ?? clearInterval;
+	let stopped = false;
+	let socket = null;
+	let channels = [];
+	let refreshId = null;
+	const teardown = () => {
+		if (refreshId !== null) clearIntervalFn(refreshId);
+		refreshId = null;
+		for (const channel of channels) channel.unsubscribe();
+		channels = [];
+		socket?.disconnect();
+		socket = null;
+	};
+	const applyToken = async (existing) => {
+		const token = await options.fetchToken();
+		if (stopped) return null;
+		if (existing) {
+			await existing.setAuth(token.access_token);
+			return existing;
+		}
+		const next = createClient(token.url, token.key);
+		await next.setAuth(token.access_token);
+		if (stopped) {
+			next.disconnect();
+			return null;
+		}
+		next.connect();
+		if (stopped) {
+			next.disconnect();
+			return null;
+		}
+		const deviceChannel = bindKioskEvents(next, token.topic, options);
+		const cmsChannels = bindCmsEvents(next, token, options);
+		channels = [...deviceChannel ? [deviceChannel] : [], ...cmsChannels];
+		return next;
+	};
+	const start = async () => {
+		socket = await applyToken();
+		if (stopped) {
+			teardown();
+			return;
+		}
+		if (!socket) return;
+		refreshId = setIntervalFn(() => {
+			if (!socket) return;
+			applyToken(socket).catch((error) => {
+				const message = error instanceof Error ? error.message : String(error);
+				console.error("[realtime] kiosk token refresh failed", message);
+			});
+		}, REALTIME_REFRESH_MS);
+		if (stopped) teardown();
+	};
+	start().catch((error) => {
+		if (stopped) return;
+		const message = error instanceof Error ? error.message : String(error);
+		console.error("[realtime] listenKiosk failed", message);
+	});
+	return () => {
+		stopped = true;
+		teardown();
+	};
+};
+//#endregion
+//#region src/listenOrder.ts
+const RUN_STATUSES = [
+	"PROCESSING",
+	"WAITING",
+	"SUCCESS",
+	"FAILED"
+];
+const isRunStatus = (value) => {
+	return RUN_STATUSES.some((status) => status === value);
+};
+const isOrderChangedPayload = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const rec = value;
+	if (typeof rec.order_id !== "string") return false;
+	if (typeof rec.order_fulfillment_id !== "string") return false;
+	if (typeof rec.checkout_state !== "string") return false;
+	return isRunStatus(rec.run_status);
+};
+const callbackFromNode = (node) => {
+	const run = node.data.callback_run;
+	if (!run) return null;
+	const ok = run.response !== void 0;
+	const b1 = {
+		node_id: node.id,
+		status: node.data.mappedStatus,
+		ok
+	};
+	const b2 = {
+		attempt: run.attempt,
+		errors: run.errors
+	};
+	const b3 = {
+		response: run.response,
+		started_at: run.started_at
+	};
+	const b4 = {
+		finished_at: run.finished_at,
+		duration_ms: run.duration_ms
+	};
+	return {
+		...b1,
+		...b2,
+		...b3,
+		...b4
+	};
+};
+const orderChangedFromFulfillment = (dto) => {
+	const current = dto.current_node_ids;
+	const current_states = dto.workflow.nodes.filter((node) => {
+		return current.includes(node.id);
+	}).map((node) => node.data.mappedStatus);
+	const callbacks = [];
+	for (const node of dto.workflow.nodes) {
+		const item = callbackFromNode(node);
+		if (item) callbacks.push(item);
+	}
+	const status = dto.fulfillment_status ?? current_states[0] ?? "";
+	const customer_id = dto.customer_id ?? "";
+	const payment_status = dto.payment_status ?? "";
+	const b1 = {
+		order_id: dto.order_id,
+		order_fulfillment_id: dto.id
+	};
+	const b2 = {
+		customer_id,
+		status
+	};
+	const b3 = {
+		payment_status,
+		current_states
+	};
+	const b4 = {
+		run_status: dto.status,
+		checkout_state: dto.checkout_state
+	};
+	const b5 = {
+		entered_node_ids: current,
+		callbacks,
+		error: dto.error
+	};
+	const b6 = { emitted_at: (/* @__PURE__ */ new Date()).toISOString() };
+	return {
+		...b1,
+		...b2,
+		...b3,
+		...b4,
+		...b5,
+		...b6
+	};
+};
+const listenOrder = (options, deps = {}) => {
+	const createClient = deps.createClient ?? createRealtimeSocket;
+	const setIntervalFn = deps.setIntervalFn ?? setInterval;
+	const clearIntervalFn = deps.clearIntervalFn ?? clearInterval;
+	let stopped = false;
+	let socket = null;
+	let channel = null;
+	let refreshId = null;
+	const http = {
+		baseUrl: options.baseUrl,
+		accessToken: options.accessToken,
+		fetchImpl: options.fetchImpl
+	};
+	const deliverSnapshot = async () => {
+		const dto = await services.orders.getFulfillment(options.orderId, http);
+		if (stopped) return;
+		options.on.changed(orderChangedFromFulfillment(dto));
+	};
+	const bindOrderEvents = (next, topic) => {
+		const ch = next.channel(topic, { config: { private: true } });
+		ch.on("broadcast", { event: ORDER_CHANGED_EVENT }, (msg) => {
+			const { payload } = msg;
+			if (!isOrderChangedPayload(payload)) return;
+			if (payload.order_id !== options.orderId) return;
+			options.on.changed(payload);
+		});
+		ch.subscribe((status, err) => {
+			if (status === "SUBSCRIBED") {
+				options.on.subscribed?.();
+				deliverSnapshot().catch((error) => {
+					if (isStorefrontNotFound(error)) return;
+					const raw = error instanceof Error ? error.message : String(error);
+					console.error("[realtime] order snapshot failed", raw);
+				});
+				return;
+			}
+			if (status !== "CHANNEL_ERROR" && status !== "TIMED_OUT") return;
+			const detail = err instanceof Error ? err.message : status;
+			console.error("[realtime] subscribe failed", detail);
+		});
+		return ch;
+	};
+	const teardown = () => {
+		if (refreshId !== null) clearIntervalFn(refreshId);
+		refreshId = null;
+		channel?.unsubscribe();
+		channel = null;
+		socket?.disconnect();
+		socket = null;
+	};
+	const applyToken = async (existing) => {
+		const token = await fetchRealtimeToken({}, http);
+		if (stopped) return null;
+		if (existing) {
+			await existing.setAuth(token.access_token);
+			return existing;
+		}
+		const next = createClient(token.url, token.key);
+		await next.setAuth(token.access_token);
+		if (stopped) {
+			next.disconnect();
+			return null;
+		}
+		next.connect();
+		if (stopped) {
+			next.disconnect();
+			return null;
+		}
+		const topic = token.customer_topic;
+		channel = bindOrderEvents(next, topic);
+		return next;
+	};
+	const start = async () => {
+		socket = await applyToken();
+		if (stopped) {
+			teardown();
+			return;
+		}
+		if (!socket) return;
+		refreshId = setIntervalFn(() => {
+			if (!socket) return;
+			applyToken(socket).catch((error) => {
+				const message = error instanceof Error ? error.message : String(error);
+				console.error("[realtime] token refresh failed", message);
+			});
+		}, REALTIME_REFRESH_MS);
+		if (stopped) teardown();
+	};
+	start().catch((error) => {
+		if (stopped) return;
+		const message = error instanceof Error ? error.message : String(error);
+		console.error("[realtime] listenOrder failed", message);
+	});
+	return () => {
+		stopped = true;
+		teardown();
+	};
+};
+//#endregion
+//#region src/index.ts
+const realtime = {
+	listen,
+	listenKiosk,
+	listenOrder
+};
+//#endregion
+export { AVAILABILITY_CHANGED_EVENT, CMS_CHANGED_EVENT, KIOSK_COMMAND_EVENT, KIOSK_CONFIG_CHANGED_EVENT, MENU_CHANGED_EVENT, ORDER_CHANGED_EVENT, listen, listenKiosk, listenOrder, realtime };