@ozanarslan/corpus 0.1.4 → 0.1.6

package/dist/index.cjs

@@ -0,0 +1,2014 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  default: () => exports_C,
+  _routerStore: () => _routerStore,
+  _prefixStore: () => _prefixStore,
+  _corsStore: () => _corsStore,
+  X: () => exports_X,
+  Status: () => Status,
+  StaticRoute: () => StaticRoute,
+  Server: () => Server,
+  Route: () => Route,
+  Response: () => CResponse,
+  Request: () => CRequest,
+  Repository: () => RepositoryAbstract,
+  Parser: () => Parser,
+  Middleware: () => Middleware,
+  Method: () => Method,
+  MemoiristAdapter: () => MemoiristAdapter,
+  Headers: () => CHeaders,
+  File: () => XFile,
+  Extra: () => exports_X,
+  Error: () => CError,
+  Cors: () => Cors,
+  Cookies: () => Cookies,
+  Controller: () => ControllerAbstract,
+  Context: () => Context,
+  Config: () => Config,
+  CommonHeaders: () => CommonHeaders,
+  C: () => exports_C
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/Store/StoreAbstract.ts
+class StoreAbstract {
+  set(value) {
+    this.value = value;
+  }
+  get() {
+    return this.value;
+  }
+}
+
+// src/Store/globals/GlobalPrefixStore.ts
+class GlobalPrefixStore extends StoreAbstract {
+  value = "";
+}
+
+// src/Store/globals/GlobalRouterStore.ts
+class GlobalRouterStore extends StoreAbstract {
+  value = null;
+  get() {
+    if (!this.value) {
+      console.error("Router instance is not set. Please instantiate your Server before your routes.");
+      process.exit(1);
+    }
+    return this.value;
+  }
+}
+
+// src/Store/globals/GlobalCorsStore.ts
+class GlobalCorsStore extends StoreAbstract {
+  value = null;
+}
+
+// src/C.ts
+var exports_C = {};
+__export(exports_C, {
+  Status: () => Status,
+  StaticRoute: () => StaticRoute,
+  Server: () => Server,
+  Route: () => Route,
+  Response: () => CResponse,
+  Request: () => CRequest,
+  Middleware: () => Middleware,
+  Method: () => Method,
+  Headers: () => CHeaders,
+  Error: () => CError,
+  Cookies: () => Cookies,
+  Controller: () => ControllerAbstract,
+  Context: () => Context,
+  Config: () => Config,
+  CommonHeaders: () => CommonHeaders
+});
+
+// src/Config/enums/RuntimeOptions.ts
+var RuntimeOptions = {
+  bun: "bun",
+  node: "node"
+};
+
+// src/utils/strIsDefined.ts
+function strIsDefined(input) {
+  return !!input?.trim() && typeof input === "string";
+}
+
+// src/Config/Config.ts
+var import_path = __toESM(require("path"));
+
+class Config {
+  static get runtime() {
+    if (typeof Bun !== "undefined") {
+      return RuntimeOptions.bun;
+    }
+    if (typeof process !== "undefined" && process?.env) {
+      return RuntimeOptions.node;
+    }
+    console.warn("\u26A0\uFE0F Runtime isn't Bun or NodeJS. Features may not be available. App might not start.");
+    return "unknown";
+  }
+  static get nodeEnv() {
+    return this.env.NODE_ENV ?? "development";
+  }
+  static get env() {
+    switch (this.runtime) {
+      case RuntimeOptions.bun:
+        return Bun.env;
+      case RuntimeOptions.node:
+        return process.env;
+      default:
+        console.warn("\u26A0\uFE0F process.env wasn't available. Your environment variables are in memory.");
+        return {};
+    }
+  }
+  static cwd() {
+    return process.cwd();
+  }
+  static resolvePath(...paths) {
+    return import_path.default.resolve(...paths);
+  }
+  static get(key, opts) {
+    const value = this.env[key];
+    if (strIsDefined(value)) {
+      return opts?.parser ? opts?.parser(value) : value;
+    }
+    if (opts?.fallback !== undefined) {
+      return opts?.fallback;
+    }
+    console.error(`${key} doesn't exist in env`);
+    return;
+  }
+  static set(key, value) {
+    if (typeof value === "number") {
+      this.env[key] = value.toString();
+      return;
+    }
+    if (typeof value === "boolean") {
+      this.env[key] = value ? "true" : "false";
+      return;
+    }
+    this.env[key] = value;
+  }
+}
+// src/CResponse/enums/Status.ts
+var Status = {
+  CONTINUE: 100,
+  SWITCHING_PROTOCOLS: 101,
+  PROCESSING: 102,
+  EARLY_HINTS: 103,
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MULTI_STATUS: 207,
+  ALREADY_REPORTED: 208,
+  IM_USED: 226,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  USE_PROXY: 305,
+  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,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  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,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  IM_A_TEAPOT: 418,
+  MISDIRECTED_REQUEST: 421,
+  UNPROCESSABLE_ENTITY: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  TOO_EARLY: 425,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508,
+  NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+
+// src/CResponse/enums/DefaultStatusTexts.ts
+var DefaultStatusTexts = {
+  [Status.OK]: "OK",
+  [Status.CREATED]: "Created",
+  [Status.NO_CONTENT]: "No Content",
+  [Status.MOVED_PERMANENTLY]: "Moved Permanently",
+  [Status.FOUND]: "Found",
+  [Status.SEE_OTHER]: "See Other",
+  [Status.TEMPORARY_REDIRECT]: "Temporary Redirect",
+  [Status.PERMANENT_REDIRECT]: "Permanent Redirect",
+  [Status.BAD_REQUEST]: "Bad Request",
+  [Status.UNAUTHORIZED]: "Unauthorized",
+  [Status.FORBIDDEN]: "Forbidden",
+  [Status.NOT_FOUND]: "Not Found",
+  [Status.INTERNAL_SERVER_ERROR]: "Internal Server Error"
+};
+
+// src/CHeaders/enums/CommonHeaders.ts
+var CommonHeaders = {
+  CacheControl: "Cache-Control",
+  ContentType: "Content-Type",
+  ContentLength: "Content-Length",
+  ContentDisposition: "Content-Disposition",
+  AcceptEncoding: "Accept-Encoding",
+  Accept: "Accept",
+  Authorization: "Authorization",
+  UserAgent: "User-Agent",
+  Host: "Host",
+  Referer: "Referer",
+  Connection: "Connection",
+  Pragma: "Pragma",
+  Date: "Date",
+  IfNoneMatch: "If-None-Match",
+  IfModifiedSince: "If-Modified-Since",
+  ETag: "ETag",
+  Expires: "Expires",
+  LastModified: "Last-Modified",
+  Location: "Location",
+  WWWAuthenticate: "WWW-Authenticate",
+  AccessControlAllowOrigin: "Access-Control-Allow-Origin",
+  AccessControlMaxAge: "Access-Control-Max-Age",
+  AccessControlAllowCredentials: "Access-Control-Allow-Credentials",
+  AccessControlRequestMethod: "Access-Control-Request-Method",
+  SetCookie: "Set-Cookie",
+  Cookie: "Cookie"
+};
+
+// src/Cookies/CookiesAbstract.ts
+class CookiesAbstract {
+  applyInit(init) {
+    if (!init)
+      return;
+    if (init instanceof CookiesAbstract) {
+      for (const name of init.keys()) {
+        const value = init.get(name) ?? "";
+        this.set({ name, value });
+      }
+    } else if (Array.isArray(init)) {
+      for (const opts of init) {
+        this.set(opts);
+      }
+    } else {
+      this.set(init);
+    }
+  }
+}
+
+// src/Cookies/CookiesUsingBun.ts
+class CookiesUsingBun extends CookiesAbstract {
+  constructor(init) {
+    super();
+    this.applyInit(init);
+  }
+  map = new Bun.CookieMap;
+  toSetCookieHeaders() {
+    return this.map.toSetCookieHeaders();
+  }
+  set(opts) {
+    this.map.set(opts.name, opts.value, opts);
+  }
+  setMany(optsArr) {
+    for (const opts of optsArr) {
+      this.set(opts);
+    }
+  }
+  get(name) {
+    return this.map.get(name);
+  }
+  has(name) {
+    return this.map.has(name);
+  }
+  get count() {
+    return this.values().length;
+  }
+  delete(name) {
+    this.map.delete(name);
+  }
+  entries() {
+    return this.map.entries();
+  }
+  values() {
+    return Array.from(this.map.values());
+  }
+  keys() {
+    return Array.from(this.map.keys());
+  }
+}
+
+// src/Cookies/Cookies.ts
+class Cookies extends CookiesUsingBun {
+}
+
+// src/CHeaders/CHeaders.ts
+class CHeaders extends Headers {
+  constructor(init) {
+    super(init);
+  }
+  append(name, value) {
+    super.append(name, value);
+  }
+  set(name, value) {
+    super.set(name, value);
+  }
+  get(name) {
+    return super.get(name) || super.get(name.toLowerCase());
+  }
+  has(name) {
+    return super.has(name) || super.has(name.toLowerCase());
+  }
+  delete(name) {
+    return super.delete(name);
+  }
+  static combine(source, target) {
+    source.forEach((value, key) => {
+      if (key.toLowerCase() === "set-cookie") {
+        target.append(key, value);
+      } else {
+        target.set(key, value);
+      }
+    });
+    return target;
+  }
+  innerCombine(source) {
+    CHeaders.combine(source, this);
+  }
+  setMany(init) {
+    const entries = Array.isArray(init) ? init : Object.entries(init);
+    for (const [key, value] of entries) {
+      if (!strIsDefined(value))
+        continue;
+      this.set(key, value);
+    }
+  }
+  static findHeaderInInit(init, name) {
+    if (init instanceof CHeaders || init instanceof Headers) {
+      return init.get(name);
+    } else if (Array.isArray(init)) {
+      return init.find((entry) => entry[0] === name)?.[1] ?? null;
+    } else {
+      return init[name] ?? null;
+    }
+  }
+}
+
+// src/utils/isNil.ts
+function isNil(input) {
+  return input === null || input === undefined;
+}
+
+// src/utils/isPrimitive.ts
+function isPrimitive(input) {
+  return typeof input === "string" || typeof input === "number" || typeof input === "boolean" || typeof input === "bigint";
+}
+
+// src/utils/isPlainObject.ts
+function isPlainObject(input) {
+  return typeof input === "object" && input !== null && input.constructor === Object;
+}
+
+// src/CError/CError.ts
+class CError extends Error {
+  message;
+  status;
+  data;
+  constructor(message, status, data) {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.data = data;
+  }
+  toResponse() {
+    return new CResponse(this.data ? { error: this.data, message: this.message } : { error: true, message: this.message }, { status: this.status });
+  }
+  isStatusOf(status) {
+    return this.status === status;
+  }
+  static internalServerError(msg) {
+    const status = Status.INTERNAL_SERVER_ERROR;
+    return new this(msg ?? status.toString(), status);
+  }
+  static badRequest(msg) {
+    const status = Status.BAD_REQUEST;
+    return new this(msg ?? status.toString(), status);
+  }
+  static notFound(msg) {
+    const status = Status.NOT_FOUND;
+    return new this(msg ?? status.toString(), status);
+  }
+  static methodNotAllowed(msg) {
+    const status = Status.METHOD_NOT_ALLOWED;
+    return new this(msg ?? status.toString(), status);
+  }
+  static unprocessableEntity(msg) {
+    const status = Status.UNPROCESSABLE_ENTITY;
+    return new this(msg ?? status.toString(), status);
+  }
+}
+
+// src/XFile/XFileAbstract.ts
+class XFileAbstract {
+  path;
+  fallbackExtension;
+  constructor(path2, fallbackExtension) {
+    this.path = path2;
+    this.fallbackExtension = fallbackExtension;
+  }
+  get name() {
+    return this.path.split("/").pop() ?? this.path;
+  }
+  get extension() {
+    return this.path.split(".").pop() ?? this.fallbackExtension ?? "txt";
+  }
+  get mimeType() {
+    const mimeTypes = {
+      html: "text/html",
+      htm: "text/html",
+      css: "text/css",
+      js: "application/javascript",
+      ts: "application/javascript",
+      mjs: "application/javascript",
+      json: "application/json",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      svg: "image/svg+xml",
+      ico: "image/x-icon",
+      txt: "text/plain",
+      xml: "application/xml",
+      pdf: "application/pdf",
+      zip: "application/zip",
+      mp3: "audio/mpeg",
+      mp4: "video/mp4",
+      webm: "video/webm",
+      woff: "font/woff",
+      woff2: "font/woff2",
+      ttf: "font/ttf"
+    };
+    return mimeTypes[this.extension] ?? "application/octet-stream";
+  }
+}
+
+// src/XFile/XFileUsingBun.ts
+class XFileUsingBun extends XFileAbstract {
+  constructor(...args) {
+    super(...args);
+    this.file = Bun.file(args[0]);
+  }
+  file;
+  async exists() {
+    return await this.file.exists();
+  }
+  async text() {
+    return await this.file.text();
+  }
+  stream() {
+    return this.file.stream();
+  }
+}
+
+// src/XFile/XFile.ts
+class XFile extends XFileUsingBun {
+}
+// src/CResponse/CResponse.ts
+class CResponse {
+  data;
+  init;
+  constructor(data, init) {
+    this.data = data;
+    this.init = init;
+    this.cookies = this.resolveCookies();
+    this.headers = this.resolveHeaders();
+    this.body = this.resolveBody();
+    this.status = this.resolveStatus();
+    this.statusText = this.getDefaultStatusText();
+  }
+  body;
+  headers;
+  status;
+  statusText;
+  cookies;
+  get response() {
+    return new Response(this.body, {
+      status: this.status,
+      statusText: this.statusText,
+      headers: this.headers
+    });
+  }
+  static redirect(url, init) {
+    const res = new CResponse(undefined, {
+      ...init,
+      status: init?.status ?? Status.FOUND,
+      statusText: init?.statusText ?? DefaultStatusTexts[Status.FOUND]
+    });
+    const urlString = url instanceof URL ? url.toString() : url;
+    res.headers.set(CommonHeaders.Location, urlString);
+    return res;
+  }
+  static permanentRedirect(url, init) {
+    return this.redirect(url, {
+      ...init,
+      status: Status.MOVED_PERMANENTLY
+    });
+  }
+  static temporaryRedirect(url, init) {
+    return this.redirect(url, { ...init, status: Status.TEMPORARY_REDIRECT });
+  }
+  static seeOther(url, init) {
+    return this.redirect(url, { ...init, status: Status.SEE_OTHER });
+  }
+  static createStream(execute) {
+    let cancelled = false;
+    let cleanup;
+    return new ReadableStream({
+      start(controller) {
+        try {
+          cleanup = execute(controller, () => cancelled);
+          if (typeof cleanup !== "function") {
+            controller.close();
+          }
+        } catch (err) {
+          controller.error(err);
+        }
+      },
+      cancel() {
+        cancelled = true;
+        cleanup?.();
+      }
+    });
+  }
+  static sse(source, init, retry) {
+    const encoder = new TextEncoder;
+    const stream = CResponse.createStream((controller, isCancelled) => {
+      return source((event) => {
+        if (isCancelled())
+          return;
+        let chunk = "";
+        if (retry !== undefined)
+          chunk += `retry: ${retry}
+`;
+        if (event.id)
+          chunk += `id: ${event.id}
+`;
+        if (event.event)
+          chunk += `event: ${event.event}
+`;
+        chunk += `data: ${JSON.stringify(event.data)}
+
+`;
+        controller.enqueue(encoder.encode(chunk));
+      });
+    });
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: "text/event-stream",
+      [CommonHeaders.CacheControl]: "no-cache",
+      [CommonHeaders.Connection]: "keep-alive"
+    });
+    return res;
+  }
+  static ndjson(source, init) {
+    const encoder = new TextEncoder;
+    const stream = CResponse.createStream((controller, isCancelled) => {
+      return source((item) => {
+        if (isCancelled())
+          return;
+        controller.enqueue(encoder.encode(`${JSON.stringify(item)}
+`));
+      });
+    });
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: "application/x-ndjson",
+      [CommonHeaders.CacheControl]: "no-cache"
+    });
+    return res;
+  }
+  static async streamFile(filePath, disposition = "attachment", init) {
+    const file = new XFile(filePath);
+    if (!file) {
+      throw CError.notFound();
+    }
+    const stream = file.stream();
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: file.mimeType,
+      [CommonHeaders.ContentDisposition]: `${disposition}; filename="${file.name}"`
+    });
+    return res;
+  }
+  static async file(filePath, init) {
+    const file = new XFile(filePath);
+    if (!file) {
+      throw CError.notFound();
+    }
+    const content = await file.text();
+    const res = new CResponse(content, init);
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: file.mimeType,
+      [CommonHeaders.ContentLength]: content.length.toString()
+    });
+    return res;
+  }
+  resolveCookies() {
+    return new Cookies(this.init?.cookies);
+  }
+  resolveHeaders() {
+    const headers = new CHeaders(this.init?.headers);
+    const setCookieHeaders = this.cookies.toSetCookieHeaders();
+    if (setCookieHeaders.length > 0) {
+      for (const header of setCookieHeaders) {
+        headers.append(CommonHeaders.SetCookie, header);
+      }
+    }
+    return headers;
+  }
+  resolveStatus() {
+    if (this.init?.status)
+      return this.init.status;
+    if (this.headers.has(CommonHeaders.Location)) {
+      return Status.FOUND;
+    }
+    return Status.OK;
+  }
+  setContentType(value) {
+    if (!this.headers.has(CommonHeaders.ContentType) || this.headers.get(CommonHeaders.ContentType) === "text/plain") {
+      this.headers.set(CommonHeaders.ContentType, value);
+    }
+  }
+  resolveBody() {
+    if (isNil(this.data)) {
+      this.setContentType("text/plain");
+      return "";
+    }
+    if (isPrimitive(this.data)) {
+      this.setContentType("text/plain");
+      return String(this.data);
+    }
+    if (this.data instanceof ArrayBuffer) {
+      this.setContentType("application/octet-stream");
+      return this.data;
+    }
+    if (this.data instanceof Blob) {
+      if (this.data.type)
+        this.setContentType(this.data.type);
+      return this.data;
+    }
+    if (this.data instanceof FormData) {
+      this.setContentType("multipart/form-data");
+      return this.data;
+    }
+    if (this.data instanceof URLSearchParams) {
+      this.setContentType("application/x-www-form-urlencoded");
+      return this.data;
+    }
+    if (this.data instanceof ReadableStream) {
+      return this.data;
+    }
+    if (this.data instanceof Date) {
+      this.setContentType("text/plain");
+      return this.data.toISOString();
+    }
+    if (Array.isArray(this.data) || isPlainObject(this.data)) {
+      this.setContentType("application/json");
+      return JSON.stringify(this.data);
+    }
+    this.setContentType("text/plain");
+    return String(this.data);
+  }
+  getDefaultStatusText() {
+    const key = this.status;
+    return DefaultStatusTexts[key] ?? "Unknown";
+  }
+}
+
+// src/CRequest/enums/Method.ts
+var Method = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  PATCH: "PATCH",
+  DELETE: "DELETE",
+  HEAD: "HEAD",
+  OPTIONS: "OPTIONS",
+  CONNECT: "CONNECT",
+  TRACE: "TRACE"
+};
+
+// src/utils/arrIncludes.ts
+function arrIncludes(input, array) {
+  return array.includes(input);
+}
+
+// src/utils/isObjectWith.ts
+function isObjectWith(item, key) {
+  return item !== null && item !== undefined && typeof item === "object" && key in item;
+}
+
+// src/utils/objAppendEntry.ts
+function objAppendEntry(data, key, value) {
+  const existing = data[key];
+  if (existing !== undefined) {
+    data[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+  } else {
+    data[key] = value;
+  }
+}
+
+// src/Model/Parser.ts
+class Parser {
+  static async parse(data, validate) {
+    if (!validate)
+      return data;
+    const result = await validate(data);
+    if (result.issues !== undefined) {
+      const msg = this.issuesToErrorMessage(result.issues);
+      throw CError.unprocessableEntity(msg);
+    }
+    return result.value;
+  }
+  static issuesToErrorMessage(issues) {
+    if (issues.length === 0)
+      return "";
+    return issues.map((issue) => {
+      if (!issue.path || issue.path.length === 0) {
+        return issue.message;
+      }
+      const key = issue.path.map((segment) => isObjectWith(segment, "key") ? String(segment.key) : String(segment)).join(".");
+      return `${key}: ${issue.message}`;
+    }).join(`
+`);
+  }
+  static async parseUrlData(params, validate) {
+    const data = {};
+    for (const [key, value] of Object.entries(params)) {
+      data[key] = decodeURIComponent(value);
+    }
+    return await this.parse(data, validate);
+  }
+  static async parseBody(r, validate) {
+    let data;
+    const empty = {};
+    const input = r instanceof Request ? r : r instanceof Response ? r : r.response;
+    try {
+      switch (Parser.getNormalizedContentType(input)) {
+        case "json":
+          data = await this.getJsonBody(input);
+          break;
+        case "form-urlencoded":
+          data = await this.getFormUrlEncodedBody(input);
+          break;
+        case "form-data":
+          data = await this.getFormDataBody(input);
+          break;
+        case "text":
+          data = await this.getTextBody(input);
+          break;
+        case "unknown":
+          data = await this.getUnknownBody(input);
+          break;
+        case "xml":
+        case "binary":
+        case "pdf":
+        case "image":
+        case "audio":
+        case "video":
+          throw new CError("unprocessable.contentType", Status.UNPROCESSABLE_ENTITY);
+        case "no-body-allowed":
+        default:
+          return empty;
+      }
+      return await this.parse(data, validate);
+    } catch (err) {
+      if (err instanceof SyntaxError)
+        return empty;
+      throw err;
+    }
+  }
+  static async getUnknownBody(input, validate) {
+    if (!validate) {
+      return await this.getTextBody(input);
+    }
+    try {
+      return await this.getJsonBody(input);
+    } catch {
+      return await this.getTextBody(input);
+    }
+  }
+  static async getJsonBody(req) {
+    return await req.json();
+  }
+  static async getFormUrlEncodedBody(input) {
+    const text = await input.text();
+    if (!text || text.trim().length === 0) {
+      throw new SyntaxError("Body is empty");
+    }
+    const params = new URLSearchParams(text);
+    const body = {};
+    for (const [key, value] of params.entries()) {
+      objAppendEntry(body, key, value);
+    }
+    return body;
+  }
+  static async getFormDataBody(input) {
+    const formData = await input.formData();
+    const entries = formData.entries();
+    const body = {};
+    for (const [key, value] of entries) {
+      if (value instanceof File) {
+        body[key] = value;
+      } else {
+        objAppendEntry(body, key, value);
+      }
+    }
+    return body;
+  }
+  static async getTextBody(input) {
+    const contentLength = input.headers.get(CommonHeaders.ContentLength);
+    const length = contentLength ? parseInt(contentLength) : 0;
+    if (length > 0 && length < 1024 * 1024) {
+      return await input.text();
+    }
+    const buffer = await input.arrayBuffer();
+    const contentType = input.headers.get(CommonHeaders.ContentType) || "";
+    const match = contentType.match(/charset=([^;]+)/i);
+    const charset = match?.[1] ? match[1].trim() : null;
+    const decoder = new TextDecoder(charset || "utf-8");
+    return decoder.decode(buffer);
+  }
+  static getNormalizedContentType(input) {
+    const contentTypeHeader = input.headers.get(CommonHeaders.ContentType) || "";
+    if ("method" in input && typeof input.method === "string" && !arrIncludes(input.method.toUpperCase(), [
+      Method.POST,
+      Method.PUT,
+      Method.PATCH,
+      Method.DELETE
+    ])) {
+      return "no-body-allowed";
+    }
+    if (contentTypeHeader.includes("application/json")) {
+      return "json";
+    } else if (contentTypeHeader.includes("application/x-www-form-urlencoded")) {
+      return "form-urlencoded";
+    } else if (contentTypeHeader.includes("multipart/form-data")) {
+      return "form-data";
+    } else if (contentTypeHeader.includes("text/plain")) {
+      return "text";
+    } else if (contentTypeHeader.includes("application/xml")) {
+      return "xml";
+    } else if (contentTypeHeader.includes("text/xml")) {
+      return "xml";
+    } else if (contentTypeHeader.includes("application/octet-stream")) {
+      return "binary";
+    } else if (contentTypeHeader.includes("application/pdf")) {
+      return "pdf";
+    } else if (contentTypeHeader.includes("image/")) {
+      return "image";
+    } else if (contentTypeHeader.includes("audio/")) {
+      return "audio";
+    } else if (contentTypeHeader.includes("video/")) {
+      return "video";
+    }
+    return "unknown";
+  }
+}
+
+// src/Context/Context.ts
+class Context {
+  constructor(req, body, search, params, res) {
+    this.req = req;
+    this.url = req.urlObject;
+    this.headers = req.headers;
+    this.cookies = req.cookies;
+    this.body = body;
+    this.search = search;
+    this.params = params;
+    this.res = res ?? new CResponse;
+  }
+  req;
+  url;
+  headers;
+  cookies;
+  body;
+  search;
+  params;
+  res;
+  data = {};
+  static makeFromRequest(req) {
+    return new Context(req, {}, {}, {});
+  }
+  static async appendParsedData(ctx, req, params, search, model) {
+    ctx.body = await Parser.parseBody(req, model?.body);
+    ctx.params = await Parser.parseUrlData(params, model?.params);
+    ctx.search = await Parser.parseUrlData(search, model?.search);
+  }
+}
+// src/Route/enums/RouteVariant.ts
+var RouteVariant = {
+  static: "static",
+  dynamic: "dynamic"
+};
+
+// src/utils/joinPathSegments.ts
+function joinPathSegments(...segments) {
+  const joined = segments.map((segment) => typeof segment === "number" ? segment.toString() : segment).filter((segment) => segment !== undefined && segment !== null && segment.trim() !== "").map((segment) => segment.replace(/^\/+|\/+$/g, "")).filter((segment) => segment.length > 0).join("/");
+  return `/${joined}`;
+}
+
+// src/Route/RouteAbstract.ts
+class RouteAbstract {
+  resolveEndpoint(definition, variant) {
+    const endpoint = typeof definition === "string" ? definition : definition.path;
+    if (variant === RouteVariant.dynamic) {
+      return joinPathSegments(_prefixStore.get(), endpoint);
+    }
+    return endpoint;
+  }
+  resolveMethod(definition) {
+    return typeof definition === "string" ? Method.GET : definition.method;
+  }
+  resolvePattern(endpoint) {
+    return Route.makeRoutePattern(endpoint);
+  }
+  resolveId(method, endpoint) {
+    return Route.makeRouteId(method, endpoint);
+  }
+}
+
+// src/Route/Route.ts
+class Route extends RouteAbstract {
+  constructor(definition, handler, model) {
+    super();
+    this.variant = RouteVariant.dynamic;
+    this.endpoint = this.resolveEndpoint(definition, this.variant);
+    this.method = this.resolveMethod(definition);
+    this.pattern = this.resolvePattern(this.endpoint);
+    this.id = this.resolveId(this.method, this.endpoint);
+    this.model = model;
+    this.handler = handler;
+    _routerStore.get().addRoute(this);
+    if (model) {
+      _routerStore.get().addModel(this, model);
+    }
+  }
+  variant;
+  endpoint;
+  method;
+  pattern;
+  id;
+  handler;
+  model;
+  static makeRouteId(method, endpoint) {
+    return `${method.toUpperCase()} ${endpoint}`;
+  }
+  static makeRoutePattern(endpoint) {
+    const regex = endpoint.split("/").map((part) => part.startsWith(":") ? "([^\\/]+)" : part).join("/");
+    return new RegExp(`^${regex}$`);
+  }
+}
+
+// src/Route/StaticRoute.ts
+class StaticRoute extends RouteAbstract {
+  constructor(path2, definition, handler, model) {
+    super();
+    this.variant = RouteVariant.static;
+    this.endpoint = this.resolveEndpoint(path2, this.variant);
+    this.method = Method.GET;
+    this.pattern = this.resolvePattern(this.endpoint);
+    this.id = this.resolveId(this.method, this.endpoint);
+    this.model = model;
+    this.filePath = this.resolveFilePath(definition);
+    this.handler = this.resolveHandler(definition, handler);
+    _routerStore.get().addRoute(this);
+  }
+  id;
+  variant;
+  method;
+  endpoint;
+  pattern;
+  model;
+  handler;
+  filePath;
+  resolveFilePath(definition) {
+    return typeof definition === "string" ? definition : definition.filePath;
+  }
+  resolveHandler(definition, customHandler) {
+    if (customHandler !== undefined) {
+      return async (c) => {
+        const file = new XFile(this.filePath);
+        if (!file) {
+          console.error("File not found at:", this.filePath);
+          throw CError.notFound();
+        }
+        const content = await file.text();
+        c.res.headers.setMany({
+          [CommonHeaders.ContentType]: file.mimeType,
+          [CommonHeaders.ContentLength]: content.length.toString()
+        });
+        return customHandler(c, content);
+      };
+    } else if (typeof definition === "string") {
+      return async () => await CResponse.file(this.filePath);
+    } else {
+      return async () => await CResponse.streamFile(this.filePath);
+    }
+  }
+}
+
+// src/Controller/ControllerAbstract.ts
+class ControllerAbstract {
+  constructor(opts) {
+    this.prefix = opts?.prefix;
+    this.beforeEach = opts?.beforeEach;
+  }
+  routeIds = new Set;
+  prefix;
+  beforeEach;
+  route(...args) {
+    const [definition, handler, model] = args;
+    const route = new Route(this.resolveRouteDefinition(definition), async (ctx) => {
+      await this.beforeEach?.(ctx);
+      return handler(ctx);
+    }, model);
+    this.routeIds.add(route.id);
+    return route;
+  }
+  staticRoute(...args) {
+    const [path2, filePath, handler, model] = args;
+    const route = new StaticRoute(joinPathSegments(this.prefix, path2), filePath, handler, model);
+    this.routeIds.add(route.id);
+    return route;
+  }
+  resolveRouteDefinition(definition) {
+    if (typeof definition === "string") {
+      return joinPathSegments(this.prefix, definition);
+    }
+    return {
+      method: definition.method,
+      path: joinPathSegments(this.prefix, definition.path)
+    };
+  }
+}
+// src/Middleware/Middleware.ts
+class Middleware {
+  constructor(opts) {
+    this.useOn = opts.useOn;
+    this.handler = opts.handler;
+    _routerStore.get().addMiddleware(opts);
+  }
+  useOn;
+  handler;
+}
+// src/utils/assert.ts
+function assert(condition, message) {
+  const conditionName = String(condition);
+  if (!condition) {
+    if (!message) {
+      message = `Assertion failed for ${conditionName}`;
+    } else {
+      message = `${conditionName}: ${message}`;
+    }
+    throw new Error(message);
+  }
+}
+
+// src/utils/strSplit.ts
+function strSplit(mark, input, minLength) {
+  const parts = input.split(mark).map((part) => part.trim()).filter(Boolean);
+  if (minLength) {
+    assert(parts.length >= minLength);
+    return parts;
+  }
+  return parts;
+}
+
+// src/CRequest/CRequest.ts
+class CRequest extends Request {
+  info;
+  init;
+  constructor(info, init) {
+    super(info, init);
+    this.info = info;
+    this.init = init;
+    this.urlObject = this.resolveUrlObject();
+    this.headers = this.resolveHeaders();
+    this.cookies = this.resolveCookies();
+    this.isPreflight = this.resolveIsPreflight();
+  }
+  urlObject;
+  isPreflight;
+  cookies;
+  headers;
+  resolveUrlObject() {
+    let urlObject;
+    switch (true) {
+      case this.info instanceof URL:
+        urlObject = this.info;
+        break;
+      case this.info instanceof CRequest:
+        urlObject = this.info.urlObject;
+        break;
+      case this.info instanceof Request:
+        urlObject = new URL(this.info.url);
+        break;
+      default:
+        urlObject = new URL(this.info);
+        break;
+    }
+    if (!urlObject.pathname) {
+      urlObject.pathname += "/";
+    }
+    return urlObject;
+  }
+  resolveHeaders() {
+    if (this.init?.headers !== undefined) {
+      return new CHeaders(this.init.headers);
+    }
+    if (this.info instanceof Request || this.info instanceof CRequest) {
+      return new CHeaders(this.info.headers);
+    }
+    return new CHeaders;
+  }
+  resolveCookies() {
+    const jar = new Cookies;
+    const cookieHeader = this.headers.get(CommonHeaders.Cookie);
+    if (cookieHeader) {
+      const pairs = strSplit(";", cookieHeader);
+      for (const pair of pairs) {
+        const [name, value] = strSplit("=", pair);
+        if (!name || !value)
+          continue;
+        jar.set({ name, value });
+      }
+    }
+    return jar;
+  }
+  resolveIsPreflight() {
+    const accessControlRequestMethodHeader = this.headers.has(CommonHeaders.AccessControlRequestMethod);
+    return this.method === Method.OPTIONS && accessControlRequestMethodHeader;
+  }
+}
+// src/utils/isRegexMatch.ts
+function isRegexMatch(source, pattern) {
+  return pattern.test(source);
+}
+
+// src/utils/strIsEqual.ts
+function strIsEqual(source, target, modifier) {
+  source = source.trim();
+  target = target.trim();
+  if (modifier === "upper") {
+    return source.toUpperCase() === target.toUpperCase();
+  }
+  if (modifier === "lower") {
+    return source.toUpperCase() === target.toUpperCase();
+  }
+  return source === target;
+}
+
+// src/Store/LazyMap.ts
+class LazyMap {
+  constructor() {
+    return new Proxy(this, {
+      get(target, prop) {
+        const val = Reflect.get(target.map, prop);
+        return typeof val === "function" ? val.bind(target.map) : val;
+      }
+    });
+  }
+  _map;
+  get map() {
+    if (!this._map) {
+      this._map = new Map;
+    }
+    return this._map;
+  }
+  get [Symbol.toStringTag]() {
+    return "LazyMap";
+  }
+}
+
+// src/utils/strRemoveWhitespace.ts
+function strRemoveWhitespace(str) {
+  return str.trim().replace(/\s+/g, "");
+}
+
+// src/Router/registries/ModelRegistry.ts
+class ModelRegistry {
+  map = new LazyMap;
+  add(method, endpoint, model) {
+    const entry = ModelRegistry.toRouterModelData(model);
+    this.map.set(Route.makeRouteId(method, endpoint), entry);
+  }
+  find(routeId) {
+    return this.map.get(routeId);
+  }
+  static internFuncMap = new LazyMap;
+  static toRouterModelData(model) {
+    const entry = {};
+    for (const k of Object.keys(model)) {
+      const key = k;
+      const schema = model[key];
+      if (!schema)
+        continue;
+      const handler = schema["~standard"].validate;
+      entry[key] = this.intern(handler, "model", strRemoveWhitespace(JSON.stringify(schema)));
+    }
+    return entry;
+  }
+  static intern(value, ...namespace) {
+    const key = namespace.join("::");
+    const existing = this.internFuncMap.get(key);
+    if (existing)
+      return existing;
+    this.internFuncMap.set(key, value);
+    return value;
+  }
+}
+
+// src/utils/compile.ts
+function compile(fns) {
+  return async (...args) => {
+    for (const fn of fns) {
+      if (!fn)
+        continue;
+      await fn(...args);
+    }
+  };
+}
+
+// src/Router/registries/MiddlewareRegistry.ts
+class MiddlewareRegistry {
+  middlewares = new LazyMap;
+  add(m) {
+    const resolved = MiddlewareRegistry.resolveRouteIds(m);
+    if (resolved.isGlobal) {
+      const existing = this.middlewares.get("*") ?? [];
+      this.middlewares.set("*", [...existing, m.handler]);
+      return;
+    }
+    for (const routeId of resolved.routeIds) {
+      const existing = this.middlewares.get(routeId) ?? [];
+      this.middlewares.set(routeId, [...existing, m.handler]);
+    }
+  }
+  find(routeId) {
+    const globals = this.middlewares.get("*") ?? [];
+    const locals = this.middlewares.get(routeId) ?? [];
+    return compile([...globals, ...locals]);
+  }
+  static resolveRouteIds(m) {
+    if (m.useOn === "*")
+      return { isGlobal: true };
+    const targets = Array.isArray(m.useOn) ? m.useOn : [m.useOn];
+    const routeIds = [];
+    for (const target of targets) {
+      if (target instanceof Route) {
+        routeIds.push(target.id);
+      } else if (target instanceof ControllerAbstract) {
+        routeIds.push(...target.routeIds);
+      }
+    }
+    return { isGlobal: false, routeIds };
+  }
+}
+
+// src/Router/adapters/CorpusAdapter.ts
+class CorpusAdapter {
+  routes = new Map;
+  modelRegistry = new ModelRegistry;
+  middlewareRegistry = new MiddlewareRegistry;
+  addRoute(data) {
+    this.checkPossibleCollision(data);
+    this.routes.set(data.id, data);
+  }
+  addModel(route, model) {
+    this.modelRegistry.add(route.method, route.endpoint, model);
+  }
+  addMiddleware(middleware) {
+    this.middlewareRegistry.add(middleware);
+  }
+  find(req) {
+    const method = req.method;
+    const pathname = req.urlObject.pathname;
+    const searchParams = req.urlObject.searchParams;
+    let route = null;
+    for (const data of this.routes.values()) {
+      if (this.hasAnyParam(data.endpoint) && isRegexMatch(pathname, data.pattern)) {
+        route = data;
+        break;
+      }
+      if (this.hasLastPartParam(data.endpoint) && strIsEqual(this.removeLastParam(data.endpoint), pathname, "lower")) {
+        route = data;
+        break;
+      }
+      if (strIsEqual(data.endpoint, pathname)) {
+        route = data;
+        break;
+      }
+    }
+    if (route === null) {
+      throw CError.notFound();
+    }
+    if (!strIsEqual(method, route.method, "upper")) {
+      throw CError.methodNotAllowed();
+    }
+    return {
+      route,
+      model: this.modelRegistry.find(route.id),
+      middleware: this.middlewareRegistry.find(route.id),
+      params: this.extractParams(pathname, route.endpoint),
+      search: Object.fromEntries(searchParams)
+    };
+  }
+  list() {
+    return Array.from(this.routes.values());
+  }
+  checkPossibleCollision(n) {
+    const dupeMsg = (nId) => console.error(`Duplicate route detected. ${nId} has already been registered.`);
+    const dynamicPatternMsg = (nId, oId) => console.error(`Ambiguous dynamic routes. ${nId} and ${oId} match the same URL patterns.`);
+    const baseDupeMsg = (nId, oId) => console.error(`Dynamic route overlaps existing route. ${nId} \u2014 dropping the last param segment matches ${oId}.`);
+    const shadowMsg = (nId, oId) => console.error(`Route shadowed by existing dynamic route. ${nId} will be unreachable \u2014 ${oId} captures the same URL space.`);
+    const existing = this.routes.get(n.id);
+    if (existing) {
+      dupeMsg(n.id);
+      return true;
+    }
+    const nHasAnyParam = this.hasAnyParam(n.endpoint);
+    const nHasLastPartParam = this.hasLastPartParam(n.endpoint);
+    for (const o of this.routes.values()) {
+      if (o.method !== n.method)
+        continue;
+      if (nHasAnyParam) {
+        if (isRegexMatch(n.endpoint, o.pattern) || isRegexMatch(o.endpoint, n.pattern)) {
+          dynamicPatternMsg(n.id, o.id);
+          return true;
+        }
+      }
+      if (nHasLastPartParam) {
+        if (isRegexMatch(this.removeLastParam(n.endpoint), o.pattern)) {
+          baseDupeMsg(n.id, o.id);
+          return true;
+        }
+      }
+      const oHasLastPartParam = this.hasLastPartParam(o.endpoint);
+      if (oHasLastPartParam) {
+        if (isRegexMatch(n.endpoint, Route.makeRoutePattern(this.removeLastParam(o.endpoint)))) {
+          shadowMsg(n.id, o.id);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  extractParams(pathname, endpoint) {
+    const data = {};
+    if (!this.hasAnyParam(endpoint))
+      return data;
+    const defParts = endpoint.split("/");
+    const reqParts = pathname.split("/");
+    for (const [i, defPart] of defParts.entries()) {
+      const reqPart = reqParts[i];
+      if (defPart.startsWith(":") && reqPart !== undefined) {
+        data[defPart.slice(1)] = decodeURIComponent(reqPart);
+      }
+    }
+    return data;
+  }
+  hasLastPartParam(endpoint) {
+    if (!this.hasAnyParam(endpoint))
+      return false;
+    const parts = endpoint.split("/");
+    return parts[parts.length - 1]?.startsWith(":") ?? false;
+  }
+  removeLastParam(endpoint) {
+    return endpoint.split("/").slice(0, -1).join("/");
+  }
+  hasAnyParam(endpoint) {
+    if (endpoint.includes("/:"))
+      return true;
+    if (!endpoint.includes(":"))
+      return false;
+    return endpoint.split("/").some((p) => p.startsWith(":"));
+  }
+}
+
+// src/Router/Router.ts
+class Router {
+  constructor(adapter) {
+    this._adapter = adapter ?? new CorpusAdapter;
+  }
+  models = [];
+  _adapter;
+  cache = new WeakMap;
+  checkPossibleCollision(n) {
+    if (this._adapter instanceof CorpusAdapter) {
+      return this._adapter.checkPossibleCollision(n);
+    }
+    return false;
+  }
+  addModel(route, model) {
+    this.models.push(model);
+    this._adapter.addModel(route, model);
+  }
+  addMiddleware(middleware) {
+    this._adapter.addMiddleware(middleware);
+  }
+  addRoute(r) {
+    this._adapter.addRoute({
+      id: r.id,
+      endpoint: r.endpoint,
+      method: r.method,
+      handler: r.handler,
+      pattern: r.pattern
+    });
+  }
+  findRouteHandler(req) {
+    const cached = this.cache.get(req);
+    if (cached)
+      return cached;
+    const match = this._adapter.find(req);
+    if (!match)
+      throw CError.notFound();
+    const ctx = Context.makeFromRequest(req);
+    const handler = async () => {
+      await match.middleware?.(ctx);
+      await Context.appendParsedData(ctx, req, match.params, match.search, match.model);
+      const res = await match.route.handler(ctx);
+      return res instanceof CResponse ? res : new CResponse(res, {
+        cookies: ctx.res.cookies,
+        headers: ctx.res.headers,
+        status: ctx.res.status,
+        statusText: ctx.res.statusText
+      });
+    };
+    this.cache.set(req, handler);
+    return handler;
+  }
+  getRouteList() {
+    return this._adapter.list().map((v) => [v.method, v.endpoint]);
+  }
+}
+
+// src/Server/ServerAbstract.ts
+class ServerAbstract {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    _routerStore.set(new Router(opts?.adapter));
+  }
+  get routes() {
+    return _routerStore.get().getRouteList();
+  }
+  setGlobalPrefix(value) {
+    _prefixStore.set(value);
+  }
+  async listen(port, hostname = "0.0.0.0") {
+    try {
+      process.on("SIGINT", () => this.close());
+      process.on("SIGTERM", () => this.close());
+      console.log(`Listening on ${hostname}:${port}`);
+      await this.handleBeforeListen?.();
+      this.serve({
+        port,
+        hostname,
+        fetch: (r) => this.handle(r)
+      });
+    } catch (err) {
+      console.error("Server unable to start:", err);
+      await this.close();
+    }
+  }
+  async handle(request) {
+    const req = new CRequest(request);
+    let res = await this.getResponse(req);
+    const cors = _corsStore.get();
+    if (cors !== null) {
+      cors.apply(req, res);
+    }
+    if (this.handleAfterResponse) {
+      res = await this.handleAfterResponse(res);
+    }
+    return res.response;
+  }
+  async getResponse(req) {
+    try {
+      if (req.isPreflight) {
+        return new CResponse("Departed");
+      }
+      const handler = _routerStore.get().findRouteHandler(req);
+      return await handler();
+    } catch (err) {
+      if (err instanceof CError) {
+        if (err.isStatusOf(Status.NOT_FOUND)) {
+          return await this.handleNotFound(req);
+        }
+        if (err.isStatusOf(Status.METHOD_NOT_ALLOWED)) {
+          return await this.handleMethodNotAllowed(req);
+        }
+      }
+      return await this.handleError(err);
+    }
+  }
+  handleBeforeListen;
+  setOnBeforeListen(handler) {
+    this.handleBeforeListen = handler;
+  }
+  defaultOnBeforeListen = undefined;
+  handleBeforeClose;
+  setOnBeforeClose(handler) {
+    this.handleBeforeClose = handler;
+  }
+  defaultOnBeforeClose = undefined;
+  handleAfterResponse;
+  setOnAfterResponse(handler) {
+    this.handleAfterResponse = handler;
+  }
+  defaultOnAfterResponse = undefined;
+  handleError = (err) => this.defaultErrorHandler(err);
+  setOnError(handler) {
+    this.handleError = handler;
+  }
+  defaultErrorHandler = (err) => {
+    if (!(err instanceof Error)) {
+      return new CResponse({ error: err, message: "Unknown" }, { status: Status.INTERNAL_SERVER_ERROR });
+    }
+    if (err instanceof CError) {
+      return err.toResponse();
+    }
+    return new CResponse({ error: err, message: err.message }, { status: Status.INTERNAL_SERVER_ERROR });
+  };
+  handleNotFound = (req) => this.defaultNotFoundHandler(req);
+  setOnNotFound(handler) {
+    this.handleNotFound = handler;
+  }
+  defaultNotFoundHandler = (req) => {
+    return new CResponse({ error: true, message: `${req.method} on ${req.url} does not exist.` }, { status: Status.NOT_FOUND });
+  };
+  handleMethodNotAllowed = (req) => this.defaultMethodNotFoundHandler(req);
+  defaultMethodNotFoundHandler = (req) => {
+    return new CResponse({ error: `${req.method} ${req.url} does not exist.` }, { status: Status.METHOD_NOT_ALLOWED });
+  };
+}
+
+// src/Server/ServerUsingBun.ts
+class ServerUsingBun extends ServerAbstract {
+  app;
+  serve(args) {
+    this.app = this.createApp(args);
+  }
+  async close() {
+    await this.handleBeforeClose?.();
+    console.log("Closing...");
+    await this.app?.stop(true);
+    if (Config.nodeEnv !== "test") {
+      process.exit(0);
+    }
+  }
+  createApp(options) {
+    return Bun.serve({
+      port: options.port,
+      hostname: options.hostname,
+      fetch: options.fetch,
+      idleTimeout: this.opts?.idleTimeout,
+      tls: this.opts?.tls
+    });
+  }
+}
+
+// src/Server/Server.ts
+class Server extends ServerUsingBun {
+}
+// src/X.ts
+var exports_X = {};
+__export(exports_X, {
+  Repository: () => RepositoryAbstract,
+  Parser: () => Parser,
+  MemoiristAdapter: () => MemoiristAdapter,
+  File: () => XFile,
+  Cors: () => Cors
+});
+// src/utils/boolToString.ts
+function boolToString(arg) {
+  return arg ? "true" : "false";
+}
+
+// src/utils/isSomeArray.ts
+function isSomeArray(arg) {
+  return arg !== undefined && Array.isArray(arg) && arg.length > 0 && arg.every((a) => a !== null && a !== undefined);
+}
+
+// src/Cors/Cors.ts
+class Cors {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    if (opts === undefined) {
+      _corsStore.set(null);
+    } else {
+      _corsStore.set(this);
+    }
+  }
+  originKey = "Access-Control-Allow-Origin";
+  methodsKey = "Access-Control-Allow-Methods";
+  headersKey = "Access-Control-Allow-Headers";
+  credentialsKey = "Access-Control-Allow-Credentials";
+  getCorsHeaders(req, res) {
+    const reqOrigin = req.headers.get("origin") ?? "";
+    const { allowedOrigins, allowedMethods, allowedHeaders, credentials } = this.opts ?? {};
+    if (isSomeArray(allowedOrigins) && allowedOrigins.includes(reqOrigin)) {
+      res.headers.set(this.originKey, reqOrigin);
+    }
+    if (isSomeArray(allowedMethods)) {
+      res.headers.set(this.methodsKey, allowedMethods.join(", "));
+    }
+    if (isSomeArray(allowedHeaders)) {
+      res.headers.set(this.headersKey, allowedHeaders.join(", "));
+    }
+    res.headers.set(this.credentialsKey, boolToString(credentials));
+    return res.headers;
+  }
+  apply(req, res) {
+    const headers = this.getCorsHeaders(req, res);
+    res.headers.innerCombine(headers);
+  }
+}
+// src/Repository/RepositoryAbstract.ts
+class RepositoryAbstract {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+}
+// node_modules/memoirist/dist/bun/index.js
+var Y = (v, b) => {
+  let A = b?.length ? {} : null;
+  if (A)
+    for (let Q of b)
+      A[Q.part.charCodeAt(0)] = Q;
+  return { part: v, store: null, inert: A, params: null, wildcardStore: null };
+};
+var k = (v, b) => ({ ...v, part: b });
+var T = (v) => ({ name: v, store: null, inert: null });
+
+class _ {
+  config;
+  root = {};
+  history = [];
+  deferred = [];
+  constructor(v = {}) {
+    this.config = v;
+    if (v.lazy)
+      this.find = this.lazyFind;
+    if (v.onParam && !Array.isArray(v.onParam))
+      this.config.onParam = [this.config.onParam];
+  }
+  static regex = { static: /:.+?(?=\/|$)/, params: /:.+?(?=\/|$)/g, optionalParams: /(\/:\w+\?)/g };
+  lazyFind = (v, b) => {
+    if (!this.config.lazy)
+      return this.find;
+    return this.build(), this.find(v, b);
+  };
+  build() {
+    if (!this.config.lazy)
+      return;
+    for (let [v, b, A] of this.deferred)
+      this.add(v, b, A, { lazy: false, ignoreHistory: true });
+    this.deferred = [], this.find = (v, b) => {
+      let A = this.root[v];
+      if (!A)
+        return null;
+      return $(b, b.length, A, 0, this.config.onParam);
+    };
+  }
+  add(v, b, A, { ignoreError: Q = false, ignoreHistory: O = false, lazy: V = this.config.lazy } = {}) {
+    if (V)
+      return this.find = this.lazyFind, this.deferred.push([v, b, A]), A;
+    if (typeof b !== "string")
+      throw new TypeError("Route path must be a string");
+    if (b === "")
+      b = "/";
+    else if (b[0] !== "/")
+      b = `/${b}`;
+    let X = b[b.length - 1] === "*", J = b.match(_.regex.optionalParams);
+    if (J) {
+      let F = b.replaceAll("?", "");
+      this.add(v, F, A, { ignoreError: Q, ignoreHistory: O, lazy: V });
+      for (let B = 0;B < J.length; B++) {
+        let D = b.replace(J[B], "");
+        this.add(v, D, A, { ignoreError: true, ignoreHistory: O, lazy: V });
+      }
+      return A;
+    }
+    if (J)
+      b = b.replaceAll("?", "");
+    if (this.history.find(([F, B, D]) => F === v && B === b))
+      return A;
+    if (X || J && b.charCodeAt(b.length - 1) === 63)
+      b = b.slice(0, -1);
+    if (!O)
+      this.history.push([v, b, A]);
+    let K = b.split(_.regex.static), G = b.match(_.regex.params) || [];
+    if (K[K.length - 1] === "")
+      K.pop();
+    let q;
+    if (!this.root[v])
+      q = this.root[v] = Y("/");
+    else
+      q = this.root[v];
+    let U = 0;
+    for (let F = 0;F < K.length; ++F) {
+      let B = K[F];
+      if (F > 0) {
+        let D = G[U++].slice(1);
+        if (q.params === null)
+          q.params = T(D);
+        else if (q.params.name !== D)
+          if (Q)
+            return A;
+          else
+            throw new Error(`Cannot create route "${b}" with parameter "${D}" because a route already exists with a different parameter name ("${q.params.name}") in the same location`);
+        let S = q.params;
+        if (S.inert === null) {
+          q = S.inert = Y(B);
+          continue;
+        }
+        q = S.inert;
+      }
+      for (let D = 0;; ) {
+        if (D === B.length) {
+          if (D < q.part.length) {
+            let S = k(q, q.part.slice(D));
+            Object.assign(q, Y(B, [S]));
+          }
+          break;
+        }
+        if (D === q.part.length) {
+          if (q.inert === null)
+            q.inert = {};
+          let S = q.inert[B.charCodeAt(D)];
+          if (S) {
+            q = S, B = B.slice(D), D = 0;
+            continue;
+          }
+          let Z = Y(B.slice(D));
+          q.inert[B.charCodeAt(D)] = Z, q = Z;
+          break;
+        }
+        if (B[D] !== q.part[D]) {
+          let S = k(q, q.part.slice(D)), Z = Y(B.slice(D));
+          Object.assign(q, Y(q.part.slice(0, D), [S, Z])), q = Z;
+          break;
+        }
+        ++D;
+      }
+    }
+    if (U < G.length) {
+      let B = G[U].slice(1);
+      if (q.params === null)
+        q.params = T(B);
+      else if (q.params.name !== B)
+        if (Q)
+          return A;
+        else
+          throw new Error(`Cannot create route "${b}" with parameter "${B}" because a route already exists with a different parameter name ("${q.params.name}") in the same location`);
+      if (q.params.store === null)
+        q.params.store = A;
+      return q.params.store;
+    }
+    if (X) {
+      if (q.wildcardStore === null)
+        q.wildcardStore = A;
+      return q.wildcardStore;
+    }
+    if (q.store === null)
+      q.store = A;
+    return q.store;
+  }
+  find(v, b) {
+    let A = this.root[v];
+    if (!A)
+      return null;
+    return $(b, b.length, A, 0, this.config.onParam);
+  }
+}
+var $ = (v, b, A, Q, O) => {
+  let V = A.part, X = V.length, J = Q + X;
+  if (X > 1) {
+    if (J > b)
+      return null;
+    if (X < 15) {
+      for (let K = 1, G = Q + 1;K < X; ++K, ++G)
+        if (V.charCodeAt(K) !== v.charCodeAt(G))
+          return null;
+    } else if (v.slice(Q, J) !== V)
+      return null;
+  }
+  if (J === b) {
+    if (A.store !== null)
+      return { store: A.store, params: {} };
+    if (A.wildcardStore !== null)
+      return { store: A.wildcardStore, params: { "*": "" } };
+    return null;
+  }
+  if (A.inert !== null) {
+    let K = A.inert[v.charCodeAt(J)];
+    if (K !== undefined) {
+      let G = $(v, b, K, J, O);
+      if (G !== null)
+        return G;
+    }
+  }
+  if (A.params !== null) {
+    let { store: K, name: G, inert: q } = A.params, U = v.indexOf("/", J);
+    if (U !== J) {
+      if (U === -1 || U >= b) {
+        if (K !== null) {
+          let F = {};
+          if (F[G] = v.substring(J, b), O)
+            for (let B = 0;B < O.length; B++) {
+              let D = O[B](F[G], G);
+              if (D !== undefined)
+                F[G] = D;
+            }
+          return { store: K, params: F };
+        }
+      } else if (q !== null) {
+        let F = $(v, b, q, U, O);
+        if (F !== null) {
+          if (F.params[G] = v.substring(J, U), O)
+            for (let B = 0;B < O.length; B++) {
+              let D = O[B](F.params[G], G);
+              if (D !== undefined)
+                F.params[G] = D;
+            }
+          return F;
+        }
+      }
+    }
+  }
+  if (A.wildcardStore !== null)
+    return { store: A.wildcardStore, params: { "*": v.substring(J, b) } };
+  return null;
+};
+var w = _;
+
+// src/Router/adapters/MemoiristAdapter.ts
+class MemoiristAdapter {
+  router = new w;
+  pendingMiddlewares = new Map;
+  find(req) {
+    const method = req.method;
+    const pathname = req.urlObject.pathname;
+    const searchParams = req.urlObject.searchParams;
+    const result = this.router.find(method, pathname);
+    if (!result)
+      return null;
+    return {
+      route: result.store.route,
+      model: result.store.model,
+      params: result.params,
+      search: Object.fromEntries(searchParams),
+      middleware: compile(result.store.middlewares ?? [])
+    };
+  }
+  list() {
+    return this.router.history.map((v) => v[2].route);
+  }
+  addRoute(data) {
+    this.router.add(data.method, data.endpoint, { route: data });
+    const pending = this.pendingMiddlewares.get(data.id);
+    if (pending) {
+      const store = this.router.find(data.method, data.endpoint)?.store;
+      if (store)
+        store.middlewares = pending;
+      this.pendingMiddlewares.delete(data.id);
+    }
+  }
+  addModel(route, model) {
+    const result = this.router.find(route.method, route.endpoint);
+    if (!result)
+      return;
+    result.store.model = ModelRegistry.toRouterModelData(model);
+  }
+  addMiddleware(middleware) {
+    const resolved = MiddlewareRegistry.resolveRouteIds(middleware);
+    if (resolved.isGlobal) {
+      for (const [, , store] of this.router.history) {
+        store.middlewares = [...store.middlewares ?? [], middleware.handler];
+      }
+      return;
+    }
+    for (const routeId of resolved.routeIds) {
+      const [method, endpoint] = routeId.split(" ", 2);
+      const result = this.router.find(method, endpoint);
+      if (result) {
+        result.store.middlewares = [
+          ...result.store.middlewares ?? [],
+          middleware.handler
+        ];
+      } else {
+        const pending = this.pendingMiddlewares.get(routeId) ?? [];
+        this.pendingMiddlewares.set(routeId, [...pending, middleware.handler]);
+      }
+    }
+  }
+}
+// src/index.ts
+var _prefixStore = new GlobalPrefixStore;
+var _routerStore = new GlobalRouterStore;
+var _corsStore = new GlobalCorsStore;
+})