better-auth 1.7.0-beta.2 → 1.7.0-beta.4

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.mjs

@@ -0,0 +1,42 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWin = process.platform === "win32";
+	function notFoundError(original, syscall) {
+		return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${syscall} ${original.command}`,
+			path: original.command,
+			spawnargs: original.args
+		});
+	}
+	function hookChildProcess(cp, parsed) {
+		if (!isWin) return;
+		const originalEmit = cp.emit;
+		cp.emit = function(name, arg1) {
+			if (name === "exit") {
+				const err = verifyENOENT(arg1, parsed);
+				if (err) return originalEmit.call(cp, "error", err);
+			}
+			return originalEmit.apply(cp, arguments);
+		};
+	}
+	function verifyENOENT(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
+		return null;
+	}
+	function verifyENOENTSync(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
+		return null;
+	}
+	module.exports = {
+		hookChildProcess,
+		verifyENOENT,
+		verifyENOENTSync,
+		notFoundError
+	};
+}));
+//#endregion
+export default require_enoent();
+export { require_enoent };

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.mjs

@@ -0,0 +1,67 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_resolveCommand } from "./util/resolveCommand.mjs";
+import { require_escape } from "./util/escape.mjs";
+import { require_readShebang } from "./util/readShebang.mjs";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const resolveCommand = require_resolveCommand();
+	const escape = require_escape();
+	const readShebang = require_readShebang();
+	const isWin = process.platform === "win32";
+	const isExecutableRegExp = /\.(?:com|exe)$/i;
+	const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function detectShebang(parsed) {
+		parsed.file = resolveCommand(parsed);
+		const shebang = parsed.file && readShebang(parsed.file);
+		if (shebang) {
+			parsed.args.unshift(parsed.file);
+			parsed.command = shebang;
+			return resolveCommand(parsed);
+		}
+		return parsed.file;
+	}
+	function parseNonShell(parsed) {
+		if (!isWin) return parsed;
+		const commandFile = detectShebang(parsed);
+		const needsShell = !isExecutableRegExp.test(commandFile);
+		if (parsed.options.forceShell || needsShell) {
+			const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+			parsed.command = path.normalize(parsed.command);
+			parsed.command = escape.command(parsed.command);
+			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+			parsed.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[parsed.command].concat(parsed.args).join(" ")}"`
+			];
+			parsed.command = process.env.comspec || "cmd.exe";
+			parsed.options.windowsVerbatimArguments = true;
+		}
+		return parsed;
+	}
+	function parse(command, args, options) {
+		if (args && !Array.isArray(args)) {
+			options = args;
+			args = null;
+		}
+		args = args ? args.slice(0) : [];
+		options = Object.assign({}, options);
+		const parsed = {
+			command,
+			args,
+			options,
+			file: void 0,
+			original: {
+				command,
+				args
+			}
+		};
+		return options.shell ? parsed : parseNonShell(parsed);
+	}
+	module.exports = parse;
+}));
+//#endregion
+export default require_parse();
+export { require_parse };

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.mjs

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+	function escapeCommand(arg) {
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	function escapeArgument(arg, doubleEscapeMetaChars) {
+		arg = `${arg}`;
+		arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+		arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+		arg = `"${arg}"`;
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	module.exports.command = escapeCommand;
+	module.exports.argument = escapeArgument;
+}));
+//#endregion
+export default require_escape();
+export { require_escape };

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.mjs

@@ -0,0 +1,22 @@
+import { __commonJSMin, __require } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_shebang_command } from "../../../../../shebang-command@2.0.0/node_modules/shebang-command/index.mjs";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = __require("fs");
+	const shebangCommand = require_shebang_command();
+	function readShebang(command) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd;
+		try {
+			fd = fs.openSync(command, "r");
+			fs.readSync(fd, buffer, 0, size, 0);
+			fs.closeSync(fd);
+		} catch (e) {}
+		return shebangCommand(buffer.toString());
+	}
+	module.exports = readShebang;
+}));
+//#endregion
+export default require_readShebang();
+export { require_readShebang };

package/dist/node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.mjs

@@ -0,0 +1,36 @@
+import { __commonJSMin, __require } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_which } from "../../../../../which@2.0.2/node_modules/which/which.mjs";
+import { require_path_key } from "../../../../../path-key@3.1.1/node_modules/path-key/index.mjs";
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const which = require_which();
+	const getPathKey = require_path_key();
+	function resolveCommandAttempt(parsed, withoutPathExt) {
+		const env = parsed.options.env || process.env;
+		const cwd = process.cwd();
+		const hasCustomCwd = parsed.options.cwd != null;
+		const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+		if (shouldSwitchCwd) try {
+			process.chdir(parsed.options.cwd);
+		} catch (err) {}
+		let resolved;
+		try {
+			resolved = which.sync(parsed.command, {
+				path: env[getPathKey({ env })],
+				pathExt: withoutPathExt ? path.delimiter : void 0
+			});
+		} catch (e) {} finally {
+			if (shouldSwitchCwd) process.chdir(cwd);
+		}
+		if (resolved) resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+		return resolved;
+	}
+	function resolveCommand(parsed) {
+		return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+	}
+	module.exports = resolveCommand;
+}));
+//#endregion
+export default require_resolveCommand();
+export { require_resolveCommand };

package/dist/node_modules/.pnpm/crossws@0.3.5/node_modules/crossws/dist/adapters/node.d.mts

@@ -0,0 +1,292 @@
+import { AdapterOptions } from "../index.mjs";
+import { Agent, ClientRequest, ClientRequestArgs, IncomingMessage, OutgoingHttpHeaders, Server } from "node:http";
+import { Server as Server$1 } from "node:https";
+import { URL } from "node:url";
+import { EventEmitter } from "events";
+import { Duplex, DuplexOptions } from "node:stream";
+import { SecureContextOptions } from "node:tls";
+import { ZlibOptions } from "node:zlib";
+
+//#region ../../node_modules/.pnpm/crossws@0.3.5/node_modules/crossws/dist/adapters/node.d.mts
+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$2;
+  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<V> | Server$1<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$2<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$2<T>, socket: InstanceType<T>, request: InstanceType<U>) => void): this;
+  on(event: "error", cb: (this: Server$2<T>, error: Error) => void): this;
+  on(event: "headers", cb: (this: Server$2<T>, headers: string[], request: InstanceType<U>) => void): this;
+  on(event: "close" | "listening", cb: (this: Server$2<T>) => void): this;
+  on(event: string | symbol, listener: (this: Server$2<T>, ...args: any[]) => void): this;
+  once(event: "connection", cb: (this: Server$2<T>, socket: InstanceType<T>, request: InstanceType<U>) => void): this;
+  once(event: "error", cb: (this: Server$2<T>, error: Error) => void): this;
+  once(event: "headers", cb: (this: Server$2<T>, headers: string[], request: InstanceType<U>) => void): this;
+  once(event: "close" | "listening", cb: (this: Server$2<T>) => void): this;
+  once(event: string | symbol, listener: (this: Server$2<T>, ...args: any[]) => void): this;
+  off(event: "connection", cb: (this: Server$2<T>, socket: InstanceType<T>, request: InstanceType<U>) => void): this;
+  off(event: "error", cb: (this: Server$2<T>, error: Error) => void): this;
+  off(event: "headers", cb: (this: Server$2<T>, headers: string[], request: InstanceType<U>) => void): this;
+  off(event: "close" | "listening", cb: (this: Server$2<T>) => void): this;
+  off(event: string | symbol, listener: (this: Server$2<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$2;
+declare function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
+interface NodeOptions extends AdapterOptions {
+  wss?: WebSocketServer;
+  serverOptions?: ServerOptions;
+}
+//#endregion
+export { type NodeOptions };

package/dist/node_modules/.pnpm/crossws@0.3.5/node_modules/crossws/dist/adapters/node.mjs

@@ -0,0 +1,127 @@
+import { Message, Peer, toBufferLike } from "../shared/crossws.DfCzGthR.mjs";
+import { AdapterHookable, adapterUtils } from "../shared/crossws.D9ehKjSh.mjs";
+import { WSError } from "../shared/crossws.By9qWDAI.mjs";
+import { _WebSocketServer } from "../shared/crossws.CipVM6lf.mjs";
+//#region ../../node_modules/.pnpm/crossws@0.3.5/node_modules/crossws/dist/adapters/node.mjs
+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 peer = new NodePeer({
+			ws,
+			request: new NodeReqProxy(nodeReq),
+			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);
+		}
+	};
+};
+var NodePeer = class 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();
+	}
+};
+var NodeReqProxy = class {
+	_req;
+	_headers;
+	_url;
+	constructor(req) {
+		this._req = req;
+	}
+	get url() {
+		if (!this._url) {
+			const req = this._req;
+			const host = req.headers["host"] || "localhost";
+			this._url = `${req.socket?.encrypted ?? req.headers["x-forwarded-proto"] === "https" ? "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();
+		});
+	});
+}
+//#endregion
+export { nodeAdapter as default };