@ozanarslan/corpus 0.1.5 → 0.1.6

package/dist/index.js

@@ -41,23 +41,24 @@ class GlobalRouterStore extends StoreAbstract {
   }
 }
 
-// src/exports.ts
-var exports_exports = {};
-__export(exports_exports, {
+// src/Store/globals/GlobalCorsStore.ts
+class GlobalCorsStore extends StoreAbstract {
+  value = null;
+}
+
+// src/C.ts
+var exports_C = {};
+__export(exports_C, {
   Status: () => Status,
   StaticRoute: () => StaticRoute,
   Server: () => Server,
   Route: () => Route,
-  Response: () => HttpResponse,
-  Request: () => HttpRequest,
-  Repository: () => RepositoryAbstract,
-  Parser: () => Parser,
+  Response: () => CResponse,
+  Request: () => CRequest,
   Middleware: () => Middleware,
   Method: () => Method,
-  Headers: () => HttpHeaders,
-  FileWalker: () => FileWalker,
-  Error: () => HttpError,
-  DefaultStatusTexts: () => DefaultStatusTexts,
+  Headers: () => CHeaders,
+  Error: () => CError,
   Cookies: () => Cookies,
   Controller: () => ControllerAbstract,
   Context: () => Context,
@@ -133,7 +134,7 @@ class Config {
     this.env[key] = value;
   }
 }
-// src/Response/enums/Status.ts
+// src/CResponse/enums/Status.ts
 var Status = {
   CONTINUE: 100,
   SWITCHING_PROTOCOLS: 101,
@@ -199,7 +200,7 @@ var Status = {
   NETWORK_AUTHENTICATION_REQUIRED: 511
 };
 
-// src/Response/enums/DefaultStatusTexts.ts
+// src/CResponse/enums/DefaultStatusTexts.ts
 var DefaultStatusTexts = {
   [Status.OK]: "OK",
   [Status.CREATED]: "Created",
@@ -216,11 +217,12 @@ var DefaultStatusTexts = {
   [Status.INTERNAL_SERVER_ERROR]: "Internal Server Error"
 };
 
-// src/Headers/enums/CommonHeaders.ts
+// src/CHeaders/enums/CommonHeaders.ts
 var CommonHeaders = {
   CacheControl: "Cache-Control",
   ContentType: "Content-Type",
   ContentLength: "Content-Length",
+  ContentDisposition: "Content-Disposition",
   AcceptEncoding: "Accept-Encoding",
   Accept: "Accept",
   Authorization: "Authorization",
@@ -310,8 +312,8 @@ class CookiesUsingBun extends CookiesAbstract {
 class Cookies extends CookiesUsingBun {
 }
 
-// src/Headers/HttpHeaders.ts
-class HttpHeaders extends Headers {
+// src/CHeaders/CHeaders.ts
+class CHeaders extends Headers {
   constructor(init) {
     super(init);
   }
@@ -341,7 +343,7 @@ class HttpHeaders extends Headers {
     return target;
   }
   innerCombine(source) {
-    HttpHeaders.combine(source, this);
+    CHeaders.combine(source, this);
   }
   setMany(init) {
     const entries = Array.isArray(init) ? init : Object.entries(init);
@@ -352,7 +354,7 @@ class HttpHeaders extends Headers {
     }
   }
   static findHeaderInInit(init, name) {
-    if (init instanceof HttpHeaders || init instanceof Headers) {
+    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;
@@ -362,19 +364,139 @@ class HttpHeaders extends Headers {
   }
 }
 
-// src/Response/HttpResponse.ts
-class HttpResponse {
-  body;
+// src/utils/isNil.ts
+function isNil(input) {
+  return input === null || input === undefined;
+}
+
+// src/utils/isPrimitive.ts
+function isPrimitive(input) {
+  return typeof input === "string" || typeof input === "number" || typeof input === "boolean" || typeof input === "bigint";
+}
+
+// src/utils/isPlainObject.ts
+function isPlainObject(input) {
+  return typeof input === "object" && input !== null && input.constructor === Object;
+}
+
+// src/CError/CError.ts
+class CError extends Error {
+  message;
+  status;
+  data;
+  constructor(message, status, data) {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.data = data;
+  }
+  toResponse() {
+    return new CResponse(this.data ? { error: this.data, message: this.message } : { error: true, message: this.message }, { status: this.status });
+  }
+  isStatusOf(status) {
+    return this.status === status;
+  }
+  static internalServerError(msg) {
+    const status = Status.INTERNAL_SERVER_ERROR;
+    return new this(msg ?? status.toString(), status);
+  }
+  static badRequest(msg) {
+    const status = Status.BAD_REQUEST;
+    return new this(msg ?? status.toString(), status);
+  }
+  static notFound(msg) {
+    const status = Status.NOT_FOUND;
+    return new this(msg ?? status.toString(), status);
+  }
+  static methodNotAllowed(msg) {
+    const status = Status.METHOD_NOT_ALLOWED;
+    return new this(msg ?? status.toString(), status);
+  }
+  static unprocessableEntity(msg) {
+    const status = Status.UNPROCESSABLE_ENTITY;
+    return new this(msg ?? status.toString(), status);
+  }
+}
+
+// src/XFile/XFileAbstract.ts
+class XFileAbstract {
+  path;
+  fallbackExtension;
+  constructor(path2, fallbackExtension) {
+    this.path = path2;
+    this.fallbackExtension = fallbackExtension;
+  }
+  get name() {
+    return this.path.split("/").pop() ?? this.path;
+  }
+  get extension() {
+    return this.path.split(".").pop() ?? this.fallbackExtension ?? "txt";
+  }
+  get mimeType() {
+    const mimeTypes = {
+      html: "text/html",
+      htm: "text/html",
+      css: "text/css",
+      js: "application/javascript",
+      ts: "application/javascript",
+      mjs: "application/javascript",
+      json: "application/json",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      svg: "image/svg+xml",
+      ico: "image/x-icon",
+      txt: "text/plain",
+      xml: "application/xml",
+      pdf: "application/pdf",
+      zip: "application/zip",
+      mp3: "audio/mpeg",
+      mp4: "video/mp4",
+      webm: "video/webm",
+      woff: "font/woff",
+      woff2: "font/woff2",
+      ttf: "font/ttf"
+    };
+    return mimeTypes[this.extension] ?? "application/octet-stream";
+  }
+}
+
+// src/XFile/XFileUsingBun.ts
+class XFileUsingBun extends XFileAbstract {
+  constructor(...args) {
+    super(...args);
+    this.file = Bun.file(args[0]);
+  }
+  file;
+  async exists() {
+    return await this.file.exists();
+  }
+  async text() {
+    return await this.file.text();
+  }
+  stream() {
+    return this.file.stream();
+  }
+}
+
+// src/XFile/XFile.ts
+class XFile extends XFileUsingBun {
+}
+// src/CResponse/CResponse.ts
+class CResponse {
+  data;
   init;
-  constructor(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.cookies = this.resolveCookies();
+    this.headers = this.resolveHeaders();
+    this.body = this.resolveBody();
+    this.status = this.resolveStatus();
     this.statusText = this.getDefaultStatusText();
   }
+  body;
   headers;
   status;
   statusText;
@@ -386,11 +508,126 @@ class HttpResponse {
       headers: this.headers
     });
   }
-  getCookies() {
+  static redirect(url, init) {
+    const res = new CResponse(undefined, {
+      ...init,
+      status: init?.status ?? Status.FOUND,
+      statusText: init?.statusText ?? DefaultStatusTexts[Status.FOUND]
+    });
+    const urlString = url instanceof URL ? url.toString() : url;
+    res.headers.set(CommonHeaders.Location, urlString);
+    return res;
+  }
+  static permanentRedirect(url, init) {
+    return this.redirect(url, {
+      ...init,
+      status: Status.MOVED_PERMANENTLY
+    });
+  }
+  static temporaryRedirect(url, init) {
+    return this.redirect(url, { ...init, status: Status.TEMPORARY_REDIRECT });
+  }
+  static seeOther(url, init) {
+    return this.redirect(url, { ...init, status: Status.SEE_OTHER });
+  }
+  static createStream(execute) {
+    let cancelled = false;
+    let cleanup;
+    return new ReadableStream({
+      start(controller) {
+        try {
+          cleanup = execute(controller, () => cancelled);
+          if (typeof cleanup !== "function") {
+            controller.close();
+          }
+        } catch (err) {
+          controller.error(err);
+        }
+      },
+      cancel() {
+        cancelled = true;
+        cleanup?.();
+      }
+    });
+  }
+  static sse(source, init, retry) {
+    const encoder = new TextEncoder;
+    const stream = CResponse.createStream((controller, isCancelled) => {
+      return source((event) => {
+        if (isCancelled())
+          return;
+        let chunk = "";
+        if (retry !== undefined)
+          chunk += `retry: ${retry}
+`;
+        if (event.id)
+          chunk += `id: ${event.id}
+`;
+        if (event.event)
+          chunk += `event: ${event.event}
+`;
+        chunk += `data: ${JSON.stringify(event.data)}
+
+`;
+        controller.enqueue(encoder.encode(chunk));
+      });
+    });
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: "text/event-stream",
+      [CommonHeaders.CacheControl]: "no-cache",
+      [CommonHeaders.Connection]: "keep-alive"
+    });
+    return res;
+  }
+  static ndjson(source, init) {
+    const encoder = new TextEncoder;
+    const stream = CResponse.createStream((controller, isCancelled) => {
+      return source((item) => {
+        if (isCancelled())
+          return;
+        controller.enqueue(encoder.encode(`${JSON.stringify(item)}
+`));
+      });
+    });
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: "application/x-ndjson",
+      [CommonHeaders.CacheControl]: "no-cache"
+    });
+    return res;
+  }
+  static async streamFile(filePath, disposition = "attachment", init) {
+    const file = new XFile(filePath);
+    if (!file) {
+      throw CError.notFound();
+    }
+    const stream = file.stream();
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: file.mimeType,
+      [CommonHeaders.ContentDisposition]: `${disposition}; filename="${file.name}"`
+    });
+    return res;
+  }
+  static async file(filePath, init) {
+    const file = new XFile(filePath);
+    if (!file) {
+      throw CError.notFound();
+    }
+    const content = await file.text();
+    const res = new CResponse(content, init);
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: file.mimeType,
+      [CommonHeaders.ContentLength]: content.length.toString()
+    });
+    return res;
+  }
+  resolveCookies() {
     return new Cookies(this.init?.cookies);
   }
-  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) {
@@ -399,7 +636,7 @@ class HttpResponse {
     }
     return headers;
   }
-  getStatus() {
+  resolveStatus() {
     if (this.init?.status)
       return this.init.status;
     if (this.headers.has(CommonHeaders.Location)) {
@@ -412,58 +649,53 @@ 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.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 Blob) {
+      if (this.data.type)
+        this.setContentType(this.data.type);
+      return this.data;
     }
-    if (this.body instanceof Date) {
+    if (this.data instanceof FormData) {
+      this.setContentType("multipart/form-data");
+      return this.data;
+    }
+    if (this.data instanceof URLSearchParams) {
+      this.setContentType("application/x-www-form-urlencoded");
+      return this.data;
+    }
+    if (this.data instanceof ReadableStream) {
+      return this.data;
+    }
+    if (this.data instanceof Date) {
       this.setContentType("text/plain");
-      return this.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;
     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 });
-  }
 }
 
-// src/Request/enums/Method.ts
+// src/CRequest/enums/Method.ts
 var Method = {
   GET: "GET",
   POST: "POST",
@@ -476,45 +708,6 @@ var Method = {
   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/utils/arrIncludes.ts
 function arrIncludes(input, array) {
   return array.includes(input);
@@ -543,7 +736,7 @@ class Parser {
     const result = await validate(data);
     if (result.issues !== undefined) {
       const msg = this.issuesToErrorMessage(result.issues);
-      throw HttpError.unprocessableEntity(msg);
+      throw CError.unprocessableEntity(msg);
     }
     return result.value;
   }
@@ -559,14 +752,14 @@ 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;
@@ -593,7 +786,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;
@@ -605,23 +798,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);
@@ -643,7 +819,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;
   }
@@ -655,7 +831,7 @@ class Parser {
       if (value instanceof File) {
         body[key] = value;
       } else {
-        objAppendEntry(body, key, this.processString(value));
+        objAppendEntry(body, key, value);
       }
     }
     return body;
@@ -664,16 +840,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) || "";
@@ -710,17 +884,6 @@ 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;
-  }
 }
 
 // src/Context/Context.ts
@@ -733,7 +896,7 @@ class Context {
     this.body = body;
     this.search = search;
     this.params = params;
-    this.res = res ?? new HttpResponse;
+    this.res = res ?? new CResponse;
   }
   req;
   url;
@@ -747,10 +910,10 @@ 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 Parser.parseBody(req, model?.body);
+    ctx.params = await Parser.parseUrlData(params, model?.params);
+    ctx.search = await Parser.parseUrlData(search, model?.search);
   }
 }
 // src/Route/enums/RouteVariant.ts
@@ -770,7 +933,7 @@ class RouteAbstract {
   resolveEndpoint(definition, variant) {
     const endpoint = typeof definition === "string" ? definition : definition.path;
     if (variant === RouteVariant.dynamic) {
-      return joinPathSegments(_globalPrefix.get(), endpoint);
+      return joinPathSegments(_prefixStore.get(), endpoint);
     }
     return endpoint;
   }
@@ -796,9 +959,9 @@ class Route extends RouteAbstract {
     this.id = this.resolveId(this.method, this.endpoint);
     this.model = model;
     this.handler = handler;
-    _router.get().addRoute(this);
+    _routerStore.get().addRoute(this);
     if (model) {
-      _router.get().addModel(this.id, model);
+      _routerStore.get().addModel(this, model);
     }
   }
   variant;
@@ -817,59 +980,19 @@ 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/FileWalker/FileWalker.ts
-class FileWalker extends FileWalkerUsingBun {
-}
-
 // src/Route/StaticRoute.ts
 class StaticRoute extends RouteAbstract {
-  filePath;
-  constructor(path2, filePath, handler, model) {
+  constructor(path2, definition, 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);
+    this.filePath = this.resolveFilePath(definition);
+    this.handler = this.resolveHandler(definition, handler);
+    _routerStore.get().addRoute(this);
   }
   id;
   variant;
@@ -878,48 +1001,31 @@ class StaticRoute extends RouteAbstract {
   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;
-  };
-  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"
-  };
+  filePath;
+  resolveFilePath(definition) {
+    return typeof definition === "string" ? definition : definition.filePath;
+  }
+  resolveHandler(definition, customHandler) {
+    if (customHandler !== undefined) {
+      return async (c) => {
+        const file = new XFile(this.filePath);
+        if (!file) {
+          console.error("File not found at:", this.filePath);
+          throw CError.notFound();
+        }
+        const content = await file.text();
+        c.res.headers.setMany({
+          [CommonHeaders.ContentType]: file.mimeType,
+          [CommonHeaders.ContentLength]: content.length.toString()
+        });
+        return customHandler(c, content);
+      };
+    } else if (typeof definition === "string") {
+      return async () => await CResponse.file(this.filePath);
+    } else {
+      return async () => await CResponse.streamFile(this.filePath);
+    }
+  }
 }
 
 // src/Controller/ControllerAbstract.ts
@@ -961,18 +1067,11 @@ class Middleware {
   constructor(opts) {
     this.useOn = opts.useOn;
     this.handler = opts.handler;
-    _router.get().addMiddleware(opts);
+    _routerStore.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);
@@ -996,8 +1095,8 @@ function strSplit(mark, input, minLength) {
   return parts;
 }
 
-// src/Request/HttpRequest.ts
-class HttpRequest extends Request {
+// src/CRequest/CRequest.ts
+class CRequest extends Request {
   info;
   init;
   constructor(info, init) {
@@ -1019,7 +1118,7 @@ class HttpRequest extends Request {
       case this.info instanceof URL:
         urlObject = this.info;
         break;
-      case this.info instanceof HttpRequest:
+      case this.info instanceof CRequest:
         urlObject = this.info.urlObject;
         break;
       case this.info instanceof Request:
@@ -1036,12 +1135,12 @@ class HttpRequest extends Request {
   }
   resolveHeaders() {
     if (this.init?.headers !== undefined) {
-      return new HttpHeaders(this.init.headers);
+      return new CHeaders(this.init.headers);
     }
-    if (this.info instanceof Request || this.info instanceof HttpRequest) {
-      return new HttpHeaders(this.info.headers);
+    if (this.info instanceof Request || this.info instanceof CRequest) {
+      return new CHeaders(this.info.headers);
     }
-    return new HttpHeaders;
+    return new CHeaders;
   }
   resolveCookies() {
     const jar = new Cookies;
@@ -1062,44 +1161,43 @@ class HttpRequest extends Request {
     return this.method === Method.OPTIONS && accessControlRequestMethodHeader;
   }
 }
-// src/utils/boolToString.ts
-function boolToString(arg) {
-  return arg ? "true" : "false";
+// src/utils/isRegexMatch.ts
+function isRegexMatch(source, pattern) {
+  return pattern.test(source);
 }
 
-// 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/strIsEqual.ts
+function strIsEqual(source, target, modifier) {
+  source = source.trim();
+  target = target.trim();
+  if (modifier === "upper") {
+    return source.toUpperCase() === target.toUpperCase();
+  }
+  if (modifier === "lower") {
+    return source.toUpperCase() === target.toUpperCase();
+  }
+  return source === target;
 }
 
-// src/Cors/Cors.ts
-class Cors {
-  opts;
-  constructor(opts) {
-    this.opts = opts;
+// 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;
+      }
+    });
   }
-  originKey = "Access-Control-Allow-Origin";
-  methodsKey = "Access-Control-Allow-Methods";
-  headersKey = "Access-Control-Allow-Headers";
-  credentialsKey = "Access-Control-Allow-Credentials";
-  getCorsHeaders(req, res) {
-    const reqOrigin = req.headers.get("origin") ?? "";
-    const { allowedOrigins, allowedMethods, allowedHeaders, credentials } = this.opts;
-    if (isSomeArray(allowedOrigins) && allowedOrigins.includes(reqOrigin)) {
-      res.headers.set(this.originKey, reqOrigin);
-    }
-    if (isSomeArray(allowedMethods)) {
-      res.headers.set(this.methodsKey, allowedMethods.join(", "));
-    }
-    if (isSomeArray(allowedHeaders)) {
-      res.headers.set(this.headersKey, allowedHeaders.join(", "));
+  _map;
+  get map() {
+    if (!this._map) {
+      this._map = new Map;
     }
-    res.headers.set(this.credentialsKey, boolToString(credentials));
-    return res.headers;
+    return this._map;
   }
-  apply(req, res) {
-    const headers = this.getCorsHeaders(req, res);
-    res.headers.innerCombine(headers);
+  get [Symbol.toStringTag]() {
+    return "LazyMap";
   }
 }
 
@@ -1108,55 +1206,133 @@ function strRemoveWhitespace(str) {
   return str.trim().replace(/\s+/g, "");
 }
 
-// src/utils/isRegexMatch.ts
-function isRegexMatch(source, pattern) {
-  return pattern.test(source);
+// src/Router/registries/ModelRegistry.ts
+class ModelRegistry {
+  map = new LazyMap;
+  add(method, endpoint, model) {
+    const entry = ModelRegistry.toRouterModelData(model);
+    this.map.set(Route.makeRouteId(method, endpoint), entry);
+  }
+  find(routeId) {
+    return this.map.get(routeId);
+  }
+  static internFuncMap = new LazyMap;
+  static toRouterModelData(model) {
+    const entry = {};
+    for (const k of Object.keys(model)) {
+      const key = k;
+      const schema = model[key];
+      if (!schema)
+        continue;
+      const handler = schema["~standard"].validate;
+      entry[key] = this.intern(handler, "model", strRemoveWhitespace(JSON.stringify(schema)));
+    }
+    return entry;
+  }
+  static intern(value, ...namespace) {
+    const key = namespace.join("::");
+    const existing = this.internFuncMap.get(key);
+    if (existing)
+      return existing;
+    this.internFuncMap.set(key, value);
+    return value;
+  }
 }
 
-// src/utils/strIsEqual.ts
-function strIsEqual(source, target, modifier) {
-  source = source.trim();
-  target = target.trim();
-  if (modifier === "upper") {
-    return source.toUpperCase() === target.toUpperCase();
+// src/utils/compile.ts
+function compile(fns) {
+  return async (...args) => {
+    for (const fn of fns) {
+      if (!fn)
+        continue;
+      await fn(...args);
+    }
+  };
+}
+
+// src/Router/registries/MiddlewareRegistry.ts
+class MiddlewareRegistry {
+  middlewares = new LazyMap;
+  add(m) {
+    const resolved = MiddlewareRegistry.resolveRouteIds(m);
+    if (resolved.isGlobal) {
+      const existing = this.middlewares.get("*") ?? [];
+      this.middlewares.set("*", [...existing, m.handler]);
+      return;
+    }
+    for (const routeId of resolved.routeIds) {
+      const existing = this.middlewares.get(routeId) ?? [];
+      this.middlewares.set(routeId, [...existing, m.handler]);
+    }
   }
-  if (modifier === "lower") {
-    return source.toUpperCase() === target.toUpperCase();
+  find(routeId) {
+    const globals = this.middlewares.get("*") ?? [];
+    const locals = this.middlewares.get(routeId) ?? [];
+    return compile([...globals, ...locals]);
+  }
+  static resolveRouteIds(m) {
+    if (m.useOn === "*")
+      return { isGlobal: true };
+    const targets = Array.isArray(m.useOn) ? m.useOn : [m.useOn];
+    const routeIds = [];
+    for (const target of targets) {
+      if (target instanceof Route) {
+        routeIds.push(target.id);
+      } else if (target instanceof ControllerAbstract) {
+        routeIds.push(...target.routeIds);
+      }
+    }
+    return { isGlobal: false, routeIds };
   }
-  return source === target;
 }
 
 // src/Router/adapters/CorpusAdapter.ts
 class CorpusAdapter {
   routes = new Map;
-  add(data) {
+  modelRegistry = new ModelRegistry;
+  middlewareRegistry = new MiddlewareRegistry;
+  addRoute(data) {
     this.checkPossibleCollision(data);
     this.routes.set(data.id, data);
   }
-  find(method, path2) {
+  addModel(route, model) {
+    this.modelRegistry.add(route.method, route.endpoint, model);
+  }
+  addMiddleware(middleware) {
+    this.middlewareRegistry.add(middleware);
+  }
+  find(req) {
+    const method = req.method;
+    const pathname = req.urlObject.pathname;
+    const searchParams = req.urlObject.searchParams;
     let route = null;
     for (const data of this.routes.values()) {
-      const endpoint = data.endpoint;
-      if (this.hasAnyParam(endpoint) && isRegexMatch(path2, data.pattern)) {
+      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();
+      throw CError.notFound();
     }
     if (!strIsEqual(method, route.method, "upper")) {
-      throw HttpError.methodNotAllowed();
+      throw CError.methodNotAllowed();
     }
-    return { route };
+    return {
+      route,
+      model: this.modelRegistry.find(route.id),
+      middleware: this.middlewareRegistry.find(route.id),
+      params: this.extractParams(pathname, route.endpoint),
+      search: Object.fromEntries(searchParams)
+    };
   }
   list() {
     return Array.from(this.routes.values());
@@ -1198,6 +1374,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;
@@ -1216,82 +1406,29 @@ class CorpusAdapter {
   }
 }
 
-// src/Store/LazyMap.ts
-class LazyMap {
-  constructor() {
-    return new Proxy(this, {
-      get(target, prop) {
-        const val = Reflect.get(target.map, prop);
-        return typeof val === "function" ? val.bind(target.map) : val;
-      }
-    });
-  }
-  _map;
-  get map() {
-    if (!this._map) {
-      this._map = new Map;
-    }
-    return this._map;
-  }
-  get [Symbol.toStringTag]() {
-    return "LazyMap";
-  }
-}
-
 // src/Router/Router.ts
 class Router {
   constructor(adapter) {
     this._adapter = adapter ?? new CorpusAdapter;
   }
+  models = [];
   _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);
     }
     return false;
   }
-  addModel(routeId, 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)));
-    }
-    this.models.set(routeId, entry);
-  }
-  findModel(routeId) {
-    return this.models.get(routeId);
-  }
-  addMiddleware(m) {
-    const useOn = m.useOn;
-    const handler = m.handler;
-    if (useOn === "*") {
-      const existing = this.middlewares.get("*") ?? [];
-      this.middlewares.set("*", [...existing, 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]);
-      }
-    }
+  addModel(route, model) {
+    this.models.push(model);
+    this._adapter.addModel(route, model);
   }
-  findMiddleware(routeId) {
-    const globals = this.middlewares.get("*") ?? [];
-    const locals = this.middlewares.get(routeId) ?? [];
-    return this.compile([...globals, ...locals]);
+  addMiddleware(middleware) {
+    this._adapter.addMiddleware(middleware);
   }
   addRoute(r) {
-    this._adapter.add({
+    this._adapter.addRoute({
       id: r.id,
       endpoint: r.endpoint,
       method: r.method,
@@ -1303,17 +1440,15 @@ class Router {
     const cached = this.cache.get(req);
     if (cached)
       return cached;
-    const match = this._adapter.find(req.method, req.urlObject.pathname);
+    const match = this._adapter.find(req);
     if (!match)
-      throw HttpError.notFound();
+      throw CError.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);
+      await match.middleware?.(ctx);
+      await Context.appendParsedData(ctx, req, match.params, match.search, match.model);
       const res = await match.route.handler(ctx);
-      return res instanceof HttpResponse ? res : new HttpResponse(res, {
+      return res instanceof CResponse ? res : new CResponse(res, {
         cookies: ctx.res.cookies,
         headers: ctx.res.headers,
         status: ctx.res.status,
@@ -1326,35 +1461,20 @@ class Router {
   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);
-      }
-    };
-  }
-  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/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 {
@@ -1373,10 +1493,11 @@ class ServerAbstract {
     }
   }
   async handle(request) {
-    const req = new HttpRequest(request);
+    const req = new CRequest(request);
     let res = await this.getResponse(req);
-    if (this.cors !== undefined) {
-      this.cors.apply(req, res);
+    const cors = _corsStore.get();
+    if (cors !== null) {
+      cors.apply(req, res);
     }
     if (this.handleAfterResponse) {
       res = await this.handleAfterResponse(res);
@@ -1386,12 +1507,12 @@ class ServerAbstract {
   async getResponse(req) {
     try {
       if (req.isPreflight) {
-        return new HttpResponse("Departed");
+        return new CResponse("Departed");
       }
-      const handler = _router.get().findRouteHandler(req);
+      const handler = _routerStore.get().findRouteHandler(req);
       return await handler();
     } catch (err) {
-      if (err instanceof HttpError) {
+      if (err instanceof CError) {
         if (err.isStatusOf(Status.NOT_FOUND)) {
           return await this.handleNotFound(req);
         }
@@ -1402,10 +1523,6 @@ class ServerAbstract {
       return await this.handleError(err);
     }
   }
-  cors;
-  setCors(opts) {
-    this.cors = opts ? new Cors(opts) : undefined;
-  }
   handleBeforeListen;
   setOnBeforeListen(handler) {
     this.handleBeforeListen = handler;
@@ -1427,23 +1544,23 @@ class ServerAbstract {
   }
   defaultErrorHandler = (err) => {
     if (!(err instanceof Error)) {
-      return new HttpResponse({ error: err, message: "Unknown" }, { status: Status.INTERNAL_SERVER_ERROR });
+      return new CResponse({ 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: err.message }, { 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 });
+    return new CResponse({ error: `${req.method} ${req.url} does not exist.` }, { status: Status.METHOD_NOT_ALLOWED });
   };
 }
 
@@ -1456,7 +1573,7 @@ class ServerUsingBun extends ServerAbstract {
   async close() {
     await this.handleBeforeClose?.();
     console.log("Closing...");
-    await this.app?.stop();
+    await this.app?.stop(true);
     if (Config.nodeEnv !== "test") {
       process.exit(0);
     }
@@ -1465,7 +1582,9 @@ class ServerUsingBun extends ServerAbstract {
     return Bun.serve({
       port: options.port,
       hostname: options.hostname,
-      fetch: options.fetch
+      fetch: options.fetch,
+      idleTimeout: this.opts?.idleTimeout,
+      tls: this.opts?.tls
     });
   }
 }
@@ -1473,6 +1592,67 @@ class ServerUsingBun extends ServerAbstract {
 // src/Server/Server.ts
 class Server extends ServerUsingBun {
 }
+// src/X.ts
+var exports_X = {};
+__export(exports_X, {
+  Repository: () => RepositoryAbstract,
+  Parser: () => Parser,
+  MemoiristAdapter: () => MemoiristAdapter,
+  File: () => XFile,
+  Cors: () => Cors
+});
+// src/utils/boolToString.ts
+function boolToString(arg) {
+  return arg ? "true" : "false";
+}
+
+// src/utils/isSomeArray.ts
+function isSomeArray(arg) {
+  return arg !== undefined && Array.isArray(arg) && arg.length > 0 && arg.every((a) => a !== null && a !== undefined);
+}
+
+// src/Cors/Cors.ts
+class Cors {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    if (opts === undefined) {
+      _corsStore.set(null);
+    } else {
+      _corsStore.set(this);
+    }
+  }
+  originKey = "Access-Control-Allow-Origin";
+  methodsKey = "Access-Control-Allow-Methods";
+  headersKey = "Access-Control-Allow-Headers";
+  credentialsKey = "Access-Control-Allow-Credentials";
+  getCorsHeaders(req, res) {
+    const reqOrigin = req.headers.get("origin") ?? "";
+    const { allowedOrigins, allowedMethods, allowedHeaders, credentials } = this.opts ?? {};
+    if (isSomeArray(allowedOrigins) && allowedOrigins.includes(reqOrigin)) {
+      res.headers.set(this.originKey, reqOrigin);
+    }
+    if (isSomeArray(allowedMethods)) {
+      res.headers.set(this.methodsKey, allowedMethods.join(", "));
+    }
+    if (isSomeArray(allowedHeaders)) {
+      res.headers.set(this.headersKey, allowedHeaders.join(", "));
+    }
+    res.headers.set(this.credentialsKey, boolToString(credentials));
+    return res.headers;
+  }
+  apply(req, res) {
+    const headers = this.getCorsHeaders(req, res);
+    res.headers.innerCombine(headers);
+  }
+}
+// src/Repository/RepositoryAbstract.ts
+class RepositoryAbstract {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+}
 // node_modules/memoirist/dist/bun/index.js
 var Y = (v, b) => {
   let A = b?.length ? {} : null;
@@ -1689,47 +1869,94 @@ var 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);
+  pendingMiddlewares = new Map;
+  find(req) {
+    const method = req.method;
+    const pathname = req.urlObject.pathname;
+    const searchParams = req.urlObject.searchParams;
+    const result = this.router.find(method, pathname);
     if (!result)
       return null;
-    return { route: result.store, params: result.params };
+    return {
+      route: result.store.route,
+      model: result.store.model,
+      params: result.params,
+      search: Object.fromEntries(searchParams),
+      middleware: compile(result.store.middlewares ?? [])
+    };
   }
   list() {
-    return this.router.history.map((v) => v[2]);
+    return this.router.history.map((v) => v[2].route);
+  }
+  addRoute(data) {
+    this.router.add(data.method, data.endpoint, { route: data });
+    const pending = this.pendingMiddlewares.get(data.id);
+    if (pending) {
+      const store = this.router.find(data.method, data.endpoint)?.store;
+      if (store)
+        store.middlewares = pending;
+      this.pendingMiddlewares.delete(data.id);
+    }
+  }
+  addModel(route, model) {
+    const result = this.router.find(route.method, route.endpoint);
+    if (!result)
+      return;
+    result.store.model = ModelRegistry.toRouterModelData(model);
+  }
+  addMiddleware(middleware) {
+    const resolved = MiddlewareRegistry.resolveRouteIds(middleware);
+    if (resolved.isGlobal) {
+      for (const [, , store] of this.router.history) {
+        store.middlewares = [...store.middlewares ?? [], middleware.handler];
+      }
+      return;
+    }
+    for (const routeId of resolved.routeIds) {
+      const [method, endpoint] = routeId.split(" ", 2);
+      const result = this.router.find(method, endpoint);
+      if (result) {
+        result.store.middlewares = [
+          ...result.store.middlewares ?? [],
+          middleware.handler
+        ];
+      } else {
+        const pending = this.pendingMiddlewares.get(routeId) ?? [];
+        this.pendingMiddlewares.set(routeId, [...pending, middleware.handler]);
+      }
+    }
   }
 }
-
 // src/index.ts
-var _globalPrefix = new GlobalPrefixStore;
-var _router = new GlobalRouterStore;
-var src_default = exports_exports;
+var _prefixStore = new GlobalPrefixStore;
+var _routerStore = new GlobalRouterStore;
+var _corsStore = new GlobalCorsStore;
 export {
-  src_default as default,
-  _router,
-  _globalPrefix,
+  exports_C as default,
+  _routerStore,
+  _prefixStore,
+  _corsStore,
+  exports_X as X,
   Status,
   StaticRoute,
   Server,
   Route,
-  HttpResponse as Response,
-  HttpRequest as Request,
+  CResponse as Response,
+  CRequest as Request,
   RepositoryAbstract as Repository,
   Parser,
   Middleware,
   Method,
   MemoiristAdapter,
-  HttpHeaders as Headers,
-  FileWalker,
-  HttpError as Error,
-  DefaultStatusTexts,
+  CHeaders as Headers,
+  XFile as File,
+  exports_X as Extra,
+  CError as Error,
+  Cors,
   Cookies,
   ControllerAbstract as Controller,
   Context,
   Config,
   CommonHeaders,
-  exports_exports as C
+  exports_C as C
 };