crossws 0.0.0 → 0.1.0

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,286 @@
+# ⛨ 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] -->
+
+👉 Elegant, typed, and simple interface to implement platform-agnostic WebSocket servers
+
+🧩 Seamlessly integrates with, [Node.js](https://nodejs.org/en), [Bun](https://bun.sh/), [Deno](https://deno.com/) and [Cloudflare Workers](https://workers.cloudflare.com/)!
+
+🚀 High-performance server hooks, avoiding heavy per-connection events API ([why](https://bun.sh/docs/api/websockets#lcYFjkFYJC-summary))
+
+📦 No external dependencies, includes [ws](https://github.com/websockets/ws) for Node.js support
+
+💡 Extremely lightweight and tree-shakable packaging with ESM and CJS support
+
+🔍 Developer-friendly object logging
+
+> [!WARNING]
+> This project and API are under development.
+
+## Install
+
+```sh
+# npm
+npm install crossws
+
+# yarn
+yarn add crossws
+
+# pnpm
+pnpm install crossws
+
+# bun
+bun install crossws
+```
+
+## Unified Hooks
+
+CrossWS provides a cross-platform API to define WebSocket servers. An implementation with these hooks works across runtimes without needing you to go into details of any of them (while you always have the power to control low-level hooks). You can only define the life-cycle hooks that you only need and only those will be called run runtime.
+
+> [!NOTE]
+> For type support and IDE auto-completion, you can use `defineWebSocketHooks` utility or `WebSocketHooks` type export from the main.
+
+```ts
+import { defineWebSocketHooks } from "crossws";
+
+const websocketHooks = defineWebSocketHooks({
+  open(peer) {
+    console.log("[ws] open", peer);
+  },
+
+  message(peer, message) {
+    console.log("[ws] message", peer, message);
+    if (message.text().includes("ping")) {
+      peer.send("pong");
+    }
+  },
+
+  close(peer, event) {
+    console.log("[ws] close", peer, event);
+  },
+
+  error(peer, error) {
+    console.log("[ws] error", peer, error);
+  },
+
+  // ... platform hooks such as bun:drain ...
+});
+```
+
+### Peer Object
+
+Websocket hooks always accept a peer instance as the first argument. `peer`, keeps the state of the connected client.
+
+**Properties:**
+
+- `peer.id?`: The peer address or unique id (might be `undefined`)
+- `peer.readyState`: The connection status ([MDN](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/readyState))
+- `peer.ctx[name]`: Keeps the state of native client connection
+
+**Methods:**
+
+- `send(message, compress)`: Send a message to the connected client
+
+> [!TIP]
+> You can safely log a peer instance to the console using `console.log` it will be automatically stringified with useful information including the remote address and connection status!
+
+### Message Object
+
+on `message` hook, you receive a message object containing an incoming message from the client.
+
+**Properties:**
+
+- `message.rawData`: Raw message data
+- `message.isBinary`: Indicates if the message is binary (might be `undefined`)
+
+**Methods:**
+
+- `message.text()`: Get stringified version of the message
+
+> [!TIP]
+> You can safely log `message` object to the console using `console.log` it will be automatically stringified!
+
+## Error handling
+
+You can catch errors using `error` hook. The second argument is error wrapped into a `WebSocketError` class.
+
+## Universal WebSocket client
+
+CrossWS also exposes a universal way to use [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) API in order to connect to the server. For all runtimes, except Node.js, native implementation is used, and for Node.js, a bundled version of [`ws.WebSocket`](https://www.npmjs.com/package/ws) is bundled.
+
+```js
+import WebSocket from "crossws/websocket";
+```
+
+> [!NOTE]
+> Using export conditions, the correct version will be always used so you don't have to worry about picking the right build!
+
+## Integrations
+
+CrossWS allows integrating your WebSocket hooks with different runtimes and platforms using built-in adapters. Each runtime has a specific method of integrating WebSocket. Once integrated, your custom hooks (such as `message` and `close`) 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 Hooks
+import nodeWSAdapter from "crossws/adapters/node";
+
+const { handleUpgrade } = nodeWSAdapter({ message: console.log });
+server.on("upgrade", handleUpgrade);
+```
+
+**Node-specific hooks:**
+
+- `node:open (peer)`
+- `node:message (peer, data, isBinary)`
+- `node:close (peer, code, reason)`
+- `node:error (peer, error)`
+- `node:ping (peer)`
+- `node:pong (peer)`
+- `node:unexpected-response (peer, req, res)`
+- `node:upgrade (peer, req)`
+
+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 CrossWS 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({ message: console.log });
+
+Bun.serve({
+  port: 3000,
+  websocket,
+  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" } },
+    );
+  },
+});
+```
+
+**Bun-specific hooks:**
+
+- `bun:message (peer, ws,message)`
+- `bun:open (peer, ws)`
+- `bun:close (peer, ws)`
+- `bun:drain (peer)`
+- `bun:error (peer, ws, error)`
+- `bun:ping (peer, ws, data)`
+- `bun:pong (peer, ws, data)`
+
+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({ message: 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" } },
+  );
+});
+```
+
+**Deno-specific hooks:**
+
+- `deno:open (peer)`
+- `deno:message (peer, event)`
+- `deno:close (peer)`
+- `deno:error (peer, error)`
+
+See [playground/deno.ts](./playground/deno.ts) for demo and [src/adapters/deno.ts](./src/adapters/deno.ts) for implementation.
+
+### Integration with **Cloudflare Workers**
+
+To integrate CrossWS with your Cloudflare Workers, you need to check for the `upgrade` header
+
+```ts
+import cloudflareAdapter from "crossws/adapters/cloudflare";
+
+const { handleUpgrade } = cloudflareAdapter({ message: console.log });
+
+export default {
+  async fetch(request, env, context) {
+    if (request.headers.get("upgrade") === "websocket") {
+      return handleUpgrade(request, env, context);
+    }
+    return new Response(
+      `<script>new WebSocket("ws://localhost:3000").addEventListener("open", (e) => e.target.send("Hello from client!"));</script>`,
+      { headers: { "content-type": "text/html" } },
+    );
+  },
+};
+```
+
+**Cloudflare-specific hooks:**
+
+- `cloudflare:accept(peer)`
+- `cloudflare:message(peer, event)`
+- `cloudflare:error(peer, event)`
+- `cloudflare:close(peer, event)`
+
+See [playground/cloudflare.ts](./playground/cloudflare.ts) for demo and [src/adapters/cloudflare.ts](./src/adapters/cloudflare.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 an idea of how adapters can be implemented and feel free to directly make a Pull Request to support your environment in CrossWS!
+
+## Development
+
+- Clone this repository
+- Install the 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/adapters/bun.d.ts

@@ -0,0 +1 @@
+export * from "../dist/adapters/bun";

package/adapters/cloudflare.d.ts

@@ -0,0 +1 @@
+export * from "../dist/adapters/cloudflare";

package/adapters/deno.d.ts

@@ -0,0 +1 @@
+export * from "../dist/adapters/deno";

package/adapters/node.d.ts

@@ -0,0 +1 @@
+export * from "../dist/adapters/node";

package/dist/adapters/bun.cjs

@@ -0,0 +1,72 @@
+'use strict';
+
+const peer = require('../shared/crossws.21e14e0d.cjs');
+
+const bun = peer.defineWebSocketAdapter(
+  (hooks, opts = {}) => {
+    const getPeer = (ws) => {
+      if (ws.data?._peer) {
+        return ws.data._peer;
+      }
+      const peer = new WebSocketPeer({ bun: { ws } });
+      ws.data = ws.data || {};
+      ws.data._peer = peer;
+      return peer;
+    };
+    return {
+      websocket: {
+        message: (ws, message) => {
+          const peer$1 = getPeer(ws);
+          hooks["bun:message"]?.(peer$1, ws, message);
+          hooks.message?.(peer$1, new peer.WebSocketMessage(message));
+        },
+        open: (ws) => {
+          const peer = getPeer(ws);
+          hooks["bun:open"]?.(peer, ws);
+          hooks.open?.(peer);
+        },
+        close: (ws) => {
+          const peer = getPeer(ws);
+          hooks["bun:close"]?.(peer, ws);
+          hooks.close?.(peer, {});
+        },
+        drain: (ws) => {
+          const peer = getPeer(ws);
+          hooks["bun:drain"]?.(peer);
+        },
+        // @ts-expect-error types unavailable but mentioned in docs
+        error: (ws, error) => {
+          const peer$1 = getPeer(ws);
+          hooks["bun:error"]?.(peer$1, ws, error);
+          hooks.error?.(peer$1, new peer.WebSocketError(error));
+        },
+        ping(ws, data) {
+          const peer = getPeer(ws);
+          hooks["bun:ping"]?.(peer, ws, data);
+        },
+        pong(ws, data) {
+          const peer = getPeer(ws);
+          hooks["bun:pong"]?.(peer, ws, data);
+        }
+      }
+    };
+  }
+);
+class WebSocketPeer extends peer.WebSocketPeerBase {
+  get id() {
+    let addr = this.ctx.bun.ws.remoteAddress;
+    if (addr.includes(":")) {
+      addr = `[${addr}]`;
+    }
+    return addr;
+  }
+  get readyState() {
+    return this.ctx.bun.ws.readyState;
+  }
+  send(message) {
+    this.ctx.bun.ws.send(message);
+    return 0;
+  }
+}
+
+module.exports = bun;

package/dist/adapters/bun.d.cts

@@ -0,0 +1,13 @@
+import { WebSocketAdapter } from '../index.cjs';
+
+interface AdapterOptions {
+}
+type WebSocketHooks = Extract<Parameters<typeof Bun.serve<ContextData>>[0], {
+    websocket: any;
+}>["websocket"];
+interface Adapter {
+    websocket: WebSocketHooks;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/bun.d.mts

@@ -0,0 +1,13 @@
+import { WebSocketAdapter } from '../index.mjs';
+
+interface AdapterOptions {
+}
+type WebSocketHooks = Extract<Parameters<typeof Bun.serve<ContextData>>[0], {
+    websocket: any;
+}>["websocket"];
+interface Adapter {
+    websocket: WebSocketHooks;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/bun.d.ts

@@ -0,0 +1,13 @@
+import { WebSocketAdapter } from '../index.js';
+
+interface AdapterOptions {
+}
+type WebSocketHooks = Extract<Parameters<typeof Bun.serve<ContextData>>[0], {
+    websocket: any;
+}>["websocket"];
+interface Adapter {
+    websocket: WebSocketHooks;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/bun.mjs

@@ -0,0 +1,70 @@
+import { d as defineWebSocketAdapter, a as WebSocketMessage, W as WebSocketError, b as WebSocketPeerBase } from '../shared/crossws.9536f626.mjs';
+
+const bun = defineWebSocketAdapter(
+  (hooks, opts = {}) => {
+    const getPeer = (ws) => {
+      if (ws.data?._peer) {
+        return ws.data._peer;
+      }
+      const peer = new WebSocketPeer({ bun: { ws } });
+      ws.data = ws.data || {};
+      ws.data._peer = peer;
+      return peer;
+    };
+    return {
+      websocket: {
+        message: (ws, message) => {
+          const peer = getPeer(ws);
+          hooks["bun:message"]?.(peer, ws, message);
+          hooks.message?.(peer, new WebSocketMessage(message));
+        },
+        open: (ws) => {
+          const peer = getPeer(ws);
+          hooks["bun:open"]?.(peer, ws);
+          hooks.open?.(peer);
+        },
+        close: (ws) => {
+          const peer = getPeer(ws);
+          hooks["bun:close"]?.(peer, ws);
+          hooks.close?.(peer, {});
+        },
+        drain: (ws) => {
+          const peer = getPeer(ws);
+          hooks["bun:drain"]?.(peer);
+        },
+        // @ts-expect-error types unavailable but mentioned in docs
+        error: (ws, error) => {
+          const peer = getPeer(ws);
+          hooks["bun:error"]?.(peer, ws, error);
+          hooks.error?.(peer, new WebSocketError(error));
+        },
+        ping(ws, data) {
+          const peer = getPeer(ws);
+          hooks["bun:ping"]?.(peer, ws, data);
+        },
+        pong(ws, data) {
+          const peer = getPeer(ws);
+          hooks["bun:pong"]?.(peer, ws, data);
+        }
+      }
+    };
+  }
+);
+class WebSocketPeer extends WebSocketPeerBase {
+  get id() {
+    let addr = this.ctx.bun.ws.remoteAddress;
+    if (addr.includes(":")) {
+      addr = `[${addr}]`;
+    }
+    return addr;
+  }
+  get readyState() {
+    return this.ctx.bun.ws.readyState;
+  }
+  send(message) {
+    this.ctx.bun.ws.send(message);
+    return 0;
+  }
+}
+
+export { bun as default };

package/dist/adapters/cloudflare.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+const peer = require('../shared/crossws.21e14e0d.cjs');
+
+const cloudflare = peer.defineWebSocketAdapter(
+  (hooks, opts = {}) => {
+    const handleUpgrade = (request, env, context) => {
+      const pair = new WebSocketPair();
+      const client = pair[0];
+      const server = pair[1];
+      const peer$1 = new CloudflareWebSocketPeer({
+        cloudflare: { client, server, request, env, context }
+      });
+      server.accept();
+      hooks["cloudflare:accept"]?.(peer$1);
+      hooks.open?.(peer$1);
+      server.addEventListener("message", (event) => {
+        hooks["cloudflare:message"]?.(peer$1, event);
+        hooks.message?.(peer$1, new peer.WebSocketMessage(event.data));
+      });
+      server.addEventListener("error", (event) => {
+        hooks["cloudflare:error"]?.(peer$1, event);
+        hooks.error?.(peer$1, new peer.WebSocketError(event.error));
+      });
+      server.addEventListener("close", (event) => {
+        hooks["cloudflare:close"]?.(peer$1, event);
+        hooks.close?.(peer$1, { code: event.code, reason: event.reason });
+      });
+      return new Response(null, {
+        status: 101,
+        webSocket: client
+      });
+    };
+    return {
+      handleUpgrade
+    };
+  }
+);
+class CloudflareWebSocketPeer extends peer.WebSocketPeerBase {
+  get id() {
+    return void 0;
+  }
+  get readyState() {
+    return this.ctx.cloudflare.client.readyState;
+  }
+  send(message) {
+    this.ctx.cloudflare.server.send(message);
+    return 0;
+  }
+}
+
+module.exports = cloudflare;

package/dist/adapters/cloudflare.d.cts

@@ -0,0 +1,12 @@
+import { WebSocketAdapter } from '../index.cjs';
+import * as _cf from '@cloudflare/workers-types';
+
+type Env = Record<string, any>;
+interface AdapterOptions {
+}
+interface Adapter {
+    handleUpgrade(req: _cf.Request, env: Env, context: _cf.ExecutionContext): _cf.Response;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/cloudflare.d.mts

@@ -0,0 +1,12 @@
+import { WebSocketAdapter } from '../index.mjs';
+import * as _cf from '@cloudflare/workers-types';
+
+type Env = Record<string, any>;
+interface AdapterOptions {
+}
+interface Adapter {
+    handleUpgrade(req: _cf.Request, env: Env, context: _cf.ExecutionContext): _cf.Response;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/cloudflare.d.ts

@@ -0,0 +1,12 @@
+import { WebSocketAdapter } from '../index.js';
+import * as _cf from '@cloudflare/workers-types';
+
+type Env = Record<string, any>;
+interface AdapterOptions {
+}
+interface Adapter {
+    handleUpgrade(req: _cf.Request, env: Env, context: _cf.ExecutionContext): _cf.Response;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/cloudflare.mjs

@@ -0,0 +1,50 @@
+import { d as defineWebSocketAdapter, a as WebSocketMessage, W as WebSocketError, b as WebSocketPeerBase } from '../shared/crossws.9536f626.mjs';
+
+const cloudflare = defineWebSocketAdapter(
+  (hooks, opts = {}) => {
+    const handleUpgrade = (request, env, context) => {
+      const pair = new WebSocketPair();
+      const client = pair[0];
+      const server = pair[1];
+      const peer = new CloudflareWebSocketPeer({
+        cloudflare: { client, server, request, env, context }
+      });
+      server.accept();
+      hooks["cloudflare:accept"]?.(peer);
+      hooks.open?.(peer);
+      server.addEventListener("message", (event) => {
+        hooks["cloudflare:message"]?.(peer, event);
+        hooks.message?.(peer, new WebSocketMessage(event.data));
+      });
+      server.addEventListener("error", (event) => {
+        hooks["cloudflare:error"]?.(peer, event);
+        hooks.error?.(peer, new WebSocketError(event.error));
+      });
+      server.addEventListener("close", (event) => {
+        hooks["cloudflare:close"]?.(peer, event);
+        hooks.close?.(peer, { code: event.code, reason: event.reason });
+      });
+      return new Response(null, {
+        status: 101,
+        webSocket: client
+      });
+    };
+    return {
+      handleUpgrade
+    };
+  }
+);
+class CloudflareWebSocketPeer extends WebSocketPeerBase {
+  get id() {
+    return void 0;
+  }
+  get readyState() {
+    return this.ctx.cloudflare.client.readyState;
+  }
+  send(message) {
+    this.ctx.cloudflare.server.send(message);
+    return 0;
+  }
+}
+
+export { cloudflare as default };