elit 2.0.1 → 3.0.1

package/dist/http.mjs

@@ -0,0 +1,605 @@
+import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/http.ts
+import { EventEmitter } from "events";
+
+// src/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
+// src/http.ts
+function queueCallback(callback) {
+  if (callback) queueMicrotask(callback);
+}
+function headersToInit(headers) {
+  const result = {};
+  for (const key in headers) {
+    const value = headers[key];
+    result[key] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return result;
+}
+function createAddress(port, address, family = "IPv4") {
+  return { port, family, address };
+}
+function createErrorResponse() {
+  return new Response("Internal Server Error", { status: 500 });
+}
+function emitListeningWithCallback(server, callback) {
+  server._listening = true;
+  server.emit("listening");
+  queueCallback(callback);
+}
+function closeAndEmit(server, callback) {
+  server._listening = false;
+  server.emit("close");
+  if (callback) queueMicrotask(() => callback());
+}
+var http;
+var https;
+if (isNode && typeof process !== "undefined") {
+  try {
+    http = __require("http");
+    https = __require("https");
+  } catch (e) {
+    http = __require("http");
+    https = __require("https");
+  }
+}
+var METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+];
+var STATUS_CODES = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a teapot",
+  422: "Unprocessable Entity",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+var IncomingMessage = class extends EventEmitter {
+  constructor(req) {
+    super();
+    this.httpVersion = "1.1";
+    this.rawHeaders = [];
+    this._req = req;
+    if (isNode) {
+      this.method = req.method;
+      this.url = req.url;
+      this.headers = req.headers;
+      this.statusCode = req.statusCode;
+      this.statusMessage = req.statusMessage;
+      this.httpVersion = req.httpVersion;
+      this.rawHeaders = req.rawHeaders;
+      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 = [];
+    }
+  }
+  async text() {
+    if (isNode) {
+      return new Promise((resolve, reject) => {
+        const chunks = [];
+        this._req.on("data", (chunk) => chunks.push(chunk));
+        this._req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        this._req.on("error", reject);
+      });
+    }
+    return this._req.text();
+  }
+  async json() {
+    if (isNode) {
+      const text = await this.text();
+      return JSON.parse(text);
+    }
+    return this._req.json();
+  }
+};
+var ServerResponse = class extends EventEmitter {
+  constructor(_req, nodeRes) {
+    super();
+    this.statusCode = 200;
+    this.statusMessage = "OK";
+    this.headersSent = false;
+    this._body = "";
+    this._finished = false;
+    this._nodeRes = nodeRes;
+    this._headers = /* @__PURE__ */ Object.create(null);
+  }
+  setHeader(name, value) {
+    if (this.headersSent) {
+      throw new Error("Cannot set headers after they are sent");
+    }
+    if (isNode && this._nodeRes) {
+      this._nodeRes.setHeader(name, value);
+    }
+    this._headers[name.toLowerCase()] = value;
+    return this;
+  }
+  getHeader(name) {
+    if (isNode && this._nodeRes) {
+      return this._nodeRes.getHeader(name);
+    }
+    return this._headers[name.toLowerCase()];
+  }
+  getHeaders() {
+    if (isNode && this._nodeRes) {
+      return this._nodeRes.getHeaders();
+    }
+    return { ...this._headers };
+  }
+  getHeaderNames() {
+    if (isNode && this._nodeRes) {
+      return this._nodeRes.getHeaderNames();
+    }
+    return Object.keys(this._headers);
+  }
+  hasHeader(name) {
+    if (isNode && this._nodeRes) {
+      return this._nodeRes.hasHeader(name);
+    }
+    return name.toLowerCase() in this._headers;
+  }
+  removeHeader(name) {
+    if (this.headersSent) {
+      throw new Error("Cannot remove headers after they are sent");
+    }
+    if (isNode && this._nodeRes) {
+      this._nodeRes.removeHeader(name);
+    }
+    delete this._headers[name.toLowerCase()];
+  }
+  writeHead(statusCode, statusMessage, headers) {
+    if (this.headersSent) {
+      throw new Error("Cannot write headers after they are sent");
+    }
+    this.statusCode = statusCode;
+    if (typeof statusMessage === "string") {
+      this.statusMessage = statusMessage;
+      if (headers) {
+        for (const key in headers) {
+          this.setHeader(key, headers[key]);
+        }
+      }
+    } else if (statusMessage) {
+      for (const key in statusMessage) {
+        this.setHeader(key, statusMessage[key]);
+      }
+    }
+    if (isNode && this._nodeRes) {
+      if (typeof statusMessage === "string") {
+        this._nodeRes.writeHead(statusCode, statusMessage, headers);
+      } else {
+        this._nodeRes.writeHead(statusCode, statusMessage);
+      }
+    }
+    this.headersSent = true;
+    return this;
+  }
+  write(chunk, encoding, callback) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = "utf8";
+    }
+    if (!this.headersSent) {
+      this.writeHead(this.statusCode);
+    }
+    if (isNode && this._nodeRes) {
+      return this._nodeRes.write(chunk, encoding, callback);
+    }
+    this._body += chunk;
+    queueCallback(callback);
+    return true;
+  }
+  end(chunk, encoding, callback) {
+    if (this._finished) {
+      return this;
+    }
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = void 0;
+    } else if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = "utf8";
+    }
+    if (chunk !== void 0) {
+      this.write(chunk, encoding);
+    }
+    if (!this.headersSent) {
+      this.writeHead(this.statusCode);
+    }
+    this._finished = true;
+    if (isNode && this._nodeRes) {
+      this._nodeRes.end(callback);
+      this.emit("finish");
+    } else {
+      const response = new Response(this._body, {
+        status: this.statusCode,
+        statusText: this.statusMessage,
+        headers: headersToInit(this._headers)
+      });
+      if (this._resolve) {
+        this._resolve(response);
+      }
+      queueCallback(callback);
+    }
+    return this;
+  }
+  _setResolver(resolve) {
+    this._resolve = resolve;
+  }
+};
+var Server = class extends EventEmitter {
+  constructor(requestListener) {
+    super();
+    this._listening = false;
+    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) {
+      this.nativeServer = http.createServer((req, res) => {
+        const incomingMessage = new IncomingMessage(req);
+        const serverResponse = new ServerResponse(incomingMessage, res);
+        if (self.requestListener) {
+          self.requestListener(incomingMessage, serverResponse);
+        } else {
+          self.emit("request", incomingMessage, serverResponse);
+        }
+      });
+      this.nativeServer.on("upgrade", (req, socket, head) => {
+        self.emit("upgrade", req, socket, head);
+      });
+      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) {
+      this.nativeServer = Bun.serve({
+        port,
+        hostname,
+        fetch: (req) => {
+          const urlObj = new URL(req.url);
+          const pathname = urlObj.pathname + urlObj.search;
+          let statusCode = 200;
+          let statusMessage = "OK";
+          let body = "";
+          const headers = /* @__PURE__ */ Object.create(null);
+          let responseReady = false;
+          const incomingMessage = {
+            method: req.method,
+            url: pathname,
+            headers: req.headers,
+            httpVersion: "1.1",
+            rawHeaders: [],
+            _req: req,
+            text: () => req.text(),
+            json: () => req.json()
+          };
+          const serverResponse = {
+            statusCode: 200,
+            statusMessage: "OK",
+            headersSent: false,
+            _headers: headers,
+            setHeader(name, value) {
+              headers[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+              return this;
+            },
+            getHeader(name) {
+              return headers[name.toLowerCase()];
+            },
+            getHeaders() {
+              return { ...headers };
+            },
+            writeHead(status, arg2, arg3) {
+              statusCode = status;
+              this.statusCode = status;
+              this.headersSent = true;
+              if (typeof arg2 === "string") {
+                statusMessage = arg2;
+                this.statusMessage = arg2;
+                if (arg3) {
+                  for (const key in arg3) {
+                    headers[key.toLowerCase()] = arg3[key];
+                  }
+                }
+              } else if (arg2) {
+                for (const key in arg2) {
+                  headers[key.toLowerCase()] = arg2[key];
+                }
+              }
+              return this;
+            },
+            write(chunk) {
+              if (!this.headersSent) {
+                this.writeHead(statusCode);
+              }
+              body += chunk;
+              return true;
+            },
+            end(chunk) {
+              if (chunk !== void 0) {
+                this.write(chunk);
+              }
+              if (!this.headersSent) {
+                this.writeHead(statusCode);
+              }
+              responseReady = true;
+              return this;
+            }
+          };
+          if (self.requestListener) {
+            self.requestListener(incomingMessage, serverResponse);
+          }
+          if (responseReady) {
+            return new Response(body, {
+              status: statusCode,
+              statusText: statusMessage,
+              headers
+            });
+          }
+          return new Promise((resolve) => {
+            serverResponse.end = (chunk) => {
+              if (chunk !== void 0) {
+                body += chunk;
+              }
+              resolve(new Response(body, {
+                status: statusCode,
+                statusText: statusMessage,
+                headers
+              }));
+            };
+          });
+        },
+        error: createErrorResponse
+      });
+      emitListeningWithCallback(this, callback);
+    } else if (isDeno) {
+      this.nativeServer = Deno.serve({
+        port,
+        hostname,
+        handler: (req) => {
+          return new Promise((resolve) => {
+            const incomingMessage = new IncomingMessage(req);
+            const serverResponse = new ServerResponse();
+            serverResponse._setResolver(resolve);
+            if (self.requestListener) {
+              self.requestListener(incomingMessage, serverResponse);
+            } else {
+              self.emit("request", incomingMessage, serverResponse);
+            }
+          });
+        },
+        onError: (error) => {
+          this.emit("error", error);
+          return createErrorResponse();
+        }
+      });
+      emitListeningWithCallback(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();
+      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;
+    } else if (isBun) {
+      return createAddress(this.nativeServer.port, this.nativeServer.hostname);
+    } else if (isDeno) {
+      const addr = this.nativeServer.addr;
+      return createAddress(addr.port, addr.hostname);
+    }
+    return null;
+  }
+  get listening() {
+    return this._listening;
+  }
+};
+var ClientRequest = class extends EventEmitter {
+  constructor(_url, _options = {}) {
+    super();
+  }
+  write(_chunk) {
+    return true;
+  }
+  end(callback) {
+    queueCallback(callback);
+  }
+};
+var Agent = class {
+  constructor(options) {
+    this.options = options;
+  }
+};
+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);
+      }
+    });
+  }
+  return req;
+}
+function get(url, options, callback) {
+  return request(url, { ...options, method: "GET" }, callback);
+}
+function getRuntime() {
+  return runtime;
+}
+var http_default = {
+  createServer,
+  request,
+  get,
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  Agent,
+  ClientRequest,
+  METHODS,
+  STATUS_CODES,
+  getRuntime
+};
+export {
+  Agent,
+  ClientRequest,
+  IncomingMessage,
+  METHODS,
+  STATUS_CODES,
+  Server,
+  ServerResponse,
+  createServer,
+  http_default as default,
+  get,
+  getRuntime,
+  request
+};

package/dist/https.d.mts

@@ -0,0 +1,108 @@
+import { EventEmitter } from 'events';
+import { IncomingMessage, ServerResponse, RequestListener, RequestOptions } from './http.mjs';
+import 'node:events';
+
+/**
+ * HTTPS module with unified API across runtimes
+ * Optimized for maximum performance across Node.js, Bun, and Deno
+ */
+
+/**
+ * HTTPS Server options
+ */
+interface ServerOptions {
+    IncomingMessage?: typeof IncomingMessage;
+    ServerResponse?: typeof ServerResponse;
+    key?: string | Buffer | Array<string | Buffer>;
+    cert?: string | Buffer | Array<string | Buffer>;
+    ca?: string | Buffer | Array<string | Buffer>;
+    passphrase?: string;
+    pfx?: string | Buffer | Array<string | Buffer>;
+    dhparam?: string | Buffer;
+    ecdhCurve?: string;
+    honorCipherOrder?: boolean;
+    requestCert?: boolean;
+    rejectUnauthorized?: boolean;
+    NPNProtocols?: string[] | Buffer[] | Uint8Array[] | Buffer | Uint8Array;
+    ALPNProtocols?: string[] | Buffer[] | Uint8Array[] | Buffer | Uint8Array;
+    SNICallback?: (servername: string, cb: (err: Error | null, ctx?: any) => void) => void;
+    sessionTimeout?: number;
+    ticketKeys?: Buffer;
+    tls?: {
+        key?: string | Buffer;
+        cert?: string | Buffer;
+        ca?: string | Buffer;
+        passphrase?: string;
+        dhParamsFile?: string;
+    };
+}
+/**
+ * HTTPS Server - Optimized for each runtime
+ */
+declare class Server extends EventEmitter {
+    private nativeServer?;
+    private requestListener?;
+    _listening: boolean;
+    private options;
+    constructor(options: ServerOptions, requestListener?: RequestListener);
+    listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): this;
+    listen(port?: number, hostname?: string, listeningListener?: () => void): this;
+    listen(port?: number, listeningListener?: () => void): this;
+    listen(options?: {
+        port?: number;
+        hostname?: string;
+        backlog?: number;
+    }, listeningListener?: () => void): this;
+    close(callback?: (err?: Error) => void): this;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+    get listening(): boolean;
+}
+/**
+ * Client request
+ */
+declare class ClientRequest extends EventEmitter {
+    constructor(_url: string | URL, _options?: RequestOptions);
+    write(_chunk: any): boolean;
+    end(callback?: () => void): void;
+}
+/**
+ * HTTPS Agent
+ */
+declare class Agent {
+    options?: any | undefined;
+    constructor(options?: any | undefined);
+}
+/**
+ * Create HTTPS server
+ */
+declare function createServer(options: ServerOptions, requestListener?: RequestListener): Server;
+/**
+ * Make HTTPS request - optimized per runtime
+ */
+declare function request(url: string | URL, options?: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
+/**
+ * Make HTTPS GET request
+ */
+declare function get(url: string | URL, options?: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
+/**
+ * Get current runtime
+ */
+declare function getRuntime(): 'node' | 'bun' | 'deno';
+/**
+ * Default export
+ */
+declare const _default: {
+    createServer: typeof createServer;
+    request: typeof request;
+    get: typeof get;
+    Server: typeof Server;
+    Agent: typeof Agent;
+    ClientRequest: typeof ClientRequest;
+    getRuntime: typeof getRuntime;
+};
+
+export { Agent, ClientRequest, Server, type ServerOptions, createServer, _default as default, get, getRuntime, request };