full site update

node_modules/crossws/dist/adapters/bun.d.mts

@@ -0,0 +1,39 @@
+import { WebSocketHandler, ServerWebSocket, Server } from 'bun';
+import { Adapter, AdapterInstance, Peer, AdapterOptions } from '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+
+interface BunAdapter extends AdapterInstance {
+    websocket: WebSocketHandler<ContextData>;
+    handleUpgrade(req: Request, server: Server): Promise<Response | undefined>;
+}
+interface BunOptions extends AdapterOptions {
+}
+type ContextData = {
+    peer?: BunPeer;
+    request: Request;
+    server?: Server;
+    context: Peer["context"];
+};
+declare const bunAdapter: Adapter<BunAdapter, BunOptions>;
+
+declare class BunPeer extends Peer<{
+    ws: ServerWebSocket<ContextData>;
+    request: Request;
+    peers: Set<BunPeer>;
+}> {
+    get remoteAddress(): string;
+    get context(): Peer["context"];
+    send(data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    publish(topic: string, data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    close(code?: number, reason?: string): void;
+    terminate(): void;
+}
+
+export { bunAdapter as default };
+export type { BunAdapter, BunOptions };

node_modules/crossws/dist/adapters/bun.d.ts

@@ -0,0 +1,39 @@
+import { WebSocketHandler, ServerWebSocket, Server } from 'bun';
+import { Adapter, AdapterInstance, Peer, AdapterOptions } from '../index.js';
+import '../shared/crossws.BQXMA5bH.js';
+
+interface BunAdapter extends AdapterInstance {
+    websocket: WebSocketHandler<ContextData>;
+    handleUpgrade(req: Request, server: Server): Promise<Response | undefined>;
+}
+interface BunOptions extends AdapterOptions {
+}
+type ContextData = {
+    peer?: BunPeer;
+    request: Request;
+    server?: Server;
+    context: Peer["context"];
+};
+declare const bunAdapter: Adapter<BunAdapter, BunOptions>;
+
+declare class BunPeer extends Peer<{
+    ws: ServerWebSocket<ContextData>;
+    request: Request;
+    peers: Set<BunPeer>;
+}> {
+    get remoteAddress(): string;
+    get context(): Peer["context"];
+    send(data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    publish(topic: string, data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    close(code?: number, reason?: string): void;
+    terminate(): void;
+}
+
+export { bunAdapter as default };
+export type { BunAdapter, BunOptions };

node_modules/crossws/dist/adapters/bun.mjs

@@ -0,0 +1,89 @@
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
+import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
+import 'uncrypto';
+
+const bunAdapter = (options = {}) => {
+  const hooks = new AdapterHookable(options);
+  const peers = /* @__PURE__ */ new Set();
+  return {
+    ...adapterUtils(peers),
+    async handleUpgrade(request, server) {
+      const { upgradeHeaders, endResponse, context } = await hooks.upgrade(request);
+      if (endResponse) {
+        return endResponse;
+      }
+      const upgradeOK = server.upgrade(request, {
+        data: {
+          server,
+          request,
+          context
+        },
+        headers: upgradeHeaders
+      });
+      if (!upgradeOK) {
+        return new Response("Upgrade failed", { status: 500 });
+      }
+    },
+    websocket: {
+      message: (ws, message) => {
+        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);
+      },
+      close: (ws, code, reason) => {
+        const peer = getPeer(ws, peers);
+        peers.delete(peer);
+        hooks.callHook("close", peer, { code, reason });
+      }
+    }
+  };
+};
+function getPeer(ws, peers) {
+  if (ws.data?.peer) {
+    return ws.data.peer;
+  }
+  const peer = new BunPeer({ ws, request: ws.data.request, peers });
+  ws.data = {
+    ...ws.data,
+    peer
+  };
+  return peer;
+}
+class BunPeer extends Peer {
+  get remoteAddress() {
+    return this._internal.ws.remoteAddress;
+  }
+  get context() {
+    return this._internal.ws.data.context;
+  }
+  send(data, options) {
+    return this._internal.ws.send(toBufferLike(data), options?.compress);
+  }
+  publish(topic, data, options) {
+    return this._internal.ws.publish(
+      topic,
+      toBufferLike(data),
+      options?.compress
+    );
+  }
+  subscribe(topic) {
+    this._topics.add(topic);
+    this._internal.ws.subscribe(topic);
+  }
+  unsubscribe(topic) {
+    this._topics.delete(topic);
+    this._internal.ws.unsubscribe(topic);
+  }
+  close(code, reason) {
+    this._internal.ws.close(code, reason);
+  }
+  terminate() {
+    this._internal.ws.terminate();
+  }
+}
+
+export { bunAdapter as default };

node_modules/crossws/dist/adapters/cloudflare-durable.d.mts

@@ -0,0 +1,42 @@
+import * as CF from '@cloudflare/workers-types';
+import { DurableObject } from 'cloudflare:workers';
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.mjs';
+import { W as WebSocket$1 } from '../shared/crossws.BQXMA5bH.mjs';
+
+type ResolveDurableStub = (req: CF.Request, env: unknown, context: CF.ExecutionContext) => CF.DurableObjectStub | Promise<CF.DurableObjectStub>;
+interface CloudflareOptions extends AdapterOptions {
+    /**
+     * Durable Object binding name from environment.
+     *
+     * **Note:** This option will be ignored if `resolveDurableStub` is provided.
+     *
+     * @default "$DurableObject"
+     */
+    bindingName?: string;
+    /**
+     * Durable Object instance name.
+     *
+     * **Note:** This option will be ignored if `resolveDurableStub` is provided.
+     *
+     * @default "crossws"
+     */
+    instanceName?: string;
+    /**
+     * Custom function that resolves Durable Object binding to handle the WebSocket upgrade.
+     *
+     * **Note:** This option will override `bindingName` and `instanceName`.
+     */
+    resolveDurableStub?: ResolveDurableStub;
+}
+declare const cloudflareDurableAdapter: Adapter<CloudflareDurableAdapter, CloudflareOptions>;
+
+interface CloudflareDurableAdapter extends AdapterInstance {
+    handleUpgrade(req: Request | CF.Request, env: unknown, context: CF.ExecutionContext): Promise<Response>;
+    handleDurableInit(obj: DurableObject, state: DurableObjectState, env: unknown): void;
+    handleDurableUpgrade(obj: DurableObject, req: Request | CF.Request): Promise<Response>;
+    handleDurableMessage(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, message: ArrayBuffer | string): Promise<void>;
+    handleDurableClose(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, code: number, reason: string, wasClean: boolean): Promise<void>;
+}
+
+export { cloudflareDurableAdapter as default };
+export type { CloudflareDurableAdapter, CloudflareOptions };

node_modules/crossws/dist/adapters/cloudflare-durable.d.ts

@@ -0,0 +1,42 @@
+import * as CF from '@cloudflare/workers-types';
+import { DurableObject } from 'cloudflare:workers';
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.js';
+import { W as WebSocket$1 } from '../shared/crossws.BQXMA5bH.js';
+
+type ResolveDurableStub = (req: CF.Request, env: unknown, context: CF.ExecutionContext) => CF.DurableObjectStub | Promise<CF.DurableObjectStub>;
+interface CloudflareOptions extends AdapterOptions {
+    /**
+     * Durable Object binding name from environment.
+     *
+     * **Note:** This option will be ignored if `resolveDurableStub` is provided.
+     *
+     * @default "$DurableObject"
+     */
+    bindingName?: string;
+    /**
+     * Durable Object instance name.
+     *
+     * **Note:** This option will be ignored if `resolveDurableStub` is provided.
+     *
+     * @default "crossws"
+     */
+    instanceName?: string;
+    /**
+     * Custom function that resolves Durable Object binding to handle the WebSocket upgrade.
+     *
+     * **Note:** This option will override `bindingName` and `instanceName`.
+     */
+    resolveDurableStub?: ResolveDurableStub;
+}
+declare const cloudflareDurableAdapter: Adapter<CloudflareDurableAdapter, CloudflareOptions>;
+
+interface CloudflareDurableAdapter extends AdapterInstance {
+    handleUpgrade(req: Request | CF.Request, env: unknown, context: CF.ExecutionContext): Promise<Response>;
+    handleDurableInit(obj: DurableObject, state: DurableObjectState, env: unknown): void;
+    handleDurableUpgrade(obj: DurableObject, req: Request | CF.Request): Promise<Response>;
+    handleDurableMessage(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, message: ArrayBuffer | string): Promise<void>;
+    handleDurableClose(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, code: number, reason: string, wasClean: boolean): Promise<void>;
+}
+
+export { cloudflareDurableAdapter as default };
+export type { CloudflareDurableAdapter, CloudflareOptions };

node_modules/crossws/dist/adapters/cloudflare-durable.mjs

@@ -0,0 +1,141 @@
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
+import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
+import 'uncrypto';
+
+const cloudflareDurableAdapter = (opts = {}) => {
+  const hooks = new AdapterHookable(opts);
+  const peers = /* @__PURE__ */ new Set();
+  const resolveDurableStub = opts.resolveDurableStub || ((_req, env, _context) => {
+    const bindingName = opts.bindingName || "$DurableObject";
+    const binding = env[bindingName];
+    if (!binding) {
+      throw new Error(
+        `Durable Object binding "${bindingName}" not available`
+      );
+    }
+    const instanceId = binding.idFromName(opts.instanceName || "crossws");
+    return binding.get(instanceId);
+  });
+  return {
+    ...adapterUtils(peers),
+    handleUpgrade: async (req, env, context) => {
+      const stub = await resolveDurableStub(req, env, context);
+      return stub.fetch(req);
+    },
+    handleDurableInit: async (obj, state, env) => {
+    },
+    handleDurableUpgrade: async (obj, request) => {
+      const { upgradeHeaders, endResponse } = await hooks.upgrade(
+        request
+      );
+      if (endResponse) {
+        return endResponse;
+      }
+      const pair = new WebSocketPair();
+      const client = pair[0];
+      const server = pair[1];
+      const peer = CloudflareDurablePeer._restore(
+        obj,
+        server,
+        request
+      );
+      peers.add(peer);
+      obj.ctx.acceptWebSocket(server);
+      await hooks.callHook("open", peer);
+      return new Response(null, {
+        status: 101,
+        webSocket: client,
+        headers: upgradeHeaders
+      });
+    },
+    handleDurableMessage: async (obj, ws, message) => {
+      const peer = CloudflareDurablePeer._restore(obj, ws);
+      await hooks.callHook("message", peer, new Message(message, peer));
+    },
+    handleDurableClose: async (obj, ws, code, reason, wasClean) => {
+      const peer = CloudflareDurablePeer._restore(obj, ws);
+      peers.delete(peer);
+      const details = { code, reason, wasClean };
+      await hooks.callHook("close", peer, details);
+    }
+  };
+};
+class CloudflareDurablePeer extends Peer {
+  get peers() {
+    return new Set(
+      this.#getwebsockets().map(
+        (ws) => CloudflareDurablePeer._restore(this._internal.durable, ws)
+      )
+    );
+  }
+  #getwebsockets() {
+    return this._internal.durable.ctx.getWebSockets();
+  }
+  send(data) {
+    return this._internal.ws.send(toBufferLike(data));
+  }
+  subscribe(topic) {
+    super.subscribe(topic);
+    const state = getAttachedState(this._internal.ws);
+    if (!state.t) {
+      state.t = /* @__PURE__ */ new Set();
+    }
+    state.t.add(topic);
+    setAttachedState(this._internal.ws, state);
+  }
+  publish(topic, data) {
+    const websockets = this.#getwebsockets();
+    if (websockets.length < 2) {
+      return;
+    }
+    const dataBuff = toBufferLike(data);
+    for (const ws of websockets) {
+      if (ws === this._internal.ws) {
+        continue;
+      }
+      const state = getAttachedState(ws);
+      if (state.t?.has(topic)) {
+        ws.send(dataBuff);
+      }
+    }
+  }
+  close(code, reason) {
+    this._internal.ws.close(code, reason);
+  }
+  static _restore(durable, ws, request) {
+    let peer = ws._crosswsPeer;
+    if (peer) {
+      return peer;
+    }
+    const state = ws.deserializeAttachment() || {};
+    peer = ws._crosswsPeer = new CloudflareDurablePeer({
+      ws,
+      request: request || { url: state.u },
+      durable
+    });
+    if (state.i) {
+      peer._id = state.i;
+    }
+    if (request?.url) {
+      state.u = request.url;
+    }
+    state.i = peer.id;
+    setAttachedState(ws, state);
+    return peer;
+  }
+}
+function getAttachedState(ws) {
+  let state = ws._crosswsState;
+  if (state) {
+    return state;
+  }
+  state = ws.deserializeAttachment() || {};
+  ws._crosswsState = state;
+  return state;
+}
+function setAttachedState(ws, state) {
+  ws._crosswsState = state;
+  ws.serializeAttachment(state);
+}
+
+export { cloudflareDurableAdapter as default };

node_modules/crossws/dist/adapters/cloudflare.d.mts

@@ -0,0 +1,13 @@
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.mjs';
+import * as CF from '@cloudflare/workers-types';
+import '../shared/crossws.BQXMA5bH.mjs';
+
+interface CloudflareAdapter extends AdapterInstance {
+    handleUpgrade(req: CF.Request, env: unknown, context: CF.ExecutionContext): Promise<CF.Response>;
+}
+interface CloudflareOptions extends AdapterOptions {
+}
+declare const cloudflareAdapter: Adapter<CloudflareAdapter, CloudflareOptions>;
+
+export { cloudflareAdapter as default };
+export type { CloudflareAdapter, CloudflareOptions };

node_modules/crossws/dist/adapters/cloudflare.d.ts

@@ -0,0 +1,13 @@
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.js';
+import * as CF from '@cloudflare/workers-types';
+import '../shared/crossws.BQXMA5bH.js';
+
+interface CloudflareAdapter extends AdapterInstance {
+    handleUpgrade(req: CF.Request, env: unknown, context: CF.ExecutionContext): Promise<CF.Response>;
+}
+interface CloudflareOptions extends AdapterOptions {
+}
+declare const cloudflareAdapter: Adapter<CloudflareAdapter, CloudflareOptions>;
+
+export { cloudflareAdapter as default };
+export type { CloudflareAdapter, CloudflareOptions };

node_modules/crossws/dist/adapters/cloudflare.mjs

@@ -0,0 +1,68 @@
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
+import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
+import { W as WSError } from '../shared/crossws.By9qWDAI.mjs';
+import 'uncrypto';
+
+const cloudflareAdapter = (options = {}) => {
+  const hooks = new AdapterHookable(options);
+  const peers = /* @__PURE__ */ new Set();
+  return {
+    ...adapterUtils(peers),
+    handleUpgrade: async (request, env, cfCtx) => {
+      const { upgradeHeaders, endResponse, context } = await hooks.upgrade(
+        request
+      );
+      if (endResponse) {
+        return endResponse;
+      }
+      const pair = new WebSocketPair();
+      const client = pair[0];
+      const server = pair[1];
+      const peer = new CloudflarePeer({
+        ws: client,
+        peers,
+        wsServer: server,
+        request,
+        cfEnv: env,
+        cfCtx,
+        context
+      });
+      peers.add(peer);
+      server.accept();
+      hooks.callHook("open", peer);
+      server.addEventListener("message", (event) => {
+        hooks.callHook(
+          "message",
+          peer,
+          new Message(event.data, peer, event)
+        );
+      });
+      server.addEventListener("error", (event) => {
+        peers.delete(peer);
+        hooks.callHook("error", peer, new WSError(event.error));
+      });
+      server.addEventListener("close", (event) => {
+        peers.delete(peer);
+        hooks.callHook("close", peer, event);
+      });
+      return new Response(null, {
+        status: 101,
+        webSocket: client,
+        headers: upgradeHeaders
+      });
+    }
+  };
+};
+class CloudflarePeer extends Peer {
+  send(data) {
+    this._internal.wsServer.send(toBufferLike(data));
+    return 0;
+  }
+  publish(_topic, _message) {
+  }
+  close(code, reason) {
+    this._internal.ws.close(code, reason);
+  }
+}
+
+export { cloudflareAdapter as default };

node_modules/crossws/dist/adapters/deno.d.mts

@@ -0,0 +1,19 @@
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+
+interface DenoAdapter extends AdapterInstance {
+    handleUpgrade(req: Request, info: ServeHandlerInfo): Promise<Response>;
+}
+interface DenoOptions extends AdapterOptions {
+}
+type ServeHandlerInfo = {
+    remoteAddr?: {
+        transport: string;
+        hostname: string;
+        port: number;
+    };
+};
+declare const denoAdapter: Adapter<DenoAdapter, DenoOptions>;
+
+export { denoAdapter as default };
+export type { DenoAdapter, DenoOptions };

node_modules/crossws/dist/adapters/deno.d.ts

@@ -0,0 +1,19 @@
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.js';
+import '../shared/crossws.BQXMA5bH.js';
+
+interface DenoAdapter extends AdapterInstance {
+    handleUpgrade(req: Request, info: ServeHandlerInfo): Promise<Response>;
+}
+interface DenoOptions extends AdapterOptions {
+}
+type ServeHandlerInfo = {
+    remoteAddr?: {
+        transport: string;
+        hostname: string;
+        port: number;
+    };
+};
+declare const denoAdapter: Adapter<DenoAdapter, DenoOptions>;
+
+export { denoAdapter as default };
+export type { DenoAdapter, DenoOptions };

node_modules/crossws/dist/adapters/deno.mjs

@@ -0,0 +1,69 @@
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
+import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
+import { W as WSError } from '../shared/crossws.By9qWDAI.mjs';
+import 'uncrypto';
+
+const denoAdapter = (options = {}) => {
+  const hooks = new AdapterHookable(options);
+  const peers = /* @__PURE__ */ new Set();
+  return {
+    ...adapterUtils(peers),
+    handleUpgrade: async (request, info) => {
+      const { upgradeHeaders, endResponse, context } = await hooks.upgrade(request);
+      if (endResponse) {
+        return endResponse;
+      }
+      const upgrade = Deno.upgradeWebSocket(request, {
+        // @ts-expect-error https://github.com/denoland/deno/pull/22242
+        headers: upgradeHeaders
+      });
+      const peer = new DenoPeer({
+        ws: upgrade.socket,
+        request,
+        peers,
+        denoInfo: info,
+        context
+      });
+      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 remoteAddress() {
+    return this._internal.denoInfo.remoteAddr?.hostname;
+  }
+  send(data) {
+    return this._internal.ws.send(toBufferLike(data));
+  }
+  publish(topic, data) {
+    const dataBuff = toBufferLike(data);
+    for (const peer of this._internal.peers) {
+      if (peer !== this && peer._topics.has(topic)) {
+        peer._internal.ws.send(dataBuff);
+      }
+    }
+  }
+  close(code, reason) {
+    this._internal.ws.close(code, reason);
+  }
+  terminate() {
+    this._internal.ws.terminate();
+  }
+}
+
+export { denoAdapter as default };

node_modules/crossws/dist/adapters/node.d.mts

@@ -0,0 +1,299 @@
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.mjs';
+import { Agent, ClientRequestArgs, IncomingMessage, ClientRequest, Server as Server$1, OutgoingHttpHeaders } from 'node:http';
+import { DuplexOptions, Duplex } from 'node:stream';
+import { EventEmitter } from 'events';
+import { Server as Server$2 } from 'node:https';
+import { SecureContextOptions } from 'node:tls';
+import { URL } from 'node:url';
+import { ZlibOptions } from 'node:zlib';
+import '../shared/crossws.BQXMA5bH.mjs';
+
+type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly any[] | readonly number[] | {
+    valueOf(): ArrayBuffer;
+} | {
+    valueOf(): SharedArrayBuffer;
+} | {
+    valueOf(): Uint8Array;
+} | {
+    valueOf(): readonly number[];
+} | {
+    valueOf(): string;
+} | {
+    [Symbol.toPrimitive](hint: string): string;
+};
+declare class WebSocket extends EventEmitter {
+    static readonly createWebSocketStream: typeof createWebSocketStream;
+    static readonly WebSocketServer: WebSocketServer;
+    static readonly Server: typeof Server;
+    static readonly WebSocket: typeof WebSocket;
+    /** The connection is not yet open. */
+    static readonly CONNECTING: 0;
+    /** The connection is open and ready to communicate. */
+    static readonly OPEN: 1;
+    /** The connection is in the process of closing. */
+    static readonly CLOSING: 2;
+    /** The connection is closed. */
+    static readonly CLOSED: 3;
+    binaryType: "nodebuffer" | "arraybuffer" | "fragments";
+    readonly bufferedAmount: number;
+    readonly extensions: string;
+    /** Indicates whether the websocket is paused */
+    readonly isPaused: boolean;
+    readonly protocol: string;
+    /** The current state of the connection */
+    readonly readyState: typeof WebSocket.CONNECTING | typeof WebSocket.OPEN | typeof WebSocket.CLOSING | typeof WebSocket.CLOSED;
+    readonly url: string;
+    /** The connection is not yet open. */
+    readonly CONNECTING: 0;
+    /** The connection is open and ready to communicate. */
+    readonly OPEN: 1;
+    /** The connection is in the process of closing. */
+    readonly CLOSING: 2;
+    /** The connection is closed. */
+    readonly CLOSED: 3;
+    onopen: ((event: Event) => void) | null;
+    onerror: ((event: ErrorEvent) => void) | null;
+    onclose: ((event: CloseEvent) => void) | null;
+    onmessage: ((event: MessageEvent) => void) | null;
+    constructor(address: null);
+    constructor(address: string | URL, options?: ClientOptions | ClientRequestArgs);
+    constructor(address: string | URL, protocols?: string | string[], options?: ClientOptions | ClientRequestArgs);
+    close(code?: number, data?: string | Buffer): void;
+    ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+    pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+    send(data: BufferLike, cb?: (err?: Error) => void): void;
+    send(data: BufferLike, options: {
+        mask?: boolean | undefined;
+        binary?: boolean | undefined;
+        compress?: boolean | undefined;
+        fin?: boolean | undefined;
+    }, cb?: (err?: Error) => void): void;
+    terminate(): void;
+    /**
+     * Pause the websocket causing it to stop emitting events. Some events can still be
+     * emitted after this is called, until all buffered data is consumed. This method
+     * is a noop if the ready state is `CONNECTING` or `CLOSED`.
+     */
+    pause(): void;
+    /**
+     * Make a paused socket resume emitting events. This method is a noop if the ready
+     * state is `CONNECTING` or `CLOSED`.
+     */
+    resume(): void;
+    addEventListener(method: "message", cb: (event: MessageEvent) => void, options?: EventListenerOptions): void;
+    addEventListener(method: "close", cb: (event: CloseEvent) => void, options?: EventListenerOptions): void;
+    addEventListener(method: "error", cb: (event: ErrorEvent) => void, options?: EventListenerOptions): void;
+    addEventListener(method: "open", cb: (event: Event) => void, options?: EventListenerOptions): void;
+    removeEventListener(method: "message", cb: (event: MessageEvent) => void): void;
+    removeEventListener(method: "close", cb: (event: CloseEvent) => void): void;
+    removeEventListener(method: "error", cb: (event: ErrorEvent) => void): void;
+    removeEventListener(method: "open", cb: (event: Event) => void): void;
+    on(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
+    on(event: "error", listener: (this: WebSocket, err: Error) => void): this;
+    on(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this;
+    on(event: "message", listener: (this: WebSocket, data: RawData, isBinary: boolean) => void): this;
+    on(event: "open", listener: (this: WebSocket) => void): this;
+    on(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this;
+    on(event: "unexpected-response", listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void): this;
+    on(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
+    once(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
+    once(event: "error", listener: (this: WebSocket, err: Error) => void): this;
+    once(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this;
+    once(event: "message", listener: (this: WebSocket, data: RawData, isBinary: boolean) => void): this;
+    once(event: "open", listener: (this: WebSocket) => void): this;
+    once(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this;
+    once(event: "unexpected-response", listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void): this;
+    once(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
+    off(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
+    off(event: "error", listener: (this: WebSocket, err: Error) => void): this;
+    off(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this;
+    off(event: "message", listener: (this: WebSocket, data: RawData, isBinary: boolean) => void): this;
+    off(event: "open", listener: (this: WebSocket) => void): this;
+    off(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this;
+    off(event: "unexpected-response", listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void): this;
+    off(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
+    addListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "upgrade", listener: (request: IncomingMessage) => void): this;
+    addListener(event: "message", listener: (data: RawData, isBinary: boolean) => void): this;
+    addListener(event: "open", listener: () => void): this;
+    addListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
+    addListener(event: "unexpected-response", listener: (request: ClientRequest, response: IncomingMessage) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
+    removeListener(event: "error", listener: (err: Error) => void): this;
+    removeListener(event: "upgrade", listener: (request: IncomingMessage) => void): this;
+    removeListener(event: "message", listener: (data: RawData, isBinary: boolean) => void): this;
+    removeListener(event: "open", listener: () => void): this;
+    removeListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
+    removeListener(event: "unexpected-response", listener: (request: ClientRequest, response: IncomingMessage) => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+/**
+ * Data represents the raw message payload received over the
+ */
+type RawData = Buffer | ArrayBuffer | Buffer[];
+/**
+ * Data represents the message payload received over the
+ */
+type Data = string | Buffer | ArrayBuffer | Buffer[];
+/**
+ * CertMeta represents the accepted types for certificate & key data.
+ */
+type CertMeta = string | string[] | Buffer | Buffer[];
+/**
+ * VerifyClientCallbackSync is a synchronous callback used to inspect the
+ * incoming message. The return value (boolean) of the function determines
+ * whether or not to accept the handshake.
+ */
+type VerifyClientCallbackSync<Request extends IncomingMessage = IncomingMessage> = (info: {
+    origin: string;
+    secure: boolean;
+    req: Request;
+}) => boolean;
+/**
+ * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
+ * incoming message. The return value (boolean) of the function determines
+ * whether or not to accept the handshake.
+ */
+type VerifyClientCallbackAsync<Request extends IncomingMessage = IncomingMessage> = (info: {
+    origin: string;
+    secure: boolean;
+    req: Request;
+}, callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void) => void;
+interface ClientOptions extends SecureContextOptions {
+    protocol?: string | undefined;
+    followRedirects?: boolean | undefined;
+    generateMask?(mask: Buffer): void;
+    handshakeTimeout?: number | undefined;
+    maxRedirects?: number | undefined;
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+    localAddress?: string | undefined;
+    protocolVersion?: number | undefined;
+    headers?: {
+        [key: string]: string;
+    } | undefined;
+    origin?: string | undefined;
+    agent?: Agent | undefined;
+    host?: string | undefined;
+    family?: number | undefined;
+    checkServerIdentity?(servername: string, cert: CertMeta): boolean;
+    rejectUnauthorized?: boolean | undefined;
+    maxPayload?: number | undefined;
+    skipUTF8Validation?: boolean | undefined;
+}
+interface PerMessageDeflateOptions {
+    serverNoContextTakeover?: boolean | undefined;
+    clientNoContextTakeover?: boolean | undefined;
+    serverMaxWindowBits?: number | undefined;
+    clientMaxWindowBits?: number | undefined;
+    zlibDeflateOptions?: {
+        flush?: number | undefined;
+        finishFlush?: number | undefined;
+        chunkSize?: number | undefined;
+        windowBits?: number | undefined;
+        level?: number | undefined;
+        memLevel?: number | undefined;
+        strategy?: number | undefined;
+        dictionary?: Buffer | Buffer[] | DataView | undefined;
+        info?: boolean | undefined;
+    } | undefined;
+    zlibInflateOptions?: ZlibOptions | undefined;
+    threshold?: number | undefined;
+    concurrencyLimit?: number | undefined;
+}
+interface Event {
+    type: string;
+    target: WebSocket;
+}
+interface ErrorEvent {
+    error: any;
+    message: string;
+    type: string;
+    target: WebSocket;
+}
+interface CloseEvent {
+    wasClean: boolean;
+    code: number;
+    reason: string;
+    type: string;
+    target: WebSocket;
+}
+interface MessageEvent {
+    data: Data;
+    type: string;
+    target: WebSocket;
+}
+interface EventListenerOptions {
+    once?: boolean | undefined;
+}
+interface ServerOptions<U extends typeof WebSocket = typeof WebSocket, V extends typeof IncomingMessage = typeof IncomingMessage> {
+    host?: string | undefined;
+    port?: number | undefined;
+    backlog?: number | undefined;
+    server?: Server$1<V> | Server$2<V> | undefined;
+    verifyClient?: VerifyClientCallbackAsync<InstanceType<V>> | VerifyClientCallbackSync<InstanceType<V>> | undefined;
+    handleProtocols?: (protocols: Set<string>, request: InstanceType<V>) => string | false;
+    path?: string | undefined;
+    noServer?: boolean | undefined;
+    clientTracking?: boolean | undefined;
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+    maxPayload?: number | undefined;
+    skipUTF8Validation?: boolean | undefined;
+    WebSocket?: U | undefined;
+}
+interface AddressInfo {
+    address: string;
+    family: string;
+    port: number;
+}
+declare class Server<T extends typeof WebSocket = typeof WebSocket, U extends typeof IncomingMessage = typeof IncomingMessage> extends EventEmitter {
+    options: ServerOptions<T, U>;
+    path: string;
+    clients: Set<InstanceType<T>>;
+    constructor(options?: ServerOptions<T, U>, callback?: () => void);
+    address(): AddressInfo | string;
+    close(cb?: (err?: Error) => void): void;
+    handleUpgrade(request: InstanceType<U>, socket: Duplex, upgradeHead: Buffer, callback: (client: InstanceType<T>, request: InstanceType<U>) => void): void;
+    shouldHandle(request: InstanceType<U>): boolean | Promise<boolean>;
+    on(event: "connection", cb: (this: Server<T>, socket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    on(event: "error", cb: (this: Server<T>, error: Error) => void): this;
+    on(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
+    on(event: "close" | "listening", cb: (this: Server<T>) => void): this;
+    on(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    once(event: "connection", cb: (this: Server<T>, socket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    once(event: "error", cb: (this: Server<T>, error: Error) => void): this;
+    once(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
+    once(event: "close" | "listening", cb: (this: Server<T>) => void): this;
+    once(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    off(event: "connection", cb: (this: Server<T>, socket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    off(event: "error", cb: (this: Server<T>, error: Error) => void): this;
+    off(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
+    off(event: "close" | "listening", cb: (this: Server<T>) => void): this;
+    off(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    addListener(event: "connection", cb: (client: InstanceType<T>, request: InstanceType<U>) => void): this;
+    addListener(event: "error", cb: (err: Error) => void): this;
+    addListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    addListener(event: "close" | "listening", cb: () => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener(event: "connection", cb: (client: InstanceType<T>, request: InstanceType<U>) => void): this;
+    removeListener(event: "error", cb: (err: Error) => void): this;
+    removeListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    removeListener(event: "close" | "listening", cb: () => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+type WebSocketServer = Server;
+declare function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
+
+interface NodeAdapter extends AdapterInstance {
+    handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer): Promise<void>;
+    closeAll: (code?: number, data?: string | Buffer, force?: boolean) => void;
+}
+interface NodeOptions extends AdapterOptions {
+    wss?: WebSocketServer;
+    serverOptions?: ServerOptions;
+}
+declare const nodeAdapter: Adapter<NodeAdapter, NodeOptions>;
+
+export { nodeAdapter as default };
+export type { NodeAdapter, NodeOptions };

node_modules/crossws/dist/adapters/node.d.ts

@@ -0,0 +1,299 @@
+import { Adapter, AdapterInstance, AdapterOptions } from '../index.js';
+import { Agent, ClientRequestArgs, IncomingMessage, ClientRequest, Server as Server$1, OutgoingHttpHeaders } from 'node:http';
+import { DuplexOptions, Duplex } from 'node:stream';
+import { EventEmitter } from 'events';
+import { Server as Server$2 } from 'node:https';
+import { SecureContextOptions } from 'node:tls';
+import { URL } from 'node:url';
+import { ZlibOptions } from 'node:zlib';
+import '../shared/crossws.BQXMA5bH.js';
+
+type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly any[] | readonly number[] | {
+    valueOf(): ArrayBuffer;
+} | {
+    valueOf(): SharedArrayBuffer;
+} | {
+    valueOf(): Uint8Array;
+} | {
+    valueOf(): readonly number[];
+} | {
+    valueOf(): string;
+} | {
+    [Symbol.toPrimitive](hint: string): string;
+};
+declare class WebSocket extends EventEmitter {
+    static readonly createWebSocketStream: typeof createWebSocketStream;
+    static readonly WebSocketServer: WebSocketServer;
+    static readonly Server: typeof Server;
+    static readonly WebSocket: typeof WebSocket;
+    /** The connection is not yet open. */
+    static readonly CONNECTING: 0;
+    /** The connection is open and ready to communicate. */
+    static readonly OPEN: 1;
+    /** The connection is in the process of closing. */
+    static readonly CLOSING: 2;
+    /** The connection is closed. */
+    static readonly CLOSED: 3;
+    binaryType: "nodebuffer" | "arraybuffer" | "fragments";
+    readonly bufferedAmount: number;
+    readonly extensions: string;
+    /** Indicates whether the websocket is paused */
+    readonly isPaused: boolean;
+    readonly protocol: string;
+    /** The current state of the connection */
+    readonly readyState: typeof WebSocket.CONNECTING | typeof WebSocket.OPEN | typeof WebSocket.CLOSING | typeof WebSocket.CLOSED;
+    readonly url: string;
+    /** The connection is not yet open. */
+    readonly CONNECTING: 0;
+    /** The connection is open and ready to communicate. */
+    readonly OPEN: 1;
+    /** The connection is in the process of closing. */
+    readonly CLOSING: 2;
+    /** The connection is closed. */
+    readonly CLOSED: 3;
+    onopen: ((event: Event) => void) | null;
+    onerror: ((event: ErrorEvent) => void) | null;
+    onclose: ((event: CloseEvent) => void) | null;
+    onmessage: ((event: MessageEvent) => void) | null;
+    constructor(address: null);
+    constructor(address: string | URL, options?: ClientOptions | ClientRequestArgs);
+    constructor(address: string | URL, protocols?: string | string[], options?: ClientOptions | ClientRequestArgs);
+    close(code?: number, data?: string | Buffer): void;
+    ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+    pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+    send(data: BufferLike, cb?: (err?: Error) => void): void;
+    send(data: BufferLike, options: {
+        mask?: boolean | undefined;
+        binary?: boolean | undefined;
+        compress?: boolean | undefined;
+        fin?: boolean | undefined;
+    }, cb?: (err?: Error) => void): void;
+    terminate(): void;
+    /**
+     * Pause the websocket causing it to stop emitting events. Some events can still be
+     * emitted after this is called, until all buffered data is consumed. This method
+     * is a noop if the ready state is `CONNECTING` or `CLOSED`.
+     */
+    pause(): void;
+    /**
+     * Make a paused socket resume emitting events. This method is a noop if the ready
+     * state is `CONNECTING` or `CLOSED`.
+     */
+    resume(): void;
+    addEventListener(method: "message", cb: (event: MessageEvent) => void, options?: EventListenerOptions): void;
+    addEventListener(method: "close", cb: (event: CloseEvent) => void, options?: EventListenerOptions): void;
+    addEventListener(method: "error", cb: (event: ErrorEvent) => void, options?: EventListenerOptions): void;
+    addEventListener(method: "open", cb: (event: Event) => void, options?: EventListenerOptions): void;
+    removeEventListener(method: "message", cb: (event: MessageEvent) => void): void;
+    removeEventListener(method: "close", cb: (event: CloseEvent) => void): void;
+    removeEventListener(method: "error", cb: (event: ErrorEvent) => void): void;
+    removeEventListener(method: "open", cb: (event: Event) => void): void;
+    on(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
+    on(event: "error", listener: (this: WebSocket, err: Error) => void): this;
+    on(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this;
+    on(event: "message", listener: (this: WebSocket, data: RawData, isBinary: boolean) => void): this;
+    on(event: "open", listener: (this: WebSocket) => void): this;
+    on(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this;
+    on(event: "unexpected-response", listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void): this;
+    on(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
+    once(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
+    once(event: "error", listener: (this: WebSocket, err: Error) => void): this;
+    once(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this;
+    once(event: "message", listener: (this: WebSocket, data: RawData, isBinary: boolean) => void): this;
+    once(event: "open", listener: (this: WebSocket) => void): this;
+    once(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this;
+    once(event: "unexpected-response", listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void): this;
+    once(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
+    off(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
+    off(event: "error", listener: (this: WebSocket, err: Error) => void): this;
+    off(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this;
+    off(event: "message", listener: (this: WebSocket, data: RawData, isBinary: boolean) => void): this;
+    off(event: "open", listener: (this: WebSocket) => void): this;
+    off(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this;
+    off(event: "unexpected-response", listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void): this;
+    off(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
+    addListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "upgrade", listener: (request: IncomingMessage) => void): this;
+    addListener(event: "message", listener: (data: RawData, isBinary: boolean) => void): this;
+    addListener(event: "open", listener: () => void): this;
+    addListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
+    addListener(event: "unexpected-response", listener: (request: ClientRequest, response: IncomingMessage) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
+    removeListener(event: "error", listener: (err: Error) => void): this;
+    removeListener(event: "upgrade", listener: (request: IncomingMessage) => void): this;
+    removeListener(event: "message", listener: (data: RawData, isBinary: boolean) => void): this;
+    removeListener(event: "open", listener: () => void): this;
+    removeListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
+    removeListener(event: "unexpected-response", listener: (request: ClientRequest, response: IncomingMessage) => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+/**
+ * Data represents the raw message payload received over the
+ */
+type RawData = Buffer | ArrayBuffer | Buffer[];
+/**
+ * Data represents the message payload received over the
+ */
+type Data = string | Buffer | ArrayBuffer | Buffer[];
+/**
+ * CertMeta represents the accepted types for certificate & key data.
+ */
+type CertMeta = string | string[] | Buffer | Buffer[];
+/**
+ * VerifyClientCallbackSync is a synchronous callback used to inspect the
+ * incoming message. The return value (boolean) of the function determines
+ * whether or not to accept the handshake.
+ */
+type VerifyClientCallbackSync<Request extends IncomingMessage = IncomingMessage> = (info: {
+    origin: string;
+    secure: boolean;
+    req: Request;
+}) => boolean;
+/**
+ * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
+ * incoming message. The return value (boolean) of the function determines
+ * whether or not to accept the handshake.
+ */
+type VerifyClientCallbackAsync<Request extends IncomingMessage = IncomingMessage> = (info: {
+    origin: string;
+    secure: boolean;
+    req: Request;
+}, callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void) => void;
+interface ClientOptions extends SecureContextOptions {
+    protocol?: string | undefined;
+    followRedirects?: boolean | undefined;
+    generateMask?(mask: Buffer): void;
+    handshakeTimeout?: number | undefined;
+    maxRedirects?: number | undefined;
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+    localAddress?: string | undefined;
+    protocolVersion?: number | undefined;
+    headers?: {
+        [key: string]: string;
+    } | undefined;
+    origin?: string | undefined;
+    agent?: Agent | undefined;
+    host?: string | undefined;
+    family?: number | undefined;
+    checkServerIdentity?(servername: string, cert: CertMeta): boolean;
+    rejectUnauthorized?: boolean | undefined;
+    maxPayload?: number | undefined;
+    skipUTF8Validation?: boolean | undefined;
+}
+interface PerMessageDeflateOptions {
+    serverNoContextTakeover?: boolean | undefined;
+    clientNoContextTakeover?: boolean | undefined;
+    serverMaxWindowBits?: number | undefined;
+    clientMaxWindowBits?: number | undefined;
+    zlibDeflateOptions?: {
+        flush?: number | undefined;
+        finishFlush?: number | undefined;
+        chunkSize?: number | undefined;
+        windowBits?: number | undefined;
+        level?: number | undefined;
+        memLevel?: number | undefined;
+        strategy?: number | undefined;
+        dictionary?: Buffer | Buffer[] | DataView | undefined;
+        info?: boolean | undefined;
+    } | undefined;
+    zlibInflateOptions?: ZlibOptions | undefined;
+    threshold?: number | undefined;
+    concurrencyLimit?: number | undefined;
+}
+interface Event {
+    type: string;
+    target: WebSocket;
+}
+interface ErrorEvent {
+    error: any;
+    message: string;
+    type: string;
+    target: WebSocket;
+}
+interface CloseEvent {
+    wasClean: boolean;
+    code: number;
+    reason: string;
+    type: string;
+    target: WebSocket;
+}
+interface MessageEvent {
+    data: Data;
+    type: string;
+    target: WebSocket;
+}
+interface EventListenerOptions {
+    once?: boolean | undefined;
+}
+interface ServerOptions<U extends typeof WebSocket = typeof WebSocket, V extends typeof IncomingMessage = typeof IncomingMessage> {
+    host?: string | undefined;
+    port?: number | undefined;
+    backlog?: number | undefined;
+    server?: Server$1<V> | Server$2<V> | undefined;
+    verifyClient?: VerifyClientCallbackAsync<InstanceType<V>> | VerifyClientCallbackSync<InstanceType<V>> | undefined;
+    handleProtocols?: (protocols: Set<string>, request: InstanceType<V>) => string | false;
+    path?: string | undefined;
+    noServer?: boolean | undefined;
+    clientTracking?: boolean | undefined;
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+    maxPayload?: number | undefined;
+    skipUTF8Validation?: boolean | undefined;
+    WebSocket?: U | undefined;
+}
+interface AddressInfo {
+    address: string;
+    family: string;
+    port: number;
+}
+declare class Server<T extends typeof WebSocket = typeof WebSocket, U extends typeof IncomingMessage = typeof IncomingMessage> extends EventEmitter {
+    options: ServerOptions<T, U>;
+    path: string;
+    clients: Set<InstanceType<T>>;
+    constructor(options?: ServerOptions<T, U>, callback?: () => void);
+    address(): AddressInfo | string;
+    close(cb?: (err?: Error) => void): void;
+    handleUpgrade(request: InstanceType<U>, socket: Duplex, upgradeHead: Buffer, callback: (client: InstanceType<T>, request: InstanceType<U>) => void): void;
+    shouldHandle(request: InstanceType<U>): boolean | Promise<boolean>;
+    on(event: "connection", cb: (this: Server<T>, socket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    on(event: "error", cb: (this: Server<T>, error: Error) => void): this;
+    on(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
+    on(event: "close" | "listening", cb: (this: Server<T>) => void): this;
+    on(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    once(event: "connection", cb: (this: Server<T>, socket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    once(event: "error", cb: (this: Server<T>, error: Error) => void): this;
+    once(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
+    once(event: "close" | "listening", cb: (this: Server<T>) => void): this;
+    once(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    off(event: "connection", cb: (this: Server<T>, socket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    off(event: "error", cb: (this: Server<T>, error: Error) => void): this;
+    off(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
+    off(event: "close" | "listening", cb: (this: Server<T>) => void): this;
+    off(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    addListener(event: "connection", cb: (client: InstanceType<T>, request: InstanceType<U>) => void): this;
+    addListener(event: "error", cb: (err: Error) => void): this;
+    addListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    addListener(event: "close" | "listening", cb: () => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener(event: "connection", cb: (client: InstanceType<T>, request: InstanceType<U>) => void): this;
+    removeListener(event: "error", cb: (err: Error) => void): this;
+    removeListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    removeListener(event: "close" | "listening", cb: () => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+type WebSocketServer = Server;
+declare function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
+
+interface NodeAdapter extends AdapterInstance {
+    handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer): Promise<void>;
+    closeAll: (code?: number, data?: string | Buffer, force?: boolean) => void;
+}
+interface NodeOptions extends AdapterOptions {
+    wss?: WebSocketServer;
+    serverOptions?: ServerOptions;
+}
+declare const nodeAdapter: Adapter<NodeAdapter, NodeOptions>;
+
+export { nodeAdapter as default };
+export type { NodeAdapter, NodeOptions };

node_modules/crossws/dist/adapters/node.mjs

@@ -0,0 +1,163 @@
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
+import { A as AdapterHookable, a as adapterUtils } from '../shared/crossws.D9ehKjSh.mjs';
+import { W as WSError } from '../shared/crossws.By9qWDAI.mjs';
+import { _ as _WebSocketServer } from '../shared/crossws.CipVM6lf.mjs';
+import 'uncrypto';
+import 'stream';
+import 'events';
+import 'http';
+import 'crypto';
+import 'buffer';
+import 'zlib';
+import 'https';
+import 'net';
+import 'tls';
+import 'url';
+
+const nodeAdapter = (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, 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);
+      }
+      hooks.callHook("message", peer, new Message(data, peer));
+    });
+    ws.on("error", (error) => {
+      peers.delete(peer);
+      hooks.callHook("error", peer, new WSError(error));
+    });
+    ws.on("close", (code, reason) => {
+      peers.delete(peer);
+      hooks.callHook("close", peer, {
+        code,
+        reason: reason?.toString()
+      });
+    });
+  });
+  wss.on("headers", (outgoingHeaders, req) => {
+    const upgradeHeaders = req._upgradeHeaders;
+    if (upgradeHeaders) {
+      for (const [key, value] of new Headers(upgradeHeaders)) {
+        outgoingHeaders.push(`${key}: ${value}`);
+      }
+    }
+  });
+  return {
+    ...adapterUtils(peers),
+    handleUpgrade: async (nodeReq, socket, head) => {
+      const request = new NodeReqProxy(nodeReq);
+      const { upgradeHeaders, endResponse, context } = await hooks.upgrade(request);
+      if (endResponse) {
+        return sendResponse(socket, endResponse);
+      }
+      nodeReq._request = request;
+      nodeReq._upgradeHeaders = upgradeHeaders;
+      nodeReq._context = context;
+      wss.handleUpgrade(nodeReq, socket, head, (ws) => {
+        wss.emit("connection", ws, nodeReq);
+      });
+    },
+    closeAll: (code, data, force) => {
+      for (const client of wss.clients) {
+        if (force) {
+          client.terminate();
+        } else {
+          client.close(code, data);
+        }
+      }
+    }
+  };
+};
+class NodePeer extends Peer {
+  get remoteAddress() {
+    return this._internal.nodeReq.socket?.remoteAddress;
+  }
+  get context() {
+    return this._internal.nodeReq._context;
+  }
+  send(data, options) {
+    const dataBuff = toBufferLike(data);
+    const isBinary = typeof dataBuff !== "string";
+    this._internal.ws.send(dataBuff, {
+      compress: options?.compress,
+      binary: isBinary,
+      ...options
+    });
+    return 0;
+  }
+  publish(topic, data, options) {
+    const dataBuff = toBufferLike(data);
+    const isBinary = typeof data !== "string";
+    const sendOptions = {
+      compress: options?.compress,
+      binary: isBinary,
+      ...options
+    };
+    for (const peer of this._internal.peers) {
+      if (peer !== this && peer._topics.has(topic)) {
+        peer._internal.ws.send(dataBuff, sendOptions);
+      }
+    }
+  }
+  close(code, data) {
+    this._internal.ws.close(code, data);
+  }
+  terminate() {
+    this._internal.ws.terminate();
+  }
+}
+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(() => {
+      socket.destroy();
+      resolve();
+    });
+  });
+}
+
+export { nodeAdapter as default };

node_modules/crossws/dist/adapters/sse.d.mts

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

node_modules/crossws/dist/adapters/sse.d.ts

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

node_modules/crossws/dist/adapters/sse.mjs

@@ -0,0 +1,121 @@
+import { M as Message, P as Peer, a as toString } from '../shared/crossws.DfCzGthR.mjs';
+import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
+import 'uncrypto';
+
+const sseAdapter = (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 { upgradeHeaders, endResponse, context } = await hooks.upgrade(request);
+      if (endResponse) {
+        return endResponse;
+      }
+      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,
+          context
+        });
+        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 (upgradeHeaders) {
+        headers = new Headers(headers);
+        for (const [key, value] of new Headers(upgradeHeaders)) {
+          headers.set(key, value);
+        }
+      }
+      return new Response(peer._sseStream, { 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 { sseAdapter as default };

node_modules/crossws/dist/adapters/uws.d.mts

@@ -0,0 +1,59 @@
+import { Adapter, AdapterInstance, Peer, AdapterOptions } from '../index.mjs';
+import { W as WebSocket } from '../shared/crossws.BQXMA5bH.mjs';
+import uws from 'uWebSockets.js';
+
+type UserData = {
+    peer?: UWSPeer;
+    req: uws.HttpRequest;
+    res: uws.HttpResponse;
+    protocol: string;
+    extensions: string;
+    context: Peer["context"];
+};
+type WebSocketHandler = uws.WebSocketBehavior<UserData>;
+interface UWSAdapter extends AdapterInstance {
+    websocket: WebSocketHandler;
+}
+interface UWSOptions extends AdapterOptions {
+    uws?: Exclude<uws.WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
+}
+declare const uwsAdapter: 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;
+    get context(): Record<string, unknown>;
+    send(data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    subscribe(topic: string): void;
+    unsubscribe(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 { uwsAdapter as default };
+export type { UWSAdapter, UWSOptions };

node_modules/crossws/dist/adapters/uws.d.ts

@@ -0,0 +1,59 @@
+import { Adapter, AdapterInstance, Peer, AdapterOptions } from '../index.js';
+import { W as WebSocket } from '../shared/crossws.BQXMA5bH.js';
+import uws from 'uWebSockets.js';
+
+type UserData = {
+    peer?: UWSPeer;
+    req: uws.HttpRequest;
+    res: uws.HttpResponse;
+    protocol: string;
+    extensions: string;
+    context: Peer["context"];
+};
+type WebSocketHandler = uws.WebSocketBehavior<UserData>;
+interface UWSAdapter extends AdapterInstance {
+    websocket: WebSocketHandler;
+}
+interface UWSOptions extends AdapterOptions {
+    uws?: Exclude<uws.WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
+}
+declare const uwsAdapter: 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;
+    get context(): Record<string, unknown>;
+    send(data: unknown, options?: {
+        compress?: boolean;
+    }): number;
+    subscribe(topic: string): void;
+    unsubscribe(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 { uwsAdapter as default };
+export type { UWSAdapter, UWSOptions };

node_modules/crossws/dist/adapters/uws.mjs

@@ -0,0 +1,183 @@
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
+import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
+import 'uncrypto';
+
+const uwsAdapter = (options = {}) => {
+  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, uwsContext) {
+        let aborted = false;
+        res.onAborted(() => {
+          aborted = true;
+        });
+        const { upgradeHeaders, endResponse, context } = await hooks.upgrade(
+          new UWSReqProxy(req)
+        );
+        if (endResponse) {
+          res.writeStatus(`${endResponse.status} ${endResponse.statusText}`);
+          for (const [key, value] of endResponse.headers) {
+            res.writeHeader(key, value);
+          }
+          if (endResponse.body) {
+            for await (const chunk of endResponse.body) {
+              if (aborted) break;
+              res.write(chunk);
+            }
+          }
+          if (!aborted) {
+            res.end();
+          }
+          return;
+        }
+        if (aborted) {
+          return;
+        }
+        res.writeStatus("101 Switching Protocols");
+        if (upgradeHeaders) {
+          const headers = upgradeHeaders instanceof Headers ? upgradeHeaders : new Headers(upgradeHeaders);
+          for (const [key, value] of 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,
+              context
+            },
+            key,
+            protocol,
+            extensions,
+            uwsContext
+          );
+        });
+      }
+    }
+  };
+};
+function getPeer(uws, peers) {
+  const uwsData = uws.getUserData();
+  if (uwsData.peer) {
+    return uwsData.peer;
+  }
+  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 = new TextDecoder().decode(
+        this._internal.uws.getRemoteAddressAsText()
+      );
+      return addr;
+    } catch {
+    }
+  }
+  get context() {
+    return this._internal.uwsData.context;
+  }
+  send(data, options) {
+    const dataBuff = toBufferLike(data);
+    const isBinary = typeof dataBuff !== "string";
+    return this._internal.uws.send(dataBuff, isBinary, options?.compress);
+  }
+  subscribe(topic) {
+    this._topics.add(topic);
+    this._internal.uws.subscribe(topic);
+  }
+  unsubscribe(topic) {
+    this._topics.delete(topic);
+    this._internal.uws.unsubscribe(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 = new Headers(this._rawHeaders);
+    }
+    return this._headers;
+  }
+}
+class UwsWebSocketProxy {
+  constructor(_uws) {
+    this._uws = _uws;
+  }
+  readyState = 1;
+  get bufferedAmount() {
+    return this._uws?.getBufferedAmount();
+  }
+  get protocol() {
+    return this._uws?.getUserData().protocol;
+  }
+  get extensions() {
+    return this._uws?.getUserData().extensions;
+  }
+}
+
+export { uwsAdapter as default };