elit 3.6.6 → 3.6.7

package/dist/wss.cjs

@@ -20,10 +20,10 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/runtime.ts
+// src/shares/runtime.ts
 var runtime, isNode, isBun, isDeno;
 var init_runtime = __esm({
-  "src/runtime.ts"() {
+  "src/shares/runtime.ts"() {
     "use strict";
     runtime = (() => {
       if (typeof Deno !== "undefined") return "deno";
@@ -36,25 +36,78 @@ var init_runtime = __esm({
   }
 });
 
-// src/http.ts
-var http_exports = {};
-__export(http_exports, {
-  Agent: () => Agent,
-  ClientRequest: () => ClientRequest,
-  IncomingMessage: () => IncomingMessage,
-  METHODS: () => METHODS,
-  STATUS_CODES: () => STATUS_CODES,
-  Server: () => Server,
-  ServerResponse: () => ServerResponse,
-  createServer: () => createServer,
-  default: () => http_default,
-  get: () => get,
-  getRuntime: () => getRuntime,
-  request: () => request
-});
-function queueCallback(callback) {
+// src/server/http/utils.ts
+function queueCallback2(callback) {
   if (callback) queueMicrotask(callback);
 }
+function getRequestPath2(url) {
+  if (!url) return "";
+  try {
+    const urlObj = new URL(url);
+    return urlObj.pathname + urlObj.search;
+  } catch {
+    return url;
+  }
+}
+function headersToRecord(headers) {
+  const result = /* @__PURE__ */ Object.create(null);
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function headersToRawHeaders(headers) {
+  const rawHeaders = [];
+  headers.forEach((value, key) => {
+    rawHeaders.push(key, value);
+  });
+  return rawHeaders;
+}
+function normalizeRequestBodyChunk(chunk, encoding = "utf8") {
+  if (typeof chunk === "string") {
+    if (encoding !== "utf8" && typeof Buffer !== "undefined") {
+      return Buffer.from(chunk, encoding);
+    }
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return chunk;
+  }
+  if (chunk instanceof ArrayBuffer) {
+    return new Uint8Array(chunk);
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  }
+  return new TextEncoder().encode(String(chunk));
+}
+function buildRequestBody(chunks) {
+  if (chunks.length === 0) {
+    return void 0;
+  }
+  if (chunks.length === 1) {
+    return chunks[0];
+  }
+  if (chunks.every((chunk) => typeof chunk === "string")) {
+    return chunks.join("");
+  }
+  const encoder = new TextEncoder();
+  const bodyParts = chunks.map((chunk) => typeof chunk === "string" ? encoder.encode(chunk) : chunk);
+  const totalLength = bodyParts.reduce((sum, part) => sum + part.byteLength, 0);
+  const body = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const part of bodyParts) {
+    body.set(part, offset);
+    offset += part.byteLength;
+  }
+  return body;
+}
+function isFetchResponse(value) {
+  return typeof value?.status === "number" && typeof value?.statusText === "string" && typeof value?.headers?.forEach === "function";
+}
+function isNodeIncomingMessage(value) {
+  return typeof value?.on === "function" && typeof value?.headers === "object" && (typeof value?.httpVersion === "string" || value?.socket !== void 0);
+}
 function headersToInit(headers) {
   const result = {};
   for (const key in headers) {
@@ -72,76 +125,110 @@ function createErrorResponse() {
 function emitListeningWithCallback(server, callback) {
   server._listening = true;
   server.emit("listening");
-  queueCallback(callback);
+  queueCallback2(callback);
 }
 function closeAndEmit(server, callback) {
   server._listening = false;
   server.emit("close");
   if (callback) queueMicrotask(() => callback());
 }
-function createServer(optionsOrListener, requestListener) {
-  return new Server(typeof optionsOrListener === "function" ? optionsOrListener : requestListener);
-}
-function request(url, options, callback) {
-  const urlString = typeof url === "string" ? url : url.toString();
-  const req = new ClientRequest(urlString, options);
-  if (isNode) {
-    const urlObj = new URL(urlString);
-    const client = urlObj.protocol === "https:" ? https : http;
-    const nodeReq = client.request(urlString, {
-      method: options?.method || "GET",
-      headers: options?.headers,
-      timeout: options?.timeout,
-      signal: options?.signal
-    }, (res) => {
-      const incomingMessage = new IncomingMessage(res);
-      if (callback) callback(incomingMessage);
-      req.emit("response", incomingMessage);
-    });
-    nodeReq.on("error", (error) => req.emit("error", error));
-    nodeReq.end();
-  } else {
-    queueMicrotask(async () => {
-      try {
-        const response = await fetch(urlString, {
-          method: options?.method || "GET",
-          headers: options?.headers,
-          signal: options?.signal
-        });
-        const fetchRequest = new Request(urlString);
-        const incomingMessage = new IncomingMessage(fetchRequest);
-        incomingMessage.statusCode = response.status;
-        incomingMessage.statusMessage = response.statusText;
-        if (callback) callback(incomingMessage);
-        req.emit("response", incomingMessage);
-      } catch (error) {
-        req.emit("error", error);
+var init_utils = __esm({
+  "src/server/http/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/http/agent.ts
+var Agent;
+var init_agent = __esm({
+  "src/server/http/agent.ts"() {
+    "use strict";
+    Agent = class {
+      constructor(options) {
+        this.options = options;
       }
-    });
+    };
   }
-  return req;
-}
-function get(url, options, callback) {
-  return request(url, { ...options, method: "GET" }, callback);
-}
-function getRuntime() {
-  return runtime;
-}
-var import_node_events, http, https, METHODS, STATUS_CODES, IncomingMessage, ServerResponse, Server, ClientRequest, Agent, http_default;
-var init_http = __esm({
-  "src/http.ts"() {
+});
+
+// src/server/http/client-request.ts
+var import_node_events2, ClientRequest;
+var init_client_request = __esm({
+  "src/server/http/client-request.ts"() {
     "use strict";
-    import_node_events = require("events");
-    init_runtime();
-    if (isNode && typeof process !== "undefined") {
-      try {
-        http = require("http");
-        https = require("https");
-      } catch (e) {
-        http = require("http");
-        https = require("https");
+    import_node_events2 = require("events");
+    init_utils();
+    ClientRequest = class extends import_node_events2.EventEmitter {
+      constructor(_url, _options = {}) {
+        super();
+        this._bodyChunks = [];
+        this._ended = false;
       }
-    }
+      _setNativeRequest(nativeRequest) {
+        this._nativeRequest = nativeRequest;
+      }
+      _setExecutor(executor) {
+        this._executor = executor;
+      }
+      write(chunk, encoding, callback) {
+        if (this._ended) {
+          throw new Error("Cannot write after end");
+        }
+        if (typeof encoding === "function") {
+          callback = encoding;
+          encoding = void 0;
+        }
+        if (this._nativeRequest) {
+          const actualEncoding2 = typeof encoding === "string" ? encoding : void 0;
+          return this._nativeRequest.write(chunk, actualEncoding2, callback);
+        }
+        const actualEncoding = typeof encoding === "string" ? encoding : "utf8";
+        this._bodyChunks.push(normalizeRequestBodyChunk(chunk, actualEncoding));
+        queueCallback2(callback);
+        return true;
+      }
+      end(chunk, encoding, callback) {
+        if (typeof chunk === "function") {
+          callback = chunk;
+          chunk = void 0;
+          encoding = void 0;
+        } else if (typeof encoding === "function") {
+          callback = encoding;
+          encoding = void 0;
+        }
+        if (this._ended) {
+          queueCallback2(callback);
+          return;
+        }
+        this._ended = true;
+        if (this._nativeRequest) {
+          const actualEncoding = typeof encoding === "string" ? encoding : void 0;
+          if (chunk !== void 0) {
+            this._nativeRequest.end(chunk, actualEncoding, callback);
+          } else {
+            this._nativeRequest.end(callback);
+          }
+          return;
+        }
+        if (chunk !== void 0) {
+          this._bodyChunks.push(normalizeRequestBodyChunk(chunk, typeof encoding === "string" ? encoding : "utf8"));
+        }
+        const executor = this._executor;
+        const body = buildRequestBody(this._bodyChunks);
+        if (executor) {
+          Promise.resolve().then(() => executor(body)).catch((error) => this.emit("error", error));
+        }
+        queueCallback2(callback);
+      }
+    };
+  }
+});
+
+// src/server/http/constants.ts
+var METHODS, STATUS_CODES;
+var init_constants = __esm({
+  "src/server/http/constants.ts"() {
+    "use strict";
     METHODS = [
       "GET",
       "POST",
@@ -209,13 +296,30 @@ var init_http = __esm({
       510: "Not Extended",
       511: "Network Authentication Required"
     };
-    IncomingMessage = class extends import_node_events.EventEmitter {
-      constructor(req) {
+  }
+});
+
+// src/server/http/incoming-message.ts
+var import_node_events3, IncomingMessage;
+var init_incoming_message = __esm({
+  "src/server/http/incoming-message.ts"() {
+    "use strict";
+    import_node_events3 = require("events");
+    init_utils();
+    IncomingMessage = class extends import_node_events3.EventEmitter {
+      constructor(req, requestMethod) {
         super();
         this.httpVersion = "1.1";
         this.rawHeaders = [];
         this._req = req;
-        if (isNode) {
+        if (isFetchResponse(req)) {
+          this.method = requestMethod || "GET";
+          this.url = getRequestPath2(req.url);
+          this.headers = headersToRecord(req.headers);
+          this.statusCode = req.status;
+          this.statusMessage = req.statusText;
+          this.rawHeaders = headersToRawHeaders(req.headers);
+        } else if (isNodeIncomingMessage(req)) {
           this.method = req.method;
           this.url = req.url;
           this.headers = req.headers;
@@ -226,14 +330,13 @@ var init_http = __esm({
           this.socket = req.socket;
         } else {
           this.method = req.method;
-          const urlObj = new URL(req.url);
-          this.url = urlObj.pathname + urlObj.search;
-          this.headers = req.headers;
-          this.rawHeaders = [];
+          this.url = getRequestPath2(req.url);
+          this.headers = headersToRecord(req.headers);
+          this.rawHeaders = headersToRawHeaders(req.headers);
         }
       }
       async text() {
-        if (isNode) {
+        if (isNodeIncomingMessage(this._req)) {
           return new Promise((resolve, reject) => {
             const chunks = [];
             this._req.on("data", (chunk) => chunks.push(chunk));
@@ -244,14 +347,92 @@ var init_http = __esm({
         return this._req.text();
       }
       async json() {
-        if (isNode) {
+        if (isNodeIncomingMessage(this._req)) {
           const text = await this.text();
           return JSON.parse(text);
         }
         return this._req.json();
       }
     };
-    ServerResponse = class extends import_node_events.EventEmitter {
+  }
+});
+
+// src/server/http/node-modules.ts
+var http, https;
+var init_node_modules = __esm({
+  "src/server/http/node-modules.ts"() {
+    "use strict";
+    init_runtime();
+    if (isNode && typeof process !== "undefined") {
+      try {
+        http = require("http");
+        https = require("https");
+      } catch {
+        http = require("http");
+        https = require("https");
+      }
+    }
+  }
+});
+
+// src/server/http/request-api.ts
+function request(url, options, callback) {
+  const urlString = typeof url === "string" ? url : url.toString();
+  const req = new ClientRequest(urlString, options);
+  if (isNode) {
+    const urlObj = new URL(urlString);
+    const client = urlObj.protocol === "https:" ? https : http;
+    const nodeReq = client.request(urlString, {
+      method: options?.method || "GET",
+      headers: options?.headers,
+      timeout: options?.timeout,
+      signal: options?.signal
+    }, (res) => {
+      const incomingMessage = new IncomingMessage(res);
+      if (callback) callback(incomingMessage);
+      req.emit("response", incomingMessage);
+    });
+    req._setNativeRequest(nodeReq);
+    nodeReq.on("error", (error) => req.emit("error", error));
+  } else {
+    req._setExecutor(async (body) => {
+      const response = await fetch(urlString, {
+        method: options?.method || "GET",
+        headers: options?.headers,
+        body,
+        signal: options?.signal
+      });
+      const incomingMessage = new IncomingMessage(response, options?.method || "GET");
+      if (callback) callback(incomingMessage);
+      req.emit("response", incomingMessage);
+    });
+  }
+  return req;
+}
+function get(url, options, callback) {
+  const req = request(url, { ...options, method: "GET" }, callback);
+  req.end();
+  return req;
+}
+var init_request_api = __esm({
+  "src/server/http/request-api.ts"() {
+    "use strict";
+    init_runtime();
+    init_client_request();
+    init_incoming_message();
+    init_node_modules();
+  }
+});
+
+// src/server/http/response.ts
+var import_node_events4, ServerResponse;
+var init_response = __esm({
+  "src/server/http/response.ts"() {
+    "use strict";
+    import_node_events4 = require("events");
+    init_runtime();
+    init_utils();
+    ServerResponse = class extends import_node_events4.EventEmitter {
       constructor(_req, nodeRes) {
         super();
         this.statusCode = 200;
@@ -344,7 +525,7 @@ var init_http = __esm({
           return this._nodeRes.write(chunk, encoding, callback);
         }
         this._body += chunk;
-        queueCallback(callback);
+        queueCallback2(callback);
         return true;
       }
       end(chunk, encoding, callback) {
@@ -377,14 +558,13 @@ var init_http = __esm({
           if (this._resolve) {
             this._resolve(response);
           }
-          queueCallback(callback);
+          queueCallback2(callback);
         }
         return this;
       }
       _setResolver(resolve) {
         this._resolve = resolve;
       }
-      // Express.js-like methods
       json(data, statusCode = 200) {
         if (!this.headersSent) {
           this.setHeader("Content-Type", "application/json");
@@ -408,7 +588,35 @@ var init_http = __esm({
         return this;
       }
     };
-    Server = class extends import_node_events.EventEmitter {
+  }
+});
+
+// src/server/http/runtime.ts
+function getRuntime3() {
+  return runtime;
+}
+var init_runtime2 = __esm({
+  "src/server/http/runtime.ts"() {
+    "use strict";
+    init_runtime();
+  }
+});
+
+// src/server/http/server-runtime.ts
+function createServer(optionsOrListener, requestListener) {
+  return new Server(typeof optionsOrListener === "function" ? optionsOrListener : requestListener);
+}
+var import_node_events5, Server;
+var init_server_runtime = __esm({
+  "src/server/http/server-runtime.ts"() {
+    "use strict";
+    import_node_events5 = require("events");
+    init_runtime();
+    init_node_modules();
+    init_incoming_message();
+    init_response();
+    init_utils();
+    Server = class extends import_node_events5.EventEmitter {
       constructor(requestListener) {
         super();
         this._bunWebSocketServers = /* @__PURE__ */ new Set();
@@ -483,6 +691,8 @@ var init_http = __esm({
               const urlObj = new URL(req.url);
               const pathname = urlObj.pathname;
               const requestUrl = urlObj.pathname + urlObj.search;
+              const incomingHeaders = headersToRecord(req.headers);
+              const rawHeaders = headersToRawHeaders(req.headers);
               const upgradeHeader = req.headers.get("upgrade");
               if (upgradeHeader && upgradeHeader.toLowerCase() === "websocket") {
                 const matchingWebSocketServer = Array.from(this._bunWebSocketServers).find((wsServer) => {
@@ -519,9 +729,9 @@ var init_http = __esm({
               const incomingMessage = {
                 method: req.method,
                 url: requestUrl,
-                headers: req.headers,
+                headers: incomingHeaders,
                 httpVersion: "1.1",
-                rawHeaders: [],
+                rawHeaders,
                 _req: req,
                 text: () => req.text(),
                 json: () => req.json()
@@ -580,6 +790,8 @@ var init_http = __esm({
               };
               if (self.requestListener) {
                 self.requestListener(incomingMessage, serverResponse);
+              } else {
+                self.emit("request", incomingMessage, serverResponse);
               }
               if (responseReady) {
                 return new Response(body, {
@@ -654,9 +866,11 @@ var init_http = __esm({
             return createAddress(0, addr, "unix");
           }
           return addr;
-        } else if (isBun) {
+        }
+        if (isBun) {
           return createAddress(this.nativeServer.port, this.nativeServer.hostname);
-        } else if (isDeno) {
+        }
+        if (isDeno) {
           const addr = this.nativeServer.addr;
           return createAddress(addr.port, addr.hostname);
         }
@@ -666,22 +880,45 @@ var init_http = __esm({
         return this._listening;
       }
     };
-    ClientRequest = class extends import_node_events.EventEmitter {
-      constructor(_url, _options = {}) {
-        super();
-      }
-      write(_chunk) {
-        return true;
-      }
-      end(callback) {
-        queueCallback(callback);
-      }
-    };
-    Agent = class {
-      constructor(options) {
-        this.options = options;
-      }
-    };
+  }
+});
+
+// src/server/http/index.ts
+var http_exports = {};
+__export(http_exports, {
+  Agent: () => Agent,
+  ClientRequest: () => ClientRequest,
+  IncomingMessage: () => IncomingMessage,
+  METHODS: () => METHODS,
+  STATUS_CODES: () => STATUS_CODES,
+  Server: () => Server,
+  ServerResponse: () => ServerResponse,
+  createServer: () => createServer,
+  default: () => http_default,
+  get: () => get,
+  getRuntime: () => getRuntime3,
+  request: () => request
+});
+var http_default;
+var init_http = __esm({
+  "src/server/http/index.ts"() {
+    "use strict";
+    init_agent();
+    init_client_request();
+    init_constants();
+    init_incoming_message();
+    init_request_api();
+    init_response();
+    init_runtime2();
+    init_server_runtime();
+    init_agent();
+    init_client_request();
+    init_constants();
+    init_incoming_message();
+    init_request_api();
+    init_response();
+    init_runtime2();
+    init_server_runtime();
     http_default = {
       createServer,
       request,
@@ -693,12 +930,12 @@ var init_http = __esm({
       ClientRequest,
       METHODS,
       STATUS_CODES,
-      getRuntime
+      getRuntime: getRuntime3
     };
   }
 });
 
-// src/wss.ts
+// src/server/wss/index.ts
 var wss_exports = {};
 __export(wss_exports, {
   CLOSE_CODES: () => CLOSE_CODES,
@@ -711,221 +948,40 @@ __export(wss_exports, {
   getRuntime: () => getRuntime2
 });
 module.exports = __toCommonJS(wss_exports);
-var import_events3 = require("events");
 
-// src/https.ts
-var import_events = require("events");
+// src/server/ws/constants.ts
+var ReadyState = /* @__PURE__ */ ((ReadyState2) => {
+  ReadyState2[ReadyState2["CONNECTING"] = 0] = "CONNECTING";
+  ReadyState2[ReadyState2["OPEN"] = 1] = "OPEN";
+  ReadyState2[ReadyState2["CLOSING"] = 2] = "CLOSING";
+  ReadyState2[ReadyState2["CLOSED"] = 3] = "CLOSED";
+  return ReadyState2;
+})(ReadyState || {});
+var CLOSE_CODES = {
+  NORMAL: 1e3,
+  GOING_AWAY: 1001,
+  PROTOCOL_ERROR: 1002,
+  UNSUPPORTED_DATA: 1003,
+  NO_STATUS: 1005,
+  ABNORMAL: 1006,
+  INVALID_DATA: 1007,
+  POLICY_VIOLATION: 1008,
+  MESSAGE_TOO_BIG: 1009,
+  EXTENSION_REQUIRED: 1010,
+  INTERNAL_ERROR: 1011,
+  SERVICE_RESTART: 1012,
+  TRY_AGAIN_LATER: 1013,
+  BAD_GATEWAY: 1014,
+  TLS_HANDSHAKE_FAIL: 1015
+};
+
+// src/server/ws/server.ts
+var import_events2 = require("events");
 init_runtime();
-function queueCallback2(callback) {
-  if (callback) queueMicrotask(callback);
-}
-function createErrorResponse2() {
-  return new Response("Internal Server Error", { status: 500 });
-}
-function createAddress2(port, address, family = "IPv4") {
-  return { port, family, address };
-}
-function emitListeningWithCallback2(server, callback) {
-  server._listening = true;
-  server.emit("listening");
-  queueCallback2(callback);
-}
-function closeAndEmit2(server, callback) {
-  server._listening = false;
-  server.emit("close");
-  if (callback) queueMicrotask(() => callback());
-}
-function loadHttpClasses() {
-  const httpModule = (init_http(), __toCommonJS(http_exports));
-  return {
-    IncomingMessage: httpModule.IncomingMessage,
-    ServerResponse: httpModule.ServerResponse
-  };
-}
-var https2;
-var Server2 = class extends import_events.EventEmitter {
-  constructor(options, requestListener) {
-    super();
-    this._listening = false;
-    this.options = options;
-    this.requestListener = requestListener;
-  }
-  listen(...args) {
-    let port = 3e3;
-    let hostname = "0.0.0.0";
-    let callback;
-    const firstArg = args[0];
-    if (typeof firstArg === "number") {
-      port = firstArg;
-      const secondArg = args[1];
-      if (typeof secondArg === "string") {
-        hostname = secondArg;
-        callback = args[2] || args[3];
-      } else if (typeof secondArg === "function") {
-        callback = secondArg;
-      }
-    } else if (firstArg && typeof firstArg === "object") {
-      port = firstArg.port || 3e3;
-      hostname = firstArg.hostname || "0.0.0.0";
-      callback = args[1];
-    }
-    const self = this;
-    if (isNode) {
-      const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
-      if (!https2) https2 = require("https");
-      this.nativeServer = https2.createServer(this.options, (req, res) => {
-        const incomingMessage = new IncomingMessage2(req);
-        const serverResponse = new ServerResponse2(incomingMessage, res);
-        if (self.requestListener) {
-          self.requestListener(incomingMessage, serverResponse);
-        } else {
-          self.emit("request", incomingMessage, serverResponse);
-        }
-      });
-      this.nativeServer.listen(port, hostname, () => {
-        this._listening = true;
-        this.emit("listening");
-        if (callback) callback();
-      });
-      this.nativeServer.on("error", (err) => this.emit("error", err));
-      this.nativeServer.on("close", () => {
-        this._listening = false;
-        this.emit("close");
-      });
-    } else if (isBun) {
-      const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
-      const tlsOptions = {
-        port,
-        hostname,
-        fetch: (req) => {
-          return new Promise((resolve) => {
-            const incomingMessage = new IncomingMessage2(req);
-            const serverResponse = new ServerResponse2();
-            serverResponse._setResolver(resolve);
-            if (self.requestListener) {
-              self.requestListener(incomingMessage, serverResponse);
-            } else {
-              self.emit("request", incomingMessage, serverResponse);
-            }
-          });
-        },
-        error: (error) => {
-          this.emit("error", error);
-          return createErrorResponse2();
-        }
-      };
-      if (this.options.key || this.options.cert) {
-        tlsOptions.tls = {
-          key: this.options.key,
-          cert: this.options.cert,
-          ca: this.options.ca,
-          passphrase: this.options.passphrase
-        };
-      } else if (this.options.tls) {
-        tlsOptions.tls = this.options.tls;
-      }
-      this.nativeServer = Bun.serve(tlsOptions);
-      emitListeningWithCallback2(this, callback);
-    } else if (isDeno) {
-      const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
-      const serveOptions = {
-        port,
-        hostname,
-        handler: (req) => {
-          return new Promise((resolve) => {
-            const incomingMessage = new IncomingMessage2(req);
-            const serverResponse = new ServerResponse2();
-            serverResponse._setResolver(resolve);
-            if (self.requestListener) {
-              self.requestListener(incomingMessage, serverResponse);
-            } else {
-              self.emit("request", incomingMessage, serverResponse);
-            }
-          });
-        },
-        onError: (error) => {
-          this.emit("error", error);
-          return createErrorResponse2();
-        }
-      };
-      if (this.options.key && this.options.cert) {
-        serveOptions.cert = this.options.cert;
-        serveOptions.key = this.options.key;
-      }
-      this.nativeServer = Deno.serve(serveOptions);
-      emitListeningWithCallback2(this, callback);
-    }
-    return this;
-  }
-  close(callback) {
-    if (!this.nativeServer) {
-      if (callback) queueMicrotask(() => callback());
-      return this;
-    }
-    if (isNode) {
-      this.nativeServer.close(callback);
-    } else if (isBun) {
-      this.nativeServer.stop();
-      closeAndEmit2(this, callback);
-    } else if (isDeno) {
-      this.nativeServer.shutdown();
-      closeAndEmit2(this, callback);
-    }
-    return this;
-  }
-  address() {
-    if (!this.nativeServer) return null;
-    if (isNode) {
-      const addr = this.nativeServer.address();
-      if (!addr) return null;
-      if (typeof addr === "string") {
-        return createAddress2(0, addr, "unix");
-      }
-      return addr;
-    } else if (isBun) {
-      return createAddress2(this.nativeServer.port, this.nativeServer.hostname);
-    } else if (isDeno) {
-      const addr = this.nativeServer.addr;
-      return createAddress2(addr.port, addr.hostname);
-    }
-    return null;
-  }
-  get listening() {
-    return this._listening;
-  }
-};
-function createServer2(options, requestListener) {
-  return new Server2(options, requestListener);
-}
 
-// src/ws.ts
-var import_events2 = require("events");
+// src/server/ws/utils.ts
 init_runtime();
-var ReadyState = /* @__PURE__ */ ((ReadyState2) => {
-  ReadyState2[ReadyState2["CONNECTING"] = 0] = "CONNECTING";
-  ReadyState2[ReadyState2["OPEN"] = 1] = "OPEN";
-  ReadyState2[ReadyState2["CLOSING"] = 2] = "CLOSING";
-  ReadyState2[ReadyState2["CLOSED"] = 3] = "CLOSED";
-  return ReadyState2;
-})(ReadyState || {});
-var CLOSE_CODES = {
-  NORMAL: 1e3,
-  GOING_AWAY: 1001,
-  PROTOCOL_ERROR: 1002,
-  UNSUPPORTED_DATA: 1003,
-  NO_STATUS: 1005,
-  ABNORMAL: 1006,
-  INVALID_DATA: 1007,
-  POLICY_VIOLATION: 1008,
-  MESSAGE_TOO_BIG: 1009,
-  EXTENSION_REQUIRED: 1010,
-  INTERNAL_ERROR: 1011,
-  SERVICE_RESTART: 1012,
-  TRY_AGAIN_LATER: 1013,
-  BAD_GATEWAY: 1014,
-  TLS_HANDSHAKE_FAIL: 1015
-};
-function queueCallback3(callback, error) {
+function queueCallback(callback, error) {
   if (callback) {
     queueMicrotask(() => callback(error));
   }
@@ -940,7 +996,74 @@ function getRequestPath(url) {
   const [pathname = "/"] = (url || "/").split("?");
   return pathname || "/";
 }
-var WebSocket = class extends import_events2.EventEmitter {
+function isIgnorableConnectionError(error) {
+  const errorCode = error?.code;
+  return errorCode === "ECONNABORTED" || errorCode === "ECONNRESET" || errorCode === "EPIPE";
+}
+function coerceBunMessage(message) {
+  const isBinary = typeof message !== "string";
+  const payload = typeof message === "string" ? message : message instanceof ArrayBuffer ? Buffer.from(message) : ArrayBuffer.isView(message) ? Buffer.from(message.buffer, message.byteOffset, message.byteLength) : Buffer.from(String(message));
+  return { payload, isBinary };
+}
+function parseFrame(data) {
+  if (data.length < 2) {
+    return null;
+  }
+  const firstByte = data[0];
+  const secondByte = data[1];
+  const opcode = firstByte & 15;
+  const isMasked = (secondByte & 128) === 128;
+  let payloadLength = secondByte & 127;
+  let offset = 2;
+  if (payloadLength === 126) {
+    payloadLength = data.readUInt16BE(2);
+    offset = 4;
+  } else if (payloadLength === 127) {
+    payloadLength = Number(data.readBigUInt64BE(2));
+    offset = 10;
+  }
+  let payload = data.subarray(offset);
+  if (isMasked) {
+    const maskKey = data.subarray(offset, offset + 4);
+    payload = data.subarray(offset + 4, offset + 4 + payloadLength);
+    for (let index = 0; index < payload.length; index += 1) {
+      payload[index] ^= maskKey[index % 4];
+    }
+  }
+  if (opcode === 1) {
+    return payload.toString("utf8");
+  }
+  return null;
+}
+function createFrame(data) {
+  const payload = typeof data === "string" ? Buffer.from(data) : data;
+  const payloadLength = Buffer.isBuffer(payload) ? payload.length : 0;
+  let frame;
+  let offset = 2;
+  if (payloadLength < 126) {
+    frame = Buffer.allocUnsafe(2 + payloadLength);
+    frame[1] = payloadLength;
+  } else if (payloadLength < 65536) {
+    frame = Buffer.allocUnsafe(4 + payloadLength);
+    frame[1] = 126;
+    frame.writeUInt16BE(payloadLength, 2);
+    offset = 4;
+  } else {
+    frame = Buffer.allocUnsafe(10 + payloadLength);
+    frame[1] = 127;
+    frame.writeBigUInt64BE(BigInt(payloadLength), 2);
+    offset = 10;
+  }
+  frame[0] = 129;
+  if (Buffer.isBuffer(payload)) {
+    payload.copy(frame, offset);
+  }
+  return frame;
+}
+
+// src/server/ws/websocket.ts
+var import_events = require("events");
+var WebSocket = class extends import_events.EventEmitter {
   constructor(address, protocols, _options) {
     super();
     this.readyState = 0 /* CONNECTING */;
@@ -970,22 +1093,23 @@ var WebSocket = class extends import_events2.EventEmitter {
     };
   }
   /**
-   * Send data through WebSocket
+   * Send data through WebSocket.
    */
   send(data, options, callback) {
     const cb = typeof options === "function" ? options : callback;
     if (this.readyState !== 1 /* OPEN */) {
-      return queueCallback3(cb, new Error("WebSocket is not open"));
+      queueCallback(cb, new Error("WebSocket is not open"));
+      return;
     }
     try {
       this._socket.send(data);
-      queueCallback3(cb);
+      queueCallback(cb);
     } catch (error) {
-      queueCallback3(cb, error);
+      queueCallback(cb, error);
     }
   }
   /**
-   * Close the WebSocket connection
+   * Close the WebSocket connection.
    */
   close(code, reason) {
     if (this.readyState === 3 /* CLOSED */ || this.readyState === 2 /* CLOSING */) {
@@ -995,41 +1119,43 @@ var WebSocket = class extends import_events2.EventEmitter {
     this._socket.close(code, typeof reason === "string" ? reason : reason?.toString());
   }
   /**
-   * Pause the socket (no-op for native WebSocket)
+   * Pause the socket (no-op for native WebSocket).
    */
   pause() {
   }
   /**
-   * Resume the socket (no-op for native WebSocket)
+   * Resume the socket (no-op for native WebSocket).
    */
   resume() {
   }
   /**
-   * Send a ping frame (no-op for native WebSocket)
+   * Send a ping frame (no-op for native WebSocket).
    */
   ping(_data, _mask, callback) {
-    queueCallback3(callback);
+    queueCallback(callback);
   }
   /**
-   * Send a pong frame (no-op for native WebSocket)
+   * Send a pong frame (no-op for native WebSocket).
    */
   pong(_data, _mask, callback) {
-    queueCallback3(callback);
+    queueCallback(callback);
   }
   /**
-   * Terminate the connection
+   * Terminate the connection.
    */
   terminate() {
     this._socket.close();
     this.readyState = 3 /* CLOSED */;
   }
   /**
-   * Get buffered amount
+   * Get buffered amount.
    */
   get bufferedAmount() {
     return this._socket.bufferedAmount || 0;
   }
 };
+
+// src/server/ws/server.ts
 var WebSocketServer = class extends import_events2.EventEmitter {
   constructor(options, callback) {
     super();
@@ -1041,8 +1167,7 @@ var WebSocketServer = class extends import_events2.EventEmitter {
       if (options?.server) {
         this._httpServer = options.server;
         this._setupUpgradeHandler();
-      } else if (options?.noServer) {
-      } else {
+      } else if (!options?.noServer) {
         const http2 = require("http");
         this._httpServer = http2.createServer();
         this._ownsHttpServer = true;
@@ -1056,30 +1181,30 @@ var WebSocketServer = class extends import_events2.EventEmitter {
         this._httpServer = options.server;
         options.server.registerWebSocketServer(this);
       }
-      queueCallback3(callback);
+      queueCallback(callback);
     } else {
-      queueCallback3(callback);
+      queueCallback(callback);
     }
   }
   _setupUpgradeHandler() {
-    this._httpServer.on("upgrade", (request2, socket, head) => {
-      const requestPath = getRequestPath(request2.url);
+    this._httpServer.on("upgrade", (request3, socket, head) => {
+      const requestPath = getRequestPath(request3.url);
       console.log("[WebSocket] Upgrade request:", requestPath, "Expected:", this.path || "(any)");
       if (this.path && requestPath !== this.path) {
         console.log("[WebSocket] Path mismatch, ignoring");
         return;
       }
-      this.handleUpgrade(request2, socket, head, (client) => {
+      this.handleUpgrade(request3, socket, head, (client) => {
         console.log("[WebSocket] Client connected");
-        this.emit("connection", client, request2);
+        this.emit("connection", client, request3);
       });
     });
   }
   /**
-   * Handle HTTP upgrade for WebSocket
+   * Handle HTTP upgrade for WebSocket.
    */
-  handleUpgrade(request2, socket, _head, callback) {
-    const key = request2.headers["sec-websocket-key"];
+  handleUpgrade(request3, socket, _head, callback) {
+    const key = request3.headers["sec-websocket-key"];
     if (!key) {
       socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
       return;
@@ -1115,7 +1240,7 @@ var WebSocketServer = class extends import_events2.EventEmitter {
     client._socket = socket;
     socket.on("data", (data) => {
       try {
-        const message = this._parseFrame(data);
+        const message = parseFrame(data);
         if (message) {
           client.emit("message", message, false);
         }
@@ -1128,36 +1253,34 @@ var WebSocketServer = class extends import_events2.EventEmitter {
       client.emit("close", CLOSE_CODES.NORMAL, "");
     });
     socket.on("error", (error) => {
-      const errorCode = error.code;
-      if (errorCode === "ECONNABORTED" || errorCode === "ECONNRESET" || errorCode === "EPIPE") {
+      if (isIgnorableConnectionError(error)) {
         return;
       }
       client.emit("error", error);
     });
     client.send = (data, _options, callback) => {
       if (!socket.writable || client.readyState !== 1 /* OPEN */) {
-        const err = new Error("WebSocket is not open");
-        err.code = "WS_NOT_OPEN";
-        queueCallback3(callback, err);
+        const error = new Error("WebSocket is not open");
+        error.code = "WS_NOT_OPEN";
+        queueCallback(callback, error);
         return;
       }
       try {
-        const frame = this._createFrame(data);
-        socket.write(frame, (err) => {
-          if (err) {
-            const errorCode = err.code;
-            if (errorCode !== "ECONNABORTED" && errorCode !== "ECONNRESET" && errorCode !== "EPIPE") {
-              queueCallback3(callback, err);
-            } else {
-              client.readyState = 3 /* CLOSED */;
-              queueCallback3(callback);
-            }
-          } else {
-            queueCallback3(callback);
+        const frame = createFrame(data);
+        socket.write(frame, (error) => {
+          if (!error) {
+            queueCallback(callback);
+            return;
+          }
+          if (isIgnorableConnectionError(error)) {
+            client.readyState = 3 /* CLOSED */;
+            queueCallback(callback);
+            return;
           }
+          queueCallback(callback, error);
         });
       } catch (error) {
-        queueCallback3(callback, error);
+        queueCallback(callback, error);
       }
     };
     client.close = (_code, _reason) => {
@@ -1177,14 +1300,14 @@ var WebSocketServer = class extends import_events2.EventEmitter {
     client._socket = socket;
     client.send = (data, _options, callback) => {
       if (client.readyState !== 1 /* OPEN */) {
-        queueCallback3(callback, new Error("WebSocket is not open"));
+        queueCallback(callback, new Error("WebSocket is not open"));
         return;
       }
       try {
         socket.send(data);
-        queueCallback3(callback);
+        queueCallback(callback);
       } catch (error) {
-        queueCallback3(callback, error);
+        queueCallback(callback, error);
       }
     };
     client.close = (code, reason) => {
@@ -1192,7 +1315,7 @@ var WebSocketServer = class extends import_events2.EventEmitter {
         return;
       }
       client.readyState = 2 /* CLOSING */;
-      socket.close(code ?? CLOSE_CODES.NORMAL, reason);
+      socket.close(code ?? CLOSE_CODES.NORMAL, typeof reason === "string" ? reason : reason?.toString());
     };
     client.terminate = () => {
       socket.close();
@@ -1200,7 +1323,7 @@ var WebSocketServer = class extends import_events2.EventEmitter {
     };
     return client;
   }
-  _handleBunOpen(socket, request2 = {}) {
+  _handleBunOpen(socket, request3 = {}) {
     const client = this._createClientFromBunSocket(socket);
     if (socket.data) {
       socket.data.client = client;
@@ -1212,9 +1335,9 @@ var WebSocketServer = class extends import_events2.EventEmitter {
       });
     }
     const incomingRequest = {
-      url: request2.url || this.path,
-      headers: request2.headers || {},
-      socket: request2.socket || { remoteAddress: void 0 }
+      url: request3.url || this.path,
+      headers: request3.headers || {},
+      socket: request3.socket || { remoteAddress: void 0 }
     };
     this.emit("connection", client, incomingRequest);
   }
@@ -1223,8 +1346,7 @@ var WebSocketServer = class extends import_events2.EventEmitter {
     if (!client) {
       return;
     }
-    const isBinary = typeof message !== "string";
-    const payload = typeof message === "string" ? message : message instanceof ArrayBuffer ? Buffer.from(message) : ArrayBuffer.isView(message) ? Buffer.from(message.buffer, message.byteOffset, message.byteLength) : Buffer.from(String(message));
+    const { payload, isBinary } = coerceBunMessage(message);
     client.emit("message", payload, isBinary);
   }
   _handleBunClose(socket, code, reason) {
@@ -1236,98 +1358,261 @@ var WebSocketServer = class extends import_events2.EventEmitter {
     client.emit("close", code, typeof reason === "string" ? reason : reason?.toString() || "");
     this.clients.delete(client);
   }
-  _parseFrame(data) {
-    if (data.length < 2) return null;
-    const firstByte = data[0];
-    const secondByte = data[1];
-    const opcode = firstByte & 15;
-    const isMasked = (secondByte & 128) === 128;
-    let payloadLength = secondByte & 127;
-    let offset = 2;
-    if (payloadLength === 126) {
-      payloadLength = data.readUInt16BE(2);
-      offset = 4;
-    } else if (payloadLength === 127) {
-      payloadLength = Number(data.readBigUInt64BE(2));
-      offset = 10;
-    }
-    let payload = data.subarray(offset);
-    if (isMasked) {
-      const maskKey = data.subarray(offset, offset + 4);
-      payload = data.subarray(offset + 4, offset + 4 + payloadLength);
-      for (let i = 0; i < payload.length; i++) {
-        payload[i] ^= maskKey[i % 4];
-      }
-    }
-    if (opcode === 1) {
-      return payload.toString("utf8");
-    }
-    return null;
-  }
-  _createFrame(data) {
-    const payload = typeof data === "string" ? Buffer.from(data) : data;
-    const payloadLength = Buffer.isBuffer(payload) ? payload.length : 0;
-    let frame;
-    let offset = 2;
-    if (payloadLength < 126) {
-      frame = Buffer.allocUnsafe(2 + payloadLength);
-      frame[1] = payloadLength;
-    } else if (payloadLength < 65536) {
-      frame = Buffer.allocUnsafe(4 + payloadLength);
-      frame[1] = 126;
-      frame.writeUInt16BE(payloadLength, 2);
-      offset = 4;
-    } else {
-      frame = Buffer.allocUnsafe(10 + payloadLength);
-      frame[1] = 127;
-      frame.writeBigUInt64BE(BigInt(payloadLength), 2);
-      offset = 10;
-    }
-    frame[0] = 129;
-    if (Buffer.isBuffer(payload)) {
-      payload.copy(frame, offset);
-    }
-    return frame;
-  }
   /**
-   * Close the server
+   * Close the server.
    */
   close(callback) {
     this.clients.forEach((client) => client.close());
     this.clients.clear();
     if (this._httpServer && this._ownsHttpServer) {
       this._httpServer.close(callback);
-    } else {
-      if (runtime === "bun" && this._httpServer?.unregisterWebSocketServer) {
-        this._httpServer.unregisterWebSocketServer(this);
-      }
-      this.emit("close");
-      queueCallback3(callback);
+      return;
+    }
+    if (runtime === "bun" && this._httpServer?.unregisterWebSocketServer) {
+      this._httpServer.unregisterWebSocketServer(this);
     }
+    this.emit("close");
+    queueCallback(callback);
   }
   /**
-   * Check if server should handle request
+   * Check if server should handle request.
    */
-  shouldHandle(request2) {
-    if (this.path && getRequestPath(request2.url) !== this.path) {
+  shouldHandle(request3) {
+    if (this.path && getRequestPath(request3.url) !== this.path) {
       return false;
     }
     return true;
   }
   /**
-   * Get server address
+   * Get server address.
    */
   address() {
-    if (this._httpServer && this._httpServer.address) {
+    if (this._httpServer?.address) {
       return this._httpServer.address();
     }
     return null;
   }
 };
 
-// src/wss.ts
+// src/server/ws/runtime.ts
+init_runtime();
+
+// src/server/wss/client.ts
+var WSSClient = class extends WebSocket {
+  constructor(address, protocols, options) {
+    const urlString = typeof address === "string" ? address : address.toString();
+    const secureUrl = urlString.replace(/^ws:\/\//i, "wss://");
+    super(secureUrl, protocols, options);
+  }
+};
+function createWSSClient(address, protocols, options) {
+  return new WSSClient(address, protocols, options);
+}
+
+// src/server/wss/runtime.ts
+init_runtime();
+function getRuntime2() {
+  return runtime;
+}
+
+// src/server/wss/server.ts
+var import_events3 = require("events");
+
+// src/server/https/client-request.ts
+var import_node_events = require("events");
+init_utils();
+
+// src/server/https/request-api.ts
+init_runtime();
+
+// src/server/https/http-classes.ts
+function loadHttpClasses() {
+  const httpModule = (init_http(), __toCommonJS(http_exports));
+  return {
+    IncomingMessage: httpModule.IncomingMessage,
+    ServerResponse: httpModule.ServerResponse
+  };
+}
+
+// src/server/https/node-modules.ts
+init_runtime();
+var https2;
+if (isNode && typeof process !== "undefined") {
+  try {
+    https2 = require("https");
+  } catch {
+    https2 = require("https");
+  }
+}
+
+// src/server/https/runtime.ts
+init_runtime();
+
+// src/server/https/server-runtime.ts
+var import_node_events6 = require("events");
+init_runtime();
+init_utils();
+var Server2 = class extends import_node_events6.EventEmitter {
+  constructor(options = {}, requestListener) {
+    super();
+    this._listening = false;
+    this.options = options;
+    this.requestListener = requestListener;
+  }
+  listen(...args) {
+    let port = 3e3;
+    let hostname = "0.0.0.0";
+    let callback;
+    const firstArg = args[0];
+    if (typeof firstArg === "number") {
+      port = firstArg;
+      const secondArg = args[1];
+      if (typeof secondArg === "string") {
+        hostname = secondArg;
+        callback = args[2] || args[3];
+      } else if (typeof secondArg === "function") {
+        callback = secondArg;
+      }
+    } else if (firstArg && typeof firstArg === "object") {
+      port = firstArg.port || 3e3;
+      hostname = firstArg.hostname || "0.0.0.0";
+      callback = args[1];
+    }
+    const self = this;
+    if (isNode) {
+      const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
+      this.nativeServer = https2.createServer(this.options, (req, res) => {
+        const incomingMessage = new IncomingMessage2(req);
+        const serverResponse = new ServerResponse2(incomingMessage, res);
+        if (self.requestListener) {
+          self.requestListener(incomingMessage, serverResponse);
+        } else {
+          self.emit("request", incomingMessage, serverResponse);
+        }
+      });
+      this.nativeServer.listen(port, hostname, () => {
+        this._listening = true;
+        this.emit("listening");
+        if (callback) callback();
+      });
+      this.nativeServer.on("error", (err) => this.emit("error", err));
+      this.nativeServer.on("close", () => {
+        this._listening = false;
+        this.emit("close");
+      });
+    } else if (isBun) {
+      const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
+      const tlsOptions = {
+        port,
+        hostname,
+        fetch: (req) => {
+          return new Promise((resolve) => {
+            const incomingMessage = new IncomingMessage2(req);
+            const serverResponse = new ServerResponse2();
+            serverResponse._setResolver(resolve);
+            if (self.requestListener) {
+              self.requestListener(incomingMessage, serverResponse);
+            } else {
+              self.emit("request", incomingMessage, serverResponse);
+            }
+          });
+        },
+        error: (error) => {
+          this.emit("error", error);
+          return createErrorResponse();
+        }
+      };
+      if (this.options.key || this.options.cert) {
+        tlsOptions.tls = {
+          key: this.options.key,
+          cert: this.options.cert,
+          ca: this.options.ca,
+          passphrase: this.options.passphrase
+        };
+      } else if (this.options.tls) {
+        tlsOptions.tls = this.options.tls;
+      }
+      this.nativeServer = Bun.serve(tlsOptions);
+      emitListeningWithCallback(this, callback);
+    } else if (isDeno) {
+      const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
+      const serveOptions = {
+        port,
+        hostname,
+        handler: (req) => {
+          return new Promise((resolve) => {
+            const incomingMessage = new IncomingMessage2(req);
+            const serverResponse = new ServerResponse2();
+            serverResponse._setResolver(resolve);
+            if (self.requestListener) {
+              self.requestListener(incomingMessage, serverResponse);
+            } else {
+              self.emit("request", incomingMessage, serverResponse);
+            }
+          });
+        },
+        onError: (error) => {
+          this.emit("error", error);
+          return createErrorResponse();
+        }
+      };
+      if (this.options.key && this.options.cert) {
+        serveOptions.cert = this.options.cert;
+        serveOptions.key = this.options.key;
+      }
+      this.nativeServer = Deno.serve(serveOptions);
+      emitListeningWithCallback(this, callback);
+    }
+    return this;
+  }
+  close(callback) {
+    if (!this.nativeServer) {
+      if (callback) queueCallback2(() => callback());
+      return this;
+    }
+    if (isNode) {
+      this.nativeServer.close(callback);
+    } else if (isBun) {
+      this.nativeServer.stop();
+      closeAndEmit(this, callback);
+    } else if (isDeno) {
+      this.nativeServer.shutdown();
+      closeAndEmit(this, callback);
+    }
+    return this;
+  }
+  address() {
+    if (!this.nativeServer) return null;
+    if (isNode) {
+      const addr = this.nativeServer.address();
+      if (!addr) return null;
+      if (typeof addr === "string") {
+        return createAddress(0, addr, "unix");
+      }
+      return addr;
+    }
+    if (isBun) {
+      return createAddress(this.nativeServer.port, this.nativeServer.hostname);
+    }
+    if (isDeno) {
+      const addr = this.nativeServer.addr;
+      return createAddress(addr.port, addr.hostname);
+    }
+    return null;
+  }
+  get listening() {
+    return this._listening;
+  }
+};
+function createServer2(options = {}, requestListener) {
+  return new Server2(options, requestListener);
+}
+
+// src/server/wss/server.ts
 init_runtime();
-function queueCallback4(callback) {
+
+// src/server/wss/utils.ts
+function queueCallback3(callback) {
   if (callback) {
     queueMicrotask(callback);
   }
@@ -1344,15 +1629,10 @@ function buildHttpsOptions(options) {
 }
 function emitCloseWithCallback(emitter, callback) {
   emitter.emit("close");
-  queueCallback4(callback);
+  queueCallback3(callback);
 }
-var WSSClient = class extends WebSocket {
-  constructor(address, protocols, options) {
-    const urlString = typeof address === "string" ? address : address.toString();
-    const secureUrl = urlString.replace(/^ws:\/\//i, "wss://");
-    super(secureUrl, protocols, options);
-  }
-};
+
+// src/server/wss/server.ts
 var WSSServer = class extends import_events3.EventEmitter {
   constructor(options, callback) {
     super();
@@ -1365,7 +1645,7 @@ var WSSServer = class extends import_events3.EventEmitter {
         this._setupServer(callback);
       } else if (options?.noServer) {
         this._wsServer = new WebSocketServer({ noServer: true });
-        queueCallback4(callback);
+        queueCallback3(callback);
       } else {
         this._httpsServer = createServer2(buildHttpsOptions(options));
         this._setupServer(callback);
@@ -1375,7 +1655,7 @@ var WSSServer = class extends import_events3.EventEmitter {
       }
     } else {
       this._wsServer = new WebSocketServer(options);
-      queueCallback4(callback);
+      queueCallback3(callback);
     }
   }
   _setupServer(callback) {
@@ -1384,44 +1664,44 @@ var WSSServer = class extends import_events3.EventEmitter {
       server: this._httpsServer,
       noServer: false
     });
-    this._wsServer.on("connection", (client, request2) => {
+    this._wsServer.on("connection", (client, request3) => {
       if (this.options.clientTracking !== false) {
         this.clients.add(client);
         client.on("close", () => {
           this.clients.delete(client);
         });
       }
-      this.emit("connection", client, request2);
+      this.emit("connection", client, request3);
     });
     this._wsServer.on("error", (error) => {
       this.emit("error", error);
     });
     if (!this.options?.port) {
-      queueCallback4(callback);
+      queueCallback3(callback);
     }
   }
   /**
-   * Handle HTTP upgrade for WebSocket
+   * Handle HTTP upgrade for WebSocket.
    */
-  handleUpgrade(request2, socket, head, callback) {
+  handleUpgrade(request3, socket, head, callback) {
     if (this._wsServer) {
-      this._wsServer.handleUpgrade(request2, socket, head, callback);
+      this._wsServer.handleUpgrade(request3, socket, head, callback);
     }
   }
   /**
-   * Check if server should handle request
+   * Check if server should handle request.
    */
-  shouldHandle(request2) {
+  shouldHandle(request3) {
     if (this._wsServer) {
-      return this._wsServer.shouldHandle(request2);
+      return this._wsServer.shouldHandle(request3);
     }
-    if (this.path && request2.url !== this.path) {
+    if (this.path && request3.url !== this.path) {
       return false;
     }
     return true;
   }
   /**
-   * Close the server
+   * Close the server.
    */
   close(callback) {
     this.clients.forEach((client) => client.close());
@@ -1434,17 +1714,19 @@ var WSSServer = class extends import_events3.EventEmitter {
           emitCloseWithCallback(this, callback);
         }
       });
-    } else if (this._httpsServer) {
+      return;
+    }
+    if (this._httpsServer) {
       this._httpsServer.close(callback);
-    } else {
-      emitCloseWithCallback(this, callback);
+      return;
     }
+    emitCloseWithCallback(this, callback);
   }
   /**
-   * Get server address
+   * Get server address.
    */
   address() {
-    if (this._httpsServer && this._httpsServer.address) {
+    if (this._httpsServer?.address) {
       return this._httpsServer.address();
     }
     if (this._wsServer) {
@@ -1453,15 +1735,11 @@ var WSSServer = class extends import_events3.EventEmitter {
     return null;
   }
 };
-function createWSSClient(address, protocols, options) {
-  return new WSSClient(address, protocols, options);
-}
 function createWSSServer(options, callback) {
   return new WSSServer(options, callback);
 }
-function getRuntime2() {
-  return runtime;
-}
+
+// src/server/wss/index.ts
 var wss_default = {
   WSSClient,
   WSSServer,