crossws 0.4.4 → 0.4.5

package/dist/_chunks/node.d.mts

@@ -1,4 +1,4 @@
-import { n as AdapterInstance, r as AdapterOptions, t as Adapter } from "./adapter.mjs";
+import { a as Hooks, n as AdapterInstance, r as AdapterOptions, t as Adapter } from "./adapter.mjs";
 import { EventEmitter } from "events";
 import { Agent, ClientRequest, ClientRequestArgs, IncomingMessage, OutgoingHttpHeaders, Server } from "node:http";
 import { Duplex, DuplexOptions } from "node:stream";
@@ -6,8 +6,6 @@ import { Server as Server$1 } from "node:https";
 import { SecureContextOptions } from "node:tls";
 import { URL } from "node:url";
 import { ZlibOptions } from "node:zlib";
-
-//#region types/ws.d.ts
 type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly any[] | readonly number[] | {
   valueOf(): ArrayBuffer;
 } | {
@@ -284,8 +282,40 @@ declare class Server$2<T extends typeof WebSocket = typeof WebSocket, U extends
 }
 type WebSocketServer = Server$2;
 declare function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
-//#endregion
-//#region src/adapters/node.d.ts
+/**
+ * A Node.js `(req, socket, head)` upgrade handler.
+ */
+type NodeUpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => void | Promise<void>;
+/**
+ * Wrap a Node.js `(req, socket, head)` upgrade handler as a {@link Hooks}
+ * object that can be mounted via `crossws/server/node`.
+ *
+ * The wrapped handler takes ownership of the socket; crossws's other
+ * lifecycle hooks (`open`/`message`/`close`/`error`) are **not** invoked
+ * for connections routed through it.
+ *
+ * @example
+ * ```ts
+ * import { WebSocketServer } from "ws";
+ * import { fromNodeUpgradeHandler } from "crossws/adapters/node";
+ * import { serve } from "crossws/server/node";
+ *
+ * const wss = new WebSocketServer({ noServer: true });
+ * wss.on("connection", (ws) => {
+ *   ws.on("message", (data) => ws.send(data));
+ * });
+ *
+ * serve({
+ *   websocket: fromNodeUpgradeHandler((req, socket, head) => {
+ *     wss.handleUpgrade(req, socket, head, (ws) => {
+ *       wss.emit("connection", ws, req);
+ *     });
+ *   }),
+ *   fetch: () => new Response("ok"),
+ * });
+ * ```
+ */
+declare function fromNodeUpgradeHandler(handler: NodeUpgradeHandler): Partial<Hooks>;
 interface NodeAdapter extends AdapterInstance {
   handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer, webRequest?: Request): Promise<void>;
   closeAll: (code?: number, data?: string | Buffer, force?: boolean) => void;
@@ -295,5 +325,4 @@ interface NodeOptions extends AdapterOptions {
   serverOptions?: ServerOptions;
 }
 declare const nodeAdapter: Adapter<NodeAdapter, NodeOptions>;
-//#endregion
-export { NodeOptions as n, nodeAdapter as r, NodeAdapter as t };
+export { fromNodeUpgradeHandler as a, NodeUpgradeHandler as i, NodeOptions as n, nodeAdapter as r, NodeAdapter as t };

package/dist/_chunks/node.mjs

@@ -0,0 +1,129 @@
+import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "./adapter.mjs";
+import { n as import_websocket_server } from "./libs/ws.mjs";
+import { n as Message, r as toBufferLike, t as Peer } from "./peer.mjs";
+import { t as WSError } from "./error.mjs";
+import { t as StubRequest } from "./_request.mjs";
+function fromNodeUpgradeHandler(handler) {
+	return { async upgrade(request) {
+		const node = request.runtime?.node;
+		if (!node?.upgrade) throw new Error("[crossws] `fromNodeUpgradeHandler` must be mounted via `crossws/server/node`.");
+		await handler(node.req, node.upgrade.socket, node.upgrade.head);
+		return { handled: true };
+	} };
+}
+const nodeAdapter = (options = {}) => {
+	if ("Deno" in globalThis || "Bun" in globalThis) throw new Error("[crossws] Using Node.js adapter in an incompatible environment.");
+	const hooks = new AdapterHookable(options);
+	const globalPeers = /* @__PURE__ */ new Map();
+	const wss = options.wss || new import_websocket_server.default({
+		noServer: true,
+		handleProtocols: () => false,
+		...options.serverOptions
+	});
+	wss.on("connection", (ws, nodeReq) => {
+		const request = new NodeReqProxy(nodeReq);
+		const peers = getPeers(globalPeers, nodeReq._namespace);
+		const peer = new NodePeer({
+			ws,
+			request,
+			peers,
+			nodeReq,
+			namespace: nodeReq._namespace
+		});
+		peers.add(peer);
+		hooks.callHook("open", peer);
+		ws.on("message", (data, isBinary) => {
+			if (Array.isArray(data)) data = Buffer.concat(data);
+			if (!isBinary && Buffer.isBuffer(data)) data = data.toString("utf8");
+			hooks.callHook("message", peer, new Message(data, peer));
+		});
+		ws.on("error", (error) => {
+			peers.delete(peer);
+			hooks.callHook("error", peer, new WSError(error));
+		});
+		ws.on("close", (code, reason) => {
+			peers.delete(peer);
+			hooks.callHook("close", peer, {
+				code,
+				reason: reason?.toString()
+			});
+		});
+	});
+	wss.on("headers", (outgoingHeaders, req) => {
+		const upgradeHeaders = req._upgradeHeaders;
+		if (upgradeHeaders) for (const [key, value] of new Headers(upgradeHeaders)) outgoingHeaders.push(`${key}: ${value}`);
+	});
+	return {
+		...adapterUtils(globalPeers),
+		handleUpgrade: async (nodeReq, socket, head, webRequest) => {
+			const request = webRequest || new NodeReqProxy(nodeReq);
+			const { upgradeHeaders, endResponse, handled, context, namespace } = await hooks.upgrade(request);
+			if (endResponse) return sendResponse(socket, endResponse);
+			if (handled) return;
+			nodeReq._request = request;
+			nodeReq._upgradeHeaders = upgradeHeaders;
+			nodeReq._context = context;
+			nodeReq._namespace = namespace;
+			wss.handleUpgrade(nodeReq, socket, head, (ws) => {
+				wss.emit("connection", ws, nodeReq);
+			});
+		},
+		closeAll: (code, data, force) => {
+			for (const client of wss.clients) if (force) client.terminate();
+			else client.close(code, data);
+		}
+	};
+};
+var NodePeer = class extends Peer {
+	get remoteAddress() {
+		return this._internal.nodeReq.socket?.remoteAddress;
+	}
+	get context() {
+		return this._internal.nodeReq._context;
+	}
+	send(data, options) {
+		const dataBuff = toBufferLike(data);
+		const isBinary = typeof dataBuff !== "string";
+		this._internal.ws.send(dataBuff, {
+			compress: options?.compress,
+			binary: isBinary,
+			...options
+		});
+		return 0;
+	}
+	publish(topic, data, options) {
+		const dataBuff = toBufferLike(data);
+		const isBinary = typeof data !== "string";
+		const sendOptions = {
+			compress: options?.compress,
+			binary: isBinary,
+			...options
+		};
+		for (const peer of this._internal.peers) if (peer !== this && peer._topics.has(topic)) peer._internal.ws.send(dataBuff, sendOptions);
+	}
+	close(code, data) {
+		this._internal.ws.close(code, data);
+	}
+	terminate() {
+		this._internal.ws.terminate();
+	}
+};
+var NodeReqProxy = class extends StubRequest {
+	constructor(req) {
+		const host = req.headers["host"] || "localhost";
+		const url = `${req.socket?.encrypted ?? req.headers["x-forwarded-proto"] === "https" ? "https" : "http"}://${host}${req.url}`;
+		super(url, { headers: req.headers });
+	}
+};
+async function sendResponse(socket, res) {
+	const head = [`HTTP/1.1 ${res.status || 200} ${res.statusText || ""}`, ...[...res.headers.entries()].map(([key, value]) => `${key}: ${value}`)];
+	socket.write(head.join("\r\n") + "\r\n\r\n");
+	if (res.body) for await (const chunk of res.body) socket.write(chunk);
+	return new Promise((resolve) => {
+		socket.end(() => {
+			socket.destroy();
+			resolve();
+		});
+	});
+}
+export { fromNodeUpgradeHandler as n, nodeAdapter as t };

package/dist/_chunks/peer.mjs

@@ -1,4 +1,3 @@
-//#region src/utils.ts
 const kNodeInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 function toBufferLike(val) {
 	if (val === void 0 || val === null) return "";
@@ -24,15 +23,9 @@ function isPlainObject(value) {
 	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
 	return true;
 }
-
-//#endregion
-//#region src/message.ts
 var Message = class {
-	/** Access to the original [message event](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/message_event) if available. */
 	event;
-	/** Access to the Peer that emitted the message. */
 	peer;
-	/** Raw message data (can be of any type). */
 	rawData;
 	#id;
 	#uint8Array;
@@ -45,18 +38,10 @@ var Message = class {
 		this.peer = peer;
 		this.event = event;
 	}
-	/**
-	* Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the message.
-	*/
 	get id() {
 		if (!this.#id) this.#id = crypto.randomUUID();
 		return this.#id;
 	}
-	/**
-	* Get data as [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) value.
-	*
-	* If raw data is in any other format or string, it will be automatically converted and encoded.
-	*/
 	uint8Array() {
 		const _uint8Array = this.#uint8Array;
 		if (_uint8Array) return _uint8Array;
@@ -75,11 +60,6 @@ var Message = class {
 		if (rawData instanceof DataView) return this.#uint8Array = new Uint8Array(rawData.buffer, rawData.byteOffset, rawData.byteLength);
 		throw new TypeError(`Unsupported message type: ${Object.prototype.toString.call(rawData)}`);
 	}
-	/**
-	* Get data as [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) or [SharedArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) value.
-	*
-	* If raw data is in any other format or string, it will be automatically converted and encoded.
-	*/
 	arrayBuffer() {
 		const _arrayBuffer = this.#arrayBuffer;
 		if (_arrayBuffer) return _arrayBuffer;
@@ -87,10 +67,6 @@ var Message = class {
 		if (rawData instanceof ArrayBuffer || rawData instanceof SharedArrayBuffer) return this.#arrayBuffer = rawData;
 		return this.#arrayBuffer = this.uint8Array().buffer;
 	}
-	/**
-	* Get data as [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) value.
-	*
-	* If raw data is in any other format or string, it will be automatically converted and encoded. */
 	blob() {
 		const _blob = this.#blob;
 		if (_blob) return _blob;
@@ -98,11 +74,6 @@ var Message = class {
 		if (rawData instanceof Blob) return this.#blob = rawData;
 		return this.#blob = new Blob([this.uint8Array()]);
 	}
-	/**
-	* Get stringified text version of the message.
-	*
-	* If raw data is in any other format, it will be automatically converted and decoded.
-	*/
 	text() {
 		const _text = this.#text;
 		if (_text) return _text;
@@ -110,17 +81,11 @@ var Message = class {
 		if (typeof rawData === "string") return this.#text = rawData;
 		return this.#text = new TextDecoder().decode(this.uint8Array());
 	}
-	/**
-	* Get parsed version of the message text with [`JSON.parse()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse).
-	*/
 	json() {
 		const _json = this.#json;
 		if (_json) return _json;
 		return this.#json = JSON.parse(this.text());
 	}
-	/**
-	* Message data (value varies based on `peer.websocket.binaryType`).
-	*/
 	get data() {
 		switch (this.peer?.websocket?.binaryType) {
 			case "arraybuffer": return this.arrayBuffer();
@@ -145,9 +110,6 @@ var Message = class {
 		} };
 	}
 };
-
-//#endregion
-//#region src/peer.ts
 var Peer = class {
 	_internal;
 	_topics;
@@ -163,27 +125,14 @@ var Peer = class {
 	get namespace() {
 		return this._internal.namespace;
 	}
-	/**
-	* Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the peer.
-	*/
 	get id() {
 		if (!this._id) this._id = crypto.randomUUID();
 		return this._id;
 	}
-	/** IP address of the peer */
 	get remoteAddress() {}
-	/** upgrade request */
 	get request() {
 		return this._internal.request;
 	}
-	/**
-	* Get the [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) instance.
-	*
-	* **Note:** crossws adds polyfill for the following properties if native values are not available:
-	* - `protocol`: Extracted from the `sec-websocket-protocol` header.
-	* - `extensions`: Extracted from the `sec-websocket-extensions` header.
-	* - `url`: Extracted from the request URL (http -> ws).
-	* */
 	get websocket() {
 		if (!this.#ws) {
 			const _ws = this._internal.ws;
@@ -192,23 +141,18 @@ var Peer = class {
 		}
 		return this.#ws;
 	}
-	/** All connected peers to the server */
 	get peers() {
 		return this._internal.peers || /* @__PURE__ */ new Set();
 	}
-	/** All topics, this peer has been subscribed to. */
 	get topics() {
 		return this._topics;
 	}
-	/** Abruptly close the connection */
 	terminate() {
 		this.close();
 	}
-	/** Subscribe to a topic */
 	subscribe(topic) {
 		this._topics.add(topic);
 	}
-	/** Unsubscribe from a topic */
 	unsubscribe(topic) {
 		this._topics.delete(topic);
 	}
@@ -239,6 +183,4 @@ function createWsProxy(ws, request) {
 		return value;
 	} });
 }
-
-//#endregion
-export { toString as i, Message as n, toBufferLike as r, Peer as t };
+export { toString as i, Message as n, toBufferLike as r, Peer as t };

package/dist/_chunks/rolldown-runtime.mjs

@@ -1,6 +1,4 @@
 import { createRequire } from "node:module";
-
-//#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -9,16 +7,12 @@ var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
 	}
 	return to;
 };
@@ -27,6 +21,4 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-//#endregion
-export { __require as n, __toESM as r, __commonJSMin as t };
+export { __require as n, __toESM as r, __commonJSMin as t };

package/dist/_chunks/sse.d.mts

@@ -1,6 +1,4 @@
 import { n as AdapterInstance, r as AdapterOptions, t as Adapter } from "./adapter.mjs";
-
-//#region src/adapters/sse.d.ts
 interface SSEAdapter extends AdapterInstance {
   fetch(req: Request): Promise<Response>;
 }
@@ -8,5 +6,4 @@ interface SSEOptions extends AdapterOptions {
   bidir?: boolean;
 }
 declare const sseAdapter: Adapter<SSEAdapter, SSEOptions>;
-//#endregion
 export { SSEOptions as n, sseAdapter as r, SSEAdapter as t };

package/dist/_chunks/web.d.mts

@@ -1,4 +1,3 @@
-//#region types/web.d.ts
 /**
  * A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute.
  *
@@ -294,5 +293,4 @@ interface WebSocket extends EventTarget {
   removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
   removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
-//#endregion
 export { WebSocket as a, MessageEvent as i, Event as n, EventTarget as r, CloseEvent as t };

package/dist/adapters/bun.mjs

@@ -1,7 +1,5 @@
 import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "../_chunks/adapter.mjs";
 import { n as Message, r as toBufferLike, t as Peer } from "../_chunks/peer.mjs";
-
-//#region src/adapters/bun.ts
 const bunAdapter = (options = {}) => {
 	if (typeof Bun === "undefined") throw new Error("[crossws] Using Bun adapter in an incompatible environment.");
 	const hooks = new AdapterHookable(options);
@@ -44,7 +42,6 @@ const bunAdapter = (options = {}) => {
 		}
 	};
 };
-var bun_default = bunAdapter;
 function getPeer(ws, peers) {
 	if (ws.data.peer) return ws.data.peer;
 	const peer = new BunPeer({
@@ -84,6 +81,4 @@ var BunPeer = class extends Peer {
 		this._internal.ws.terminate();
 	}
 };
-
-//#endregion
-export { bun_default as default };
+export { bunAdapter as default };

package/dist/adapters/bunny.d.mts

@@ -0,0 +1,2 @@
+import { n as BunnyOptions, r as bunnyAdapter, t as BunnyAdapter } from "../_chunks/bunny.mjs";
+export { BunnyAdapter, BunnyOptions, bunnyAdapter as default };

package/dist/adapters/bunny.mjs

@@ -0,0 +1,68 @@
+import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "../_chunks/adapter.mjs";
+import { n as Message, r as toBufferLike, t as Peer } from "../_chunks/peer.mjs";
+import { t as WSError } from "../_chunks/error.mjs";
+const bunnyAdapter = (options = {}) => {
+	const hooks = new AdapterHookable(options);
+	const globalPeers = /* @__PURE__ */ new Map();
+	return {
+		...adapterUtils(globalPeers),
+		handleUpgrade: async (request) => {
+			if (!request.upgradeWebSocket || typeof request.upgradeWebSocket !== "function") throw new Error("[crossws] Bunny adapter requires the request to have an upgradeWebSocket method.");
+			const { endResponse, context, namespace, upgradeHeaders } = await hooks.upgrade(request);
+			if (endResponse) return endResponse;
+			const negotiatedProtocol = (upgradeHeaders instanceof Headers ? upgradeHeaders : new Headers(upgradeHeaders)).get("sec-websocket-protocol") ?? options.protocol;
+			const upgradeOptions = {};
+			if (negotiatedProtocol) upgradeOptions.protocol = negotiatedProtocol;
+			if (options.idleTimeout !== void 0) upgradeOptions.idleTimeout = options.idleTimeout;
+			const { response, socket } = request.upgradeWebSocket(Object.keys(upgradeOptions).length > 0 ? upgradeOptions : void 0);
+			const remoteAddress = request.headers.get("x-real-ip") || void 0;
+			const peers = getPeers(globalPeers, namespace);
+			const peer = new BunnyPeer({
+				ws: socket,
+				request,
+				namespace,
+				remoteAddress,
+				peers,
+				context
+			});
+			peers.add(peer);
+			socket.addEventListener("open", () => {
+				hooks.callHook("open", peer);
+			});
+			socket.addEventListener("message", (event) => {
+				hooks.callHook("message", peer, new Message(event.data, peer, event));
+			});
+			socket.addEventListener("close", (event) => {
+				peers.delete(peer);
+				hooks.callHook("close", peer, {
+					code: event.code,
+					reason: event.reason
+				});
+			});
+			socket.addEventListener("error", (error) => {
+				peers.delete(peer);
+				hooks.callHook("error", peer, new WSError(error));
+			});
+			return response;
+		}
+	};
+};
+var BunnyPeer = class extends Peer {
+	get remoteAddress() {
+		return this._internal.remoteAddress;
+	}
+	send(data) {
+		return this._internal.ws.send(toBufferLike(data));
+	}
+	publish(topic, data) {
+		const dataBuff = toBufferLike(data);
+		for (const peer of this._internal.peers) if (peer !== this && peer._topics.has(topic)) peer._internal.ws.send(dataBuff);
+	}
+	close(code, reason) {
+		this._internal.ws.close(code, reason);
+	}
+	terminate() {
+		this._internal.ws.close();
+	}
+};
+export { bunnyAdapter as default };

package/dist/adapters/cloudflare.mjs

@@ -1,16 +1,14 @@
 import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "../_chunks/adapter.mjs";
 import { n as Message, r as toBufferLike, t as Peer } from "../_chunks/peer.mjs";
-import { t as StubRequest } from "../_chunks/_request.mjs";
 import { t as WSError } from "../_chunks/error.mjs";
-import { env as env$1 } from "cloudflare:workers";
-
-//#region src/adapters/cloudflare.ts
+import { t as StubRequest } from "../_chunks/_request.mjs";
+import { env } from "cloudflare:workers";
 const cloudflareAdapter = (opts = {}) => {
 	const hooks = new AdapterHookable(opts);
 	const globalPeers = /* @__PURE__ */ new Map();
-	const resolveDurableStub = opts.resolveDurableStub || ((_req, env, _context) => {
+	const resolveDurableStub = opts.resolveDurableStub || ((_req, env$1, _context) => {
 		const bindingName = opts.bindingName || "$DurableObject";
-		const binding = (env || env$1)[bindingName];
+		const binding = (env$1 || env)[bindingName];
 		if (binding) {
 			const instanceId = binding.idFromName(opts.instanceName || "crossws");
 			return binding.get(instanceId);
@@ -59,7 +57,7 @@ const cloudflareAdapter = (opts = {}) => {
 				headers: upgradeHeaders
 			});
 		},
-		handleDurableInit: async (obj, state, env) => {},
+		handleDurableInit: async (_obj, _state, _env) => {},
 		handleDurableUpgrade: async (obj, request) => {
 			const { upgradeHeaders, endResponse, namespace } = await hooks.upgrade(request);
 			if (endResponse) return endResponse;
@@ -95,7 +93,7 @@ const cloudflareAdapter = (opts = {}) => {
 			return durablePublish(topic, data, opts);
 		},
 		publish: async (topic, data, opts) => {
-			const stub = await resolveDurableStub(void 0, env$1, void 0);
+			const stub = await resolveDurableStub(void 0, env, void 0);
 			if (!stub) throw new Error("[crossws] Durable Object binding cannot be resolved.");
 			try {
 				return await stub.webSocketPublish(topic, data, opts);
@@ -106,7 +104,6 @@ const cloudflareAdapter = (opts = {}) => {
 		}
 	};
 };
-var cloudflare_default = cloudflareAdapter;
 var CloudflareDurablePeer = class CloudflareDurablePeer extends Peer {
 	get peers() {
 		return new Set(this.#getwebsockets().map((ws) => CloudflareDurablePeer._restore(this._internal.durable, ws)));
@@ -176,6 +173,4 @@ function setAttachedState(ws, state) {
 	ws._crosswsState = state;
 	ws.serializeAttachment(state);
 }
-
-//#endregion
-export { cloudflare_default as default };
+export { cloudflareAdapter as default };

package/dist/adapters/deno.mjs

@@ -1,8 +1,6 @@
 import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "../_chunks/adapter.mjs";
 import { n as Message, r as toBufferLike, t as Peer } from "../_chunks/peer.mjs";
 import { t as WSError } from "../_chunks/error.mjs";
-
-//#region src/adapters/deno.ts
 const denoAdapter = (options = {}) => {
 	if (typeof Deno === "undefined") throw new Error("[crossws] Using Deno adapter in an incompatible environment.");
 	const hooks = new AdapterHookable(options);
@@ -45,7 +43,6 @@ const denoAdapter = (options = {}) => {
 		}
 	};
 };
-var deno_default = denoAdapter;
 var DenoPeer = class extends Peer {
 	get remoteAddress() {
 		return this._internal.denoInfo.remoteAddr?.hostname;
@@ -64,6 +61,4 @@ var DenoPeer = class extends Peer {
 		this._internal.ws.terminate();
 	}
 };
-
-//#endregion
-export { deno_default as default };
+export { denoAdapter as default };

package/dist/adapters/node.d.mts

@@ -1,2 +1,2 @@
-import { n as NodeOptions, r as nodeAdapter, t as NodeAdapter } from "../_chunks/node.mjs";
-export { NodeAdapter, NodeOptions, nodeAdapter as default };
+import { a as fromNodeUpgradeHandler, i as NodeUpgradeHandler, n as NodeOptions, r as nodeAdapter, t as NodeAdapter } from "../_chunks/node.mjs";
+export { NodeAdapter, NodeOptions, NodeUpgradeHandler, nodeAdapter as default, fromNodeUpgradeHandler };