convex-cms 0.0.1 → 0.0.3

package/admin-dist/server/_libs/srvx.mjs

@@ -0,0 +1,719 @@
+import nodeHTTP from "node:http";
+import { Readable } from "node:stream";
+import nodeHTTPS from "node:https";
+import nodeHTTP2 from "node:http2";
+function lazyInherit(target, source, sourceKey) {
+  for (const key of [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)]) {
+    if (key === "constructor") continue;
+    const targetDesc = Object.getOwnPropertyDescriptor(target, key);
+    const desc = Object.getOwnPropertyDescriptor(source, key);
+    let modified = false;
+    if (desc.get) {
+      modified = true;
+      desc.get = targetDesc?.get || function() {
+        return this[sourceKey][key];
+      };
+    }
+    if (desc.set) {
+      modified = true;
+      desc.set = targetDesc?.set || function(value) {
+        this[sourceKey][key] = value;
+      };
+    }
+    if (!targetDesc?.value && typeof desc.value === "function") {
+      modified = true;
+      desc.value = function(...args) {
+        return this[sourceKey][key](...args);
+      };
+    }
+    if (modified) Object.defineProperty(target, key, desc);
+  }
+}
+const FastURL = /* @__PURE__ */ (() => {
+  const NativeURL = globalThis.URL;
+  const FastURL$1 = class URL {
+    #url;
+    #href;
+    #protocol;
+    #host;
+    #pathname;
+    #search;
+    #searchParams;
+    #pos;
+    constructor(url) {
+      if (typeof url === "string") this.#href = url;
+      else {
+        this.#protocol = url.protocol;
+        this.#host = url.host;
+        this.#pathname = url.pathname;
+        this.#search = url.search;
+      }
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeURL;
+    }
+    get _url() {
+      if (this.#url) return this.#url;
+      this.#url = new NativeURL(this.href);
+      this.#href = void 0;
+      this.#protocol = void 0;
+      this.#host = void 0;
+      this.#pathname = void 0;
+      this.#search = void 0;
+      this.#searchParams = void 0;
+      this.#pos = void 0;
+      return this.#url;
+    }
+    get href() {
+      if (this.#url) return this.#url.href;
+      if (!this.#href) this.#href = `${this.#protocol || "http:"}//${this.#host || "localhost"}${this.#pathname || "/"}${this.#search || ""}`;
+      return this.#href;
+    }
+    #getPos() {
+      if (!this.#pos) {
+        const url = this.href;
+        const protoIndex = url.indexOf("://");
+        const pathnameIndex = protoIndex === -1 ? -1 : url.indexOf("/", protoIndex + 4);
+        this.#pos = [
+          protoIndex,
+          pathnameIndex,
+          pathnameIndex === -1 ? -1 : url.indexOf("?", pathnameIndex)
+        ];
+      }
+      return this.#pos;
+    }
+    get pathname() {
+      if (this.#url) return this.#url.pathname;
+      if (this.#pathname === void 0) {
+        const [, pathnameIndex, queryIndex] = this.#getPos();
+        if (pathnameIndex === -1) return this._url.pathname;
+        this.#pathname = this.href.slice(pathnameIndex, queryIndex === -1 ? void 0 : queryIndex);
+      }
+      return this.#pathname;
+    }
+    get search() {
+      if (this.#url) return this.#url.search;
+      if (this.#search === void 0) {
+        const [, pathnameIndex, queryIndex] = this.#getPos();
+        if (pathnameIndex === -1) return this._url.search;
+        const url = this.href;
+        this.#search = queryIndex === -1 || queryIndex === url.length - 1 ? "" : url.slice(queryIndex);
+      }
+      return this.#search;
+    }
+    get searchParams() {
+      if (this.#url) return this.#url.searchParams;
+      if (!this.#searchParams) this.#searchParams = new URLSearchParams(this.search);
+      return this.#searchParams;
+    }
+    get protocol() {
+      if (this.#url) return this.#url.protocol;
+      if (this.#protocol === void 0) {
+        const [protocolIndex] = this.#getPos();
+        if (protocolIndex === -1) return this._url.protocol;
+        this.#protocol = this.href.slice(0, protocolIndex + 1);
+      }
+      return this.#protocol;
+    }
+    toString() {
+      return this.href;
+    }
+    toJSON() {
+      return this.href;
+    }
+  };
+  lazyInherit(FastURL$1.prototype, NativeURL.prototype, "_url");
+  Object.setPrototypeOf(FastURL$1.prototype, NativeURL.prototype);
+  Object.setPrototypeOf(FastURL$1, NativeURL);
+  return FastURL$1;
+})();
+function resolvePortAndHost(opts) {
+  const _port = opts.port ?? globalThis.process?.env.PORT ?? 3e3;
+  const port = typeof _port === "number" ? _port : Number.parseInt(_port, 10);
+  if (port < 0 || port > 65535) throw new RangeError(`Port must be between 0 and 65535 (got "${port}").`);
+  return {
+    port,
+    hostname: opts.hostname ?? globalThis.process?.env.HOST
+  };
+}
+function fmtURL(host, port, secure) {
+  if (!host || !port) return;
+  if (host.includes(":")) host = `[${host}]`;
+  return `http${secure ? "s" : ""}://${host}:${port}/`;
+}
+function printListening(opts, url) {
+  if (!url || (opts.silent ?? globalThis.process?.env?.TEST)) return;
+  let additionalInfo = "";
+  try {
+    const _url = new URL(url);
+    if (_url.hostname === "[::]" || _url.hostname === "0.0.0.0") {
+      _url.hostname = "localhost";
+      url = _url.href;
+      additionalInfo = " (all interfaces)";
+    }
+  } catch {
+  }
+  let listeningOn = `➜ Listening on:`;
+  if (globalThis.process.stdout?.isTTY) {
+    listeningOn = `\x1B[32m${listeningOn}\x1B[0m`;
+    url = `\x1B[36m${url}\x1B[0m`;
+    additionalInfo = `\x1B[2m${additionalInfo}\x1B[0m`;
+  }
+  console.log(`${listeningOn} ${url}${additionalInfo}`);
+}
+function resolveTLSOptions(opts) {
+  if (!opts.tls || opts.protocol === "http") return;
+  const cert = resolveCertOrKey(opts.tls.cert);
+  const key = resolveCertOrKey(opts.tls.key);
+  if (!cert && !key) {
+    if (opts.protocol === "https") throw new TypeError("TLS `cert` and `key` must be provided for `https` protocol.");
+    return;
+  }
+  if (!cert || !key) throw new TypeError("TLS `cert` and `key` must be provided together.");
+  return {
+    cert,
+    key,
+    passphrase: opts.tls.passphrase
+  };
+}
+function resolveCertOrKey(value) {
+  if (!value) return;
+  if (typeof value !== "string") throw new TypeError("TLS certificate and key must be strings in PEM format or file paths.");
+  if (value.startsWith("-----BEGIN ")) return value;
+  const { readFileSync } = process.getBuiltinModule("node:fs");
+  return readFileSync(value, "utf8");
+}
+function createWaitUntil() {
+  const promises = /* @__PURE__ */ new Set();
+  return {
+    waitUntil: (promise) => {
+      if (typeof promise?.then !== "function") return;
+      promises.add(Promise.resolve(promise).catch(console.error).finally(() => {
+        promises.delete(promise);
+      }));
+    },
+    wait: () => {
+      return Promise.all(promises);
+    }
+  };
+}
+const noColor = /* @__PURE__ */ (() => {
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb";
+})();
+const _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
+const red = /* @__PURE__ */ _c(31);
+const gray = /* @__PURE__ */ _c(90);
+function wrapFetch(server) {
+  const fetchHandler = server.options.fetch;
+  const middleware = server.options.middleware || [];
+  return middleware.length === 0 ? fetchHandler : (request) => callMiddleware(request, fetchHandler, middleware, 0);
+}
+function callMiddleware(request, fetchHandler, middleware, index) {
+  if (index === middleware.length) return fetchHandler(request);
+  return middleware[index](request, () => callMiddleware(request, fetchHandler, middleware, index + 1));
+}
+const errorPlugin = (server) => {
+  const errorHandler = server.options.error;
+  if (!errorHandler) return;
+  server.options.middleware.unshift((_req, next) => {
+    try {
+      const res = next();
+      return res instanceof Promise ? res.catch((error) => errorHandler(error)) : res;
+    } catch (error) {
+      return errorHandler(error);
+    }
+  });
+};
+const gracefulShutdownPlugin = (server) => {
+  const config = server.options?.gracefulShutdown;
+  if (!globalThis.process?.on || config === false || config === void 0 && (process.env.CI || process.env.TEST)) return;
+  const gracefulShutdown = config === true || !config?.gracefulTimeout ? Number.parseInt(process.env.SERVER_SHUTDOWN_TIMEOUT || "") || 3 : config.gracefulTimeout;
+  const forceShutdown = config === true || !config?.forceTimeout ? Number.parseInt(process.env.SERVER_FORCE_SHUTDOWN_TIMEOUT || "") || 5 : config.forceTimeout;
+  let isShuttingDown = false;
+  let forceClose;
+  const shutdown = async () => {
+    if (isShuttingDown) {
+      forceClose?.();
+      return;
+    }
+    isShuttingDown = true;
+    const w = process.stderr.write.bind(process.stderr);
+    w(gray(`
+Shutting down server in ${gracefulShutdown}s... (press Ctrl+C again to force close)`));
+    let timeout;
+    await Promise.race([server.close().finally(() => {
+      clearTimeout(timeout);
+      w(gray(" Server closed.\n"));
+    }), new Promise((resolve) => {
+      forceClose = () => {
+        clearTimeout(timeout);
+        w(gray("\nForce closing...\n"));
+        server.close(true);
+        resolve();
+      };
+      timeout = setTimeout(() => {
+        w(gray(`
+Force closing connections in ${forceShutdown}s...`));
+        timeout = setTimeout(() => {
+          w(red("\nCould not close connections in time, force exiting."));
+          resolve();
+        }, forceShutdown * 1e3);
+        return server.close(true);
+      }, gracefulShutdown * 1e3);
+    })]);
+    globalThis.process.exit(0);
+  };
+  for (const sig of ["SIGINT", "SIGTERM"]) globalThis.process.on(sig, shutdown);
+};
+const NodeResponse = /* @__PURE__ */ (() => {
+  const NativeResponse = globalThis.Response;
+  const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
+  class NodeResponse$1 {
+    #body;
+    #init;
+    #headers;
+    #response;
+    constructor(body, init) {
+      this.#body = body;
+      this.#init = init;
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeResponse;
+    }
+    get status() {
+      return this.#response?.status || this.#init?.status || 200;
+    }
+    get statusText() {
+      return this.#response?.statusText || this.#init?.statusText || STATUS_CODES[this.status] || "";
+    }
+    get headers() {
+      if (this.#response) return this.#response.headers;
+      if (this.#headers) return this.#headers;
+      const initHeaders = this.#init?.headers;
+      return this.#headers = initHeaders instanceof Headers ? initHeaders : new Headers(initHeaders);
+    }
+    get ok() {
+      if (this.#response) return this.#response.ok;
+      const status = this.status;
+      return status >= 200 && status < 300;
+    }
+    get _response() {
+      if (this.#response) return this.#response;
+      this.#response = new NativeResponse(this.#body, this.#headers ? {
+        ...this.#init,
+        headers: this.#headers
+      } : this.#init);
+      this.#init = void 0;
+      this.#headers = void 0;
+      this.#body = void 0;
+      return this.#response;
+    }
+    _toNodeResponse() {
+      const status = this.status;
+      const statusText = this.statusText;
+      let body;
+      let contentType;
+      let contentLength;
+      if (this.#response) body = this.#response.body;
+      else if (this.#body) if (this.#body instanceof ReadableStream) body = this.#body;
+      else if (typeof this.#body === "string") {
+        body = this.#body;
+        contentType = "text/plain; charset=UTF-8";
+        contentLength = Buffer.byteLength(this.#body);
+      } else if (this.#body instanceof ArrayBuffer) {
+        body = Buffer.from(this.#body);
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof Uint8Array) {
+        body = this.#body;
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof DataView) {
+        body = Buffer.from(this.#body.buffer);
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof Blob) {
+        body = this.#body.stream();
+        contentType = this.#body.type;
+        contentLength = this.#body.size;
+      } else if (typeof this.#body.pipe === "function") body = this.#body;
+      else body = this._response.body;
+      const headers = [];
+      const initHeaders = this.#init?.headers;
+      const headerEntries = this.#response?.headers || this.#headers || (initHeaders ? Array.isArray(initHeaders) ? initHeaders : initHeaders?.entries ? initHeaders.entries() : Object.entries(initHeaders).map(([k, v]) => [k.toLowerCase(), v]) : void 0);
+      let hasContentTypeHeader;
+      let hasContentLength;
+      if (headerEntries) for (const [key, value] of headerEntries) {
+        if (Array.isArray(value)) for (const v of value) headers.push([key, v]);
+        else headers.push([key, value]);
+        if (key === "content-type") hasContentTypeHeader = true;
+        else if (key === "content-length") hasContentLength = true;
+      }
+      if (contentType && !hasContentTypeHeader) headers.push(["content-type", contentType]);
+      if (contentLength && !hasContentLength) headers.push(["content-length", String(contentLength)]);
+      this.#init = void 0;
+      this.#headers = void 0;
+      this.#response = void 0;
+      this.#body = void 0;
+      return {
+        status,
+        statusText,
+        headers,
+        body
+      };
+    }
+  }
+  lazyInherit(NodeResponse$1.prototype, NativeResponse.prototype, "_response");
+  Object.setPrototypeOf(NodeResponse$1, NativeResponse);
+  Object.setPrototypeOf(NodeResponse$1.prototype, NativeResponse.prototype);
+  return NodeResponse$1;
+})();
+async function sendNodeResponse(nodeRes, webRes) {
+  if (!webRes) {
+    nodeRes.statusCode = 500;
+    return endNodeResponse(nodeRes);
+  }
+  if (webRes._toNodeResponse) {
+    const res = webRes._toNodeResponse();
+    writeHead(nodeRes, res.status, res.statusText, res.headers);
+    if (res.body) {
+      if (res.body instanceof ReadableStream) return streamBody(res.body, nodeRes);
+      else if (typeof res.body?.pipe === "function") {
+        res.body.pipe(nodeRes);
+        return new Promise((resolve) => nodeRes.on("close", resolve));
+      }
+      nodeRes.write(res.body);
+    }
+    return endNodeResponse(nodeRes);
+  }
+  const rawHeaders = [...webRes.headers];
+  writeHead(nodeRes, webRes.status, webRes.statusText, rawHeaders);
+  return webRes.body ? streamBody(webRes.body, nodeRes) : endNodeResponse(nodeRes);
+}
+function writeHead(nodeRes, status, statusText, rawHeaders) {
+  const writeHeaders = globalThis.Deno ? rawHeaders : rawHeaders.flat();
+  if (!nodeRes.headersSent) if (nodeRes.req?.httpVersion === "2.0") nodeRes.writeHead(status, writeHeaders);
+  else nodeRes.writeHead(status, statusText, writeHeaders);
+}
+function endNodeResponse(nodeRes) {
+  return new Promise((resolve) => nodeRes.end(resolve));
+}
+function streamBody(stream, nodeRes) {
+  if (nodeRes.destroyed) {
+    stream.cancel();
+    return;
+  }
+  const reader = stream.getReader();
+  function streamCancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error) nodeRes.destroy(error);
+  }
+  function streamHandle({ done, value }) {
+    try {
+      if (done) nodeRes.end();
+      else if (nodeRes.write(value)) reader.read().then(streamHandle, streamCancel);
+      else nodeRes.once("drain", () => reader.read().then(streamHandle, streamCancel));
+    } catch (error) {
+      streamCancel(error instanceof Error ? error : void 0);
+    }
+  }
+  nodeRes.on("close", streamCancel);
+  nodeRes.on("error", streamCancel);
+  reader.read().then(streamHandle, streamCancel);
+  return reader.closed.catch(streamCancel).finally(() => {
+    nodeRes.off("close", streamCancel);
+    nodeRes.off("error", streamCancel);
+  });
+}
+var NodeRequestURL = class extends FastURL {
+  #req;
+  constructor({ req }) {
+    const path = req.url || "/";
+    if (path[0] === "/") {
+      const qIndex = path.indexOf("?");
+      const pathname = qIndex === -1 ? path : path?.slice(0, qIndex) || "/";
+      const search = qIndex === -1 ? "" : path?.slice(qIndex) || "";
+      const host = req.headers.host || req.headers[":authority"] || `${req.socket.localFamily === "IPv6" ? "[" + req.socket.localAddress + "]" : req.socket.localAddress}:${req.socket?.localPort || "80"}`;
+      const protocol = req.socket?.encrypted || req.headers["x-forwarded-proto"] === "https" || req.headers[":scheme"] === "https" ? "https:" : "http:";
+      super({
+        protocol,
+        host,
+        pathname,
+        search
+      });
+    } else super(path);
+    this.#req = req;
+  }
+  get pathname() {
+    return super.pathname;
+  }
+  set pathname(value) {
+    this._url.pathname = value;
+    this.#req.url = this._url.pathname + this._url.search;
+  }
+};
+const NodeRequestHeaders = /* @__PURE__ */ (() => {
+  const NativeHeaders = globalThis.Headers;
+  class Headers2 {
+    #req;
+    #headers;
+    constructor(req) {
+      this.#req = req;
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeHeaders;
+    }
+    get _headers() {
+      if (!this.#headers) {
+        const headers = new NativeHeaders();
+        const rawHeaders = this.#req.rawHeaders;
+        const len = rawHeaders.length;
+        for (let i = 0; i < len; i += 2) {
+          const key = rawHeaders[i];
+          if (key.charCodeAt(0) === 58) continue;
+          const value = rawHeaders[i + 1];
+          headers.append(key, value);
+        }
+        this.#headers = headers;
+      }
+      return this.#headers;
+    }
+    get(name) {
+      if (this.#headers) return this.#headers.get(name);
+      const value = this.#req.headers[name.toLowerCase()];
+      return Array.isArray(value) ? value.join(", ") : value || null;
+    }
+    has(name) {
+      if (this.#headers) return this.#headers.has(name);
+      return name.toLowerCase() in this.#req.headers;
+    }
+    getSetCookie() {
+      if (this.#headers) return this.#headers.getSetCookie();
+      const value = this.#req.headers["set-cookie"];
+      return Array.isArray(value) ? value : value ? [value] : [];
+    }
+    *_entries() {
+      const rawHeaders = this.#req.rawHeaders;
+      const len = rawHeaders.length;
+      for (let i = 0; i < len; i += 2) {
+        const key = rawHeaders[i];
+        if (key.charCodeAt(0) === 58) continue;
+        yield [key.toLowerCase(), rawHeaders[i + 1]];
+      }
+    }
+    entries() {
+      return this.#headers ? this.#headers.entries() : this._entries();
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  }
+  lazyInherit(Headers2.prototype, NativeHeaders.prototype, "_headers");
+  Object.setPrototypeOf(Headers2, NativeHeaders);
+  Object.setPrototypeOf(Headers2.prototype, NativeHeaders.prototype);
+  return Headers2;
+})();
+const NodeRequest = /* @__PURE__ */ (() => {
+  const NativeRequest = globalThis.Request;
+  class Request {
+    runtime;
+    #req;
+    #url;
+    #bodyStream;
+    #request;
+    #headers;
+    #abortController;
+    constructor(ctx) {
+      this.#req = ctx.req;
+      this.runtime = {
+        name: "node",
+        node: ctx
+      };
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeRequest;
+    }
+    get ip() {
+      return this.#req.socket?.remoteAddress;
+    }
+    get method() {
+      if (this.#request) return this.#request.method;
+      return this.#req.method || "GET";
+    }
+    get _url() {
+      return this.#url ||= new NodeRequestURL({ req: this.#req });
+    }
+    set _url(url) {
+      this.#url = url;
+    }
+    get url() {
+      if (this.#request) return this.#request.url;
+      return this._url.href;
+    }
+    get headers() {
+      if (this.#request) return this.#request.headers;
+      return this.#headers ||= new NodeRequestHeaders(this.#req);
+    }
+    get _abortController() {
+      if (!this.#abortController) {
+        this.#abortController = new AbortController();
+        const { req, res } = this.runtime.node;
+        const abortController = this.#abortController;
+        const abort = (err) => abortController.abort?.(err);
+        if (res) res.once("close", () => {
+          const reqError = req.errored;
+          if (reqError) abort(reqError);
+          else if (!res.writableEnded) abort();
+        });
+        else req.once("close", () => {
+          if (!req.complete) abort();
+        });
+      }
+      return this.#abortController;
+    }
+    get signal() {
+      return this.#request ? this.#request.signal : this._abortController.signal;
+    }
+    get body() {
+      if (this.#request) return this.#request.body;
+      if (this.#bodyStream === void 0) {
+        const method = this.method;
+        this.#bodyStream = !(method === "GET" || method === "HEAD") ? Readable.toWeb(this.#req) : null;
+      }
+      return this.#bodyStream;
+    }
+    text() {
+      if (this.#request) return this.#request.text();
+      if (this.#bodyStream !== void 0) return this.#bodyStream ? new Response(this.#bodyStream).text() : Promise.resolve("");
+      return readBody(this.#req).then((buf) => buf.toString());
+    }
+    json() {
+      if (this.#request) return this.#request.json();
+      return this.text().then((text) => JSON.parse(text));
+    }
+    get _request() {
+      if (!this.#request) {
+        const body = this.body;
+        this.#request = new NativeRequest(this.url, {
+          method: this.method,
+          headers: this.headers,
+          signal: this._abortController.signal,
+          body,
+          duplex: body ? "half" : void 0
+        });
+        this.#headers = void 0;
+        this.#bodyStream = void 0;
+      }
+      return this.#request;
+    }
+  }
+  lazyInherit(Request.prototype, NativeRequest.prototype, "_request");
+  Object.setPrototypeOf(Request.prototype, NativeRequest.prototype);
+  return Request;
+})();
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const onData = (chunk) => {
+      chunks.push(chunk);
+    };
+    const onError = (err) => {
+      reject(err);
+    };
+    const onEnd = () => {
+      req.off("error", onError);
+      req.off("data", onData);
+      resolve(Buffer.concat(chunks));
+    };
+    req.on("data", onData).once("end", onEnd).once("error", onError);
+  });
+}
+function serve(options) {
+  return new NodeServer(options);
+}
+var NodeServer = class {
+  runtime = "node";
+  options;
+  node;
+  serveOptions;
+  fetch;
+  #isSecure;
+  #listeningPromise;
+  #wait;
+  constructor(options) {
+    this.options = {
+      ...options,
+      middleware: [...options.middleware || []]
+    };
+    for (const plugin of options.plugins || []) plugin(this);
+    errorPlugin(this);
+    gracefulShutdownPlugin(this);
+    const fetchHandler = this.fetch = wrapFetch(this);
+    this.#wait = createWaitUntil();
+    const handler = (nodeReq, nodeRes) => {
+      const request = new NodeRequest({
+        req: nodeReq,
+        res: nodeRes
+      });
+      request.waitUntil = this.#wait.waitUntil;
+      const res = fetchHandler(request);
+      return res instanceof Promise ? res.then((resolvedRes) => sendNodeResponse(nodeRes, resolvedRes)) : sendNodeResponse(nodeRes, res);
+    };
+    const tls = resolveTLSOptions(this.options);
+    const { port, hostname: host } = resolvePortAndHost(this.options);
+    this.serveOptions = {
+      port,
+      host,
+      exclusive: !this.options.reusePort,
+      ...tls ? {
+        cert: tls.cert,
+        key: tls.key,
+        passphrase: tls.passphrase
+      } : {},
+      ...this.options.node
+    };
+    let server;
+    this.#isSecure = !!this.serveOptions.cert && this.options.protocol !== "http";
+    if (this.options.node?.http2 ?? this.#isSecure) if (this.#isSecure) server = nodeHTTP2.createSecureServer({
+      allowHTTP1: true,
+      ...this.serveOptions
+    }, handler);
+    else throw new Error("node.http2 option requires tls certificate!");
+    else if (this.#isSecure) server = nodeHTTPS.createServer(this.serveOptions, handler);
+    else server = nodeHTTP.createServer(this.serveOptions, handler);
+    this.node = {
+      server,
+      handler
+    };
+    if (!options.manual) this.serve();
+  }
+  serve() {
+    if (this.#listeningPromise) return Promise.resolve(this.#listeningPromise).then(() => this);
+    this.#listeningPromise = new Promise((resolve) => {
+      this.node.server.listen(this.serveOptions, () => {
+        printListening(this.options, this.url);
+        resolve();
+      });
+    });
+  }
+  get url() {
+    const addr = this.node?.server?.address();
+    if (!addr) return;
+    return typeof addr === "string" ? addr : fmtURL(addr.address, addr.port, this.#isSecure);
+  }
+  ready() {
+    return Promise.resolve(this.#listeningPromise).then(() => this);
+  }
+  async close(closeAll) {
+    await Promise.all([this.#wait.wait(), new Promise((resolve, reject) => {
+      const server = this.node?.server;
+      if (!server || !server.listening) return resolve();
+      if (closeAll && "closeAllConnections" in server) server.closeAllConnections();
+      server.close((error) => error ? reject(error) : resolve());
+    })]);
+  }
+};
+export {
+  FastURL as F,
+  NodeResponse as N,
+  serve as s
+};