crossws 0.2.4 → 0.3.0

package/dist/adapters/deno.mjs

@@ -1,60 +1,69 @@
-import { d as defineWebSocketAdapter, M as Message, P as Peer, t as toBufferLike, c as createCrossWS } from '../shared/crossws.77e89680.mjs';
-import { WSError } from '../index.mjs';
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DTY7a69w.mjs';
+import { d as defineWebSocketAdapter, a as adapterUtils, A as AdapterHookable } from '../shared/crossws.B4sHId41.mjs';
+import { W as WSError } from '../shared/crossws.By9qWDAI.mjs';
+import 'uncrypto';
 
 const deno = defineWebSocketAdapter(
   (options = {}) => {
-    const crossws = createCrossWS(options);
-    const handleUpgrade = async (req, info) => {
-      const { headers } = await crossws.upgrade({
-        url: req.url,
-        headers: req.headers
-      });
-      const upgrade = Deno.upgradeWebSocket(req, {
-        // @ts-expect-error https://github.com/denoland/deno/pull/22242
-        headers
-      });
-      const peer = new DenoPeer({
-        deno: { ws: upgrade.socket, req, info }
-      });
-      upgrade.socket.addEventListener("open", () => {
-        crossws.$callHook("deno:open", peer);
-        crossws.callHook("open", peer);
-      });
-      upgrade.socket.addEventListener("message", (event) => {
-        crossws.$callHook("deno:message", peer, event);
-        crossws.callHook("message", peer, new Message(event.data));
-      });
-      upgrade.socket.addEventListener("close", () => {
-        crossws.$callHook("deno:close", peer);
-        crossws.callHook("close", peer, {});
-      });
-      upgrade.socket.addEventListener("error", (error) => {
-        crossws.$callHook("deno:error", peer, error);
-        crossws.callHook("error", peer, new WSError(error));
-      });
-      return upgrade.response;
-    };
+    const hooks = new AdapterHookable(options);
+    const peers = /* @__PURE__ */ new Set();
     return {
-      handleUpgrade
+      ...adapterUtils(peers),
+      handleUpgrade: async (request, info) => {
+        const res = await hooks.callHook("upgrade", request);
+        if (res instanceof Response) {
+          return res;
+        }
+        const upgrade = Deno.upgradeWebSocket(request, {
+          // @ts-expect-error https://github.com/denoland/deno/pull/22242
+          headers: res?.headers
+        });
+        const peer = new DenoPeer({
+          ws: upgrade.socket,
+          request,
+          peers,
+          denoInfo: info
+        });
+        peers.add(peer);
+        upgrade.socket.addEventListener("open", () => {
+          hooks.callHook("open", peer);
+        });
+        upgrade.socket.addEventListener("message", (event) => {
+          hooks.callHook("message", peer, new Message(event.data, peer, event));
+        });
+        upgrade.socket.addEventListener("close", () => {
+          peers.delete(peer);
+          hooks.callHook("close", peer, {});
+        });
+        upgrade.socket.addEventListener("error", (error) => {
+          peers.delete(peer);
+          hooks.callHook("error", peer, new WSError(error));
+        });
+        return upgrade.response;
+      }
     };
   }
 );
 class DenoPeer extends Peer {
-  get addr() {
-    return this.ctx.deno.ws.remoteAddress;
+  get remoteAddress() {
+    return this._internal.denoInfo.remoteAddr?.hostname;
   }
-  get readyState() {
-    return this.ctx.deno.ws.readyState;
+  send(data) {
+    return this._internal.ws.send(toBufferLike(data));
   }
-  get url() {
-    return this.ctx.deno.req.url;
+  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);
+      }
+    }
   }
-  get headers() {
-    return this.ctx.deno.req.headers || new Headers();
+  close(code, reason) {
+    this._internal.ws.close(code, reason);
   }
-  send(message) {
-    this.ctx.deno.ws.send(toBufferLike(message));
-    return 0;
+  terminate() {
+    this._internal.ws.terminate();
   }
 }
 

package/dist/adapters/node.d.mts

@@ -1,4 +1,4 @@
-import { A as AdapterOptions, b as Adapter } from '../shared/crossws.381454fe.mjs';
+import { AdapterInstance, AdapterOptions, Adapter } from '../index.mjs';
 import { IncomingMessage as IncomingMessage$1 } from 'node:http';
 import { Duplex as Duplex$1 } from 'node:stream';
 import { EventEmitter } from 'events';
@@ -8,6 +8,7 @@ import { Duplex, DuplexOptions } from 'stream';
 import { SecureContextOptions } from 'tls';
 import { URL } from 'url';
 import { ZlibOptions } from 'zlib';
+import '../shared/crossws.ChIJSJVK.mjs';
 
 type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly any[] | readonly number[] | {
     valueOf(): ArrayBuffer;
@@ -286,8 +287,9 @@ declare class Server<T extends typeof WebSocket = typeof WebSocket, U extends ty
 type WebSocketServer = Server;
 declare function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
 
-interface NodeAdapter {
+interface NodeAdapter extends AdapterInstance {
     handleUpgrade(req: IncomingMessage$1, socket: Duplex$1, head: Buffer): void;
+    closeAll: (code?: number, data?: string | Buffer) => void;
 }
 interface NodeOptions extends AdapterOptions {
     wss?: WebSocketServer;

package/dist/adapters/node.d.ts

@@ -1,4 +1,4 @@
-import { A as AdapterOptions, b as Adapter } from '../shared/crossws.381454fe.js';
+import { AdapterInstance, AdapterOptions, Adapter } from '../index.js';
 import { IncomingMessage as IncomingMessage$1 } from 'node:http';
 import { Duplex as Duplex$1 } from 'node:stream';
 import { EventEmitter } from 'events';
@@ -8,6 +8,7 @@ import { Duplex, DuplexOptions } from 'stream';
 import { SecureContextOptions } from 'tls';
 import { URL } from 'url';
 import { ZlibOptions } from 'zlib';
+import '../shared/crossws.ChIJSJVK.js';
 
 type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly any[] | readonly number[] | {
     valueOf(): ArrayBuffer;
@@ -286,8 +287,9 @@ declare class Server<T extends typeof WebSocket = typeof WebSocket, U extends ty
 type WebSocketServer = Server;
 declare function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
 
-interface NodeAdapter {
+interface NodeAdapter extends AdapterInstance {
     handleUpgrade(req: IncomingMessage$1, socket: Duplex$1, head: Buffer): void;
+    closeAll: (code?: number, data?: string | Buffer) => void;
 }
 interface NodeOptions extends AdapterOptions {
     wss?: WebSocketServer;

package/dist/adapters/node.mjs

@@ -1,10 +1,12 @@
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DTY7a69w.mjs';
+import { d as defineWebSocketAdapter, a as adapterUtils, A as AdapterHookable } from '../shared/crossws.B4sHId41.mjs';
+import { W as WSError } from '../shared/crossws.By9qWDAI.mjs';
 import 'stream';
-import { v as validationExports, g as getDefaultExportFromCjs, e as extension$1, p as permessageDeflate, w as websocket, c as constants } from '../shared/crossws.a5db571c.mjs';
+import { v as validationExports, g as getDefaultExportFromCjs, e as extension$1, p as permessageDeflate, w as websocket, c as constants } from '../shared/crossws.YgHWLi0G.mjs';
 import require$$0 from 'events';
 import require$$2 from 'http';
 import require$$1 from 'crypto';
-import { d as defineWebSocketAdapter, M as Message, P as Peer, t as toBufferLike, c as createCrossWS } from '../shared/crossws.77e89680.mjs';
-import { WSError } from '../index.mjs';
+import 'uncrypto';
 import 'https';
 import 'net';
 import 'tls';
@@ -73,7 +75,7 @@ function parse(header) {
 
 var subprotocol$1 = { parse };
 
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$" }] */
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
 
 const EventEmitter = require$$0;
 const http = require$$2;
@@ -101,7 +103,7 @@ class WebSocketServer extends EventEmitter {
    * Create a `WebSocketServer` instance.
    *
    * @param {Object} options Configuration options
-   * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
+   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
    *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
    *     multiple times in the same tick
    * @param {Boolean} [options.autoPong=true] Specifies whether or not to
@@ -132,7 +134,7 @@ class WebSocketServer extends EventEmitter {
     super();
 
     options = {
-      allowSynchronousEvents: false,
+      allowSynchronousEvents: true,
       autoPong: true,
       maxPayload: 100 * 1024 * 1024,
       skipUTF8Validation: false,
@@ -307,6 +309,7 @@ class WebSocketServer extends EventEmitter {
     socket.on('error', socketOnError);
 
     const key = req.headers['sec-websocket-key'];
+    const upgrade = req.headers.upgrade;
     const version = +req.headers['sec-websocket-version'];
 
     if (req.method !== 'GET') {
@@ -315,13 +318,13 @@ class WebSocketServer extends EventEmitter {
       return;
     }
 
-    if (req.headers.upgrade.toLowerCase() !== 'websocket') {
+    if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
       const message = 'Invalid Upgrade header';
       abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
       return;
     }
 
-    if (!key || !keyRegex.test(key)) {
+    if (key === undefined || !keyRegex.test(key)) {
       const message = 'Missing or invalid Sec-WebSocket-Key header';
       abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
       return;
@@ -614,118 +617,139 @@ const _WebSocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServer);
 
 const node = defineWebSocketAdapter(
   (options = {}) => {
-    const crossws = createCrossWS(options);
+    const hooks = new AdapterHookable(options);
+    const peers = /* @__PURE__ */ new Set();
     const wss = options.wss || new _WebSocketServer({
       noServer: true,
       ...options.serverOptions
     });
-    wss.on("connection", (ws, req) => {
-      const peer = new NodePeer({ node: { ws, req, server: wss } });
-      crossws.callHook("open", peer);
-      ws.on("message", (data, isBinary) => {
-        crossws.$callHook("node:message", peer, data, isBinary);
+    wss.on("connection", (ws, nodeReq) => {
+      const request = new NodeReqProxy(nodeReq);
+      const peer = new NodePeer({ ws, request, peers, nodeReq });
+      peers.add(peer);
+      hooks.callHook("open", peer);
+      ws.on("message", (data) => {
         if (Array.isArray(data)) {
           data = Buffer.concat(data);
         }
-        crossws.callHook("message", peer, new Message(data, isBinary));
+        hooks.callHook("message", peer, new Message(data, peer));
       });
       ws.on("error", (error) => {
-        crossws.$callHook("node:error", peer, error);
-        crossws.callHook("error", peer, new WSError(error));
+        peers.delete(peer);
+        hooks.callHook("error", peer, new WSError(error));
       });
       ws.on("close", (code, reason) => {
-        crossws.$callHook("node:close", peer, code, reason);
-        crossws.callHook("close", peer, {
+        peers.delete(peer);
+        hooks.callHook("close", peer, {
           code,
           reason: reason?.toString()
         });
       });
-      ws.on("open", () => {
-        crossws.$callHook("node:open", peer);
-      });
-      ws.on("ping", (data) => {
-        crossws.$callHook("node:ping", peer, data);
-      });
-      ws.on("pong", (data) => {
-        crossws.$callHook("node:pong", peer, data);
-      });
-      ws.on(
-        "unexpected-response",
-        (req2, res) => {
-          crossws.$callHook("node:unexpected-response", peer, req2, res);
-        }
-      );
-      ws.on("upgrade", (req2) => {
-        crossws.$callHook("node:upgrade", peer, req2);
-      });
     });
-    wss.on("headers", function(outgoingHeaders, req) {
+    wss.on("headers", (outgoingHeaders, req) => {
       const upgradeHeaders = req._upgradeHeaders;
       if (upgradeHeaders) {
-        const _headers = new Headers(upgradeHeaders);
-        for (const [key, value] of _headers) {
+        for (const [key, value] of new Headers(upgradeHeaders)) {
           outgoingHeaders.push(`${key}: ${value}`);
         }
       }
     });
     return {
-      handleUpgrade: async (req, socket, head) => {
-        const { headers } = await crossws.upgrade({
-          url: req.url || "",
-          headers: req.headers
-        });
-        req._upgradeHeaders = headers;
-        wss.handleUpgrade(req, socket, head, (ws) => {
-          wss.emit("connection", ws, req);
+      ...adapterUtils(peers),
+      handleUpgrade: async (nodeReq, socket, head) => {
+        const request = new NodeReqProxy(nodeReq);
+        const res = await hooks.callHook("upgrade", request);
+        if (res instanceof Response) {
+          return sendResponse(socket, res);
+        }
+        nodeReq._request = request;
+        nodeReq._upgradeHeaders = res?.headers;
+        wss.handleUpgrade(nodeReq, socket, head, (ws) => {
+          wss.emit("connection", ws, nodeReq);
         });
+      },
+      closeAll: (code, data) => {
+        for (const client of wss.clients) {
+          client.close(code, data);
+        }
       }
     };
   }
 );
 class NodePeer extends Peer {
-  constructor(ctx) {
-    super(ctx);
-    ctx.node.ws._peer = this;
-  }
-  get addr() {
-    const socket = this.ctx.node.req.socket;
-    if (!socket) {
-      return void 0;
-    }
-    const headers = this.ctx.node.req.headers;
-    let addr = headers["x-forwarded-for"] || socket.remoteAddress || "??";
-    if (addr.includes(":")) {
-      addr = `[${addr}]`;
-    }
-    const port = headers["x-forwarded-port"] || socket.remotePort || "??";
-    return `${addr}:${port}`;
-  }
-  get url() {
-    return this.ctx.node.req.url || "/";
-  }
-  get headers() {
-    return this.ctx.node.req.headers;
-  }
-  get readyState() {
-    return this.ctx.node.ws.readyState;
+  get remoteAddress() {
+    return this._internal.nodeReq.socket?.remoteAddress;
   }
-  send(message, options) {
-    this.ctx.node.ws.send(toBufferLike(message), {
+  send(data, options) {
+    const dataBuff = toBufferLike(data);
+    const isBinary = typeof data !== "string";
+    this._internal.ws.send(dataBuff, {
       compress: options?.compress,
-      binary: options?.binary,
+      binary: isBinary,
       ...options
     });
     return 0;
   }
-  publish(topic, message) {
-    message = toBufferLike(message);
-    for (const client of this.ctx.node.server.clients) {
-      const peer = client._peer;
-      if (peer && peer !== this && peer._subscriptions.has(topic)) {
-        peer.send(message);
+  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();
+  }
+}
+class NodeReqProxy {
+  _req;
+  _headers;
+  _url;
+  constructor(req) {
+    this._req = req;
+  }
+  get url() {
+    if (!this._url) {
+      const req = this._req;
+      const host = req.headers["host"] || "localhost";
+      const isSecure = req.socket?.encrypted ?? req.headers["x-forwarded-proto"] === "https";
+      this._url = `${isSecure ? "https" : "http"}://${host}${req.url}`;
+    }
+    return this._url;
+  }
+  get headers() {
+    if (!this._headers) {
+      this._headers = new Headers(this._req.headers);
+    }
+    return this._headers;
+  }
+}
+async function sendResponse(socket, res) {
+  const head = [
+    `HTTP/1.1 ${res.status || 200} ${res.statusText || ""}`,
+    ...[...res.headers.entries()].map(
+      ([key, value]) => `${encodeURIComponent(key)}: ${encodeURIComponent(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(resolve);
+  });
 }
 
 export { node as default };

package/dist/adapters/sse.d.mts

@@ -0,0 +1,12 @@
+import { AdapterInstance, AdapterOptions, Adapter } from '../index.mjs';
+import '../shared/crossws.ChIJSJVK.mjs';
+
+interface SSEAdapter extends AdapterInstance {
+    fetch(req: Request): Promise<Response>;
+}
+interface SSEOptions extends AdapterOptions {
+    bidir?: boolean;
+}
+declare const _default: Adapter<SSEAdapter, SSEOptions>;
+
+export { type SSEAdapter, type SSEOptions, _default as default };

package/dist/adapters/sse.d.ts

@@ -0,0 +1,12 @@
+import { AdapterInstance, AdapterOptions, Adapter } from '../index.js';
+import '../shared/crossws.ChIJSJVK.js';
+
+interface SSEAdapter extends AdapterInstance {
+    fetch(req: Request): Promise<Response>;
+}
+interface SSEOptions extends AdapterOptions {
+    bidir?: boolean;
+}
+declare const _default: Adapter<SSEAdapter, SSEOptions>;
+
+export { type SSEAdapter, type SSEOptions, _default as default };

package/dist/adapters/sse.mjs

@@ -0,0 +1,120 @@
+import { M as Message, P as Peer, a as toString } from '../shared/crossws.DTY7a69w.mjs';
+import { d as defineWebSocketAdapter, a as adapterUtils, A as AdapterHookable } from '../shared/crossws.B4sHId41.mjs';
+import 'uncrypto';
+
+const sse = defineWebSocketAdapter((opts = {}) => {
+  const hooks = new AdapterHookable(opts);
+  const peers = /* @__PURE__ */ new Set();
+  const peersMap = opts.bidir ? /* @__PURE__ */ new Map() : void 0;
+  return {
+    ...adapterUtils(peers),
+    fetch: async (request) => {
+      const _res = await hooks.callHook("upgrade", request);
+      if (_res instanceof Response) {
+        return _res;
+      }
+      let peer;
+      if (opts.bidir && request.body && request.headers.has("x-crossws-id")) {
+        const id = request.headers.get("x-crossws-id");
+        peer = peersMap?.get(id);
+        if (!peer) {
+          return new Response("invalid peer id", { status: 400 });
+        }
+        const stream = request.body.pipeThrough(new TextDecoderStream());
+        try {
+          for await (const chunk of stream) {
+            hooks.callHook("message", peer, new Message(chunk, peer));
+          }
+        } catch {
+          await stream.cancel().catch(() => {
+          });
+        }
+        return new Response(null, {});
+      } else {
+        const ws = new SSEWebSocketStub();
+        peer = new SSEPeer({
+          peers,
+          peersMap,
+          request,
+          hooks,
+          ws
+        });
+        peers.add(peer);
+        if (opts.bidir) {
+          peersMap.set(peer.id, peer);
+          peer._sendEvent("crossws-id", peer.id);
+        }
+      }
+      let headers = {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      };
+      if (opts.bidir) {
+        headers["x-crossws-id"] = peer.id;
+      }
+      if (_res?.headers) {
+        headers = new Headers(headers);
+        for (const [key, value] of new Headers(_res.headers)) {
+          headers.set(key, value);
+        }
+      }
+      return new Response(peer._sseStream, { ..._res, headers });
+    }
+  };
+});
+class SSEPeer extends Peer {
+  _sseStream;
+  // server -> client
+  _sseStreamController;
+  constructor(_internal) {
+    super(_internal);
+    _internal.ws.readyState = 0;
+    this._sseStream = new ReadableStream({
+      start: (controller) => {
+        _internal.ws.readyState = 1;
+        this._sseStreamController = controller;
+        _internal.hooks.callHook("open", this);
+      },
+      cancel: () => {
+        _internal.ws.readyState = 2;
+        _internal.peers.delete(this);
+        _internal.peersMap?.delete(this.id);
+        Promise.resolve(this._internal.hooks.callHook("close", this)).finally(
+          () => {
+            _internal.ws.readyState = 3;
+          }
+        );
+      }
+    }).pipeThrough(new TextEncoderStream());
+  }
+  _sendEvent(event, data) {
+    const lines = data.split("\n");
+    this._sseStreamController?.enqueue(
+      `event: ${event}
+${lines.map((l) => `data: ${l}`)}
+
+`
+    );
+  }
+  send(data) {
+    this._sendEvent("message", toString(data));
+    return 0;
+  }
+  publish(topic, data) {
+    const dataBuff = toString(data);
+    for (const peer of this._internal.peers) {
+      if (peer !== this && peer._topics.has(topic)) {
+        peer._sendEvent("message", dataBuff);
+      }
+    }
+  }
+  close() {
+    this._sseStreamController?.close();
+  }
+}
+class SSEWebSocketStub {
+  readyState;
+}
+
+export { sse as default };

package/dist/adapters/uws.d.mts

@@ -1,19 +1,55 @@
-import { A as AdapterOptions, b as Adapter } from '../shared/crossws.381454fe.mjs';
-import { WebSocketBehavior, HttpRequest, HttpResponse } from 'uWebSockets.js';
+import { AdapterInstance, AdapterOptions, Adapter, Peer } from '../index.mjs';
+import { W as WebSocket } from '../shared/crossws.ChIJSJVK.mjs';
+import uws from 'uWebSockets.js';
 
 type UserData = {
-    _peer?: any;
-    req: HttpRequest;
-    res: HttpResponse;
-    context: any;
+    peer?: UWSPeer;
+    req: uws.HttpRequest;
+    res: uws.HttpResponse;
+    protocol: string;
+    extensions: string;
 };
-type WebSocketHandler = WebSocketBehavior<UserData>;
-interface UWSAdapter {
+type WebSocketHandler = uws.WebSocketBehavior<UserData>;
+interface UWSAdapter extends AdapterInstance {
     websocket: WebSocketHandler;
 }
 interface UWSOptions extends AdapterOptions {
-    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
+    uws?: Exclude<uws.WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
 }
 declare const _default: Adapter<UWSAdapter, UWSOptions>;
 
+declare class UWSPeer extends Peer<{
+    peers: Set<UWSPeer>;
+    request: UWSReqProxy;
+    uws: uws.WebSocket<UserData>;
+    ws: UwsWebSocketProxy;
+    uwsData: UserData;
+}> {
+    get remoteAddress(): string | undefined;
+    send(data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    subscribe(topic: string): void;
+    publish(topic: string, message: string, options?: {
+        compress?: boolean;
+    }): number;
+    close(code?: number, reason?: uws.RecognizedString): void;
+    terminate(): void;
+}
+declare class UWSReqProxy {
+    private _headers?;
+    private _rawHeaders;
+    url: string;
+    constructor(_req: uws.HttpRequest);
+    get headers(): Headers;
+}
+declare class UwsWebSocketProxy implements Partial<WebSocket> {
+    private _uws;
+    readyState?: number;
+    constructor(_uws: uws.WebSocket<UserData>);
+    get bufferedAmount(): number;
+    get protocol(): string;
+    get extensions(): string;
+}
+
 export { type UWSAdapter, type UWSOptions, _default as default };