elit 3.6.6 → 3.6.7

package/dist/https.cjs

@@ -20,41 +20,78 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/runtime.ts
-var runtime, isNode, isBun, isDeno;
-var init_runtime = __esm({
-  "src/runtime.ts"() {
-    "use strict";
-    runtime = (() => {
-      if (typeof Deno !== "undefined") return "deno";
-      if (typeof Bun !== "undefined") return "bun";
-      return "node";
-    })();
-    isNode = runtime === "node";
-    isBun = runtime === "bun";
-    isDeno = runtime === "deno";
-  }
-});
-
-// 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
-});
+// src/server/http/utils.ts
 function queueCallback(callback) {
   if (callback) queueMicrotask(callback);
 }
+function getRequestPath(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) {
@@ -79,69 +116,119 @@ function closeAndEmit(server, callback) {
   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/shares/runtime.ts
+var runtime, isNode, isBun, isDeno;
+var init_runtime = __esm({
+  "src/shares/runtime.ts"() {
+    "use strict";
+    runtime = (() => {
+      if (typeof Deno !== "undefined") return "deno";
+      if (typeof Bun !== "undefined") return "bun";
+      return "node";
+    })();
+    isNode = runtime === "node";
+    isBun = runtime === "bun";
+    isDeno = runtime === "deno";
+  }
+});
+
+// src/server/http/agent.ts
+var Agent2;
+var init_agent = __esm({
+  "src/server/http/agent.ts"() {
+    "use strict";
+    Agent2 = 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, ClientRequest2;
+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();
+    ClientRequest2 = 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));
+        queueCallback(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) {
+          queueCallback(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));
+        }
+        queueCallback(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 = getRequestPath(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 = getRequestPath(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 ClientRequest2(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;
@@ -384,7 +565,6 @@ var init_http = __esm({
       _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 getRuntime() {
+  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: () => Agent2,
+  ClientRequest: () => ClientRequest2,
+  IncomingMessage: () => IncomingMessage,
+  METHODS: () => METHODS,
+  STATUS_CODES: () => STATUS_CODES,
+  Server: () => Server,
+  ServerResponse: () => ServerResponse,
+  createServer: () => createServer,
+  default: () => http_default,
+  get: () => get,
+  getRuntime: () => getRuntime,
+  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,
@@ -689,8 +926,8 @@ var init_http = __esm({
       Server,
       IncomingMessage,
       ServerResponse,
-      Agent,
-      ClientRequest,
+      Agent: Agent2,
+      ClientRequest: ClientRequest2,
       METHODS,
       STATUS_CODES,
       getRuntime
@@ -698,11 +935,11 @@ var init_http = __esm({
   }
 });
 
-// src/https.ts
+// src/server/https/index.ts
 var https_exports = {};
 __export(https_exports, {
-  Agent: () => Agent2,
-  ClientRequest: () => ClientRequest2,
+  Agent: () => Agent,
+  ClientRequest: () => ClientRequest,
   Server: () => Server2,
   createServer: () => createServer2,
   default: () => https_default,
@@ -711,27 +948,84 @@ __export(https_exports, {
   request: () => request2
 });
 module.exports = __toCommonJS(https_exports);
-var import_events = require("events");
+
+// src/server/https/agent.ts
+var Agent = class {
+  constructor(options) {
+    this.options = options;
+  }
+};
+
+// src/server/https/client-request.ts
+var import_node_events = require("events");
+init_utils();
+var ClientRequest = class extends import_node_events.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 actualEncoding = typeof encoding === "string" ? encoding : void 0;
+      return this._nativeRequest.write(chunk, actualEncoding, callback);
+    }
+    this._bodyChunks.push(normalizeRequestBodyChunk(chunk, typeof encoding === "string" ? encoding : "utf8"));
+    queueCallback(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) {
+      queueCallback(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));
+    }
+    queueCallback(callback);
+  }
+};
+
+// src/server/https/request-api.ts
 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());
-}
+
+// src/server/https/http-classes.ts
 function loadHttpClasses() {
   const httpModule = (init_http(), __toCommonJS(http_exports));
   return {
@@ -739,9 +1033,70 @@ function loadHttpClasses() {
     ServerResponse: httpModule.ServerResponse
   };
 }
+
+// src/server/https/node-modules.ts
+init_runtime();
 var https2;
-var Server2 = class extends import_events.EventEmitter {
-  constructor(options, requestListener) {
+if (isNode && typeof process !== "undefined") {
+  try {
+    https2 = require("https");
+  } catch {
+    https2 = require("https");
+  }
+}
+
+// src/server/https/request-api.ts
+function request2(url, options, callback) {
+  const urlString = typeof url === "string" ? url : url.toString();
+  const req = new ClientRequest(urlString, options);
+  if (isNode) {
+    const { IncomingMessage: IncomingMessage2 } = loadHttpClasses();
+    const nodeReq = https2.request(urlString, {
+      method: options?.method || "GET",
+      headers: options?.headers,
+      timeout: options?.timeout,
+      signal: options?.signal
+    }, (res) => {
+      const incomingMessage = new IncomingMessage2(res);
+      if (callback) callback(incomingMessage);
+      req.emit("response", incomingMessage);
+    });
+    req._setNativeRequest(nodeReq);
+    nodeReq.on("error", (error) => req.emit("error", error));
+  } else {
+    const { IncomingMessage: IncomingMessage2 } = loadHttpClasses();
+    req._setExecutor(async (body) => {
+      const response = await fetch(urlString, {
+        method: options?.method || "GET",
+        headers: options?.headers,
+        body,
+        signal: options?.signal
+      });
+      const incomingMessage = new IncomingMessage2(response, options?.method || "GET");
+      if (callback) callback(incomingMessage);
+      req.emit("response", incomingMessage);
+    });
+  }
+  return req;
+}
+function get2(url, options, callback) {
+  const req = request2(url, { ...options, method: "GET" }, callback);
+  req.end();
+  return req;
+}
+
+// src/server/https/runtime.ts
+init_runtime();
+function getRuntime2() {
+  return 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;
@@ -769,7 +1124,6 @@ var Server2 = class extends import_events.EventEmitter {
     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);
@@ -808,7 +1162,7 @@ var Server2 = class extends import_events.EventEmitter {
         },
         error: (error) => {
           this.emit("error", error);
-          return createErrorResponse2();
+          return createErrorResponse();
         }
       };
       if (this.options.key || this.options.cert) {
@@ -822,7 +1176,7 @@ var Server2 = class extends import_events.EventEmitter {
         tlsOptions.tls = this.options.tls;
       }
       this.nativeServer = Bun.serve(tlsOptions);
-      emitListeningWithCallback2(this, callback);
+      emitListeningWithCallback(this, callback);
     } else if (isDeno) {
       const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
       const serveOptions = {
@@ -842,7 +1196,7 @@ var Server2 = class extends import_events.EventEmitter {
         },
         onError: (error) => {
           this.emit("error", error);
-          return createErrorResponse2();
+          return createErrorResponse();
         }
       };
       if (this.options.key && this.options.cert) {
@@ -850,23 +1204,23 @@ var Server2 = class extends import_events.EventEmitter {
         serveOptions.key = this.options.key;
       }
       this.nativeServer = Deno.serve(serveOptions);
-      emitListeningWithCallback2(this, callback);
+      emitListeningWithCallback(this, callback);
     }
     return this;
   }
   close(callback) {
     if (!this.nativeServer) {
-      if (callback) queueMicrotask(() => callback());
+      if (callback) queueCallback(() => callback());
       return this;
     }
     if (isNode) {
       this.nativeServer.close(callback);
     } else if (isBun) {
       this.nativeServer.stop();
-      closeAndEmit2(this, callback);
+      closeAndEmit(this, callback);
     } else if (isDeno) {
       this.nativeServer.shutdown();
-      closeAndEmit2(this, callback);
+      closeAndEmit(this, callback);
     }
     return this;
   }
@@ -876,14 +1230,16 @@ var Server2 = class extends import_events.EventEmitter {
       const addr = this.nativeServer.address();
       if (!addr) return null;
       if (typeof addr === "string") {
-        return createAddress2(0, addr, "unix");
+        return createAddress(0, addr, "unix");
       }
       return addr;
-    } else if (isBun) {
-      return createAddress2(this.nativeServer.port, this.nativeServer.hostname);
-    } else if (isDeno) {
+    }
+    if (isBun) {
+      return createAddress(this.nativeServer.port, this.nativeServer.hostname);
+    }
+    if (isDeno) {
       const addr = this.nativeServer.addr;
-      return createAddress2(addr.port, addr.hostname);
+      return createAddress(addr.port, addr.hostname);
     }
     return null;
   }
@@ -891,78 +1247,18 @@ var Server2 = class extends import_events.EventEmitter {
     return this._listening;
   }
 };
-var ClientRequest2 = class extends import_events.EventEmitter {
-  constructor(_url, _options = {}) {
-    super();
-  }
-  write(_chunk) {
-    return true;
-  }
-  end(callback) {
-    queueCallback2(callback);
-  }
-};
-var Agent2 = class {
-  constructor(options) {
-    this.options = options;
-  }
-};
-function createServer2(options, requestListener) {
+function createServer2(options = {}, requestListener) {
   return new Server2(options, requestListener);
 }
-function request2(url, options, callback) {
-  const urlString = typeof url === "string" ? url : url.toString();
-  const req = new ClientRequest2(urlString, options);
-  if (isNode) {
-    const { IncomingMessage: IncomingMessage2 } = loadHttpClasses();
-    if (!https2) https2 = require("https");
-    const nodeReq = https2.request(urlString, {
-      method: options?.method || "GET",
-      headers: options?.headers,
-      timeout: options?.timeout,
-      signal: options?.signal
-    }, (res) => {
-      const incomingMessage = new IncomingMessage2(res);
-      if (callback) callback(incomingMessage);
-      req.emit("response", incomingMessage);
-    });
-    nodeReq.on("error", (error) => req.emit("error", error));
-    nodeReq.end();
-  } else {
-    const { IncomingMessage: IncomingMessage2 } = loadHttpClasses();
-    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 IncomingMessage2(fetchRequest);
-        incomingMessage.statusCode = response.status;
-        incomingMessage.statusMessage = response.statusText;
-        if (callback) callback(incomingMessage);
-        req.emit("response", incomingMessage);
-      } catch (error) {
-        req.emit("error", error);
-      }
-    });
-  }
-  return req;
-}
-function get2(url, options, callback) {
-  return request2(url, { ...options, method: "GET" }, callback);
-}
-function getRuntime2() {
-  return runtime;
-}
+
+// src/server/https/index.ts
 var https_default = {
   createServer: createServer2,
   request: request2,
   get: get2,
   Server: Server2,
-  Agent: Agent2,
-  ClientRequest: ClientRequest2,
+  Agent,
+  ClientRequest,
   getRuntime: getRuntime2
 };
 // Annotate the CommonJS export names for ESM import in node: