@ozanarslan/corpus 0.1.6 → 0.1.10

package/dist/index.cjs

@@ -60,41 +60,9 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// 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
+// src/store/StoreAbstract.ts
 class StoreAbstract {
   set(value) {
     this.value = value;
@@ -104,231 +72,178 @@ class StoreAbstract {
   }
 }
 
-// src/Store/globals/GlobalPrefixStore.ts
-class GlobalPrefixStore extends StoreAbstract {
-  value = "";
-}
+// src/store/GlobalPrefixStore.ts
+var GlobalPrefixStore;
+var init_GlobalPrefixStore = __esm(() => {
+  GlobalPrefixStore = 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/utils/internalLogger.ts
+function makeLog() {
+  const log = console;
+  log.success = (...args) => console.log("\u2705", ...args);
+  log.fatal = (...args) => {
+    console.error("\uD83D\uDC80", ...args);
+    process.exit(1);
+  };
+  return log;
 }
-
-// src/Store/globals/GlobalCorsStore.ts
-class GlobalCorsStore extends StoreAbstract {
-  value = null;
+function logFatal(...args) {
+  console.error(...args);
+  process.exit(1);
 }
-
-// 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
+var log;
+var init_internalLogger = __esm(() => {
+  log = makeLog();
 });
 
-// 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;
+// src/store/GlobalRouterStore.ts
+var GlobalRouterStore;
+var init_GlobalRouterStore = __esm(() => {
+  init_internalLogger();
+  GlobalRouterStore = class GlobalRouterStore extends StoreAbstract {
+    value = null;
+    get() {
+      if (!this.value) {
+        logFatal("Router instance is not set. Please instantiate your Server before your routes.");
+      }
+      return this.value;
     }
-    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
-};
+var Status;
+var init_Status = __esm(() => {
+  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"
-};
+var DefaultStatusTexts;
+var init_DefaultStatusTexts = __esm(() => {
+  init_Status();
+  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"
-};
+var CommonHeaders;
+var init_CommonHeaders = __esm(() => {
+  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",
+    Upgrade: "Upgrade",
+    Pragma: "Pragma",
+    Date: "Date",
+    IfNoneMatch: "If-None-Match",
+    IfModifiedSince: "If-Modified-Since",
+    ETag: "ETag",
+    Expires: "Expires",
+    LastModified: "Last-Modified",
+    Location: "Location",
+    WWWAuthenticate: "WWW-Authenticate",
+    AccessControlMaxAge: "Access-Control-Max-Age",
+    AccessControlAllowCredentials: "Access-Control-Allow-Credentials",
+    AccessControlRequestMethod: "Access-Control-Request-Method",
+    AccessControlExposeHeaders: "Access-Control-Expose-Headers",
+    AccessControlAllowOrigin: "Access-Control-Allow-Origin",
+    AccessControlAllowMethods: "Access-Control-Allow-Methods",
+    AccessControlAllowHeaders: "Access-Control-Allow-Headers",
+    SetCookie: "Set-Cookie",
+    Cookie: "Cookie"
+  };
+});
 
 // src/Cookies/CookiesAbstract.ts
 class CookiesAbstract {
+  constructor(_) {}
   applyInit(init) {
     if (!init)
       return;
@@ -341,108 +256,314 @@ class CookiesAbstract {
       for (const opts of init) {
         this.set(opts);
       }
-    } else {
+    } else if ("name" in init && "value" in init) {
       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);
+// src/Cookies/Cookies.bun.ts
+var exports_Cookies_bun = {};
+__export(exports_Cookies_bun, {
+  default: () => CookiesUsingBun
+});
+var CookiesUsingBun;
+var init_Cookies_bun = __esm(() => {
+  CookiesUsingBun = 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/utils/strIsDefined.ts
+function strIsDefined(input) {
+  return !!input?.trim() && typeof input === "string";
+}
+
+// src/utils/strAfterMark.ts
+function strAfterMark(mark, input) {
+  const index = input.indexOf(mark);
+  return index === -1 ? "" : input.slice(index + mark.length);
+}
+
+// src/utils/strBeforeMark.ts
+function strBeforeMark(mark, input) {
+  const index = input.indexOf(mark);
+  return index === -1 ? input : input.slice(0, index);
+}
+
+// src/utils/strCapitalize.ts
+function strCapitalize(input) {
+  return input.length > 0 ? input.split(" ").map((part) => part.charAt(0).toLocaleUpperCase() + input.slice(1)).join(" ") : input;
+}
+
+// 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);
   }
-  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/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;
 }
+var init_strSplit = () => {};
+
+// src/Cookies/Cookies.node.ts
+var exports_Cookies_node = {};
+__export(exports_Cookies_node, {
+  default: () => CookiesUsingMap
+});
+var CookiesUsingMap;
+var init_Cookies_node = __esm(() => {
+  init_strSplit();
+  init_internalLogger();
+  CookiesUsingMap = class CookiesUsingMap extends CookiesAbstract {
+    constructor(init) {
+      super(init);
+      this.applyInit(init);
+    }
+    map = new Map;
+    toSetCookieHeaders() {
+      return Array.from(this.map.values());
+    }
+    set(opts) {
+      this.map.set(opts.name, this.createHeader(opts));
+    }
+    setMany(optsArr) {
+      for (const opts of optsArr) {
+        this.set(opts);
+      }
+    }
+    get(name) {
+      const cookieString = this.map.get(name);
+      if (!cookieString)
+        return null;
+      const value = this.extractValue(cookieString);
+      return strIsDefined(value) ? value : null;
+    }
+    has(name) {
+      const has = this.map.has(name);
+      if (!has)
+        return false;
+      const value = this.get(name);
+      return !!value;
+    }
+    get count() {
+      return this.values().filter((value) => strIsDefined(value)).length;
+    }
+    delete(name) {
+      const cookieString = this.map.get(name);
+      if (!cookieString)
+        return;
+      const opts = this.extractOptions(cookieString);
+      this.set({ ...opts, value: "", expires: new Date(0) });
+    }
+    entries() {
+      return this.map.entries();
+    }
+    values() {
+      return Array.from(this.map.values()).map((cookieString) => this.extractValue(cookieString));
+    }
+    keys() {
+      return Array.from(this.map.keys());
+    }
+    extractValue(cookieString) {
+      const encodedRest = strAfterMark("=", cookieString);
+      if (!strIsDefined(encodedRest))
+        return "";
+      const encodedValue = strBeforeMark(";", encodedRest);
+      return decodeURIComponent(encodedValue);
+    }
+    extractOptions(cookieString) {
+      const keyMap = {
+        Domain: "domain",
+        Path: "path",
+        Expires: "expires",
+        Secure: "secure",
+        SameSite: "sameSite",
+        HttpOnly: "httpOnly",
+        Partitioned: "partitioned",
+        "Max-Age": "maxAge"
+      };
+      const opts = {};
+      const first = strBeforeMark(";", cookieString).trim();
+      const rest = strAfterMark(";", cookieString).trim();
+      const [name, value] = strSplit("=", first);
+      opts["name"] = name;
+      opts["value"] = value;
+      for (const part of strSplit(";", rest)) {
+        if (part.includes("=")) {
+          const [key, val] = strSplit("=", part, 2);
+          if (!key || !keyMap[key]) {
+            log.warn(`cookie extracting and ${key} is not a cookie key`);
+            continue;
+          }
+          opts[keyMap[key]] = val;
+        } else {
+          if (!keyMap[part]) {
+            log.warn(`cookie extracting and ${part} is not a cookie key`);
+            continue;
+          }
+          opts[keyMap[part]] = true;
+        }
+      }
+      return opts;
+    }
+    createHeader(opts) {
+      let result = `${encodeURIComponent(opts.name)}=${encodeURIComponent(opts.value)}`;
+      if (strIsDefined(opts.domain)) {
+        result += `; Domain=${opts.domain}`;
+      }
+      if (strIsDefined(opts.path)) {
+        result += `; Path=${opts.path}`;
+      } else {
+        result += `; Path=/`;
+      }
+      if (opts.expires) {
+        if (typeof opts.expires === "number") {
+          result += `; Expires=${new Date(opts.expires).toUTCString()}`;
+        } else {
+          result += `; Expires=${opts.expires.toUTCString()}`;
+        }
+      }
+      if (opts.maxAge && Number.isInteger(opts.maxAge)) {
+        result += `; Max-Age=${opts.maxAge}`;
+      }
+      if (opts.secure === true) {
+        result += "; Secure";
+      }
+      if (opts.httpOnly === true) {
+        result += "; HttpOnly";
+      }
+      if (opts.partitioned === true) {
+        result += "; Partitioned";
+      }
+      if (strIsDefined(opts.sameSite)) {
+        result += `; SameSite=${strCapitalize(opts.sameSite)}`;
+      } else {
+        result += `; SameSite=Lax`;
+      }
+      return result;
+    }
+  };
+});
 
 // src/Cookies/Cookies.ts
-class Cookies extends CookiesUsingBun {
-}
+var Adapted, Cookies;
+var init_Cookies = __esm(() => {
+  Adapted = (typeof Bun !== "undefined" ? (init_Cookies_bun(), __toCommonJS(exports_Cookies_bun)) : (init_Cookies_node(), __toCommonJS(exports_Cookies_node))).default;
+  Cookies = class Cookies extends Adapted {
+  };
+});
 
 // 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);
+var CHeaders;
+var init_CHeaders = __esm(() => {
+  CHeaders = class CHeaders extends Headers {
+    constructor(init) {
+      super(init);
+    }
+    append(name, value) {
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          super.append(name, v);
+        }
       } else {
-        target.set(key, value);
+        super.append(name, 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;
+    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) {
@@ -460,50 +581,38 @@ function isPlainObject(input) {
 }
 
 // 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);
-  }
-}
+var CError;
+var init_CError = __esm(() => {
+  init_CResponse();
+  CError = class CError extends Error {
+    message;
+    status;
+    data;
+    constructor(message, status, data) {
+      super(message);
+      this.message = message;
+      this.status = status;
+      this.data = data;
+    }
+    toResponse() {
+      if (this.data instanceof CResponse) {
+        this.data.status = this.status;
+        return this.data;
+      }
+      return new CResponse({ error: this.data ?? true, message: this.message }, { status: this.status });
+    }
+    isStatusOf(status) {
+      return this.status === status;
+    }
+  };
+});
 
 // src/XFile/XFileAbstract.ts
 class XFileAbstract {
   path;
   fallbackExtension;
-  constructor(path2, fallbackExtension) {
-    this.path = path2;
+  constructor(path, fallbackExtension) {
+    this.path = path;
     this.fallbackExtension = fallbackExtension;
   }
   get name() {
@@ -542,27 +651,73 @@ class XFileAbstract {
   }
 }
 
-// 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.bun.ts
+var exports_XFile_bun = {};
+__export(exports_XFile_bun, {
+  default: () => XFileUsingBun
+});
+var XFileUsingBun;
+var init_XFile_bun = __esm(() => {
+  XFileUsingBun = 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.node.ts
+var exports_XFile_node = {};
+__export(exports_XFile_node, {
+  default: () => XFileUsingNode
+});
+var import_node_fs, XFileUsingNode;
+var init_XFile_node = __esm(() => {
+  import_node_fs = __toESM(require("fs"));
+  XFileUsingNode = class XFileUsingNode extends XFileAbstract {
+    async exists() {
+      return import_node_fs.default.existsSync(this.path);
+    }
+    async text() {
+      return import_node_fs.default.readFileSync(this.path, "utf-8");
+    }
+    stream() {
+      const nodeStream = import_node_fs.default.createReadStream(this.path);
+      const encoder = new TextEncoder;
+      return new ReadableStream({
+        start(controller) {
+          nodeStream.on("data", (chunk) => {
+            controller.enqueue(typeof chunk === "string" ? encoder.encode(chunk) : new Uint8Array(chunk));
+          });
+          nodeStream.on("end", () => controller.close());
+          nodeStream.on("error", (err) => controller.error(err));
+        },
+        cancel() {
+          nodeStream.destroy();
+        }
+      });
+    }
+  };
+});
 
 // src/XFile/XFile.ts
-class XFile extends XFileUsingBun {
-}
+var Adapted2, XFile;
+var init_XFile = __esm(() => {
+  Adapted2 = (typeof Bun !== "undefined" ? (init_XFile_bun(), __toCommonJS(exports_XFile_bun)) : (init_XFile_node(), __toCommonJS(exports_XFile_node))).default;
+  XFile = class XFile extends Adapted2 {
+  };
+});
+
 // src/CResponse/CResponse.ts
 class CResponse {
   data;
@@ -574,7 +729,7 @@ class CResponse {
     this.headers = this.resolveHeaders();
     this.body = this.resolveBody();
     this.status = this.resolveStatus();
-    this.statusText = this.getDefaultStatusText();
+    this.statusText = CResponse.getDefaultStatusText(this.status);
   }
   body;
   headers;
@@ -582,6 +737,12 @@ class CResponse {
   statusText;
   cookies;
   get response() {
+    const setCookieHeaders = this.cookies.toSetCookieHeaders();
+    if (setCookieHeaders.length > 0) {
+      for (const header of setCookieHeaders) {
+        this.headers.append(CommonHeaders.SetCookie, header);
+      }
+    }
     return new Response(this.body, {
       status: this.status,
       statusText: this.statusText,
@@ -679,8 +840,9 @@ class CResponse {
   }
   static async streamFile(filePath, disposition = "attachment", init) {
     const file = new XFile(filePath);
-    if (!file) {
-      throw CError.notFound();
+    const exists = await file.exists();
+    if (!exists) {
+      throw new CError(Status.NOT_FOUND.toString(), Status.NOT_FOUND, new CResponse({ filePath }, init));
     }
     const stream = file.stream();
     const res = new CResponse(stream, { ...init, status: Status.OK });
@@ -692,8 +854,9 @@ class CResponse {
   }
   static async file(filePath, init) {
     const file = new XFile(filePath);
-    if (!file) {
-      throw CError.notFound();
+    const exists = await file.exists();
+    if (!exists) {
+      throw new CError(Status.NOT_FOUND.toString(), Status.NOT_FOUND, new CResponse({ filePath }, init));
     }
     const content = await file.text();
     const res = new CResponse(content, init);
@@ -704,17 +867,10 @@ class CResponse {
     return res;
   }
   resolveCookies() {
-    return new Cookies(this.init?.cookies);
+    return this.init?.cookies instanceof Cookies ? this.init.cookies : 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;
+    return new CHeaders(this.init?.headers);
   }
   resolveStatus() {
     if (this.init?.status)
@@ -769,24 +925,36 @@ class CResponse {
     this.setContentType("text/plain");
     return String(this.data);
   }
-  getDefaultStatusText() {
-    const key = this.status;
+  static getDefaultStatusText(status) {
+    const key = status;
     return DefaultStatusTexts[key] ?? "Unknown";
   }
 }
+var init_CResponse = __esm(() => {
+  init_DefaultStatusTexts();
+  init_Status();
+  init_CommonHeaders();
+  init_Cookies();
+  init_CHeaders();
+  init_CError();
+  init_XFile();
+});
 
 // 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"
-};
+var Method;
+var init_Method = __esm(() => {
+  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) {
@@ -808,15 +976,15 @@ function objAppendEntry(data, key, value) {
   }
 }
 
-// src/Model/Parser.ts
-class Parser {
+// src/Model/XParser.ts
+class XParser {
   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);
+      throw new CError(msg, Status.UNPROCESSABLE_ENTITY, data);
     }
     return result.value;
   }
@@ -844,7 +1012,7 @@ class Parser {
     const empty = {};
     const input = r instanceof Request ? r : r instanceof Response ? r : r.response;
     try {
-      switch (Parser.getNormalizedContentType(input)) {
+      switch (XParser.getNormalizedContentType(input)) {
         case "json":
           data = await this.getJsonBody(input);
           break;
@@ -965,6 +1133,12 @@ class Parser {
     return "unknown";
   }
 }
+var init_XParser = __esm(() => {
+  init_Status();
+  init_Method();
+  init_CommonHeaders();
+  init_CError();
+});
 
 // src/Context/Context.ts
 class Context {
@@ -990,67 +1164,35 @@ class Context {
   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);
+  static async appendParsedData(ctx, req, data) {
+    ctx.body = await XParser.parseBody(req, data.route.model?.body);
+    ctx.params = await XParser.parseUrlData(data.params, data.route.model?.params);
+    ctx.search = await XParser.parseUrlData(data.search, data.route.model?.search);
   }
 }
-// src/Route/enums/RouteVariant.ts
-var RouteVariant = {
-  static: "static",
-  dynamic: "dynamic"
-};
+var init_Context = __esm(() => {
+  init_CResponse();
+  init_XParser();
+});
 
-// 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/enums/RouteVariant.ts
+var RouteVariant;
+var init_RouteVariant = __esm(() => {
+  RouteVariant = {
+    static: "static",
+    dynamic: "dynamic",
+    websocket: "websocket"
+  };
+});
 
 // 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);
+    return RouteAbstract.makeRoutePattern(endpoint);
   }
   resolveId(method, endpoint) {
-    return Route.makeRouteId(method, endpoint);
+    return RouteAbstract.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}`;
   }
@@ -1060,56 +1202,105 @@ class Route extends RouteAbstract {
   }
 }
 
+// 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/DynamicRoute.ts
+var DynamicRoute;
+var init_DynamicRoute = __esm(() => {
+  init_Method();
+  init_src();
+  init_RouteVariant();
+  DynamicRoute = class DynamicRoute extends RouteAbstract {
+    constructor(definition, handler, model) {
+      super();
+      this.endpoint = this.resolveEndpoint(definition);
+      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);
+    }
+    id;
+    method;
+    endpoint;
+    pattern;
+    handler;
+    model;
+    variant = RouteVariant.dynamic;
+    resolveEndpoint(definition) {
+      return joinPathSegments($prefixStore.get(), typeof definition === "string" ? definition : definition.path);
+    }
+    resolveMethod(definition) {
+      return typeof definition === "string" ? Method.GET : definition.method;
+    }
+  };
+});
+
 // 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);
+var StaticRoute;
+var init_StaticRoute = __esm(() => {
+  init_Method();
+  init_CResponse();
+  init_src();
+  init_CError();
+  init_RouteVariant();
+  init_XFile();
+  init_Status();
+  init_CommonHeaders();
+  StaticRoute = class StaticRoute extends RouteAbstract {
+    constructor(path, definition, handler, model) {
+      super();
+      this.endpoint = path;
+      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;
+    method;
+    endpoint;
+    pattern;
+    handler;
+    model;
+    filePath;
+    variant = RouteVariant.static;
+    resolveFilePath(definition) {
+      return typeof definition === "string" ? definition : definition.filePath;
+    }
+    resolveHandler(definition, customHandler) {
+      if (customHandler !== undefined) {
+        return async (c) => {
+          const file = new XFile(this.filePath);
+          const exists = await file.exists();
+          if (!exists) {
+            throw new CError(Status.NOT_FOUND.toString(), Status.NOT_FOUND);
+          }
+          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 {
+// src/Controller/Controller.ts
+class Controller {
   constructor(opts) {
     this.prefix = opts?.prefix;
     this.beforeEach = opts?.beforeEach;
@@ -1118,8 +1309,10 @@ class ControllerAbstract {
   prefix;
   beforeEach;
   route(...args) {
-    const [definition, handler, model] = args;
-    const route = new Route(this.resolveRouteDefinition(definition), async (ctx) => {
+    const [def, handler, model] = args;
+    const method = typeof def === "string" ? Method.GET : def.method;
+    const path = joinPathSegments(this.prefix, typeof def === "string" ? def : def.path);
+    const route = new DynamicRoute({ method, path }, async (ctx) => {
       await this.beforeEach?.(ctx);
       return handler(ctx);
     }, model);
@@ -1127,120 +1320,223 @@ class ControllerAbstract {
     return route;
   }
   staticRoute(...args) {
-    const [path2, filePath, handler, model] = args;
-    const route = new StaticRoute(joinPathSegments(this.prefix, path2), filePath, handler, model);
+    const [path, filePath, handler, model] = args;
+    const route = new StaticRoute(joinPathSegments(this.prefix, path), 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);
-  }
 }
+var init_Controller = __esm(() => {
+  init_DynamicRoute();
+  init_StaticRoute();
+  init_Method();
+});
 
-// 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/Middleware/MiddlewareAbstract.ts
+class MiddlewareAbstract {
 }
 
+// src/Middleware/enums/MiddlewareVariant.ts
+var MiddlewareVariant;
+var init_MiddlewareVariant = __esm(() => {
+  MiddlewareVariant = {
+    inbound: "inbound",
+    outbound: "outbound"
+  };
+});
+
+// src/Middleware/Middleware.ts
+var Middleware;
+var init_Middleware = __esm(() => {
+  init_src();
+  init_MiddlewareVariant();
+  Middleware = class Middleware extends MiddlewareAbstract {
+    constructor(opts) {
+      super();
+      this.variant = opts.variant ?? MiddlewareVariant.inbound;
+      this.useOn = opts.useOn;
+      this.handler = opts.handler;
+      $routerStore.get().addMiddleware(this);
+    }
+    variant;
+    useOn;
+    handler;
+  };
+});
+
 // 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();
+var CRequest;
+var init_CRequest = __esm(() => {
+  init_Method();
+  init_CommonHeaders();
+  init_Cookies();
+  init_CHeaders();
+  init_strSplit();
+  CRequest = 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();
+      this.isWebsocket = this.resolveIsWebsocketUpgrade();
+    }
+    urlObject;
+    isPreflight;
+    isWebsocket;
+    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() {
+      return this.method === Method.OPTIONS && this.headers.has(CommonHeaders.AccessControlRequestMethod);
+    }
+    resolveIsWebsocketUpgrade() {
+      const isUpgrade = this.headers.get(CommonHeaders.Connection)?.toLowerCase() === "upgrade";
+      const isWebsocket = this.headers.get(CommonHeaders.Upgrade)?.toLowerCase() === "websocket";
+      return isUpgrade && isWebsocket;
+    }
+  };
+});
+
+// src/Route/WebSocketRoute.ts
+var WebSocketRoute;
+var init_WebSocketRoute = __esm(() => {
+  init_src();
+  init_Method();
+  init_RouteVariant();
+  WebSocketRoute = class WebSocketRoute extends RouteAbstract {
+    constructor(path, definition) {
+      super();
+      this.endpoint = path;
+      this.method = Method.GET;
+      this.pattern = this.resolvePattern(this.endpoint);
+      this.id = this.resolveId(this.method, this.endpoint);
+      this.onOpen = definition.onOpen;
+      this.onClose = definition.onClose;
+      this.onMessage = definition.onMessage;
+      $routerStore.get().addRoute(this);
+    }
+    id;
+    method;
+    endpoint;
+    pattern;
+    model = undefined;
+    handler = () => this;
+    variant = RouteVariant.websocket;
+    onOpen;
+    onClose;
+    onMessage;
+  };
+});
+
+// src/XConfig/XConfig.ts
+class XConfig {
+  static get runtime() {
+    if (typeof Bun !== "undefined") {
+      return "bun";
+    }
+    if (typeof process !== "undefined" && process?.env) {
+      return "node";
+    }
+    log.warn("\u26A0\uFE0F Runtime isn't Bun or NodeJS. Features may not be available. App might not start.");
+    return "unknown";
   }
-  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;
+  static get nodeEnv() {
+    return this.env.NODE_ENV ?? "development";
+  }
+  static get env() {
+    switch (this.runtime) {
+      case "bun":
+        return Bun.env;
+      case "node":
+        return process.env;
       default:
-        urlObject = new URL(this.info);
-        break;
-    }
-    if (!urlObject.pathname) {
-      urlObject.pathname += "/";
+        log.warn("\u26A0\uFE0F process.env wasn't available. Your environment variables are in memory.");
+        return {};
     }
-    return urlObject;
   }
-  resolveHeaders() {
-    if (this.init?.headers !== undefined) {
-      return new CHeaders(this.init.headers);
+  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 (this.info instanceof Request || this.info instanceof CRequest) {
-      return new CHeaders(this.info.headers);
+    if (opts?.fallback !== undefined) {
+      return opts?.fallback;
     }
-    return new CHeaders;
+    log.warn(`${key} doesn't exist in env`);
+    return;
   }
-  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 });
-      }
+  static set(key, value) {
+    if (typeof value === "number") {
+      this.env[key] = value.toString();
+      return;
     }
-    return jar;
-  }
-  resolveIsPreflight() {
-    const accessControlRequestMethodHeader = this.headers.has(CommonHeaders.AccessControlRequestMethod);
-    return this.method === Method.OPTIONS && accessControlRequestMethodHeader;
+    if (typeof value === "boolean") {
+      this.env[key] = value ? "true" : "false";
+      return;
+    }
+    this.env[key] = value;
   }
 }
+var import_path;
+var init_XConfig = __esm(() => {
+  init_internalLogger();
+  import_path = __toESM(require("path"));
+});
+
 // src/utils/isRegexMatch.ts
 function isRegexMatch(source, pattern) {
   return pattern.test(source);
@@ -1259,134 +1555,21 @@ function strIsEqual(source, target, modifier) {
   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) {
+  add(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 (method !== data.method)
+        continue;
       if (this.hasAnyParam(data.endpoint) && isRegexMatch(pathname, data.pattern)) {
         route = data;
         break;
@@ -1401,15 +1584,10 @@ class CorpusAdapter {
       }
     }
     if (route === null) {
-      throw CError.notFound();
-    }
-    if (!strIsEqual(method, route.method, "upper")) {
-      throw CError.methodNotAllowed();
+      return null;
     }
     return {
       route,
-      model: this.modelRegistry.find(route.id),
-      middleware: this.middlewareRegistry.find(route.id),
       params: this.extractParams(pathname, route.endpoint),
       search: Object.fromEntries(searchParams)
     };
@@ -1418,10 +1596,10 @@ class CorpusAdapter {
     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 dupeMsg = (nId) => log.error(`Duplicate route detected. ${nId} has already been registered.`);
+    const dynamicPatternMsg = (nId, oId) => log.error(`Ambiguous dynamic routes. ${nId} and ${oId} match the same URL patterns.`);
+    const baseDupeMsg = (nId, oId) => log.error(`Dynamic route overlaps existing route. ${nId} \u2014 dropping the last param segment matches ${oId}.`);
+    const shadowMsg = (nId, oId) => log.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);
@@ -1446,7 +1624,7 @@ class CorpusAdapter {
       }
       const oHasLastPartParam = this.hasLastPartParam(o.endpoint);
       if (oHasLastPartParam) {
-        if (isRegexMatch(n.endpoint, Route.makeRoutePattern(this.removeLastParam(o.endpoint)))) {
+        if (isRegexMatch(n.endpoint, DynamicRoute.makeRoutePattern(this.removeLastParam(o.endpoint)))) {
           shadowMsg(n.id, o.id);
           return true;
         }
@@ -1485,202 +1663,616 @@ class CorpusAdapter {
     return endpoint.split("/").some((p) => p.startsWith(":"));
   }
 }
+var init_CorpusAdapter = __esm(() => {
+  init_DynamicRoute();
+  init_internalLogger();
+});
 
-// src/Router/Router.ts
-class Router {
-  constructor(adapter) {
-    this._adapter = adapter ?? new CorpusAdapter;
+// src/utils/LazyMap.ts
+var LazyMap;
+var init_LazyMap = __esm(() => {
+  LazyMap = 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/compile.ts
+function compile(fns) {
+  return async (...args) => {
+    for (const fn of fns) {
+      if (!fn)
+        continue;
+      const result = await fn(...args);
+      if (result !== undefined)
+        return result;
+    }
+  };
+}
+
+// src/Router/registries/MiddlewareRegistry.ts
+class MiddlewareRegistry {
+  inboundMiddlewares = new LazyMap;
+  outboundMiddlewares = new LazyMap;
+  add(middleware) {
+    const resolved = MiddlewareRegistry.resolveRouteIds(middleware);
+    const map = resolved.variant === MiddlewareVariant.inbound ? this.inboundMiddlewares : this.outboundMiddlewares;
+    if (resolved.isGlobal) {
+      const existing = map.get("*") ?? [];
+      map.set("*", [...existing, middleware.handler]);
+      return;
+    }
+    for (const routeId of resolved.routeIds) {
+      const existing = map.get(routeId) ?? [];
+      map.set(routeId, [...existing, middleware.handler]);
+    }
   }
-  models = [];
-  _adapter;
-  cache = new WeakMap;
-  checkPossibleCollision(n) {
-    if (this._adapter instanceof CorpusAdapter) {
-      return this._adapter.checkPossibleCollision(n);
+  find(routeId) {
+    return {
+      inbound: compile(this.inboundMiddlewares.get(routeId) ?? []),
+      outbound: compile(this.outboundMiddlewares.get(routeId) ?? [])
+    };
+  }
+  static resolveRouteIds(m) {
+    if (m.useOn === "*")
+      return { isGlobal: true, variant: m.variant };
+    const targets = Array.isArray(m.useOn) ? m.useOn : [m.useOn];
+    const routeIds = [];
+    for (const target of targets) {
+      if (target instanceof DynamicRoute) {
+        routeIds.push(target.id);
+      } else if (target instanceof Controller) {
+        routeIds.push(...target.routeIds);
+      }
     }
-    return false;
+    return { isGlobal: false, routeIds, variant: m.variant };
   }
-  addModel(route, model) {
-    this.models.push(model);
-    this._adapter.addModel(route, model);
+}
+var init_MiddlewareRegistry = __esm(() => {
+  init_Controller();
+  init_DynamicRoute();
+  init_LazyMap();
+  init_MiddlewareVariant();
+});
+
+// src/utils/internFunc.ts
+function internFunc(map, value, ...namespace) {
+  const key = namespace.join("::");
+  const existing = map.get(key);
+  if (existing)
+    return existing;
+  map.set(key, value);
+  return value;
+}
+
+// src/utils/strRemoveWhitespace.ts
+function strRemoveWhitespace(str) {
+  return str.trim().replace(/\s+/g, "");
+}
+
+// src/utils/objGetKeys.ts
+function objGetKeys(obj) {
+  return Object.keys(obj);
+}
+
+// src/Router/Router.ts
+class Router {
+  adapter;
+  constructor(adapter = new CorpusAdapter) {
+    this.adapter = adapter;
   }
+  middlewareRegistry = new MiddlewareRegistry;
+  cache = new WeakMap;
+  internFuncMap = new LazyMap;
   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
-    });
+    this.middlewareRegistry.add(middleware);
   }
-  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
-      });
+  findMiddleware(id) {
+    return this.middlewareRegistry.find(id);
+  }
+  addRoute(route) {
+    const data = {
+      id: route.id,
+      endpoint: route.endpoint,
+      method: route.method,
+      handler: route.handler,
+      pattern: route.pattern,
+      variant: route.variant
     };
-    this.cache.set(req, handler);
-    return handler;
+    if (route.model) {
+      const modelData = {};
+      for (const key of objGetKeys(route.model)) {
+        if (key === "response")
+          continue;
+        const schema = route.model[key];
+        if (!schema)
+          continue;
+        modelData[key] = internFunc(this.internFuncMap, schema["~standard"].validate, "model", strRemoveWhitespace(JSON.stringify(schema)));
+      }
+      data.model = modelData;
+    }
+    this.adapter.add(data);
+  }
+  findRoute(req) {
+    const match = this.cache.get(req) ?? this.adapter.find(req);
+    if (!match)
+      return null;
+    this.cache.set(req, match);
+    return match;
   }
   getRouteList() {
-    return this._adapter.list().map((v) => [v.method, v.endpoint]);
+    return this.adapter.list().map((v) => [v.method, v.endpoint]);
   }
 }
+var init_Router = __esm(() => {
+  init_CorpusAdapter();
+  init_MiddlewareRegistry();
+  init_LazyMap();
+});
 
 // src/Server/ServerAbstract.ts
 class ServerAbstract {
   opts;
   constructor(opts) {
     this.opts = opts;
-    _routerStore.set(new Router(opts?.adapter));
+    $routerStore.set(new Router(opts?.adapter));
   }
   get routes() {
-    return _routerStore.get().getRouteList();
+    return $routerStore.get().getRouteList();
   }
   setGlobalPrefix(value) {
-    _prefixStore.set(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}`);
+      log.log(`Listening on ${hostname}:${port}`);
       await this.handleBeforeListen?.();
       this.serve({
         port,
-        hostname,
-        fetch: (r) => this.handle(r)
+        hostname
       });
     } catch (err) {
-      console.error("Server unable to start:", err);
+      log.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);
+  }
+  async handle(request) {
+    const req = new CRequest(request);
+    const handled = await this.handleRequest(req, () => {
+      return;
+    });
+    if (!handled) {
+      logFatal("WebSocket requests cannot be handled with this method.");
+    }
+    return handled.response;
+  }
+  async handleRequest(req, onUpgrade) {
+    try {
+      if (req.isPreflight) {
+        return await this.handlePreflight(req);
+      }
+      const router = $routerStore.get();
+      const ctx = Context.makeFromRequest(req);
+      const gmw = router.findMiddleware("*");
+      const gmwir = await gmw.inbound(ctx);
+      if (gmwir instanceof CResponse) {
+        return gmwir;
+      }
+      const match = router.findRoute(req);
+      if (!match) {
+        ctx.res = await this.handleNotFound(req);
+      } else {
+        const lmw = router.findMiddleware(match.route.id);
+        const lmwir = await lmw.inbound(ctx);
+        if (lmwir instanceof CResponse) {
+          return lmwir;
+        }
+        await Context.appendParsedData(ctx, req, match);
+        const mr = await match.route.handler(ctx);
+        if (mr instanceof WebSocketRoute && req.isWebsocket) {
+          return onUpgrade(mr);
+        } else if (mr instanceof CResponse) {
+          ctx.res = mr;
+        } else {
+          ctx.res = new CResponse(mr, ctx.res);
+        }
+        const lmwor = await lmw.outbound(ctx);
+        if (lmwor instanceof CResponse) {
+          return lmwor;
+        }
+      }
+      const gmwor = await gmw.outbound(ctx);
+      if (gmwor instanceof CResponse) {
+        return gmwor;
+      }
+      return ctx.res;
+    } catch (err) {
+      return await this.handleError(err);
+    }
+  }
+  handleBeforeListen;
+  setOnBeforeListen(handler) {
+    this.handleBeforeListen = handler;
+  }
+  defaultOnBeforeListen = undefined;
+  handleBeforeClose;
+  setOnBeforeClose(handler) {
+    this.handleBeforeClose = handler;
+  }
+  defaultOnBeforeClose = undefined;
+  handleError = (err) => this.defaultErrorHandler(err);
+  setOnError(handler) {
+    this.handleError = handler;
+  }
+  defaultErrorHandler = (err) => {
+    if (err instanceof CError) {
+      return err.toResponse();
+    }
+    return new CResponse({ error: err, message: "message" in err ? err.message : "Unknown" }, { 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 });
+  };
+  handlePreflight = (req) => this.defaultPreflightHandler(req);
+  setOnPreflight(handler) {
+    this.handlePreflight = handler;
+  }
+  defaultPreflightHandler = () => {
+    return new CResponse("Departed");
+  };
+}
+var init_ServerAbstract = __esm(() => {
+  init_Context();
+  init_Status();
+  init_src();
+  init_CError();
+  init_CRequest();
+  init_CResponse();
+  init_Router();
+  init_internalLogger();
+  init_WebSocketRoute();
+});
+
+// src/Server/Server.bun.ts
+var exports_Server_bun = {};
+__export(exports_Server_bun, {
+  default: () => ServerUsingBun
+});
+var ServerUsingBun;
+var init_Server_bun = __esm(() => {
+  init_XConfig();
+  init_CRequest();
+  init_Status();
+  init_ServerAbstract();
+  init_internalLogger();
+  init_CError();
+  ServerUsingBun = class ServerUsingBun extends ServerAbstract {
+    app;
+    serve(args) {
+      this.app = this.createApp(args);
+    }
+    async close() {
+      await this.handleBeforeClose?.();
+      log.log("Closing...");
+      await this.app?.stop(true);
+      if (XConfig.nodeEnv !== "test") {
+        process.exit(0);
+      }
+    }
+    createApp(options) {
+      return Bun.serve({
+        port: options.port,
+        hostname: options.hostname,
+        idleTimeout: this.opts?.idleTimeout,
+        tls: this.opts?.tls,
+        fetch: (r, s) => this.fetch(r, s),
+        websocket: this.websocket
+      });
+    }
+    async fetch(request, server) {
+      const req = new CRequest(request);
+      const res = await this.handleRequest(req, (wsRoute) => {
+        const upgraded = server.upgrade(request, { data: wsRoute });
+        if (!upgraded) {
+          throw new CError("Upgrade failed", Status.UPGRADE_REQUIRED);
+        }
+        return;
+      });
+      return res?.response;
+    }
+    websocket = {
+      async open(ws) {
+        await ws.data.onOpen?.(ws);
+      },
+      async message(ws, message) {
+        await ws.data.onMessage(ws, message);
+      },
+      async close(ws, code, reason) {
+        await ws.data.onClose?.(ws, code, reason);
+      }
+    };
+  };
+});
+
+// src/CWebSocket/CWebSocket.node.ts
+class CWebSocketNode {
+  remoteAddress;
+  readyState;
+  subscriptions = [];
+  ws;
+  registry;
+  constructor(ws, registry, remoteAddress) {
+    this.ws = ws;
+    this.registry = registry;
+    this.remoteAddress = remoteAddress;
+    this.readyState = ws.readyState;
+  }
+  send(data) {
+    this.ws.send(data);
+    return 0;
+  }
+  publish(topic, data) {
+    const subscribers = this.registry.get(topic);
+    if (!subscribers)
+      return 0;
+    let count = 0;
+    for (const sub of subscribers) {
+      if (sub !== this && sub.readyState === 1) {
+        sub.send(data);
+        count++;
+      }
+    }
+    return count;
+  }
+  cork(callback) {
+    return callback(this);
+  }
+  close(code, reason) {
+    this.ws.close(code, reason);
+  }
+  terminate() {
+    this.ws.terminate();
+  }
+  subscribe(topic) {
+    if (this.isSubscribed(topic))
+      return;
+    this.subscriptions.push(topic);
+    const set = this.registry.get(topic) ?? new Set;
+    set.add(this);
+    this.registry.set(topic, set);
+  }
+  unsubscribe(topic) {
+    const idx = this.subscriptions.indexOf(topic);
+    if (idx === -1)
+      return;
+    this.subscriptions.splice(idx, 1);
+    this.registry.get(topic)?.delete(this);
+  }
+  isSubscribed(topic) {
+    return this.subscriptions.includes(topic);
+  }
+  cleanup() {
+    for (const topic of this.subscriptions) {
+      this.unsubscribe(topic);
+    }
+  }
+}
+
+// src/Server/Server.node.ts
+var exports_Server_node = {};
+__export(exports_Server_node, {
+  default: () => ServerUsingNode
+});
+var import_node_http, import_node_https, import_ws, ServerUsingNode;
+var init_Server_node = __esm(() => {
+  init_XConfig();
+  init_CRequest();
+  init_Method();
+  init_ServerAbstract();
+  init_internalLogger();
+  import_node_http = __toESM(require("http"));
+  import_node_https = __toESM(require("https"));
+  import_ws = require("ws");
+  ServerUsingNode = class ServerUsingNode extends ServerAbstract {
+    app;
+    wss;
+    registry = new Map;
+    serve(args) {
+      const app = this.createApp();
+      const wss = this.createWss();
+      app.addListener("request", async (incomingMessage, serverResponse) => {
+        const body = await this.getBody(incomingMessage);
+        const url = this.getUrl(incomingMessage);
+        const method = this.getMethod(incomingMessage);
+        const headers = this.getHeaders(incomingMessage);
+        const request = this.getRequest(url, method, headers, body);
+        const req = new CRequest(request);
+        const res = await this.handleRequest(req, () => {
+          return;
+        });
+        if (!res) {
+          return;
+        }
+        const data = await this.getData(res.response);
+        serverResponse.statusCode = res.response.status;
+        serverResponse.setHeaders(res.response.headers);
+        serverResponse.end(Buffer.from(data));
+      });
+      app.addListener("upgrade", async (incomingMessage, socket, head) => {
+        const body = undefined;
+        const url = this.getUrl(incomingMessage);
+        const method = this.getMethod(incomingMessage);
+        const headers = this.getHeaders(incomingMessage);
+        const request = this.getRequest(url, method, headers, body);
+        const req = new CRequest(request);
+        await this.handleRequest(req, (wsRoute) => {
+          if (!wsRoute) {
+            socket.destroy();
+            return;
+          }
+          wss.handleUpgrade(incomingMessage, socket, head, async (ws) => {
+            const remoteAddress = incomingMessage.socket.remoteAddress ?? "";
+            const cws = new CWebSocketNode(ws, this.registry, remoteAddress);
+            wss.emit("connection", ws, incomingMessage);
+            await wsRoute.onOpen?.(cws);
+            ws.on("message", async (message) => {
+              const msg = Buffer.isBuffer(message) ? message : Buffer.from(message);
+              await wsRoute.onMessage(cws, msg);
+            });
+            ws.on("close", async (code, reason) => {
+              cws.cleanup();
+              await wsRoute.onClose?.(cws, code, reason.toString());
+            });
+          });
+          return;
+        });
+      });
+      this.app = app;
+      this.wss = wss;
+      app.listen(args.port, args.hostname);
+    }
+    async close() {
+      await this.handleBeforeClose?.();
+      log.log("Closing...");
+      this.wss?.close();
+      this.app?.close();
+      this.app?.closeAllConnections();
+      this.app?.closeIdleConnections();
+      if (XConfig.nodeEnv !== "test") {
+        process.exit(0);
+      }
+    }
+    createWss() {
+      return new import_ws.WebSocketServer({ noServer: true });
     }
-    if (this.handleAfterResponse) {
-      res = await this.handleAfterResponse(res);
+    createApp() {
+      return this.opts?.tls ? import_node_https.default.createServer({
+        keepAliveTimeout: this.opts.idleTimeout,
+        ...this.opts.tls
+      }) : import_node_http.default.createServer({ keepAliveTimeout: this.opts?.idleTimeout });
     }
-    return res.response;
-  }
-  async getResponse(req) {
-    try {
-      if (req.isPreflight) {
-        return new CResponse("Departed");
+    async getBody(incomingMessage) {
+      let body = undefined;
+      const chunks = [];
+      for await (const chunk of incomingMessage) {
+        chunks.push(chunk);
       }
-      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);
+      if (chunks.length > 0) {
+        body = Buffer.concat(chunks);
+      }
+      return body;
+    }
+    getUrl(incomingMessage) {
+      const forwardedProtocol = incomingMessage.headers["x-forwarded-proto"];
+      const protocolFromForwarded = Array.isArray(forwardedProtocol) ? forwardedProtocol[0] : forwardedProtocol;
+      const socket = incomingMessage.socket;
+      const isEncrypted = socket.encrypted;
+      let protocol;
+      if (protocolFromForwarded) {
+        protocol = `${protocolFromForwarded}://`;
+      } else if (isEncrypted) {
+        protocol = "https://";
+      } else {
+        protocol = "http://";
+      }
+      return `${protocol}${incomingMessage.headers.host}${incomingMessage.url}`;
+    }
+    getMethod(incomingMessage) {
+      return incomingMessage.method?.toUpperCase() ?? Method.GET;
+    }
+    getHeaders(incomingMessage) {
+      const headers = new Headers;
+      for (const [key, value] of Object.entries(incomingMessage.headers)) {
+        if (Array.isArray(value)) {
+          for (const v of value)
+            headers.append(key, v);
+        } else if (value != null && typeof value === "string") {
+          headers.append(key, value);
         }
       }
-      return await this.handleError(err);
+      return headers;
     }
-  }
-  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 });
+    getRequest(url, method, headers, body) {
+      if (method !== Method.GET) {
+        return new Request(url, { method, headers, body });
+      } else {
+        return new Request(url, { method, headers });
+      }
     }
-    if (err instanceof CError) {
-      return err.toResponse();
+    async getData(response) {
+      return await response.arrayBuffer();
     }
-    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
+var Adapted3, Server;
+var init_Server = __esm(() => {
+  Adapted3 = (typeof Bun !== "undefined" ? (init_Server_bun(), __toCommonJS(exports_Server_bun)) : (init_Server_node(), __toCommonJS(exports_Server_node))).default;
+  Server = class Server extends Adapted3 {
+  };
+});
+
+// src/C.ts
+var exports_C = {};
+__export(exports_C, {
+  WebSocketRoute: () => WebSocketRoute,
+  Status: () => Status,
+  StaticRoute: () => StaticRoute,
+  Server: () => Server,
+  Route: () => DynamicRoute,
+  Response: () => CResponse,
+  Request: () => CRequest,
+  MiddlewareAbstract: () => MiddlewareAbstract,
+  Middleware: () => Middleware,
+  Method: () => Method,
+  Headers: () => CHeaders,
+  Error: () => CError,
+  Cookies: () => Cookies,
+  Controller: () => Controller,
+  Context: () => Context,
+  CommonHeaders: () => CommonHeaders
+});
+var init_C = __esm(() => {
+  init_Context();
+  init_Controller();
+  init_Cookies();
+  init_CError();
+  init_CHeaders();
+  init_Middleware();
+  init_CRequest();
+  init_CResponse();
+  init_DynamicRoute();
+  init_StaticRoute();
+  init_WebSocketRoute();
+  init_Server();
+  init_CommonHeaders();
+  init_Method();
+  init_Status();
 });
+
 // src/utils/boolToString.ts
 function boolToString(arg) {
   return arg ? "true" : "false";
@@ -1691,48 +2283,60 @@ 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 {
+// src/XCors/XCors.ts
+var XCors;
+var init_XCors = __esm(() => {
+  init_MiddlewareVariant();
+  init_CommonHeaders();
+  init_src();
+  XCors = class XCors extends MiddlewareAbstract {
+    opts;
+    constructor(opts) {
+      super();
+      this.opts = opts;
+      $routerStore.get().addMiddleware(this);
+    }
+    originKey = CommonHeaders.AccessControlAllowOrigin;
+    methodsKey = CommonHeaders.AccessControlAllowMethods;
+    headersKey = CommonHeaders.AccessControlAllowHeaders;
+    credentialsKey = CommonHeaders.AccessControlAllowCredentials;
+    exposedHeadersKey = CommonHeaders.AccessControlExposeHeaders;
+    useOn = "*";
+    variant = MiddlewareVariant.outbound;
+    handler = async (c) => {
+      const reqOrigin = c.headers.get("origin") ?? "";
+      const {
+        allowedOrigins,
+        allowedMethods,
+        allowedHeaders,
+        exposedHeaders,
+        credentials
+      } = this.opts ?? {};
+      if (isSomeArray(allowedOrigins) && allowedOrigins.includes(reqOrigin)) {
+        c.res.headers.set(this.originKey, reqOrigin);
+      }
+      if (isSomeArray(allowedMethods)) {
+        c.res.headers.append(this.methodsKey, allowedMethods);
+      }
+      if (isSomeArray(allowedHeaders)) {
+        c.res.headers.append(this.headersKey, allowedHeaders);
+      }
+      if (isSomeArray(exposedHeaders)) {
+        c.res.headers.append(this.exposedHeadersKey, exposedHeaders);
+      }
+      c.res.headers.set(this.credentialsKey, boolToString(credentials));
+    };
+  };
+});
+
+// src/XRepository/XRepository.ts
+class XRepository {
   db;
   constructor(db) {
     this.db = db;
   }
 }
+
 // node_modules/memoirist/dist/bun/index.js
 var Y = (v, b) => {
   let A = b?.length ? {} : null;
@@ -1740,152 +2344,7 @@ var Y = (v, b) => {
     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) => {
+}, k = (v, b) => ({ ...v, part: b }), T = (v) => ({ name: v, store: null, inert: null }), _, $ = (v, b, A, Q, O) => {
   let V = A.part, X = V.length, J = Q + X;
   if (X > 1) {
     if (J > b)
@@ -1943,13 +2402,155 @@ var $ = (v, b, A, Q, O) => {
   if (A.wildcardStore !== null)
     return { store: A.wildcardStore, params: { "*": v.substring(J, b) } };
   return null;
-};
-var w = _;
+}, w;
+var init_bun = __esm(() => {
+  _ = 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);
+    }
+  };
+  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;
@@ -1958,57 +2559,423 @@ class MemoiristAdapter {
     if (!result)
       return null;
     return {
-      route: result.store.route,
-      model: result.store.model,
+      route: result.store,
       params: result.params,
-      search: Object.fromEntries(searchParams),
-      middleware: compile(result.store.middlewares ?? [])
+      search: Object.fromEntries(searchParams)
     };
   }
   list() {
-    return this.router.history.map((v) => v[2].route);
+    return this.router.history.map((v) => v[2]);
   }
-  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);
-    }
+  add(data) {
+    this.router.add(data.method, data.endpoint, data);
   }
-  addModel(route, model) {
-    const result = this.router.find(route.method, route.endpoint);
-    if (!result)
+}
+var init_MemoiristAdapter = __esm(() => {
+  init_bun();
+});
+
+// src/XRateLimiter/stores/RateLimiterFileStore.ts
+class RateLimiterFileStore {
+  storeDir;
+  locks = new Map;
+  constructor(storeDir) {
+    this.storeDir = storeDir || path2.join(os.tmpdir(), "rate-limit-store");
+    this.ensureStoreDir();
+  }
+  ensureStoreDir() {
+    import_promises.default.mkdir(this.storeDir, { recursive: true }).catch((err) => {
+      log.error("Rate Limit File Store Directory could not be created:", err);
+    });
+  }
+  getFilePath(id) {
+    const safeId = import_crypto.default.hash("sha256", id).slice(0, 32);
+    return path2.join(this.storeDir, `${safeId}.json`);
+  }
+  async get(id) {
+    try {
+      const data = await import_promises.default.readFile(this.getFilePath(id), "utf-8");
+      return JSON.parse(data);
+    } catch {
       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];
+  async set(id, entry) {
+    while (this.locks.has(id)) {
+      await this.locks.get(id);
+    }
+    let resolveLock;
+    this.locks.set(id, new Promise((resolve) => {
+      resolveLock = resolve;
+    }));
+    try {
+      await import_promises.default.writeFile(this.getFilePath(id), JSON.stringify(entry), "utf-8");
+    } finally {
+      this.locks.delete(id);
+      resolveLock();
+    }
+  }
+  async delete(id) {
+    try {
+      await import_promises.default.unlink(this.getFilePath(id));
+    } catch {}
+  }
+  async cleanup(now) {
+    const files = await import_promises.default.readdir(this.storeDir);
+    for (const file of files) {
+      if (!file.endsWith(".json"))
+        continue;
+      try {
+        const data = await import_promises.default.readFile(path2.join(this.storeDir, file), "utf-8");
+        const entry = JSON.parse(data);
+        if (entry.resetAt <= now) {
+          await import_promises.default.unlink(path2.join(this.storeDir, file));
+        }
+      } catch {}
+    }
+  }
+  async clear() {
+    const files = await import_promises.default.readdir(this.storeDir);
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        await import_promises.default.unlink(path2.join(this.storeDir, file));
       }
-      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]);
+  }
+  async size() {
+    const files = await import_promises.default.readdir(this.storeDir);
+    return files.filter((f) => f.endsWith(".json")).length;
+  }
+}
+var import_crypto, import_promises, path2, os;
+var init_RateLimiterFileStore = __esm(() => {
+  init_internalLogger();
+  import_crypto = __toESM(require("crypto"));
+  import_promises = __toESM(require("fs/promises"));
+  path2 = __toESM(require("path"));
+  os = __toESM(require("os"));
+});
+
+// src/XRateLimiter/stores/RateLimiterRedisStore.ts
+class RateLimiterRedisStore {
+  redis;
+  prefix;
+  constructor(redis, prefix = "rl:") {
+    this.redis = redis;
+    this.prefix = prefix;
+  }
+  async get(id) {
+    const data = await this.redis.get(this.prefix + id);
+    return data ? JSON.parse(data) : undefined;
+  }
+  async set(id, entry) {
+    await this.redis.set(this.prefix + id, JSON.stringify(entry), "PX", Math.max(0, entry.resetAt - Date.now()));
+  }
+  async delete(id) {
+    await this.redis.del(this.prefix + id);
+  }
+  async cleanup(_now) {}
+  async clear() {
+    const keys = await this.redis.keys(this.prefix + "*");
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
+    }
+  }
+  async size() {
+    const keys = await this.redis.keys(this.prefix + "*");
+    return keys.length;
+  }
+}
+
+// src/XRateLimiter/stores/RateLimiterMemoryStore.ts
+class RateLimiterMemoryStore {
+  store = new Map;
+  locks = new Map;
+  async get(id) {
+    return this.store.get(id);
+  }
+  async set(id, entry) {
+    while (this.locks.has(id)) {
+      await this.locks.get(id);
+    }
+    let resolveLock;
+    this.locks.set(id, new Promise((resolve) => {
+      resolveLock = resolve;
+    }));
+    try {
+      this.store.set(id, entry);
+    } finally {
+      this.locks.delete(id);
+      resolveLock();
+    }
+  }
+  async delete(id) {
+    this.store.delete(id);
+  }
+  async cleanup(now) {
+    for (const [id, entry] of this.store) {
+      if (entry.resetAt <= now) {
+        await this.delete(id);
+      }
+    }
+  }
+  async clear() {
+    this.store.clear();
+  }
+  async size() {
+    return this.store.size;
+  }
+}
+
+// src/XRateLimiter/XRateLimiter.ts
+class XRateLimiter {
+  constructor(config = {}) {
+    this.config = { ...this.defaultConfig, ...config };
+    this.store = this.resolveStore();
+    this.storedSalt = this.getRandomBytes();
+    this.saltRotatesAt = Date.now() + this.config.saltRotateMs;
+    this.registerMiddleware();
+  }
+  config;
+  store;
+  storedSalt;
+  saltRotatesAt;
+  async getResult(headers) {
+    await this.maybeCleanStore();
+    const id = this.getId(headers);
+    const now = Date.now();
+    let entry = await this.store.get(id);
+    if (entry && entry.resetAt > now) {
+      entry.hits++;
+    } else {
+      entry = { hits: 1, resetAt: now + this.config.windowMs };
+    }
+    await this.store.set(id, entry);
+    const max = this.getMax(id);
+    const allowed = entry.hits <= max;
+    const remaining = Math.max(0, max - entry.hits);
+    const resetUnix = Math.ceil(entry.resetAt / 1000);
+    const keys = this.config.headerNames;
+    const responseHeaders = new CHeaders;
+    responseHeaders.setMany({
+      [keys.limit]: max.toString(),
+      [keys.remaining]: remaining.toString(),
+      [keys.reset]: resetUnix.toString()
+    });
+    if (!allowed) {
+      const retryAfter = Math.ceil((entry.resetAt - now) / 1000);
+      responseHeaders.set(keys.retryAfter, retryAfter.toString());
+    }
+    if (allowed) {
+      return { headers: responseHeaders, success: true };
+    }
+    return { headers: responseHeaders, success: false };
+  }
+  getId(headers) {
+    const authHeader = headers.get(CommonHeaders.Authorization);
+    const token = authHeader?.split(" ")[1];
+    if (strIsDefined(token) && token.length >= 20 && token.length <= 2048) {
+      return `u:${this.hash(token, 16)}`;
+    }
+    const ip = this.extractIp(headers);
+    if (ip !== null) {
+      return `i:${this.hash(ip + this.salt(), 16)}`;
+    }
+    const parts = [
+      headers.get("user-agent") ?? "no-ua",
+      headers.get("accept-language") ?? "no-lang",
+      headers.get("accept-encoding") ?? "no-enc"
+    ];
+    return `f:${this.hash(parts.join("|") + this.salt(), 16)}`;
+  }
+  getMax(id) {
+    const prefix = id.charAt(0);
+    return this.config.limits[prefix] ?? this.config.limits.f;
+  }
+  extractIp(headers) {
+    const raw = headers.get("cf-connecting-ip") || headers.get("x-real-ip") || headers.get("x-forwarded-for")?.split(",")[0]?.trim();
+    return this.isValidIp(raw) ? raw : null;
+  }
+  isValidIp(ip) {
+    if (!strIsDefined(ip) || ip.length === 0)
+      return false;
+    if (ip.includes(".")) {
+      const parts = ip.split(".");
+      if (parts.length !== 4)
+        return false;
+      return parts.every((p) => {
+        if (!/^\d+$/.test(p))
+          return false;
+        const n = Number(p);
+        return n >= 0 && n <= 255 && p === String(n);
+      });
+    }
+    if (ip.includes(":")) {
+      try {
+        new URL(`http://[${ip}]`);
+        return true;
+      } catch {
+        return false;
       }
     }
+    return false;
+  }
+  salt() {
+    if (Date.now() > this.saltRotatesAt) {
+      this.storedSalt = this.getRandomBytes();
+      this.saltRotatesAt = Date.now() + this.config.saltRotateMs;
+    }
+    return this.storedSalt;
+  }
+  async maybeCleanStore() {
+    const currentSize = await this.store.size();
+    const shouldClean = Math.random() < this.config.cleanProbability || currentSize > this.config.maxStoreSize;
+    if (shouldClean)
+      await this.cleanStore();
+  }
+  async cleanStore() {
+    const now = Date.now();
+    await this.store.cleanup(now);
+    return await this.store.size();
+  }
+  hash(data, len) {
+    return import_crypto2.default.hash("sha256", data).slice(0, len);
+  }
+  getRandomBytes() {
+    return import_crypto2.default.randomBytes(16).toString("hex");
+  }
+  async clearStore() {
+    await this.store.clear();
+  }
+  async getStoreSize() {
+    return await this.store.size();
+  }
+  defaultConfig = {
+    windowMs: 60000,
+    saltRotateMs: 24 * 3600 * 1000,
+    cleanProbability: 0.005,
+    maxStoreSize: 50000,
+    storeType: "memory",
+    limits: { u: 120, i: 60, f: 20 },
+    headerNames: {
+      limit: "RateLimit-Limit",
+      remaining: "RateLimit-Remaining",
+      reset: "RateLimit-Reset",
+      retryAfter: "Retry-After"
+    }
+  };
+  resolveStore() {
+    switch (this.config.storeType) {
+      case "file":
+        return new RateLimiterFileStore(this.config.storeDir);
+      case "redis":
+        if (!this.config.redisClient) {
+          logFatal("Redis client required for redis store type");
+        }
+        return new RateLimiterRedisStore(this.config.redisClient);
+      case "memory":
+      default:
+        return new RateLimiterMemoryStore;
+    }
+  }
+  registerMiddleware() {
+    new Middleware({
+      useOn: "*",
+      handler: async (c) => {
+        const result = await this.getResult(c.headers);
+        c.res.headers.innerCombine(result.headers);
+        const exposedHeaders = Object.values(this.config.headerNames);
+        c.res.headers.append(CommonHeaders.AccessControlExposeHeaders, exposedHeaders);
+        if (!result.success) {
+          throw new CError("Too many requests", Status.TOO_MANY_REQUESTS, c.res);
+        }
+      }
+    });
   }
 }
+var import_crypto2;
+var init_XRateLimiter = __esm(() => {
+  init_CHeaders();
+  init_CError();
+  init_RateLimiterFileStore();
+  init_Status();
+  init_CommonHeaders();
+  init_Middleware();
+  init_internalLogger();
+  import_crypto2 = __toESM(require("crypto"));
+});
+
+// src/X.ts
+var exports_X = {};
+__export(exports_X, {
+  Repository: () => XRepository,
+  RateLimiterRedisStore: () => RateLimiterRedisStore,
+  RateLimiterMemoryStore: () => RateLimiterMemoryStore,
+  RateLimiterFileStore: () => RateLimiterFileStore,
+  RateLimiter: () => XRateLimiter,
+  Parser: () => XParser,
+  MemoiristAdapter: () => MemoiristAdapter,
+  File: () => XFile,
+  Cors: () => XCors,
+  Config: () => XConfig
+});
+var init_X = __esm(() => {
+  init_XConfig();
+  init_XCors();
+  init_XFile();
+  init_MemoiristAdapter();
+  init_XRateLimiter();
+  init_RateLimiterFileStore();
+  init_XParser();
+});
+
 // src/index.ts
-var _prefixStore = new GlobalPrefixStore;
-var _routerStore = new GlobalRouterStore;
-var _corsStore = new GlobalCorsStore;
+var exports_src = {};
+__export(exports_src, {
+  X: () => exports_X,
+  WebSocketRoute: () => WebSocketRoute,
+  Status: () => Status,
+  StaticRoute: () => StaticRoute,
+  Server: () => Server,
+  Route: () => DynamicRoute,
+  Response: () => CResponse,
+  Request: () => CRequest,
+  Repository: () => XRepository,
+  RateLimiterRedisStore: () => RateLimiterRedisStore,
+  RateLimiterMemoryStore: () => RateLimiterMemoryStore,
+  RateLimiterFileStore: () => RateLimiterFileStore,
+  RateLimiter: () => XRateLimiter,
+  Parser: () => XParser,
+  MiddlewareAbstract: () => MiddlewareAbstract,
+  Middleware: () => Middleware,
+  Method: () => Method,
+  MemoiristAdapter: () => MemoiristAdapter,
+  Headers: () => CHeaders,
+  File: () => XFile,
+  Extra: () => exports_X,
+  Error: () => CError,
+  Cors: () => XCors,
+  Corpus: () => exports_C,
+  Cookies: () => Cookies,
+  Controller: () => Controller,
+  Context: () => Context,
+  Config: () => XConfig,
+  CommonHeaders: () => CommonHeaders,
+  C: () => exports_C,
+  $routerStore: () => $routerStore,
+  $prefixStore: () => $prefixStore
+});
+module.exports = __toCommonJS(exports_src);
+var $prefixStore, $routerStore;
+var init_src = __esm(() => {
+  init_GlobalPrefixStore();
+  init_GlobalRouterStore();
+  init_C();
+  init_X();
+  init_C();
+  init_X();
+  $prefixStore = new GlobalPrefixStore;
+  $routerStore = new GlobalRouterStore;
+});
+init_src();
 })