speexjs 0.2.0

package/dist/server/http/index.js

@@ -0,0 +1,871 @@
+// src/server/http/status.ts
+var HttpStatus = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+var statusTextMap = {
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  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",
+  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",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported"
+};
+function statusText(code) {
+  const text = statusTextMap[code];
+  if (text !== void 0) return text;
+  if (code >= 100 && code < 200) return "Informational";
+  if (code >= 200 && code < 300) return "Success";
+  if (code >= 300 && code < 400) return "Redirection";
+  if (code >= 400 && code < 500) return "Client Error";
+  if (code >= 500 && code < 600) return "Server Error";
+  return "Unknown";
+}
+
+// src/server/http/headers.ts
+var HeadersMap = class {
+  data;
+  constructor(initial) {
+    this.data = /* @__PURE__ */ new Map();
+    if (initial) {
+      for (const key of Object.keys(initial)) {
+        const value = initial[key];
+        if (value !== void 0) {
+          this.set(key, Array.isArray(value) ? value.join(", ") : value);
+        }
+      }
+    }
+  }
+  get(name) {
+    const values = this.data.get(name.toLowerCase());
+    if (values !== void 0 && values.length > 0) {
+      return values[0];
+    }
+    return void 0;
+  }
+  getAll(name) {
+    const values = this.data.get(name.toLowerCase());
+    return values ?? [];
+  }
+  set(name, value) {
+    this.data.set(name.toLowerCase(), [value]);
+  }
+  append(name, value) {
+    const key = name.toLowerCase();
+    const existing = this.data.get(key);
+    if (existing !== void 0) {
+      existing.push(value);
+    } else {
+      this.data.set(key, [value]);
+    }
+  }
+  has(name) {
+    return this.data.has(name.toLowerCase());
+  }
+  delete(name) {
+    this.data.delete(name.toLowerCase());
+  }
+  *entries() {
+    for (const [key, values] of this.data) {
+      for (const value of values) {
+        yield [key, value];
+      }
+    }
+  }
+  *keys() {
+    for (const key of this.data.keys()) {
+      yield key;
+    }
+  }
+  *values() {
+    for (const [, values] of this.data) {
+      for (const value of values) {
+        yield value;
+      }
+    }
+  }
+  toJSON() {
+    const result = {};
+    for (const [key, values] of this.data) {
+      result[key] = values.length === 1 ? values[0] : values;
+    }
+    return result;
+  }
+  toNodeHeaders() {
+    const result = {};
+    for (const [key, values] of this.data) {
+      if (key === "set-cookie") {
+        result[key] = values;
+      } else {
+        result[key] = values.join(", ");
+      }
+    }
+    return result;
+  }
+  get size() {
+    return this.data.size;
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+
+// src/server/http/cookie.ts
+function parseCookies(header) {
+  const result = {};
+  if (!header) return result;
+  const pairs = header.split(";");
+  for (const pair of pairs) {
+    const trimmed = pair.trim();
+    if (!trimmed) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) {
+      result[trimmed] = "";
+      continue;
+    }
+    const name = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    }
+    if (name) {
+      result[decodeURIComponent(name)] = decodeURIComponent(value);
+    }
+  }
+  return result;
+}
+function serializeCookieValue(name, value) {
+  return `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+}
+function serializeCookie(name, value, options) {
+  const parts = [serializeCookieValue(name, value)];
+  if (options) {
+    if (options.maxAge !== void 0) {
+      parts.push(`Max-Age=${Math.floor(options.maxAge)}`);
+    }
+    if (options.expires !== void 0) {
+      parts.push(`Expires=${options.expires.toUTCString()}`);
+    }
+    if (options.path !== void 0) {
+      parts.push(`Path=${options.path}`);
+    } else {
+      parts.push("Path=/");
+    }
+    if (options.domain !== void 0) {
+      parts.push(`Domain=${options.domain}`);
+    }
+    if (options.secure) {
+      parts.push("Secure");
+    }
+    if (options.httpOnly) {
+      parts.push("HttpOnly");
+    }
+    if (options.sameSite !== void 0) {
+      parts.push(`SameSite=${options.sameSite}`);
+    }
+  }
+  return parts.join("; ");
+}
+function clearCookie(name, options) {
+  return serializeCookie(name, "", {
+    ...options,
+    maxAge: 0,
+    expires: /* @__PURE__ */ new Date(0)
+  });
+}
+
+// src/server/http/upload.ts
+import { randomUUID } from "crypto";
+import { writeFile, readFile, unlink, mkdir } from "fs/promises";
+import { join, extname, basename, dirname } from "path";
+import { tmpdir } from "os";
+var IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml",
+  "image/bmp",
+  "image/tiff",
+  "image/avif"
+]);
+var VIDEO_MIME_TYPES = /* @__PURE__ */ new Set([
+  "video/mp4",
+  "video/mpeg",
+  "video/webm",
+  "video/ogg",
+  "video/quicktime",
+  "video/x-msvideo",
+  "video/x-matroska"
+]);
+var SuperUploadedFile = class _SuperUploadedFile {
+  fieldName;
+  originalName;
+  mimeType;
+  size;
+  path;
+  extension;
+  buffer;
+  constructor(opts) {
+    this.fieldName = opts.fieldName;
+    this.originalName = opts.originalName;
+    this.mimeType = opts.mimeType;
+    this.size = opts.size;
+    this.path = opts.path;
+    this.extension = extname(opts.originalName).toLowerCase();
+    this.buffer = opts.buffer ?? null;
+  }
+  async move(destination, filename) {
+    const destName = filename ?? basename(this.path);
+    const destPath = join(destination, destName);
+    await mkdir(dirname(destPath), { recursive: true });
+    const buf = await this.toBuffer();
+    await writeFile(destPath, buf);
+    return destPath;
+  }
+  async toBuffer() {
+    if (this.buffer !== null) return this.buffer;
+    this.buffer = await readFile(this.path);
+    return this.buffer;
+  }
+  toBase64() {
+    if (this.buffer === null) {
+      throw new Error(
+        "Buffer not loaded. Call toBuffer() first or read the file into memory."
+      );
+    }
+    return this.buffer.toString("base64");
+  }
+  isImage() {
+    return IMAGE_MIME_TYPES.has(this.mimeType);
+  }
+  isVideo() {
+    return VIDEO_MIME_TYPES.has(this.mimeType);
+  }
+  static async createFromBuffer(fieldName, originalName, mimeType, buffer, tempDir) {
+    const tmp = tempDir ?? tmpdir();
+    const fileName = `${randomUUID()}${extname(originalName)}`;
+    const filePath = join(tmp, fileName);
+    await writeFile(filePath, buffer);
+    return new _SuperUploadedFile({
+      fieldName,
+      originalName,
+      mimeType: mimeType || "application/octet-stream",
+      size: buffer.length,
+      path: filePath,
+      buffer
+    });
+  }
+  async cleanup() {
+    try {
+      await unlink(this.path);
+    } catch {
+    }
+  }
+};
+
+// src/server/http/request.ts
+var SuperRequest = class {
+  raw;
+  _headers;
+  _query;
+  _cookies = null;
+  _ip;
+  _params = {};
+  bodyCache = null;
+  _bodyReadPromise = null;
+  constructor(raw) {
+    this.raw = raw;
+    this._headers = new HeadersMap(
+      raw.headers
+    );
+    const parsedUrl = new URL(raw.url ?? "/", "http://localhost");
+    this._query = parseQueryParams(parsedUrl.searchParams);
+    this._ip = parseIp(raw);
+    this.path = parsedUrl.pathname;
+    this.url = raw.url ?? "/";
+    this.method = (raw.method ?? "GET").toUpperCase();
+  }
+  method;
+  url;
+  path;
+  get headers() {
+    return this._headers;
+  }
+  get query() {
+    return this._query;
+  }
+  get params() {
+    return this._params;
+  }
+  set params(value) {
+    this._params = value;
+  }
+  get ip() {
+    return this._ip;
+  }
+  async ensureBody() {
+    if (this.bodyCache !== null) return this.bodyCache;
+    if (this._bodyReadPromise === null) {
+      this._bodyReadPromise = this.readBodyFromStream();
+    }
+    this.bodyCache = await this._bodyReadPromise;
+    return this.bodyCache;
+  }
+  async readBodyFromStream() {
+    const chunks = [];
+    for await (const chunk of this.raw) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks);
+    const text = raw.toString("utf-8");
+    let json = void 0;
+    if (this.isContentType("application/json")) {
+      try {
+        json = JSON.parse(text);
+      } catch {
+        json = void 0;
+      }
+    }
+    let formData = null;
+    let multipartParsed = null;
+    let files = null;
+    if (this.isContentType("application/x-www-form-urlencoded")) {
+      formData = parseUrlEncoded(text);
+    } else if (this.isContentType("multipart/form-data")) {
+      const boundary = this.getMultipartBoundary();
+      if (boundary !== void 0) {
+        multipartParsed = parseMultipartBody(raw, boundary);
+        formData = {};
+        files = {};
+        for (const part of multipartParsed) {
+          if (part.type === "field") {
+            formData[part.name] = part.value;
+          } else if (part.type === "file") {
+            const uploadedFile = await SuperUploadedFile.createFromBuffer(
+              part.name,
+              part.filename,
+              part.mimeType,
+              part.data
+            );
+            files[part.name] = uploadedFile;
+          }
+        }
+      }
+    }
+    return {
+      raw,
+      text,
+      json,
+      parsed: json ?? text,
+      formData,
+      files,
+      multipartParsed
+    };
+  }
+  isContentType(expected) {
+    const ct = this._headers.get("content-type");
+    if (ct === void 0) return false;
+    return ct.toLowerCase().startsWith(expected);
+  }
+  getMultipartBoundary() {
+    const ct = this._headers.get("content-type");
+    if (ct === void 0) return void 0;
+    const match = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+    if (match !== null) {
+      return match[1] ?? match[2];
+    }
+    return void 0;
+  }
+  async body() {
+    const cache = await this.ensureBody();
+    return cache.parsed;
+  }
+  async json() {
+    const cache = await this.ensureBody();
+    if (cache.json !== void 0) return cache.json;
+    throw new Error("Request body is not valid JSON");
+  }
+  async text() {
+    const cache = await this.ensureBody();
+    return cache.text;
+  }
+  async formData() {
+    const cache = await this.ensureBody();
+    if (cache.formData !== null) return cache.formData;
+    if (cache.multipartParsed !== null) {
+      const result = {};
+      for (const part of cache.multipartParsed) {
+        if (part.type === "field") {
+          result[part.name] = part.value;
+        }
+      }
+      return result;
+    }
+    return {};
+  }
+  async file(name) {
+    const cache = await this.ensureBody();
+    if (cache.files !== null) {
+      return cache.files[name];
+    }
+    return void 0;
+  }
+  async files() {
+    const cache = await this.ensureBody();
+    return cache.files ?? {};
+  }
+  cookie(name) {
+    if (this._cookies === null) {
+      const cookieHeader = this._headers.get("cookie");
+      this._cookies = cookieHeader !== void 0 ? parseCookies(cookieHeader) : {};
+    }
+    return this._cookies[name];
+  }
+  async validate(schema) {
+    const data = await this.body();
+    const result = schema.validate(data);
+    if (!result.success) {
+      const messages = (result.errors ?? []).map((e) => {
+        const path = e.path ?? "";
+        return path ? `${path}: ${e.message}` : e.message;
+      }).join("; ");
+      throw new ValidationError(messages, result.errors ?? []);
+    }
+    return result.data;
+  }
+  isAjax() {
+    const requestedWith = this._headers.get("x-requested-with");
+    return requestedWith?.toLowerCase() === "xmlhttprequest";
+  }
+  wantsJson() {
+    const accept = this._headers.get("accept");
+    if (accept !== void 0 && accept.includes("application/json")) {
+      return true;
+    }
+    return this.isAjax();
+  }
+  bearerToken() {
+    const auth = this._headers.get("authorization");
+    if (auth === void 0) return void 0;
+    const match = auth.match(/^Bearer\s+(.+)$/i);
+    return match?.[1];
+  }
+  get rawRequest() {
+    return this.raw;
+  }
+};
+var ValidationError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ValidationError";
+  }
+  errors;
+};
+function parseQueryParams(searchParams) {
+  const result = {};
+  for (const key of searchParams.keys()) {
+    const values = searchParams.getAll(key);
+    result[key] = values.length === 1 ? values[0] : values;
+  }
+  return result;
+}
+function parseIp(req) {
+  const forwarded = req.headers["x-forwarded-for"];
+  if (forwarded !== void 0) {
+    const first = Array.isArray(forwarded) ? forwarded[0] : forwarded.split(",")[0];
+    if (first !== void 0) return first.trim();
+  }
+  const realIp = req.headers["x-real-ip"];
+  if (realIp !== void 0) {
+    return Array.isArray(realIp) ? realIp[0] : realIp;
+  }
+  const remote = req.socket.remoteAddress;
+  if (remote !== void 0) {
+    if (remote.startsWith("::ffff:")) return remote.slice(7);
+    return remote;
+  }
+  return "127.0.0.1";
+}
+function parseUrlEncoded(text) {
+  const result = {};
+  const pairs = text.split("&");
+  for (const pair of pairs) {
+    if (!pair) continue;
+    const eqIndex = pair.indexOf("=");
+    if (eqIndex === -1) {
+      result[decodeURIComponent(pair)] = "";
+    } else {
+      const key = decodeURIComponent(pair.slice(0, eqIndex));
+      const value = decodeURIComponent(pair.slice(eqIndex + 1));
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function parseMultipartBody(body, boundary) {
+  const result = [];
+  const boundaryBuffer = Buffer.from(`--${boundary}`);
+  let start = 0;
+  let searchFrom = 0;
+  while (true) {
+    const boundaryIndex = body.indexOf(boundaryBuffer, searchFrom);
+    if (boundaryIndex === -1) break;
+    searchFrom = boundaryIndex + boundaryBuffer.length;
+    if (searchFrom < body.length && body[searchFrom] === 45 && body[searchFrom + 1] === 45) {
+      break;
+    }
+    if (searchFrom >= body.length) break;
+    if (body[searchFrom] === 13) searchFrom++;
+    if (body[searchFrom] === 10) searchFrom++;
+    start = searchFrom;
+    const nextBoundaryIndex = body.indexOf(boundaryBuffer, searchFrom);
+    if (nextBoundaryIndex === -1) break;
+    let partEnd = nextBoundaryIndex;
+    if (partEnd >= 2 && body[partEnd - 2] === 13 && body[partEnd - 1] === 10) {
+      partEnd -= 2;
+    }
+    const partData = body.slice(start, partEnd);
+    const headerEndIndex = partData.indexOf(Buffer.from("\r\n\r\n"));
+    if (headerEndIndex === -1) {
+      searchFrom = nextBoundaryIndex;
+      continue;
+    }
+    const headerSection = partData.slice(0, headerEndIndex).toString("utf-8");
+    const contentData = partData.slice(headerEndIndex + 4);
+    const disposition = parseDisposition(headerSection);
+    if (disposition === void 0) {
+      searchFrom = nextBoundaryIndex;
+      continue;
+    }
+    if (disposition.filename !== void 0) {
+      const contentType = parseContentType(headerSection);
+      result.push({
+        type: "file",
+        name: disposition.name,
+        filename: disposition.filename,
+        mimeType: contentType,
+        data: Buffer.from(contentData)
+      });
+    } else {
+      result.push({
+        type: "field",
+        name: disposition.name,
+        value: contentData.toString("utf-8").trim()
+      });
+    }
+    searchFrom = nextBoundaryIndex;
+  }
+  return result;
+}
+function parseDisposition(headerSection) {
+  const match = headerSection.match(
+    /content-disposition:\s*form-data;\s*(.+)/i
+  );
+  if (match === null) return void 0;
+  const params = match[1];
+  const nameMatch = params.match(/name="([^"]*)"/i);
+  const filenameMatch = params.match(/filename="([^"]*)"/i);
+  if (nameMatch === null) return void 0;
+  return {
+    name: nameMatch[1],
+    filename: filenameMatch?.[1]
+  };
+}
+function parseContentType(headerSection) {
+  const match = headerSection.match(/content-type:\s*([^\s;]+)/i);
+  return match?.[1] ?? "application/octet-stream";
+}
+
+// src/server/http/response.ts
+import { createReadStream, stat } from "fs";
+import { basename as basename2, extname as extname2 } from "path";
+import { promisify } from "util";
+var statAsync = promisify(stat);
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".xml": "application/xml",
+  ".zip": "application/zip",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav"
+};
+var SuperResponse = class {
+  raw;
+  _statusCode = HttpStatus.OK;
+  _headers = new HeadersMap();
+  _cookies = [];
+  _body = null;
+  _sent = false;
+  _contentTypeSet = false;
+  constructor(raw) {
+    this.raw = raw;
+  }
+  status(code) {
+    this._statusCode = code;
+    return this;
+  }
+  header(name, value) {
+    this._headers.set(name, value);
+    return this;
+  }
+  setHeader(name, value) {
+    return this.header(name, value);
+  }
+  getHeader(name) {
+    return this._headers.get(name);
+  }
+  removeHeader(name) {
+    this._headers.delete(name);
+    return this;
+  }
+  hasHeader(name) {
+    return this._headers.has(name);
+  }
+  type(contentType) {
+    this._headers.set("content-type", contentType);
+    this._contentTypeSet = true;
+    return this;
+  }
+  json(data, status) {
+    if (status !== void 0) this._statusCode = status;
+    const body = JSON.stringify(data);
+    return this.send(body, void 0, "application/json");
+  }
+  send(body, status, contentType) {
+    if (status !== void 0) this._statusCode = status;
+    this._body = body;
+    if (contentType !== void 0 && !this._contentTypeSet) {
+      this._headers.set("content-type", contentType);
+    }
+    return this;
+  }
+  html(html, status) {
+    return this.send(html, status, "text/html; charset=utf-8");
+  }
+  redirect(url, status = HttpStatus.FOUND) {
+    this._statusCode = status;
+    this._headers.set("location", url);
+    this._body = null;
+    return this;
+  }
+  stream(stream, status) {
+    if (status !== void 0) this._statusCode = status;
+    this.flushHeaders();
+    this.raw.statusCode = this._statusCode;
+    stream.pipe(this.raw);
+    stream.on("end", () => {
+      this._sent = true;
+    });
+    stream.on("error", (_err) => {
+      if (!this._sent) {
+        this._sent = true;
+        this.raw.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+        this.raw.end();
+      }
+    });
+    return this;
+  }
+  async file(filePath, options) {
+    const fullPath = options?.root ? joinPath(options.root, filePath) : filePath;
+    try {
+      const stats = await statAsync(fullPath);
+      if (!stats.isFile()) {
+        this._statusCode = HttpStatus.NOT_FOUND;
+        this._body = null;
+        return this;
+      }
+      const ext = extname2(fullPath);
+      const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+      this._headers.set("content-type", mimeType);
+      this._headers.set("content-length", String(stats.size));
+      if (options?.cacheControl !== false) {
+        const maxAge = options?.maxAge ?? 0;
+        this._headers.set("cache-control", `public, max-age=${maxAge}`);
+      }
+      if (options?.lastModified !== false) {
+        this._headers.set("last-modified", stats.mtime.toUTCString());
+      }
+      if (options?.headers !== void 0) {
+        for (const [key, value] of Object.entries(options.headers)) {
+          this._headers.set(key, value);
+        }
+      }
+      this.flushHeaders();
+      this.raw.statusCode = this._statusCode;
+      const readStream = createReadStream(fullPath);
+      readStream.pipe(this.raw);
+      readStream.on("end", () => {
+        this._sent = true;
+      });
+      readStream.on("error", () => {
+        if (!this._sent) {
+          this._sent = true;
+          this.raw.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+          this.raw.end();
+        }
+      });
+    } catch {
+      this._statusCode = HttpStatus.NOT_FOUND;
+      this._body = null;
+    }
+    return this;
+  }
+  async download(filePath, filename) {
+    const downloadName = filename ?? basename2(filePath);
+    this._headers.set(
+      "content-disposition",
+      `attachment; filename="${downloadName}"`
+    );
+    await this.file(filePath);
+    return this;
+  }
+  attachment(filename) {
+    if (filename !== void 0) {
+      this._headers.set(
+        "content-disposition",
+        `attachment; filename="${filename}"`
+      );
+    } else {
+      this._headers.set("content-disposition", "attachment");
+    }
+    return this;
+  }
+  cookie(name, value, options) {
+    this._cookies.push(serializeCookie(name, value, options));
+    return this;
+  }
+  clearCookie(name, options) {
+    this._cookies.push(clearCookie(name, options));
+    return this;
+  }
+  get statusCode() {
+    return this._statusCode;
+  }
+  get headersSent() {
+    return this._sent;
+  }
+  get rawResponse() {
+    return this.raw;
+  }
+  async flush() {
+    if (this._sent) return;
+    this._sent = true;
+    this.flushHeaders();
+    this.raw.statusCode = this._statusCode;
+    if (this._body !== null) {
+      this.raw.end(this._body);
+    } else {
+      this.raw.end();
+    }
+  }
+  flushHeaders() {
+    if (this._cookies.length > 0) {
+      this.raw.setHeader("Set-Cookie", this._cookies);
+    }
+    for (const [name, value] of this._headers.entries()) {
+      if (name.toLowerCase() !== "set-cookie") {
+        this.raw.setHeader(name, value);
+      }
+    }
+  }
+};
+function joinPath(root, filePath) {
+  const normalizedRoot = root.replace(/\\/g, "/").replace(/\/$/, "");
+  const normalizedPath = filePath.replace(/\\/g, "/").replace(/^\//, "");
+  return `${normalizedRoot}/${normalizedPath}`;
+}
+export {
+  HeadersMap,
+  HttpStatus,
+  SuperRequest,
+  SuperResponse,
+  SuperUploadedFile,
+  ValidationError,
+  clearCookie,
+  parseCookies,
+  serializeCookie,
+  statusText
+};
+//# sourceMappingURL=index.js.map