@ozanarslan/corpus 0.1.5 → 0.1.9

package/dist/index.cjs

@@ -60,38 +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: () => src_default,
-  _router: () => _router,
-  _globalPrefix: () => _globalPrefix,
-  Status: () => Status,
-  StaticRoute: () => StaticRoute,
-  Server: () => Server,
-  Route: () => Route,
-  Response: () => HttpResponse,
-  Request: () => HttpRequest,
-  Repository: () => RepositoryAbstract,
-  Parser: () => Parser,
-  Middleware: () => Middleware,
-  Method: () => Method,
-  MemoiristAdapter: () => MemoiristAdapter,
-  Headers: () => HttpHeaders,
-  FileWalker: () => FileWalker,
-  Error: () => HttpError,
-  DefaultStatusTexts: () => DefaultStatusTexts,
-  Cookies: () => Cookies,
-  Controller: () => ControllerAbstract,
-  Context: () => Context,
-  Config: () => Config,
-  CommonHeaders: () => CommonHeaders,
-  C: () => exports_exports
-});
-module.exports = __toCommonJS(exports_src);
-
-// src/Store/StoreAbstract.ts
+// src/store/StoreAbstract.ts
 class StoreAbstract {
   set(value) {
     this.value = value;
@@ -101,52 +72,55 @@ 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/utils/internalLogger.ts
+function logFatal(...args) {
+  console.error(...args);
+  process.exit(1);
 }
+var log;
+var init_internalLogger = __esm(() => {
+  log = console;
+});
 
-// 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);
+// 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;
     }
-    return this.value;
-  }
-}
+  };
+});
 
-// src/exports.ts
-var exports_exports = {};
-__export(exports_exports, {
-  Status: () => Status,
-  StaticRoute: () => StaticRoute,
-  Server: () => Server,
-  Route: () => Route,
-  Response: () => HttpResponse,
-  Request: () => HttpRequest,
-  Repository: () => RepositoryAbstract,
-  Parser: () => Parser,
-  Middleware: () => Middleware,
-  Method: () => Method,
-  Headers: () => HttpHeaders,
-  FileWalker: () => FileWalker,
-  Error: () => HttpError,
-  DefaultStatusTexts: () => DefaultStatusTexts,
-  Cookies: () => Cookies,
-  Controller: () => ControllerAbstract,
-  Context: () => Context,
-  Config: () => Config,
-  CommonHeaders: () => CommonHeaders
+// src/store/GlobalCorsStore.ts
+var GlobalCorsStore;
+var init_GlobalCorsStore = __esm(() => {
+  GlobalCorsStore = class GlobalCorsStore extends StoreAbstract {
+    value = null;
+  };
 });
 
 // src/Config/enums/RuntimeOptions.ts
-var RuntimeOptions = {
-  bun: "bun",
-  node: "node"
-};
+var RuntimeOptions;
+var init_RuntimeOptions = __esm(() => {
+  RuntimeOptions = {
+    bun: "bun",
+    node: "node"
+  };
+});
 
 // src/utils/strIsDefined.ts
 function strIsDefined(input) {
@@ -154,8 +128,6 @@ function strIsDefined(input) {
 }
 
 // src/Config/Config.ts
-var import_path = __toESM(require("path"));
-
 class Config {
   static get runtime() {
     if (typeof Bun !== "undefined") {
@@ -164,7 +136,7 @@ class Config {
     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.");
+    log.warn("\u26A0\uFE0F Runtime isn't Bun or NodeJS. Features may not be available. App might not start.");
     return "unknown";
   }
   static get nodeEnv() {
@@ -177,7 +149,7 @@ class Config {
       case RuntimeOptions.node:
         return process.env;
       default:
-        console.warn("\u26A0\uFE0F process.env wasn't available. Your environment variables are in memory.");
+        log.warn("\u26A0\uFE0F process.env wasn't available. Your environment variables are in memory.");
         return {};
     }
   }
@@ -195,7 +167,7 @@ class Config {
     if (opts?.fallback !== undefined) {
       return opts?.fallback;
     }
-    console.error(`${key} doesn't exist in env`);
+    log.warn(`${key} doesn't exist in env`);
     return;
   }
   static set(key, value) {
@@ -210,120 +182,140 @@ class Config {
     this.env[key] = value;
   }
 }
-// src/Response/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 import_path;
+var init_Config = __esm(() => {
+  init_RuntimeOptions();
+  init_internalLogger();
+  import_path = __toESM(require("path"));
+});
 
-// src/Response/enums/DefaultStatusTexts.ts
-var DefaultStatusTexts = {
-  [Status.OK]: "OK",
-  [Status.CREATED]: "Created",
-  [Status.NO_CONTENT]: "No Content",
-  [Status.MOVED_PERMANENTLY]: "Moved Permanently",
-  [Status.FOUND]: "Found",
-  [Status.SEE_OTHER]: "See Other",
-  [Status.TEMPORARY_REDIRECT]: "Temporary Redirect",
-  [Status.PERMANENT_REDIRECT]: "Permanent Redirect",
-  [Status.BAD_REQUEST]: "Bad Request",
-  [Status.UNAUTHORIZED]: "Unauthorized",
-  [Status.FORBIDDEN]: "Forbidden",
-  [Status.NOT_FOUND]: "Not Found",
-  [Status.INTERNAL_SERVER_ERROR]: "Internal Server Error"
-};
+// src/CResponse/enums/Status.ts
+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/Headers/enums/CommonHeaders.ts
-var CommonHeaders = {
-  CacheControl: "Cache-Control",
-  ContentType: "Content-Type",
-  ContentLength: "Content-Length",
-  AcceptEncoding: "Accept-Encoding",
-  Accept: "Accept",
-  Authorization: "Authorization",
-  UserAgent: "User-Agent",
-  Host: "Host",
-  Referer: "Referer",
-  Connection: "Connection",
-  Pragma: "Pragma",
-  Date: "Date",
-  IfNoneMatch: "If-None-Match",
-  IfModifiedSince: "If-Modified-Since",
-  ETag: "ETag",
-  Expires: "Expires",
-  LastModified: "Last-Modified",
-  Location: "Location",
-  WWWAuthenticate: "WWW-Authenticate",
-  AccessControlAllowOrigin: "Access-Control-Allow-Origin",
-  AccessControlMaxAge: "Access-Control-Max-Age",
-  AccessControlAllowCredentials: "Access-Control-Allow-Credentials",
-  AccessControlRequestMethod: "Access-Control-Request-Method",
-  SetCookie: "Set-Cookie",
-  Cookie: "Cookie"
-};
+// src/CResponse/enums/DefaultStatusTexts.ts
+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;
+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",
+    AccessControlAllowOrigin: "Access-Control-Allow-Origin",
+    AccessControlMaxAge: "Access-Control-Max-Age",
+    AccessControlAllowCredentials: "Access-Control-Allow-Credentials",
+    AccessControlRequestMethod: "Access-Control-Request-Method",
+    SetCookie: "Set-Cookie",
+    Cookie: "Cookie"
+  };
+});
 
 // src/Cookies/CookiesAbstract.ts
 class CookiesAbstract {
+  constructor(_) {}
   applyInit(init) {
     if (!init)
       return;
@@ -342,116 +334,465 @@ class CookiesAbstract {
   }
 }
 
-// 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(init);
+      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());
-  }
+    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/strAfterMark.ts
+function strAfterMark(mark, input) {
+  const index = input.indexOf(mark);
+  return index === -1 ? "" : input.slice(index + mark.length);
 }
 
-// src/Cookies/Cookies.ts
-class Cookies extends CookiesUsingBun {
+// src/utils/strBeforeMark.ts
+function strBeforeMark(mark, input) {
+  const index = input.indexOf(mark);
+  return index === -1 ? input : input.slice(0, index);
 }
 
-// src/Headers/HttpHeaders.ts
-class HttpHeaders 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());
+// 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);
   }
-  delete(name) {
-    return super.delete(name);
+}
+
+// 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;
   }
-  static combine(source, target) {
-    source.forEach((value, key) => {
-      if (key.toLowerCase() === "set-cookie") {
-        target.append(key, value);
+  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 {
-        target.set(key, value);
+        result += `; Path=/`;
       }
-    });
-    return target;
-  }
-  innerCombine(source) {
-    HttpHeaders.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);
+      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;
     }
-  }
-  static findHeaderInInit(init, name) {
-    if (init instanceof HttpHeaders || 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/Cookies/Cookies.ts
+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
+var CHeaders;
+var init_CHeaders = __esm(() => {
+  CHeaders = class CHeaders extends Headers {
+    constructor(init) {
+      super(init);
+    }
+    append(name, value) {
+      super.append(name, value);
+    }
+    set(name, value) {
+      super.set(name, value);
+    }
+    get(name) {
+      return super.get(name) || super.get(name.toLowerCase());
+    }
+    has(name) {
+      return super.has(name) || super.has(name.toLowerCase());
+    }
+    delete(name) {
+      return super.delete(name);
+    }
+    static combine(source, target) {
+      source.forEach((value, key) => {
+        if (key.toLowerCase() === "set-cookie") {
+          target.append(key, value);
+        } else {
+          target.set(key, value);
+        }
+      });
+      return target;
+    }
+    innerCombine(source) {
+      CHeaders.combine(source, this);
+    }
+    setMany(init) {
+      const entries = Array.isArray(init) ? init : Object.entries(init);
+      for (const [key, value] of entries) {
+        if (!strIsDefined(value))
+          continue;
+        this.set(key, value);
+      }
+    }
+    static findHeaderInInit(init, name) {
+      if (init instanceof CHeaders || init instanceof Headers) {
+        return init.get(name);
+      } else if (Array.isArray(init)) {
+        return init.find((entry) => entry[0] === name)?.[1] ?? null;
+      } else {
+        return init[name] ?? null;
+      }
+    }
+  };
+});
+
+// src/utils/isNil.ts
+function isNil(input) {
+  return input === null || input === undefined;
+}
+
+// src/utils/isPrimitive.ts
+function isPrimitive(input) {
+  return typeof input === "string" || typeof input === "number" || typeof input === "boolean" || typeof input === "bigint";
+}
+
+// src/utils/isPlainObject.ts
+function isPlainObject(input) {
+  return typeof input === "object" && input !== null && input.constructor === Object;
+}
+
+// src/CError/CError.ts
+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;
+    this.fallbackExtension = fallbackExtension;
+  }
+  get name() {
+    return this.path.split("/").pop() ?? this.path;
+  }
+  get extension() {
+    return this.path.split(".").pop() ?? this.fallbackExtension ?? "txt";
+  }
+  get mimeType() {
+    const mimeTypes = {
+      html: "text/html",
+      htm: "text/html",
+      css: "text/css",
+      js: "application/javascript",
+      ts: "application/javascript",
+      mjs: "application/javascript",
+      json: "application/json",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      svg: "image/svg+xml",
+      ico: "image/x-icon",
+      txt: "text/plain",
+      xml: "application/xml",
+      pdf: "application/pdf",
+      zip: "application/zip",
+      mp3: "audio/mpeg",
+      mp4: "video/mp4",
+      webm: "video/webm",
+      woff: "font/woff",
+      woff2: "font/woff2",
+      ttf: "font/ttf"
+    };
+    return mimeTypes[this.extension] ?? "application/octet-stream";
   }
 }
 
-// src/Response/HttpResponse.ts
-class HttpResponse {
-  body;
+// 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
+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;
   init;
-  constructor(body, init) {
-    this.body = body;
+  constructor(data, init) {
+    this.data = data;
     this.init = init;
-    this.cookies = this.getCookies();
-    this.headers = this.getHeaders();
-    this.body = this.getBody();
-    this.status = this.getStatus();
-    this.statusText = this.getDefaultStatusText();
+    this.cookies = this.resolveCookies();
+    this.headers = this.resolveHeaders();
+    this.body = this.resolveBody();
+    this.status = this.resolveStatus();
+    this.statusText = CResponse.getDefaultStatusText(this.status);
   }
+  body;
   headers;
   status;
   statusText;
@@ -463,11 +804,128 @@ class HttpResponse {
       headers: this.headers
     });
   }
-  getCookies() {
-    return new Cookies(this.init?.cookies);
+  static redirect(url, init) {
+    const res = new CResponse(undefined, {
+      ...init,
+      status: init?.status ?? Status.FOUND,
+      statusText: init?.statusText ?? DefaultStatusTexts[Status.FOUND]
+    });
+    const urlString = url instanceof URL ? url.toString() : url;
+    res.headers.set(CommonHeaders.Location, urlString);
+    return res;
+  }
+  static permanentRedirect(url, init) {
+    return this.redirect(url, {
+      ...init,
+      status: Status.MOVED_PERMANENTLY
+    });
+  }
+  static temporaryRedirect(url, init) {
+    return this.redirect(url, { ...init, status: Status.TEMPORARY_REDIRECT });
+  }
+  static seeOther(url, init) {
+    return this.redirect(url, { ...init, status: Status.SEE_OTHER });
+  }
+  static createStream(execute) {
+    let cancelled = false;
+    let cleanup;
+    return new ReadableStream({
+      start(controller) {
+        try {
+          cleanup = execute(controller, () => cancelled);
+          if (typeof cleanup !== "function") {
+            controller.close();
+          }
+        } catch (err) {
+          controller.error(err);
+        }
+      },
+      cancel() {
+        cancelled = true;
+        cleanup?.();
+      }
+    });
+  }
+  static sse(source, init, retry) {
+    const encoder = new TextEncoder;
+    const stream = CResponse.createStream((controller, isCancelled) => {
+      return source((event) => {
+        if (isCancelled())
+          return;
+        let chunk = "";
+        if (retry !== undefined)
+          chunk += `retry: ${retry}
+`;
+        if (event.id)
+          chunk += `id: ${event.id}
+`;
+        if (event.event)
+          chunk += `event: ${event.event}
+`;
+        chunk += `data: ${JSON.stringify(event.data)}
+
+`;
+        controller.enqueue(encoder.encode(chunk));
+      });
+    });
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: "text/event-stream",
+      [CommonHeaders.CacheControl]: "no-cache",
+      [CommonHeaders.Connection]: "keep-alive"
+    });
+    return res;
+  }
+  static ndjson(source, init) {
+    const encoder = new TextEncoder;
+    const stream = CResponse.createStream((controller, isCancelled) => {
+      return source((item) => {
+        if (isCancelled())
+          return;
+        controller.enqueue(encoder.encode(`${JSON.stringify(item)}
+`));
+      });
+    });
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: "application/x-ndjson",
+      [CommonHeaders.CacheControl]: "no-cache"
+    });
+    return res;
+  }
+  static async streamFile(filePath, disposition = "attachment", init) {
+    const file = new XFile(filePath);
+    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 });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: file.mimeType,
+      [CommonHeaders.ContentDisposition]: `${disposition}; filename="${file.name}"`
+    });
+    return res;
+  }
+  static async file(filePath, init) {
+    const file = new XFile(filePath);
+    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);
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: file.mimeType,
+      [CommonHeaders.ContentLength]: content.length.toString()
+    });
+    return res;
+  }
+  resolveCookies() {
+    return this.init?.cookies instanceof Cookies ? this.init.cookies : new Cookies(this.init?.cookies);
   }
-  getHeaders() {
-    const headers = new HttpHeaders(this.init?.headers);
+  resolveHeaders() {
+    const headers = new CHeaders(this.init?.headers);
     const setCookieHeaders = this.cookies.toSetCookieHeaders();
     if (setCookieHeaders.length > 0) {
       for (const header of setCookieHeaders) {
@@ -476,7 +934,7 @@ class HttpResponse {
     }
     return headers;
   }
-  getStatus() {
+  resolveStatus() {
     if (this.init?.status)
       return this.init.status;
     if (this.headers.has(CommonHeaders.Location)) {
@@ -489,108 +947,76 @@ class HttpResponse {
       this.headers.set(CommonHeaders.ContentType, value);
     }
   }
-  getBody() {
-    if (this.body === null || this.body === undefined) {
+  resolveBody() {
+    if (isNil(this.data)) {
       this.setContentType("text/plain");
       return "";
     }
-    if (typeof this.body !== "object") {
+    if (isPrimitive(this.data)) {
       this.setContentType("text/plain");
-      return String(this.body);
+      return String(this.data);
+    }
+    if (this.data instanceof ArrayBuffer) {
+      this.setContentType("application/octet-stream");
+      return this.data;
+    }
+    if (this.data instanceof Blob) {
+      if (this.data.type)
+        this.setContentType(this.data.type);
+      return this.data;
+    }
+    if (this.data instanceof FormData) {
+      this.setContentType("multipart/form-data");
+      return this.data;
     }
-    if (this.body instanceof ArrayBuffer || this.body instanceof Blob || this.body instanceof FormData || this.body instanceof URLSearchParams || this.body instanceof ReadableStream) {
-      throw new Error("Unsupported response body: ArrayBuffer | Blob | FormData | URLSearchParams | ReadableStream");
+    if (this.data instanceof URLSearchParams) {
+      this.setContentType("application/x-www-form-urlencoded");
+      return this.data;
     }
-    if (this.body instanceof Date) {
+    if (this.data instanceof ReadableStream) {
+      return this.data;
+    }
+    if (this.data instanceof Date) {
       this.setContentType("text/plain");
-      return this.body.toISOString();
+      return this.data.toISOString();
     }
-    if (Array.isArray(this.body) || this.body.constructor === Object) {
+    if (Array.isArray(this.data) || isPlainObject(this.data)) {
       this.setContentType("application/json");
-      return JSON.stringify(this.body);
+      return JSON.stringify(this.data);
     }
     this.setContentType("text/plain");
-    return String(this.body);
+    return String(this.data);
   }
-  getDefaultStatusText() {
-    const key = this.status;
+  static getDefaultStatusText(status) {
+    const key = status;
     return DefaultStatusTexts[key] ?? "Unknown";
   }
-  static redirect(url, init) {
-    const res = new HttpResponse(undefined, {
-      ...init,
-      status: init?.status ?? Status.FOUND,
-      statusText: init?.statusText ?? DefaultStatusTexts[Status.FOUND]
-    });
-    const urlString = url instanceof URL ? url.toString() : url;
-    res.headers.set(CommonHeaders.Location, urlString);
-    return res;
-  }
-  static permanentRedirect(url, init) {
-    return this.redirect(url, {
-      ...init,
-      status: Status.MOVED_PERMANENTLY
-    });
-  }
-  static temporaryRedirect(url, init) {
-    return this.redirect(url, { ...init, status: Status.TEMPORARY_REDIRECT });
-  }
-  static seeOther(url, init) {
-    return this.redirect(url, { ...init, status: Status.SEE_OTHER });
-  }
 }
+var init_CResponse = __esm(() => {
+  init_DefaultStatusTexts();
+  init_Status();
+  init_CommonHeaders();
+  init_Cookies();
+  init_CHeaders();
+  init_CError();
+  init_XFile();
+});
 
-// src/Request/enums/Method.ts
-var Method = {
-  GET: "GET",
-  POST: "POST",
-  PUT: "PUT",
-  PATCH: "PATCH",
-  DELETE: "DELETE",
-  HEAD: "HEAD",
-  OPTIONS: "OPTIONS",
-  CONNECT: "CONNECT",
-  TRACE: "TRACE"
-};
-
-// src/Error/HttpError.ts
-class HttpError extends Error {
-  message;
-  status;
-  data;
-  constructor(message, status, data) {
-    super(message);
-    this.message = message;
-    this.status = status;
-    this.data = data;
-  }
-  toResponse() {
-    return new HttpResponse(this.data ? { error: this.data, message: this.message } : { error: true, message: this.message }, { status: this.status });
-  }
-  isStatusOf(status) {
-    return this.status === status;
-  }
-  static internalServerError(msg) {
-    const status = Status.INTERNAL_SERVER_ERROR;
-    return new this(msg ?? status.toString(), status);
-  }
-  static badRequest(msg) {
-    const status = Status.BAD_REQUEST;
-    return new this(msg ?? status.toString(), status);
-  }
-  static notFound(msg) {
-    const status = Status.NOT_FOUND;
-    return new this(msg ?? status.toString(), status);
-  }
-  static methodNotAllowed(msg) {
-    const status = Status.METHOD_NOT_ALLOWED;
-    return new this(msg ?? status.toString(), status);
-  }
-  static unprocessableEntity(msg) {
-    const status = Status.UNPROCESSABLE_ENTITY;
-    return new this(msg ?? status.toString(), status);
-  }
-}
+// src/CRequest/enums/Method.ts
+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) {
@@ -612,15 +1038,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 HttpError.unprocessableEntity(msg);
+      throw new CError(msg, Status.UNPROCESSABLE_ENTITY, data);
     }
     return result.value;
   }
@@ -636,19 +1062,19 @@ class Parser {
     }).join(`
 `);
   }
-  static async getSearch(url, validate) {
+  static async parseUrlData(params, validate) {
     const data = {};
-    for (const [key, value] of url.searchParams ?? {}) {
-      data[key] = this.processString(value);
+    for (const [key, value] of Object.entries(params)) {
+      data[key] = decodeURIComponent(value);
     }
     return await this.parse(data, validate);
   }
-  static async getBody(r, validate) {
+  static async parseBody(r, validate) {
     let data;
     const empty = {};
     const input = r instanceof Request ? r : r instanceof Response ? r : r.response;
     try {
-      switch (Parser.getNormalizedContentType(input)) {
+      switch (XParser.getNormalizedContentType(input)) {
         case "json":
           data = await this.getJsonBody(input);
           break;
@@ -670,7 +1096,7 @@ class Parser {
         case "image":
         case "audio":
         case "video":
-          throw new HttpError("unprocessable.contentType", Status.UNPROCESSABLE_ENTITY);
+          throw new CError("unprocessable.contentType", Status.UNPROCESSABLE_ENTITY);
         case "no-body-allowed":
         default:
           return empty;
@@ -682,23 +1108,6 @@ class Parser {
       throw err;
     }
   }
-  static async getParams(endpoint, url, validate) {
-    const data = {};
-    if (!endpoint.includes(":")) {
-      return data;
-    }
-    const defParts = endpoint.split("/");
-    const reqParts = url.pathname.split("/");
-    for (const [i, defPart] of defParts.entries()) {
-      const reqPart = reqParts[i];
-      if (defPart.startsWith(":") && reqPart !== undefined) {
-        const key = defPart.slice(1);
-        const value = this.processString(decodeURIComponent(reqPart));
-        data[key] = value;
-      }
-    }
-    return await this.parse(data, validate);
-  }
   static async getUnknownBody(input, validate) {
     if (!validate) {
       return await this.getTextBody(input);
@@ -720,7 +1129,7 @@ class Parser {
     const params = new URLSearchParams(text);
     const body = {};
     for (const [key, value] of params.entries()) {
-      objAppendEntry(body, key, this.processString(value));
+      objAppendEntry(body, key, value);
     }
     return body;
   }
@@ -732,7 +1141,7 @@ class Parser {
       if (value instanceof File) {
         body[key] = value;
       } else {
-        objAppendEntry(body, key, this.processString(value));
+        objAppendEntry(body, key, value);
       }
     }
     return body;
@@ -741,16 +1150,14 @@ class Parser {
     const contentLength = input.headers.get(CommonHeaders.ContentLength);
     const length = contentLength ? parseInt(contentLength) : 0;
     if (length > 0 && length < 1024 * 1024) {
-      const text2 = await input.text();
-      return this.processString(text2);
+      return await input.text();
     }
     const buffer = await input.arrayBuffer();
     const contentType = input.headers.get(CommonHeaders.ContentType) || "";
     const match = contentType.match(/charset=([^;]+)/i);
     const charset = match?.[1] ? match[1].trim() : null;
     const decoder = new TextDecoder(charset || "utf-8");
-    const text = decoder.decode(buffer);
-    return this.processString(text);
+    return decoder.decode(buffer);
   }
   static getNormalizedContentType(input) {
     const contentTypeHeader = input.headers.get(CommonHeaders.ContentType) || "";
@@ -787,18 +1194,13 @@ class Parser {
     }
     return "unknown";
   }
-  static processString(value) {
-    let processedValue = value;
-    if (!strIsDefined(value))
-      return "";
-    if (/^-?\d+(\.\d+)?$/.test(value)) {
-      processedValue = Number(value);
-    } else if (value.toLowerCase() === "true" || value.toLowerCase() === "false") {
-      processedValue = value.toLowerCase() === "true";
-    }
-    return processedValue;
-  }
 }
+var init_XParser = __esm(() => {
+  init_Status();
+  init_Method();
+  init_CommonHeaders();
+  init_CError();
+});
 
 // src/Context/Context.ts
 class Context {
@@ -810,7 +1212,7 @@ class Context {
     this.body = body;
     this.search = search;
     this.params = params;
-    this.res = res ?? new HttpResponse;
+    this.res = res ?? new CResponse;
   }
   req;
   url;
@@ -824,67 +1226,25 @@ class Context {
   static makeFromRequest(req) {
     return new Context(req, {}, {}, {});
   }
-  static async appendParsedData(ctx, req, endpoint, model, parsedParams) {
-    ctx.body = await Parser.getBody(req, model?.body);
-    ctx.search = await Parser.getSearch(ctx.url, model?.search);
-    ctx.params = parsedParams !== undefined ? await Parser.parse(parsedParams, model?.params) : await Parser.getParams(endpoint, ctx.url, model?.params);
+  static async appendParsedData(ctx, req, params, search, model) {
+    ctx.body = await XParser.parseBody(req, model?.body);
+    ctx.params = await XParser.parseUrlData(params, model?.params);
+    ctx.search = await XParser.parseUrlData(search, model?.search);
   }
 }
-// src/Route/enums/RouteVariant.ts
-var RouteVariant = {
-  static: "static",
-  dynamic: "dynamic"
-};
-
-// src/utils/joinPathSegments.ts
-function joinPathSegments(...segments) {
-  const joined = segments.map((segment) => typeof segment === "number" ? segment.toString() : segment).filter((segment) => segment !== undefined && segment !== null && segment.trim() !== "").map((segment) => segment.replace(/^\/+|\/+$/g, "")).filter((segment) => segment.length > 0).join("/");
-  return `/${joined}`;
-}
+var init_Context = __esm(() => {
+  init_CResponse();
+  init_XParser();
+});
 
 // src/Route/RouteAbstract.ts
 class RouteAbstract {
-  resolveEndpoint(definition, variant) {
-    const endpoint = typeof definition === "string" ? definition : definition.path;
-    if (variant === RouteVariant.dynamic) {
-      return joinPathSegments(_globalPrefix.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;
-    _router.get().addRoute(this);
-    if (model) {
-      _router.get().addModel(this.id, model);
-    }
-  }
-  variant;
-  endpoint;
-  method;
-  pattern;
-  id;
-  handler;
-  model;
   static makeRouteId(method, endpoint) {
     return `${method.toUpperCase()} ${endpoint}`;
   }
@@ -894,113 +1254,134 @@ class Route extends RouteAbstract {
   }
 }
 
-// src/FileWalker/FileWalkerUsingBun.ts
-class FileWalkerUsingBun {
-  static async read(address) {
-    try {
-      const file = await this.find(address);
-      if (!file)
-        return null;
-      return await file.text();
-    } catch {
-      return null;
-    }
-  }
-  static async exists(address) {
-    return await this.find(address) !== null;
-  }
-  static getExtension(address) {
-    return address.split(".").pop() ?? "txt";
-  }
-  static async find(address) {
-    const file = Bun.file(address);
-    const exists = await file.exists();
-    if (exists) {
-      return { text: () => file.text() };
-    }
-    return null;
-  }
+// 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/FileWalker/FileWalker.ts
-class FileWalker extends FileWalkerUsingBun {
-}
+// src/Route/enums/RouteVariant.ts
+var RouteVariant;
+var init_RouteVariant = __esm(() => {
+  RouteVariant = {
+    static: "static",
+    dynamic: "dynamic",
+    websocket: "websocket"
+  };
+});
 
-// src/Route/StaticRoute.ts
-class StaticRoute extends RouteAbstract {
-  filePath;
-  constructor(path2, filePath, handler, model) {
-    super();
-    this.filePath = filePath;
-    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;
-    if (handler) {
-      this.handler = async (c) => {
-        const content = await this.defaultHandler(c);
-        return handler(c, content);
-      };
-    } else {
-      this.handler = this.defaultHandler;
-    }
-    _router.get().addRoute(this);
-  }
-  id;
-  variant;
-  method;
-  endpoint;
-  pattern;
-  model;
-  handler;
-  defaultHandler = async (c) => {
-    const content = await this.getContent();
-    c.res.headers.set(CommonHeaders.ContentType, this.mimeTypes[this.extension] || "application/octet-stream");
-    c.res.headers.set(CommonHeaders.ContentLength, content.length.toString());
-    return content;
+// src/DynamicRoute/DynamicRouteAbstract.ts
+var DynamicRouteAbstract;
+var init_DynamicRouteAbstract = __esm(() => {
+  init_Method();
+  init_src();
+  init_RouteVariant();
+  DynamicRouteAbstract = class DynamicRouteAbstract extends RouteAbstract {
+    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;
+    }
   };
-  get extension() {
-    return this.filePath.split(".").pop() || "txt";
-  }
-  async getContent() {
-    const content = await FileWalker.read(this.filePath);
-    if (!content) {
-      console.error("File not found at:", this.filePath);
-      throw HttpError.notFound();
-    }
-    return content;
-  }
-  mimeTypes = {
-    html: "text/html",
-    htm: "text/html",
-    css: "text/css",
-    js: "application/javascript",
-    ts: "application/javascript",
-    mjs: "application/javascript",
-    json: "application/json",
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    svg: "image/svg+xml",
-    ico: "image/x-icon",
-    txt: "text/plain",
-    xml: "application/xml",
-    pdf: "application/pdf",
-    zip: "application/zip",
-    mp3: "audio/mpeg",
-    mp4: "video/mp4",
-    webm: "video/webm",
-    woff: "font/woff",
-    woff2: "font/woff2",
-    ttf: "font/ttf"
+});
+
+// src/DynamicRoute/DynamicRoute.ts
+var DynamicRoute;
+var init_DynamicRoute = __esm(() => {
+  init_src();
+  init_DynamicRouteAbstract();
+  DynamicRoute = class DynamicRoute extends DynamicRouteAbstract {
+    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;
   };
-}
+});
+
+// src/StaticRoute/StaticRouteAbstract.ts
+var StaticRouteAbstract;
+var init_StaticRouteAbstract = __esm(() => {
+  init_CError();
+  init_CommonHeaders();
+  init_CResponse();
+  init_Status();
+  init_RouteVariant();
+  init_internalLogger();
+  init_XFile();
+  StaticRouteAbstract = class StaticRouteAbstract extends RouteAbstract {
+    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) {
+            log.error("File not found at:", this.filePath);
+            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/StaticRoute/StaticRoute.ts
+var StaticRoute;
+var init_StaticRoute = __esm(() => {
+  init_Method();
+  init_src();
+  init_StaticRouteAbstract();
+  StaticRoute = class StaticRoute extends StaticRouteAbstract {
+    constructor(path2, definition, handler, model) {
+      super();
+      this.endpoint = path2;
+      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;
+  };
+});
 
-// src/Controller/ControllerAbstract.ts
-class ControllerAbstract {
+// src/Controller/Controller.ts
+class Controller {
   constructor(opts) {
     this.prefix = opts?.prefix;
     this.beforeEach = opts?.beforeEach;
@@ -1010,7 +1391,7 @@ class ControllerAbstract {
   beforeEach;
   route(...args) {
     const [definition, handler, model] = args;
-    const route = new Route(this.resolveRouteDefinition(definition), async (ctx) => {
+    const route = new DynamicRoute(this.resolveRouteDefinition(definition), async (ctx) => {
       await this.beforeEach?.(ctx);
       return handler(ctx);
     }, model);
@@ -1033,157 +1414,142 @@ class ControllerAbstract {
     };
   }
 }
-// src/Middleware/Middleware.ts
-class Middleware {
-  constructor(opts) {
-    this.useOn = opts.useOn;
-    this.handler = opts.handler;
-    _router.get().addMiddleware(opts);
-  }
-  useOn;
-  handler;
-}
-// src/Repository/RepositoryAbstract.ts
-class RepositoryAbstract {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-}
-// 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();
+});
 
-// 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/Request/HttpRequest.ts
-class HttpRequest extends Request {
-  info;
-  init;
-  constructor(info, init) {
-    super(info, init);
-    this.info = info;
-    this.init = init;
-    this.urlObject = this.resolveUrlObject();
-    this.headers = this.resolveHeaders();
-    this.cookies = this.resolveCookies();
-    this.isPreflight = this.resolveIsPreflight();
-  }
-  urlObject;
-  isPreflight;
-  cookies;
-  headers;
-  resolveUrlObject() {
-    let urlObject;
-    switch (true) {
-      case this.info instanceof URL:
-        urlObject = this.info;
-        break;
-      case this.info instanceof HttpRequest:
-        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 HttpHeaders(this.init.headers);
-    }
-    if (this.info instanceof Request || this.info instanceof HttpRequest) {
-      return new HttpHeaders(this.info.headers);
-    }
-    return new HttpHeaders;
-  }
-  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 });
+// src/Middleware/Middleware.ts
+var Middleware;
+var init_Middleware = __esm(() => {
+  init_src();
+  Middleware = class Middleware extends MiddlewareAbstract {
+    constructor(opts) {
+      super();
+      this.useOn = opts.useOn;
+      this.handler = opts.handler;
+      $routerStore.get().addMiddleware(this);
+    }
+    useOn;
+    handler;
+  };
+});
+
+// src/CRequest/CRequest.ts
+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;
     }
-    return jar;
-  }
-  resolveIsPreflight() {
-    const accessControlRequestMethodHeader = this.headers.has(CommonHeaders.AccessControlRequestMethod);
-    return this.method === Method.OPTIONS && accessControlRequestMethodHeader;
-  }
-}
-// src/utils/boolToString.ts
-function boolToString(arg) {
-  return arg ? "true" : "false";
-}
-
-// src/utils/isSomeArray.ts
-function isSomeArray(arg) {
-  return arg !== undefined && Array.isArray(arg) && arg.length > 0 && arg.every((a) => a !== null && a !== undefined);
-}
-
-// src/Cors/Cors.ts
-class Cors {
-  opts;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  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);
+    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;
     }
-    if (isSomeArray(allowedMethods)) {
-      res.headers.set(this.methodsKey, allowedMethods.join(", "));
+    resolveIsPreflight() {
+      return this.method === Method.OPTIONS && this.headers.has(CommonHeaders.AccessControlRequestMethod);
     }
-    if (isSomeArray(allowedHeaders)) {
-      res.headers.set(this.headersKey, allowedHeaders.join(", "));
+    resolveIsWebsocketUpgrade() {
+      const isUpgrade = this.headers.get(CommonHeaders.Connection)?.toLowerCase() === "upgrade";
+      const isWebsocket = this.headers.get(CommonHeaders.Upgrade)?.toLowerCase() === "websocket";
+      return isUpgrade && isWebsocket;
     }
-    res.headers.set(this.credentialsKey, boolToString(credentials));
-    return res.headers;
-  }
-  apply(req, res) {
-    const headers = this.getCorsHeaders(req, res);
-    res.headers.innerCombine(headers);
-  }
-}
+  };
+});
 
-// src/utils/strRemoveWhitespace.ts
-function strRemoveWhitespace(str) {
-  return str.trim().replace(/\s+/g, "");
-}
+// src/WebSocketRoute/WebSocketRoute.ts
+var WebSocketRoute;
+var init_WebSocketRoute = __esm(() => {
+  init_src();
+  init_Method();
+  init_RouteVariant();
+  WebSocketRoute = class WebSocketRoute extends RouteAbstract {
+    constructor(path2, handlers) {
+      super();
+      this.endpoint = path2;
+      this.method = Method.GET;
+      this.pattern = this.resolvePattern(this.endpoint);
+      this.id = this.resolveId(this.method, this.endpoint);
+      this.onOpen = handlers.onOpen;
+      this.onClose = handlers.onClose;
+      this.onMessage = handlers.onMessage;
+      $routerStore.get().addRoute(this);
+    }
+    id;
+    method;
+    endpoint;
+    pattern;
+    model;
+    handler = () => this;
+    variant = RouteVariant.websocket;
+    onOpen;
+    onClose;
+    onMessage;
+  };
+});
 
 // src/utils/isRegexMatch.ts
 function isRegexMatch(source, pattern) {
@@ -1210,39 +1576,44 @@ class CorpusAdapter {
     this.checkPossibleCollision(data);
     this.routes.set(data.id, data);
   }
-  find(method, path2) {
+  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()) {
-      const endpoint = data.endpoint;
-      if (this.hasAnyParam(endpoint) && isRegexMatch(path2, data.pattern)) {
+      if (method !== data.method)
+        continue;
+      if (this.hasAnyParam(data.endpoint) && isRegexMatch(pathname, data.pattern)) {
         route = data;
         break;
       }
-      if (this.hasLastPartParam(endpoint) && strIsEqual(this.removeLastParam(endpoint), path2, "lower")) {
+      if (this.hasLastPartParam(data.endpoint) && strIsEqual(this.removeLastParam(data.endpoint), pathname, "lower")) {
         route = data;
         break;
       }
-      if (strIsEqual(endpoint, path2)) {
+      if (strIsEqual(data.endpoint, pathname)) {
         route = data;
         break;
       }
     }
     if (route === null) {
-      throw HttpError.notFound();
-    }
-    if (!strIsEqual(method, route.method, "upper")) {
-      throw HttpError.methodNotAllowed();
+      return null;
     }
-    return { route };
+    return {
+      route,
+      params: this.extractParams(pathname, route.endpoint),
+      search: Object.fromEntries(searchParams)
+    };
   }
   list() {
     return Array.from(this.routes.values());
   }
   checkPossibleCollision(n) {
-    const dupeMsg = (nId) => console.error(`Duplicate route detected. ${nId} has already been registered.`);
-    const dynamicPatternMsg = (nId, oId) => console.error(`Ambiguous dynamic routes. ${nId} and ${oId} match the same URL patterns.`);
-    const baseDupeMsg = (nId, oId) => console.error(`Dynamic route overlaps existing route. ${nId} \u2014 dropping the last param segment matches ${oId}.`);
-    const shadowMsg = (nId, oId) => console.error(`Route shadowed by existing dynamic route. ${nId} will be unreachable \u2014 ${oId} captures the same URL space.`);
+    const 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);
@@ -1267,7 +1638,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;
         }
@@ -1275,6 +1646,20 @@ class CorpusAdapter {
     }
     return false;
   }
+  extractParams(pathname, endpoint) {
+    const data = {};
+    if (!this.hasAnyParam(endpoint))
+      return data;
+    const defParts = endpoint.split("/");
+    const reqParts = pathname.split("/");
+    for (const [i, defPart] of defParts.entries()) {
+      const reqPart = reqParts[i];
+      if (defPart.startsWith(":") && reqPart !== undefined) {
+        data[defPart.slice(1)] = decodeURIComponent(reqPart);
+      }
+    }
+    return data;
+  }
   hasLastPartParam(endpoint) {
     if (!this.hasAnyParam(endpoint))
       return false;
@@ -1292,196 +1677,258 @@ class CorpusAdapter {
     return endpoint.split("/").some((p) => p.startsWith(":"));
   }
 }
+var init_CorpusAdapter = __esm(() => {
+  init_DynamicRoute();
+  init_internalLogger();
+});
 
-// 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;
+// 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;
       }
-    });
-  }
-  _map;
-  get map() {
-    if (!this._map) {
-      this._map = new Map;
+      return this._map;
     }
-    return this._map;
-  }
-  get [Symbol.toStringTag]() {
-    return "LazyMap";
-  }
+    get [Symbol.toStringTag]() {
+      return "LazyMap";
+    }
+  };
+});
+
+// src/utils/strRemoveWhitespace.ts
+function strRemoveWhitespace(str) {
+  return str.trim().replace(/\s+/g, "");
 }
 
-// src/Router/Router.ts
-class Router {
-  constructor(adapter) {
-    this._adapter = adapter ?? new CorpusAdapter;
-  }
-  _adapter;
-  cache = new WeakMap;
-  internFuncMap = new LazyMap;
-  middlewares = new LazyMap;
-  models = new LazyMap;
-  checkPossibleCollision(n) {
-    if (this._adapter instanceof CorpusAdapter) {
-      return this._adapter.checkPossibleCollision(n);
+// src/Router/registries/ModelRegistry.ts
+var ModelRegistry;
+var init_ModelRegistry = __esm(() => {
+  init_LazyMap();
+  ModelRegistry = class ModelRegistry {
+    map = new LazyMap;
+    add(routeId, model) {
+      const entry = ModelRegistry.toRouterModelData(model);
+      this.map.set(routeId, 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;
     }
-    return false;
-  }
-  addModel(routeId, model) {
-    const entry = {};
-    for (const k of Object.keys(model)) {
-      const key = k;
-      const schema = model[key];
-      if (!schema)
+    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;
-      const handler = schema["~standard"].validate;
-      entry[key] = this.intern(handler, "model", strRemoveWhitespace(JSON.stringify(schema)));
+      await fn(...args);
     }
-    this.models.set(routeId, entry);
-  }
-  findModel(routeId) {
-    return this.models.get(routeId);
-  }
-  addMiddleware(m) {
-    const useOn = m.useOn;
-    const handler = m.handler;
-    if (useOn === "*") {
+  };
+}
+
+// src/Router/registries/MiddlewareRegistry.ts
+class MiddlewareRegistry {
+  middlewares = new LazyMap;
+  add(middleware) {
+    const resolved = MiddlewareRegistry.resolveRouteIds(middleware);
+    if (resolved.isGlobal) {
       const existing = this.middlewares.get("*") ?? [];
-      this.middlewares.set("*", [...existing, handler]);
+      this.middlewares.set("*", [...existing, middleware.handler]);
       return;
     }
-    for (const target of Array.isArray(useOn) ? useOn : [useOn]) {
-      const routeIds = target instanceof Route ? [target.id] : target instanceof ControllerAbstract ? Array.from(target.routeIds) : [];
-      for (const routeId of routeIds) {
-        const existing = this.middlewares.get(routeId) ?? [];
-        this.middlewares.set(routeId, [...existing, handler]);
-      }
+    for (const routeId of resolved.routeIds) {
+      const existing = this.middlewares.get(routeId) ?? [];
+      this.middlewares.set(routeId, [...existing, middleware.handler]);
     }
   }
-  findMiddleware(routeId) {
-    const globals = this.middlewares.get("*") ?? [];
-    const locals = this.middlewares.get(routeId) ?? [];
-    return this.compile([...globals, ...locals]);
+  find(routeId) {
+    return compile(this.middlewares.get(routeId) ?? []);
   }
-  addRoute(r) {
-    this._adapter.add({
-      id: r.id,
-      endpoint: r.endpoint,
-      method: r.method,
-      handler: r.handler,
-      pattern: r.pattern
+  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 DynamicRoute) {
+        routeIds.push(target.id);
+      } else if (target instanceof Controller) {
+        routeIds.push(...target.routeIds);
+      }
+    }
+    return { isGlobal: false, routeIds };
+  }
+}
+var init_MiddlewareRegistry = __esm(() => {
+  init_Controller();
+  init_DynamicRoute();
+  init_LazyMap();
+});
+
+// src/Router/Router.ts
+class Router {
+  adapter;
+  constructor(adapter = new CorpusAdapter) {
+    this.adapter = adapter;
+  }
+  modelRegistry = new ModelRegistry;
+  middlewareRegistry = new MiddlewareRegistry;
+  cache = new WeakMap;
+  addMiddleware(middleware) {
+    this.middlewareRegistry.add(middleware);
+  }
+  findMiddleware(id) {
+    return this.middlewareRegistry.find(id);
+  }
+  addRoute(route) {
+    this.adapter.add({
+      id: route.id,
+      endpoint: route.endpoint,
+      method: route.method,
+      handler: route.handler,
+      pattern: route.pattern,
+      variant: route.variant
     });
+    if (route.model) {
+      this.modelRegistry.add(route.id, route.model);
+    }
   }
   findRouteHandler(req) {
-    const cached = this.cache.get(req);
-    if (cached)
-      return cached;
-    const match = this._adapter.find(req.method, req.urlObject.pathname);
+    const match = this.cache.get(req) ?? this.adapter.find(req);
     if (!match)
-      throw HttpError.notFound();
-    const ctx = Context.makeFromRequest(req);
-    const mwHandler = this.findMiddleware(match.route.id);
-    const model = this.findModel(match.route.id);
-    const handler = async () => {
-      await mwHandler(ctx);
-      await Context.appendParsedData(ctx, req, match.route.endpoint, model, match.params);
-      const res = await match.route.handler(ctx);
-      return res instanceof HttpResponse ? res : new HttpResponse(res, {
-        cookies: ctx.res.cookies,
-        headers: ctx.res.headers,
-        status: ctx.res.status,
-        statusText: ctx.res.statusText
-      });
-    };
-    this.cache.set(req, handler);
-    return handler;
-  }
-  getRouteList() {
-    return this._adapter.list().map((v) => [v.method, v.endpoint]);
-  }
-  compile(fns) {
-    return async (...args) => {
-      for (const fn of fns) {
-        if (!fn)
-          continue;
-        await fn(...args);
+      return null;
+    this.cache.set(req, match);
+    const model = this.modelRegistry.find(match.route.id);
+    const middleware = this.middlewareRegistry.find(match.route.id);
+    return async (ctx) => {
+      await middleware(ctx);
+      await Context.appendParsedData(ctx, req, match.params, match.search, model);
+      const result = await match.route.handler(ctx);
+      if (result instanceof WebSocketRoute) {
+        return result;
+      }
+      if (result instanceof CResponse) {
+        return result;
       }
+      return new CResponse(result, ctx.res);
     };
   }
-  intern(value, ...namespace) {
-    const key = namespace.join("::");
-    const existing = this.internFuncMap.get(key);
-    if (existing)
-      return existing;
-    this.internFuncMap.set(key, value);
-    return value;
+  getRouteList() {
+    return this.adapter.list().map((v) => [v.method, v.endpoint]);
   }
 }
+var init_Router = __esm(() => {
+  init_Context();
+  init_CResponse();
+  init_CorpusAdapter();
+  init_ModelRegistry();
+  init_MiddlewareRegistry();
+  init_WebSocketRoute();
+});
 
 // src/Server/ServerAbstract.ts
 class ServerAbstract {
+  opts;
   constructor(opts) {
-    _router.set(new Router(opts?.adapter));
+    this.opts = opts;
+    $routerStore.set(new Router(opts?.adapter));
   }
   get routes() {
-    return _router.get().getRouteList();
+    return $routerStore.get().getRouteList();
   }
   setGlobalPrefix(value) {
-    _globalPrefix.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 HttpRequest(request);
-    let res = await this.getResponse(req);
-    if (this.cors !== undefined) {
-      this.cors.apply(req, res);
-    }
-    if (this.handleAfterResponse) {
-      res = await this.handleAfterResponse(res);
+    const req = new CRequest(request);
+    const handled = await this.handleRequest(req, () => {
+      return;
+    });
+    if (!handled) {
+      logFatal("WebSocket requests cannot be handled with this method.");
     }
-    return res.response;
+    return handled;
   }
-  async getResponse(req) {
+  async handleRequest(req, onUpgrade) {
+    let res;
     try {
       if (req.isPreflight) {
-        return new HttpResponse("Departed");
-      }
-      const handler = _router.get().findRouteHandler(req);
-      return await handler();
-    } catch (err) {
-      if (err instanceof HttpError) {
-        if (err.isStatusOf(Status.NOT_FOUND)) {
-          return await this.handleNotFound(req);
-        }
-        if (err.isStatusOf(Status.METHOD_NOT_ALLOWED)) {
-          return await this.handleMethodNotAllowed(req);
+        res = await this.handlePreflight(req);
+      } else {
+        const router = $routerStore.get();
+        const handleFound = router.findRouteHandler(req);
+        const ctx = Context.makeFromRequest(req);
+        const handleGlobalMiddleware = router.findMiddleware("*");
+        await handleGlobalMiddleware(ctx);
+        const result = await handleFound?.(ctx);
+        if (result instanceof WebSocketRoute && req.isWebsocket) {
+          return onUpgrade(result);
+        } else if (result instanceof CResponse) {
+          res = result;
+        } else {
+          res = await this.handleNotFound(req);
         }
       }
-      return await this.handleError(err);
+    } catch (err) {
+      res = await this.handleError(err);
     }
-  }
-  cors;
-  setCors(opts) {
-    this.cors = opts ? new Cors(opts) : undefined;
+    const cors = $corsStore.get();
+    if (cors !== null) {
+      cors.apply(req, res);
+    }
+    if (this.handleAfterResponse) {
+      res = await this.handleAfterResponse(res);
+    }
+    return res.response;
   }
   handleBeforeListen;
   setOnBeforeListen(handler) {
@@ -1503,206 +1950,496 @@ class ServerAbstract {
     this.handleError = handler;
   }
   defaultErrorHandler = (err) => {
-    if (!(err instanceof Error)) {
-      return new HttpResponse({ error: err, message: "Unknown" }, { status: Status.INTERNAL_SERVER_ERROR });
-    }
-    if (err instanceof HttpError) {
+    if (err instanceof CError) {
       return err.toResponse();
     }
-    return new HttpResponse({ error: err, message: err.message }, { status: Status.INTERNAL_SERVER_ERROR });
+    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 HttpResponse({ error: true, message: `${req.method} on ${req.url} does not exist.` }, { status: Status.NOT_FOUND });
+    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 HttpResponse({ error: `${req.method} ${req.url} does not exist.` }, { status: Status.METHOD_NOT_ALLOWED });
+  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/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();
-    if (Config.nodeEnv !== "test") {
-      process.exit(0);
-    }
-  }
-  createApp(options) {
-    return Bun.serve({
-      port: options.port,
-      hostname: options.hostname,
-      fetch: options.fetch
-    });
+// src/CWebSocket/CWebSocket.bun.ts
+class CWebSocketBun {
+  constructor(ws) {
+    this.ws = ws;
+    this.subscriptions = this.ws.subscriptions;
+    this.remoteAddress = this.ws.remoteAddress;
+    this.readyState = this.ws.readyState;
+  }
+  subscriptions;
+  remoteAddress;
+  readyState;
+  ws;
+  send(data) {
+    return this.ws.send(data);
+  }
+  publish(topic, data) {
+    return this.ws.publish(topic, data);
+  }
+  cork(callback) {
+    return this.ws.cork(callback);
+  }
+  close(code, reason) {
+    return this.ws.close(code, reason);
+  }
+  terminate() {
+    return this.ws.terminate();
+  }
+  subscribe(topic) {
+    return this.ws.subscribe(topic);
+  }
+  unsubscribe(topic) {
+    return this.ws.unsubscribe(topic);
+  }
+  isSubscribed(topic) {
+    return this.ws.isSubscribed(topic);
   }
 }
 
-// src/Server/Server.ts
-class Server extends ServerUsingBun {
-}
-// node_modules/memoirist/dist/bun/index.js
-var Y = (v, b) => {
-  let A = b?.length ? {} : null;
-  if (A)
-    for (let Q of b)
-      A[Q.part.charCodeAt(0)] = Q;
-  return { part: v, store: null, inert: A, params: null, wildcardStore: null };
-};
-var k = (v, b) => ({ ...v, part: b });
-var T = (v) => ({ name: v, store: null, inert: null });
-
-class _ {
-  config;
-  root = {};
-  history = [];
-  deferred = [];
-  constructor(v = {}) {
-    this.config = v;
-    if (v.lazy)
-      this.find = this.lazyFind;
-    if (v.onParam && !Array.isArray(v.onParam))
-      this.config.onParam = [this.config.onParam];
-  }
-  static regex = { static: /:.+?(?=\/|$)/, params: /:.+?(?=\/|$)/g, optionalParams: /(\/:\w+\?)/g };
-  lazyFind = (v, b) => {
-    if (!this.config.lazy)
-      return this.find;
-    return this.build(), this.find(v, b);
-  };
-  build() {
-    if (!this.config.lazy)
-      return;
-    for (let [v, b, A] of this.deferred)
-      this.add(v, b, A, { lazy: false, ignoreHistory: true });
-    this.deferred = [], this.find = (v, b) => {
-      let A = this.root[v];
-      if (!A)
-        return null;
-      return $(b, b.length, A, 0, this.config.onParam);
-    };
-  }
-  add(v, b, A, { ignoreError: Q = false, ignoreHistory: O = false, lazy: V = this.config.lazy } = {}) {
-    if (V)
-      return this.find = this.lazyFind, this.deferred.push([v, b, A]), A;
-    if (typeof b !== "string")
-      throw new TypeError("Route path must be a string");
-    if (b === "")
-      b = "/";
-    else if (b[0] !== "/")
-      b = `/${b}`;
-    let X = b[b.length - 1] === "*", J = b.match(_.regex.optionalParams);
-    if (J) {
-      let F = b.replaceAll("?", "");
-      this.add(v, F, A, { ignoreError: Q, ignoreHistory: O, lazy: V });
-      for (let B = 0;B < J.length; B++) {
-        let D = b.replace(J[B], "");
-        this.add(v, D, A, { ignoreError: true, ignoreHistory: O, lazy: V });
+// src/Server/Server.bun.ts
+var exports_Server_bun = {};
+__export(exports_Server_bun, {
+  default: () => ServerUsingBun
+});
+var ServerUsingBun;
+var init_Server_bun = __esm(() => {
+  init_Config();
+  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 (Config.nodeEnv !== "test") {
+        process.exit(0);
       }
-      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;
+    }
+    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);
+      return await this.handleRequest(req, (wsRoute) => {
+        const upgraded = server.upgrade(request, { data: wsRoute });
+        if (!upgraded) {
+          throw new CError("Upgrade failed", Status.UPGRADE_REQUIRED);
         }
-        q = S.inert;
+        return;
+      });
+    }
+    websocket = {
+      async open(ws) {
+        await ws.data.onOpen?.(new CWebSocketBun(ws));
+      },
+      async message(ws, message) {
+        await ws.data.onMessage(new CWebSocketBun(ws), message);
+      },
+      async close(ws, code, reason) {
+        await ws.data.onClose?.(new CWebSocketBun(ws), code, reason);
       }
-      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;
+    };
+  };
+});
+
+// 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_Config();
+  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 response = await this.handleRequest(req, () => {
+          return;
+        });
+        if (!response) {
+          return;
         }
-        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;
+        const data = await this.getData(response);
+        serverResponse.statusCode = response.status;
+        serverResponse.setHeaders(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;
           }
-          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;
+          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;
+        });
+      });
+      console.log(app.eventNames());
+      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 (Config.nodeEnv !== "test") {
+        process.exit(0);
+      }
+    }
+    createWss() {
+      return new import_ws.WebSocketServer({ noServer: true });
+    }
+    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 });
+    }
+    async getBody(incomingMessage) {
+      let body = undefined;
+      const chunks = [];
+      for await (const chunk of incomingMessage) {
+        chunks.push(chunk);
+      }
+      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);
         }
-        ++D;
       }
+      return headers;
     }
-    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);
+    getRequest(url, method, headers, body) {
+      if (method !== Method.GET) {
+        return new Request(url, { method, headers, body });
+      } else {
+        return new Request(url, { method, headers });
+      }
+    }
+    async getData(response) {
+      return await response.arrayBuffer();
+    }
+  };
+});
+
+// src/Server/Server.ts
+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,
+  StaticRouteAbstract: () => StaticRouteAbstract,
+  StaticRoute: () => StaticRoute,
+  Server: () => Server,
+  Route: () => DynamicRoute,
+  Response: () => CResponse,
+  Request: () => CRequest,
+  MiddlewareAbstract: () => MiddlewareAbstract,
+  Middleware: () => Middleware,
+  Method: () => Method,
+  Headers: () => CHeaders,
+  Error: () => CError,
+  DynamicRouteAbstract: () => DynamicRouteAbstract,
+  Cookies: () => Cookies,
+  Controller: () => Controller,
+  Context: () => Context,
+  Config: () => Config,
+  CommonHeaders: () => CommonHeaders
+});
+var init_C = __esm(() => {
+  init_Config();
+  init_Context();
+  init_Controller();
+  init_Cookies();
+  init_CError();
+  init_CHeaders();
+  init_Middleware();
+  init_CRequest();
+  init_CResponse();
+  init_DynamicRouteAbstract();
+  init_DynamicRoute();
+  init_StaticRouteAbstract();
+  init_StaticRoute();
+  init_WebSocketRoute();
+  init_Server();
+  init_CommonHeaders();
+  init_Method();
+  init_Status();
+});
+
+// src/utils/boolToString.ts
+function boolToString(arg) {
+  return arg ? "true" : "false";
+}
+
+// src/utils/isSomeArray.ts
+function isSomeArray(arg) {
+  return arg !== undefined && Array.isArray(arg) && arg.length > 0 && arg.every((a) => a !== null && a !== undefined);
+}
+
+// src/utils/arrMerge.ts
+function arrMerge(base = [], override = []) {
+  if (base.length === 0 && override.length === 0)
+    return;
+  const seen = new Set(base);
+  for (const item of override)
+    seen.add(item);
+  return [...seen];
+}
+
+// src/XCors/XCors.ts
+class XCors {
+  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";
+  exposedHeadersKey = "Access-Control-Expose-Headers";
+  getCorsHeaders(req, res) {
+    const reqOrigin = req.headers.get("origin") ?? "";
+    const {
+      allowedOrigins,
+      allowedMethods,
+      allowedHeaders,
+      exposedHeaders,
+      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(", "));
+    }
+    if (isSomeArray(exposedHeaders)) {
+      res.headers.set(this.exposedHeadersKey, exposedHeaders.join(", "));
+    }
+    res.headers.set(this.credentialsKey, boolToString(credentials));
+    return res.headers;
+  }
+  apply(req, res) {
+    const headers = this.getCorsHeaders(req, res);
+    res.headers.innerCombine(headers);
+  }
+  updateOptions(newOpts) {
+    this.opts = {
+      ...this.opts,
+      ...newOpts,
+      allowedHeaders: arrMerge(this.opts?.allowedHeaders, newOpts.allowedHeaders),
+      allowedMethods: arrMerge(this.opts?.allowedMethods, newOpts.allowedMethods),
+      allowedOrigins: arrMerge(this.opts?.allowedOrigins, newOpts.allowedOrigins),
+      exposedHeaders: arrMerge(this.opts?.exposedHeaders, newOpts.exposedHeaders)
+    };
+    $corsStore.set(this);
   }
 }
-var $ = (v, b, A, Q, O) => {
+var init_XCors = __esm(() => {
+  init_src();
+});
+
+// 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;
+  if (A)
+    for (let Q of b)
+      A[Q.part.charCodeAt(0)] = Q;
+  return { part: v, store: null, inert: A, params: null, wildcardStore: null };
+}, 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)
@@ -1760,28 +2497,590 @@ 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;
-  add(data) {
-    this.router.add(data.method, data.endpoint, data);
-  }
-  find(method, path2) {
-    const result = this.router.find(method, path2);
+  find(req) {
+    const method = req.method;
+    const pathname = req.urlObject.pathname;
+    const searchParams = req.urlObject.searchParams;
+    const result = this.router.find(method, pathname);
     if (!result)
       return null;
-    return { route: result.store, params: result.params };
+    return {
+      route: result.store,
+      params: result.params,
+      search: Object.fromEntries(searchParams)
+    };
   }
   list() {
     return this.router.history.map((v) => v[2]);
   }
+  add(data) {
+    this.router.add(data.method, data.endpoint, data);
+  }
 }
+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;
+    }
+  }
+  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));
+      }
+    }
+  }
+  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() {
+    const exposedHeaders = Object.values(this.config.headerNames);
+    const cors = $corsStore.get();
+    if (cors) {
+      cors.updateOptions({ exposedHeaders });
+    } else {
+      new XCors({ exposedHeaders });
+    }
+    new Middleware({
+      useOn: "*",
+      handler: async (c) => {
+        const result = await this.getResult(c.headers);
+        c.res.headers.innerCombine(result.headers);
+        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_XCors();
+  init_src();
+  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
+});
+var init_X = __esm(() => {
+  init_XCors();
+  init_XFile();
+  init_MemoiristAdapter();
+  init_XRateLimiter();
+  init_RateLimiterFileStore();
+  init_XParser();
+});
 
 // src/index.ts
-var _globalPrefix = new GlobalPrefixStore;
-var _router = new GlobalRouterStore;
-var src_default = exports_exports;
+var exports_src = {};
+__export(exports_src, {
+  default: () => exports_C,
+  X: () => exports_X,
+  WebSocketRoute: () => WebSocketRoute,
+  Status: () => Status,
+  StaticRouteAbstract: () => StaticRouteAbstract,
+  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,
+  DynamicRouteAbstract: () => DynamicRouteAbstract,
+  Cors: () => XCors,
+  Cookies: () => Cookies,
+  Controller: () => Controller,
+  Context: () => Context,
+  Config: () => Config,
+  CommonHeaders: () => CommonHeaders,
+  C: () => exports_C,
+  $routerStore: () => $routerStore,
+  $prefixStore: () => $prefixStore,
+  $corsStore: () => $corsStore
+});
+module.exports = __toCommonJS(exports_src);
+var $prefixStore, $routerStore, $corsStore;
+var init_src = __esm(() => {
+  init_GlobalPrefixStore();
+  init_GlobalRouterStore();
+  init_GlobalCorsStore();
+  init_C();
+  init_X();
+  init_C();
+  init_X();
+  $prefixStore = new GlobalPrefixStore;
+  $routerStore = new GlobalRouterStore;
+  $corsStore = new GlobalCorsStore;
+});
+init_src();
 })