crossws 0.0.0 → 0.0.1

package/LICENSE

@@ -0,0 +1,46 @@
+MIT License
+
+Copyright (c) Pooya Parsa <pooya@pi0.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Bundled with https://github.com/websockets/ws
+
+Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+Copyright (c) 2013 Arnout Kazemier and contributors
+Copyright (c) 2016 Luigi Pinca and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# ⛨ CrossWS
+
+[![npm version][npm-version-src]][npm-version-href]
+[![bundle][bundle-src]][bundle-href]
+
+<!-- [![npm downloads][npm-downloads-src]][npm-downloads-href] -->
+
+<!-- [![Codecov][codecov-src]][codecov-href] -->
+
+> [!WARNING]
+> This project and API are under heavy development and trial. Please don't rely on it for production yet. Feedback is more than welcome!
+
+Cross-platform WebSocket Servers:
+
+- Elegant, typed, and simple interface to define your WebSocket server handlers
+- Performant per-server handlers instead of per-connection events API ([why](https://bun.sh/docs/api/websockets#lcYFjkFYJC-summary))
+- Zero dependencies with bundled [ws](https://github.com/websockets/ws) types and runtime for [Node.js](https://nodejs.org/) support
+- Native integration with [Bun](https://bun.sh/) and [Deno](https://deno.com/) WebSocket API
+- Super lightweight tree-shakable packaging
+- Developer-Friendly logging
+
+## Install
+
+```sh
+# npm
+npm install crossws
+
+# yarn
+yarn add crossws
+
+# pnpm
+pnpm install crossws
+
+# bun
+bun install crossws
+```
+
+## Integration
+
+CrossWS allows integrating your WebSocket handlers with different runtimes and platforms using built-in adapters. Each runtime has a specific method of integrating WebSocket. Once integrated, your custom handlers (such as `onMessage`) will work consistently even if you change the runtime!
+
+### Integration with **Node.js**
+
+To integrate CrossWS with your Node.js HTTP server, you need to connect the `upgrade` event to the `handleUpgrade` method returned from the adapter. Behind the scenes, CrossWS uses an embedded version of [ws](https://github.com/websockets/ws).
+
+```ts
+// Initialize Server
+import { createServer } from "node:http";
+
+const server = createServer((req, res) => {
+  res.end(
+    `<script>new WebSocket("ws://localhost:3000").addEventListener('open', (e) => e.target.send("Hello from client!"));</script>`,
+  );
+}).listen(3000);
+
+// Initialize WebSocket Handler
+import nodeWSAdapter from "crossws/adapters/node";
+
+const { handleUpgrade } = nodeWSAdapter({ onMessage: console.log });
+server.on("upgrade", handleUpgrade);
+```
+
+See [playground/node.ts](./playground/node.ts) for demo and [src/adapters/node.ts](./src/adapters/node.ts) for implementation.
+
+## Integration with **Bun**
+
+To integrate crosws with your Bun server, you need to check for `server.upgrade` and also pass the `websocket` object returned from the adapter to server options. CrossWS leverages native Bun WebSocket API.
+
+```ts
+import bunAdapter from "./dist/adapters/bun";
+
+const { websocket } = bunAdapter({ onMessage: console.log });
+
+Bun.serve({
+  port: 3000,
+  fetch(req, server) {
+    if (server.upgrade(req)) {
+      return;
+    }
+    return new Response(
+      `<script>new WebSocket("ws://localhost:3000").addEventListener('open', (e) => e.target.send("Hello from client!"));</script>`,
+      { headers: { "content-type": "text/html" } },
+    );
+  },
+  websocket,
+});
+```
+
+See [playground/bun.ts](./playground/bun.ts) for demo and [src/adapters/bun.ts](./src/adapters/bun.ts) for implementation.
+
+## Integration with **Deno**
+
+To integrate CrossWS with your Deno server, you need to check for the `upgrade` header and then call `handleUpgrade` method from the adapter passing the incoming request object. The returned value is the server upgrade response.
+
+```ts
+import denoAdapter from "crossws/adapters/deno";
+
+const { handleUpgrade } = denoAdapter({ onMessage: console.log });
+
+Deno.serve({ port: 3000 }, (req) => {
+  if (req.headers.get("upgrade") === "websocket") {
+    return handleUpgrade(req);
+  }
+  return new Response(
+    `<script>new WebSocket("ws://localhost:3000").addEventListener("open", (e) => e.target.send("Hello from client!"));</script>`,
+    { headers: { "content-type": "text/html" } },
+  );
+});
+```
+
+See [playground/deno.ts](./playground/deno.ts) for demo and [src/adapters/deno.ts](./src/adapters/deno.ts) for implementation.
+
+## Integration with other runtimes
+
+You can define your custom adapters using `defineWebSocketAdapter` wrapper.
+
+See other adapter implementations in [./src/adapters](./src/adapters/) to get and idea how adapters can be implemented and feel free to directly make a Pull Request to support your environment in CrossWS!
+
+## Handler API
+
+Previously you saw in the adapter examples that we pass `onMessage` option.
+
+First object passed to adapters is a list of global handlers that will get called during lifecycle of a WebSocket connection. You can use `defineWebSocketHandler` utility to make a typed websocket handler object and pass it to the actual adapter when needed.
+
+**Note: API is subject to change! Feedbacks Welcome!**
+
+```ts
+import { defineWebSocketHandler } from "crossws";
+
+const websocketHandler = defineWebSocketHandler({
+  onMessage: (peer, message) => {
+    console.log("message", peer, message);
+    if (message.text().includes("ping")) {
+      peer.send("pong");
+    }
+  },
+  onError: (peer, error) => {
+    console.log("error", peer, error);
+  },
+  onOpen: (peer) => {
+    console.log("open", peer);
+  },
+  onClose: (peer, code, reason) => {
+    console.log("close", peer, code, reason);
+  },
+  onEvent: (event, ...args) => {
+    console.log("event", event);
+  },
+});
+```
+
+### `WebSocketPeer`
+
+Websocket handler methods accept a peer instance as first argument. peer is a wrapper over platform natives WebSocket connection instance and alows to send message.
+
+**Tip:** You can safely log a peer instance to console using `console.log` it will be automatically stringified with useful information including remote address and connection status!
+
+### `WebSocketMessage`
+
+Second argument to `onMessage` event handler is a message object. You can access raw data using `message.rawData` or stringified message using `message.text()`.
+
+**Tip:** You can safely log `message` object to console using `console.log` it will be automatically stringified!
+
+## Development
+
+- Clone this repository
+- Install latest LTS version of [Node.js](https://nodejs.org/en/)
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
+- Install dependencies using `pnpm install`
+- Run interactive tests using `pnpm dev`
+
+## License
+
+Made with 💛
+
+Published under [MIT License](./LICENSE).
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/crossws?style=flat&colorA=18181B&colorB=F0DB4F
+[npm-version-href]: https://npmjs.com/package/crossws
+[npm-downloads-src]: https://img.shields.io/npm/dm/crossws?style=flat&colorA=18181B&colorB=F0DB4F
+[npm-downloads-href]: https://npmjs.com/package/crossws
+[codecov-src]: https://img.shields.io/codecov/c/gh/unjs/crossws/main?style=flat&colorA=18181B&colorB=F0DB4F
+[codecov-href]: https://codecov.io/gh/unjs/crossws
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/crossws?style=flat&colorA=18181B&colorB=F0DB4F
+[bundle-href]: https://bundlephobia.com/result?p=crossws

package/dist/adapters/bun.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const peer = require('../shared/crossws.002417e5.cjs');
+
+const WebSocket = globalThis.WebSocket;
+const bun = peer.defineWebSocketAdapter(
+  (handler, opts = {}) => {
+    return {
+      websocket: {
+        message: (ws, message) => {
+          handler.onEvent?.("bun:message", ws, message);
+          const peer$1 = new BunWebSocketPeer(ws);
+          handler.onMessage?.(peer$1, new peer.WebSocketMessage(message));
+        },
+        open: (ws) => {
+          handler.onEvent?.("bun:open", ws);
+          const peer = new BunWebSocketPeer(ws);
+          handler.onOpen?.(peer);
+        },
+        close: (ws) => {
+          handler.onEvent?.("bun:close", ws);
+          const peer = new BunWebSocketPeer(ws);
+          handler.onClose?.(peer, 0, "");
+        },
+        error: (ws, error) => {
+          handler.onEvent?.("bun:error", ws, error);
+          const peer$1 = new BunWebSocketPeer(ws);
+          handler.onError?.(peer$1, new peer.WebSocketError(error));
+        },
+        drain: (ws) => {
+          handler.onEvent?.("bun:drain", ws);
+        }
+      }
+    };
+  }
+);
+class BunWebSocketPeer extends peer.WebSocketPeer {
+  constructor(_ws) {
+    super();
+    this._ws = _ws;
+  }
+  get id() {
+    return this._ws.remoteAddress;
+  }
+  get readyState() {
+    return this._ws.readyState;
+  }
+  send(message) {
+    this._ws.send(message);
+    return 0;
+  }
+}
+
+exports.WebSocket = WebSocket;
+exports.default = bun;

package/dist/adapters/bun.d.cts

@@ -0,0 +1,43 @@
+import { WebSocketAdapter } from '../index.cjs';
+
+interface BunWSOptions {
+    message: (ws: BunServerWebSocket, message: string | ArrayBuffer | Uint8Array) => void;
+    open?: (ws: BunServerWebSocket) => void;
+    close?: (ws: BunServerWebSocket) => void;
+    error?: (ws: BunServerWebSocket, error: Error) => void;
+    drain?: (ws: BunServerWebSocket) => void;
+    perMessageDeflate?: boolean | {
+        compress?: boolean | BunWSCompressor;
+        decompress?: boolean | BunWSCompressor;
+    };
+}
+type BunWSCompressor = `"disable"` | `"shared"` | `"dedicated"` | `"3KB"` | `"4KB"` | `"8KB"` | `"16KB"` | `"32KB"` | `"64KB"` | `"128KB"` | `"256KB"`;
+interface BunServerWebSocket {
+    readonly data: any;
+    readonly readyState: number;
+    readonly remoteAddress: string;
+    send(message: string | ArrayBuffer | Uint8Array, compress?: boolean): number;
+    close(code?: number, reason?: string): void;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    publish(topic: string, message: string | ArrayBuffer | Uint8Array): void;
+    isSubscribed(topic: string): boolean;
+    cork(cb: (ws: BunServerWebSocket) => void): void;
+}
+
+declare const WebSocket: {
+    new (url: string | URL, protocols?: string | string[] | undefined): WebSocket;
+    prototype: WebSocket;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+};
+interface AdapterOptions {
+}
+interface Adapter {
+    websocket: BunWSOptions;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, WebSocket, _default as default };

package/dist/adapters/bun.d.mts

@@ -0,0 +1,43 @@
+import { WebSocketAdapter } from '../index.mjs';
+
+interface BunWSOptions {
+    message: (ws: BunServerWebSocket, message: string | ArrayBuffer | Uint8Array) => void;
+    open?: (ws: BunServerWebSocket) => void;
+    close?: (ws: BunServerWebSocket) => void;
+    error?: (ws: BunServerWebSocket, error: Error) => void;
+    drain?: (ws: BunServerWebSocket) => void;
+    perMessageDeflate?: boolean | {
+        compress?: boolean | BunWSCompressor;
+        decompress?: boolean | BunWSCompressor;
+    };
+}
+type BunWSCompressor = `"disable"` | `"shared"` | `"dedicated"` | `"3KB"` | `"4KB"` | `"8KB"` | `"16KB"` | `"32KB"` | `"64KB"` | `"128KB"` | `"256KB"`;
+interface BunServerWebSocket {
+    readonly data: any;
+    readonly readyState: number;
+    readonly remoteAddress: string;
+    send(message: string | ArrayBuffer | Uint8Array, compress?: boolean): number;
+    close(code?: number, reason?: string): void;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    publish(topic: string, message: string | ArrayBuffer | Uint8Array): void;
+    isSubscribed(topic: string): boolean;
+    cork(cb: (ws: BunServerWebSocket) => void): void;
+}
+
+declare const WebSocket: {
+    new (url: string | URL, protocols?: string | string[] | undefined): WebSocket;
+    prototype: WebSocket;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+};
+interface AdapterOptions {
+}
+interface Adapter {
+    websocket: BunWSOptions;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, WebSocket, _default as default };

package/dist/adapters/bun.d.ts

@@ -0,0 +1,43 @@
+import { WebSocketAdapter } from '../index.js';
+
+interface BunWSOptions {
+    message: (ws: BunServerWebSocket, message: string | ArrayBuffer | Uint8Array) => void;
+    open?: (ws: BunServerWebSocket) => void;
+    close?: (ws: BunServerWebSocket) => void;
+    error?: (ws: BunServerWebSocket, error: Error) => void;
+    drain?: (ws: BunServerWebSocket) => void;
+    perMessageDeflate?: boolean | {
+        compress?: boolean | BunWSCompressor;
+        decompress?: boolean | BunWSCompressor;
+    };
+}
+type BunWSCompressor = `"disable"` | `"shared"` | `"dedicated"` | `"3KB"` | `"4KB"` | `"8KB"` | `"16KB"` | `"32KB"` | `"64KB"` | `"128KB"` | `"256KB"`;
+interface BunServerWebSocket {
+    readonly data: any;
+    readonly readyState: number;
+    readonly remoteAddress: string;
+    send(message: string | ArrayBuffer | Uint8Array, compress?: boolean): number;
+    close(code?: number, reason?: string): void;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    publish(topic: string, message: string | ArrayBuffer | Uint8Array): void;
+    isSubscribed(topic: string): boolean;
+    cork(cb: (ws: BunServerWebSocket) => void): void;
+}
+
+declare const WebSocket: {
+    new (url: string | URL, protocols?: string | string[] | undefined): WebSocket;
+    prototype: WebSocket;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+};
+interface AdapterOptions {
+}
+interface Adapter {
+    websocket: BunWSOptions;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, WebSocket, _default as default };

package/dist/adapters/bun.mjs

@@ -0,0 +1,52 @@
+import { d as defineWebSocketAdapter, a as WebSocketMessage, W as WebSocketError, b as WebSocketPeer } from '../shared/crossws.08866fa6.mjs';
+
+const WebSocket = globalThis.WebSocket;
+const bun = defineWebSocketAdapter(
+  (handler, opts = {}) => {
+    return {
+      websocket: {
+        message: (ws, message) => {
+          handler.onEvent?.("bun:message", ws, message);
+          const peer = new BunWebSocketPeer(ws);
+          handler.onMessage?.(peer, new WebSocketMessage(message));
+        },
+        open: (ws) => {
+          handler.onEvent?.("bun:open", ws);
+          const peer = new BunWebSocketPeer(ws);
+          handler.onOpen?.(peer);
+        },
+        close: (ws) => {
+          handler.onEvent?.("bun:close", ws);
+          const peer = new BunWebSocketPeer(ws);
+          handler.onClose?.(peer, 0, "");
+        },
+        error: (ws, error) => {
+          handler.onEvent?.("bun:error", ws, error);
+          const peer = new BunWebSocketPeer(ws);
+          handler.onError?.(peer, new WebSocketError(error));
+        },
+        drain: (ws) => {
+          handler.onEvent?.("bun:drain", ws);
+        }
+      }
+    };
+  }
+);
+class BunWebSocketPeer extends WebSocketPeer {
+  constructor(_ws) {
+    super();
+    this._ws = _ws;
+  }
+  get id() {
+    return this._ws.remoteAddress;
+  }
+  get readyState() {
+    return this._ws.readyState;
+  }
+  send(message) {
+    this._ws.send(message);
+    return 0;
+  }
+}
+
+export { WebSocket, bun as default };

package/dist/adapters/deno.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const peer = require('../shared/crossws.002417e5.cjs');
+
+const WebSocket = globalThis.WebSocket;
+const deno = peer.defineWebSocketAdapter(
+  (handler, opts = {}) => {
+    const handleUpgrade = (req) => {
+      const upgrade = Deno.upgradeWebSocket(req);
+      upgrade.socket.addEventListener("open", () => {
+        handler.onEvent?.("deno:open", upgrade.socket);
+        const peer = new DenoWebSocketPeer(upgrade.socket);
+        handler.onOpen?.(peer);
+      });
+      upgrade.socket.addEventListener("message", (event) => {
+        handler.onEvent?.("deno:message", upgrade.socket, event);
+        const peer$1 = new DenoWebSocketPeer(upgrade.socket);
+        handler.onMessage?.(peer$1, new peer.WebSocketMessage(event.data));
+      });
+      upgrade.socket.addEventListener("close", () => {
+        handler.onEvent?.("deno:close", upgrade.socket);
+        const peer = new DenoWebSocketPeer(upgrade.socket);
+        handler.onClose?.(peer, 0, "");
+      });
+      upgrade.socket.addEventListener("error", (error) => {
+        handler.onEvent?.("deno:error", upgrade.socket, error);
+        const peer$1 = new DenoWebSocketPeer(upgrade.socket);
+        handler.onError?.(peer$1, new peer.WebSocketError(error));
+      });
+      return upgrade.response;
+    };
+    return {
+      handleUpgrade
+    };
+  }
+);
+class DenoWebSocketPeer extends peer.WebSocketPeer {
+  constructor(_ws) {
+    super();
+    this._ws = _ws;
+  }
+  get id() {
+    return this._ws.remoteAddress;
+  }
+  get readyState() {
+    return this._ws.readyState;
+  }
+  send(message) {
+    this._ws.send(message);
+    return 0;
+  }
+}
+
+exports.WebSocket = WebSocket;
+exports.default = deno;

package/dist/adapters/deno.d.cts

@@ -0,0 +1,18 @@
+import { WebSocketAdapter } from '../index.cjs';
+
+declare const WebSocket: {
+    new (url: string | URL, protocols?: string | string[] | undefined): WebSocket;
+    readonly prototype: WebSocket;
+    readonly CLOSED: number;
+    readonly CLOSING: number;
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+};
+interface AdapterOptions {
+}
+interface Adapter {
+    handleUpgrade(req: Deno.Request): Response;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, WebSocket, _default as default };

package/dist/adapters/deno.d.mts

@@ -0,0 +1,18 @@
+import { WebSocketAdapter } from '../index.mjs';
+
+declare const WebSocket: {
+    new (url: string | URL, protocols?: string | string[] | undefined): WebSocket;
+    readonly prototype: WebSocket;
+    readonly CLOSED: number;
+    readonly CLOSING: number;
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+};
+interface AdapterOptions {
+}
+interface Adapter {
+    handleUpgrade(req: Deno.Request): Response;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, WebSocket, _default as default };

package/dist/adapters/deno.d.ts

@@ -0,0 +1,18 @@
+import { WebSocketAdapter } from '../index.js';
+
+declare const WebSocket: {
+    new (url: string | URL, protocols?: string | string[] | undefined): WebSocket;
+    readonly prototype: WebSocket;
+    readonly CLOSED: number;
+    readonly CLOSING: number;
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+};
+interface AdapterOptions {
+}
+interface Adapter {
+    handleUpgrade(req: Deno.Request): Response;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, WebSocket, _default as default };

package/dist/adapters/deno.mjs

@@ -0,0 +1,52 @@
+import { d as defineWebSocketAdapter, a as WebSocketMessage, W as WebSocketError, b as WebSocketPeer } from '../shared/crossws.08866fa6.mjs';
+
+const WebSocket = globalThis.WebSocket;
+const deno = defineWebSocketAdapter(
+  (handler, opts = {}) => {
+    const handleUpgrade = (req) => {
+      const upgrade = Deno.upgradeWebSocket(req);
+      upgrade.socket.addEventListener("open", () => {
+        handler.onEvent?.("deno:open", upgrade.socket);
+        const peer = new DenoWebSocketPeer(upgrade.socket);
+        handler.onOpen?.(peer);
+      });
+      upgrade.socket.addEventListener("message", (event) => {
+        handler.onEvent?.("deno:message", upgrade.socket, event);
+        const peer = new DenoWebSocketPeer(upgrade.socket);
+        handler.onMessage?.(peer, new WebSocketMessage(event.data));
+      });
+      upgrade.socket.addEventListener("close", () => {
+        handler.onEvent?.("deno:close", upgrade.socket);
+        const peer = new DenoWebSocketPeer(upgrade.socket);
+        handler.onClose?.(peer, 0, "");
+      });
+      upgrade.socket.addEventListener("error", (error) => {
+        handler.onEvent?.("deno:error", upgrade.socket, error);
+        const peer = new DenoWebSocketPeer(upgrade.socket);
+        handler.onError?.(peer, new WebSocketError(error));
+      });
+      return upgrade.response;
+    };
+    return {
+      handleUpgrade
+    };
+  }
+);
+class DenoWebSocketPeer extends WebSocketPeer {
+  constructor(_ws) {
+    super();
+    this._ws = _ws;
+  }
+  get id() {
+    return this._ws.remoteAddress;
+  }
+  get readyState() {
+    return this._ws.readyState;
+  }
+  send(message) {
+    this._ws.send(message);
+    return 0;
+  }
+}
+
+export { WebSocket, deno as default };