crossws 0.2.3 → 0.3.0

package/dist/adapters/uws.d.ts

@@ -1,19 +1,55 @@
-import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.js';
-import { WebSocketBehavior, HttpRequest, HttpResponse } from 'uWebSockets.js';
+import { AdapterInstance, AdapterOptions, Adapter, Peer } from '../index.js';
+import { W as WebSocket } from '../shared/crossws.ChIJSJVK.js';
+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 };

package/dist/adapters/uws.mjs

@@ -1,151 +1,175 @@
-import { d as defineWebSocketAdapter, c as createCrossWS, M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.34cfc8d0.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 'uncrypto';
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 const uws = defineWebSocketAdapter(
   (options = {}) => {
-    const crossws = createCrossWS(options);
-    const getPeer = (ws) => {
-      const userData = ws.getUserData();
-      if (userData._peer) {
-        return userData._peer;
-      }
-      const peer = new UWSPeer({ uws: { ws, userData } });
-      userData._peer = peer;
-      return peer;
-    };
-    const websocket = {
-      ...options.uws,
-      close(ws, code, message) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:close", peer, ws, code, message);
-        crossws.callHook("close", peer, { code, reason: message?.toString() });
-      },
-      drain(ws) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:drain", peer, ws);
-      },
-      message(ws, message, isBinary) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:message", peer, ws, message, isBinary);
-        const msg = new Message(message, isBinary);
-        crossws.callHook("message", peer, msg);
-      },
-      open(ws) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:open", peer, ws);
-        crossws.callHook("open", peer);
-      },
-      ping(ws, message) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:ping", peer, ws, message);
-      },
-      pong(ws, message) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:pong", peer, ws, message);
-      },
-      subscription(ws, topic, newCount, oldCount) {
-        const peer = getPeer(ws);
-        crossws.$callHook(
-          "uws:subscription",
-          peer,
-          ws,
-          topic,
-          newCount,
-          oldCount
-        );
-      },
-      async upgrade(res, req, context) {
-        let aborted = false;
-        res.onAborted(() => {
-          aborted = true;
-        });
-        const { headers } = await crossws.upgrade({
-          get url() {
-            return req.getUrl();
-          },
-          get headers() {
-            return _getHeaders(req);
+    const hooks = new AdapterHookable(options);
+    const peers = /* @__PURE__ */ new Set();
+    return {
+      ...adapterUtils(peers),
+      websocket: {
+        ...options.uws,
+        close(ws, code, message) {
+          const peer = getPeer(ws, peers);
+          peer._internal.ws.readyState = 2;
+          peers.delete(peer);
+          hooks.callHook("close", peer, {
+            code,
+            reason: message?.toString()
+          });
+          peer._internal.ws.readyState = 3;
+        },
+        message(ws, message, isBinary) {
+          const peer = getPeer(ws, peers);
+          hooks.callHook("message", peer, new Message(message, peer));
+        },
+        open(ws) {
+          const peer = getPeer(ws, peers);
+          peers.add(peer);
+          hooks.callHook("open", peer);
+        },
+        async upgrade(res, req, context) {
+          let aborted = false;
+          res.onAborted(() => {
+            aborted = true;
+          });
+          const _res = await hooks.callHook("upgrade", new UWSReqProxy(req));
+          if (aborted) {
+            return;
           }
-        });
-        res.writeStatus("101 Switching Protocols");
-        for (const [key, value] of new Headers(headers)) {
-          res.writeHeader(key, value);
-        }
-        if (aborted) {
-          return;
-        }
-        res.cork(() => {
-          res.upgrade(
-            {
-              req,
-              res,
+          if (_res instanceof Response) {
+            res.writeStatus(`${_res.status} ${_res.statusText}`);
+            for (const [key, value] of _res.headers) {
+              res.writeHeader(key, value);
+            }
+            if (_res.body) {
+              for await (const chunk of _res.body) {
+                if (aborted) {
+                  break;
+                }
+                res.write(chunk);
+              }
+            }
+            if (!aborted) {
+              res.end();
+            }
+            return;
+          }
+          res.writeStatus("101 Switching Protocols");
+          if (_res?.headers) {
+            for (const [key, value] of new Headers(_res.headers)) {
+              res.writeHeader(key, value);
+            }
+          }
+          res.cork(() => {
+            const key = req.getHeader("sec-websocket-key");
+            const protocol = req.getHeader("sec-websocket-protocol");
+            const extensions = req.getHeader("sec-websocket-extensions");
+            res.upgrade(
+              {
+                req,
+                res,
+                protocol,
+                extensions
+              },
+              key,
+              protocol,
+              extensions,
               context
-            },
-            req.getHeader("sec-websocket-key"),
-            req.getHeader("sec-websocket-protocol"),
-            req.getHeader("sec-websocket-extensions"),
-            context
-          );
-        });
+            );
+          });
+        }
       }
     };
-    return {
-      websocket
-    };
   }
 );
-class UWSPeer extends Peer {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "_headers");
-    __publicField(this, "_decoder", new TextDecoder());
+function getPeer(uws, peers) {
+  const uwsData = uws.getUserData();
+  if (uwsData.peer) {
+    return uwsData.peer;
   }
-  get id() {
+  const peer = new UWSPeer({
+    peers,
+    uws,
+    ws: new UwsWebSocketProxy(uws),
+    request: new UWSReqProxy(uwsData.req),
+    uwsData
+  });
+  uwsData.peer = peer;
+  return peer;
+}
+class UWSPeer extends Peer {
+  get remoteAddress() {
     try {
-      const addr = this._decoder.decode(
-        this.ctx.uws.ws?.getRemoteAddressAsText()
+      const addr = new TextDecoder().decode(
+        this._internal.uws.getRemoteAddressAsText()
       );
-      return addr.replace(/(0000:)+/, "");
+      return addr;
     } catch {
     }
   }
-  // TODO
-  // get readyState() {}
-  get url() {
-    return this.ctx.uws.userData.req.getUrl();
+  send(data, options) {
+    const dataBuff = toBufferLike(data);
+    const isBinary = typeof data !== "string";
+    return this._internal.uws.send(dataBuff, isBinary, options?.compress);
+  }
+  subscribe(topic) {
+    this._internal.uws.subscribe(topic);
+  }
+  publish(topic, message, options) {
+    const data = toBufferLike(message);
+    const isBinary = typeof data !== "string";
+    this._internal.uws.publish(topic, data, isBinary, options?.compress);
+    return 0;
+  }
+  close(code, reason) {
+    this._internal.uws.end(code, reason);
+  }
+  terminate() {
+    this._internal.uws.close();
+  }
+}
+class UWSReqProxy {
+  _headers;
+  _rawHeaders = [];
+  url;
+  constructor(_req) {
+    let host = "localhost";
+    let proto = "http";
+    _req.forEach((key, value) => {
+      if (key === "host") {
+        host = value;
+      } else if (key === "x-forwarded-proto" && value === "https") {
+        proto = "https";
+      }
+      this._rawHeaders.push([key, value]);
+    });
+    const query = _req.getQuery();
+    const pathname = _req.getUrl();
+    this.url = `${proto}://${host}${pathname}${query ? `?${query}` : ""}`;
   }
   get headers() {
     if (!this._headers) {
-      this._headers = _getHeaders(this.ctx.uws.userData.req);
+      this._headers = new Headers(this._rawHeaders);
     }
     return this._headers;
   }
-  send(message, options) {
-    return this.ctx.uws.ws.send(
-      toBufferLike(message),
-      options?.binary,
-      options?.compress
-    );
+}
+class UwsWebSocketProxy {
+  constructor(_uws) {
+    this._uws = _uws;
   }
-  subscribe(topic) {
-    this.ctx.uws.ws.subscribe(topic);
+  readyState = 1;
+  get bufferedAmount() {
+    return this._uws?.getBufferedAmount();
   }
-  publish(topic, message, options) {
-    this.ctx.uws.ws.publish(topic, message, options?.binary, options?.compress);
-    return 0;
+  get protocol() {
+    return this._uws?.getUserData().protocol;
+  }
+  get extensions() {
+    return this._uws?.getUserData().extensions;
   }
-}
-function _getHeaders(req) {
-  const headers = [];
-  req.forEach((key, value) => {
-    headers.push([key, value]);
-  });
-  return headers;
 }
 
 export { uws as default };

package/dist/index.d.mts

@@ -1,6 +1,138 @@
-import { A as AdapterOptions, C as CrossWS } from './shared/crossws.a2e5c71e.mjs';
-export { b as Adapter, f as AdapterHooks, a as Caller, H as Hooks, M as Message, P as Peer, R as ResolveHooks, W as WSError, c as WSRequest, e as defineHooks, d as defineWebSocketAdapter } from './shared/crossws.a2e5c71e.mjs';
+import { W as WebSocket } from './shared/crossws.ChIJSJVK.mjs';
 
-declare function createCrossWS(opts?: AdapterOptions): CrossWS;
+interface AdapterInternal {
+    ws: unknown;
+    request?: Request | Partial<Request>;
+    peers?: Set<Peer>;
+}
+declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal> {
+    #private;
+    protected _internal: Internal;
+    protected _topics: Set<string>;
+    protected _id?: string;
+    constructor(internal: Internal);
+    /**
+     * Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the peer.
+     */
+    get id(): string;
+    /** IP address of the peer */
+    get remoteAddress(): string | undefined;
+    /** upgrade request */
+    get request(): Request | Partial<Request> | undefined;
+    /**
+     * 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(): Partial<WebSocket>;
+    /** All connected peers to the server */
+    get peers(): Set<Peer>;
+    abstract close(code?: number, reason?: string): void;
+    /** Abruptly close the connection */
+    terminate(): void;
+    /** Subscribe to a topic */
+    subscribe(topic: string): void;
+    /** Unsubscribe from a topic */
+    unsubscribe(topic: string): void;
+    /** Send a message to the peer. */
+    abstract send(data: unknown, options?: {
+        compress?: boolean;
+    }): number | void | undefined;
+    /** Send message to subscribes of topic */
+    abstract publish(topic: string, data: unknown, options?: {
+        compress?: boolean;
+    }): void;
+    toString(): string;
+    [Symbol.toPrimitive](): string;
+    [Symbol.toStringTag](): string;
+}
 
-export { AdapterOptions, CrossWS, createCrossWS };
+interface AdapterInstance {
+    readonly peers: Set<Peer>;
+    readonly publish: Peer["publish"];
+}
+interface AdapterOptions {
+    resolve?: ResolveHooks;
+    hooks?: Hooks;
+}
+type Adapter<AdapterT extends AdapterInstance = AdapterInstance, Options extends AdapterOptions = AdapterOptions> = (options?: Options) => AdapterT;
+declare function defineWebSocketAdapter<AdapterT extends AdapterInstance = AdapterInstance, Options extends AdapterOptions = AdapterOptions>(factory: Adapter<AdapterT, Options>): Adapter<AdapterT, Options>;
+
+declare class WSError extends Error {
+    constructor(...args: any[]);
+}
+
+declare class Message implements Partial<MessageEvent> {
+    #private;
+    /** Access to the original [message event](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/message_event) if available. */
+    readonly event?: MessageEvent;
+    /** Access to the Peer that emitted the message. */
+    readonly peer?: Peer;
+    /** Raw message data (can be of any type). */
+    readonly rawData: unknown;
+    constructor(rawData: unknown, peer: Peer, event?: MessageEvent);
+    /**
+     * Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the message.
+     */
+    get id(): string;
+    /**
+     * 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(): Uint8Array;
+    /**
+     * 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(): ArrayBuffer | SharedArrayBuffer;
+    /**
+     * 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(): Blob;
+    /**
+     * Get stringified text version of the message.
+     *
+     * If raw data is in any other format, it will be automatically converted and decoded.
+     */
+    text(): string;
+    /**
+     * 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<T = unknown>(): T;
+    /**
+     * Message data (value varies based on `peer.websocket.binaryType`).
+     */
+    get data(): unknown;
+    toString(): string;
+    [Symbol.toPrimitive](): string;
+}
+
+declare function defineHooks<T extends Partial<Hooks> = Partial<Hooks>>(hooks: T): T;
+type ResolveHooks = (info: RequestInit | Peer) => Partial<Hooks> | Promise<Partial<Hooks>>;
+type MaybePromise<T> = T | Promise<T>;
+interface Hooks {
+    /** Upgrading */
+    upgrade: (request: Request | {
+        url: string;
+        headers: Headers;
+    }) => MaybePromise<Response | ResponseInit | void>;
+    /** A message is received */
+    message: (peer: Peer, message: Message) => MaybePromise<void>;
+    /** A socket is opened */
+    open: (peer: Peer) => MaybePromise<void>;
+    /** A socket is closed */
+    close: (peer: Peer, details: {
+        code?: number;
+        reason?: string;
+    }) => MaybePromise<void>;
+    /** An error occurs */
+    error: (peer: Peer, error: WSError) => MaybePromise<void>;
+}
+
+export { type Adapter, type AdapterInstance, type AdapterOptions, type Hooks, Message, Peer, type ResolveHooks, WSError, defineHooks, defineWebSocketAdapter };

package/dist/index.d.ts

@@ -1,6 +1,138 @@
-import { A as AdapterOptions, C as CrossWS } from './shared/crossws.a2e5c71e.js';
-export { b as Adapter, f as AdapterHooks, a as Caller, H as Hooks, M as Message, P as Peer, R as ResolveHooks, W as WSError, c as WSRequest, e as defineHooks, d as defineWebSocketAdapter } from './shared/crossws.a2e5c71e.js';
+import { W as WebSocket } from './shared/crossws.ChIJSJVK.js';
 
-declare function createCrossWS(opts?: AdapterOptions): CrossWS;
+interface AdapterInternal {
+    ws: unknown;
+    request?: Request | Partial<Request>;
+    peers?: Set<Peer>;
+}
+declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal> {
+    #private;
+    protected _internal: Internal;
+    protected _topics: Set<string>;
+    protected _id?: string;
+    constructor(internal: Internal);
+    /**
+     * Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the peer.
+     */
+    get id(): string;
+    /** IP address of the peer */
+    get remoteAddress(): string | undefined;
+    /** upgrade request */
+    get request(): Request | Partial<Request> | undefined;
+    /**
+     * 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(): Partial<WebSocket>;
+    /** All connected peers to the server */
+    get peers(): Set<Peer>;
+    abstract close(code?: number, reason?: string): void;
+    /** Abruptly close the connection */
+    terminate(): void;
+    /** Subscribe to a topic */
+    subscribe(topic: string): void;
+    /** Unsubscribe from a topic */
+    unsubscribe(topic: string): void;
+    /** Send a message to the peer. */
+    abstract send(data: unknown, options?: {
+        compress?: boolean;
+    }): number | void | undefined;
+    /** Send message to subscribes of topic */
+    abstract publish(topic: string, data: unknown, options?: {
+        compress?: boolean;
+    }): void;
+    toString(): string;
+    [Symbol.toPrimitive](): string;
+    [Symbol.toStringTag](): string;
+}
 
-export { AdapterOptions, CrossWS, createCrossWS };
+interface AdapterInstance {
+    readonly peers: Set<Peer>;
+    readonly publish: Peer["publish"];
+}
+interface AdapterOptions {
+    resolve?: ResolveHooks;
+    hooks?: Hooks;
+}
+type Adapter<AdapterT extends AdapterInstance = AdapterInstance, Options extends AdapterOptions = AdapterOptions> = (options?: Options) => AdapterT;
+declare function defineWebSocketAdapter<AdapterT extends AdapterInstance = AdapterInstance, Options extends AdapterOptions = AdapterOptions>(factory: Adapter<AdapterT, Options>): Adapter<AdapterT, Options>;
+
+declare class WSError extends Error {
+    constructor(...args: any[]);
+}
+
+declare class Message implements Partial<MessageEvent> {
+    #private;
+    /** Access to the original [message event](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/message_event) if available. */
+    readonly event?: MessageEvent;
+    /** Access to the Peer that emitted the message. */
+    readonly peer?: Peer;
+    /** Raw message data (can be of any type). */
+    readonly rawData: unknown;
+    constructor(rawData: unknown, peer: Peer, event?: MessageEvent);
+    /**
+     * Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the message.
+     */
+    get id(): string;
+    /**
+     * 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(): Uint8Array;
+    /**
+     * 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(): ArrayBuffer | SharedArrayBuffer;
+    /**
+     * 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(): Blob;
+    /**
+     * Get stringified text version of the message.
+     *
+     * If raw data is in any other format, it will be automatically converted and decoded.
+     */
+    text(): string;
+    /**
+     * 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<T = unknown>(): T;
+    /**
+     * Message data (value varies based on `peer.websocket.binaryType`).
+     */
+    get data(): unknown;
+    toString(): string;
+    [Symbol.toPrimitive](): string;
+}
+
+declare function defineHooks<T extends Partial<Hooks> = Partial<Hooks>>(hooks: T): T;
+type ResolveHooks = (info: RequestInit | Peer) => Partial<Hooks> | Promise<Partial<Hooks>>;
+type MaybePromise<T> = T | Promise<T>;
+interface Hooks {
+    /** Upgrading */
+    upgrade: (request: Request | {
+        url: string;
+        headers: Headers;
+    }) => MaybePromise<Response | ResponseInit | void>;
+    /** A message is received */
+    message: (peer: Peer, message: Message) => MaybePromise<void>;
+    /** A socket is opened */
+    open: (peer: Peer) => MaybePromise<void>;
+    /** A socket is closed */
+    close: (peer: Peer, details: {
+        code?: number;
+        reason?: string;
+    }) => MaybePromise<void>;
+    /** An error occurs */
+    error: (peer: Peer, error: WSError) => MaybePromise<void>;
+}
+
+export { type Adapter, type AdapterInstance, type AdapterOptions, type Hooks, Message, Peer, type ResolveHooks, WSError, defineHooks, defineWebSocketAdapter };

package/dist/index.mjs

@@ -1,10 +1 @@
-export { M as Message, P as Peer, c as createCrossWS, a as defineHooks, d as defineWebSocketAdapter } from './shared/crossws.34cfc8d0.mjs';
-
-class WSError extends Error {
-  constructor(...args) {
-    super(...args);
-    this.name = "WSError";
-  }
-}
-
-export { WSError };
+export { b as defineHooks, d as defineWebSocketAdapter } from './shared/crossws.B4sHId41.mjs';