keq 5.0.0-alpha.23 → 5.0.0-alpha.25

package/dist/index.js

@@ -67,111 +67,232 @@ __export(index_exports, {
   composeRoute: () => composeRoute,
   createProxyResponse: () => createProxyResponse,
   createRequest: () => createRequest,
-  keqHostRoute: () => keqHostRoute,
-  keqLocationRoute: () => keqLocationRoute,
-  keqMethodRoute: () => keqMethodRoute,
-  keqModuleRoute: () => keqModuleRoute,
-  keqPathnameRoute: () => keqPathnameRoute,
   request: () => request
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/context/orchestrator-context.ts
-var OrchestratorProperty = /* @__PURE__ */ Symbol("protected context.orchestration.orchestrator");
-var ExecutorProperty = /* @__PURE__ */ Symbol("protected context.orchestration.executor");
-var _a, _b;
-_b = OrchestratorProperty, _a = ExecutorProperty;
-var KeqOrchestratorContext = class {
-  constructor(orchestrator, executor) {
-    __publicField(this, _b);
-    __publicField(this, _a);
-    this[OrchestratorProperty] = orchestrator;
-    this[ExecutorProperty] = executor;
+// src/exception/exception.ts
+var import_ts_custom_error = require("ts-custom-error");
+var Exception = class extends import_ts_custom_error.CustomError {
+  constructor(message) {
+    super(message);
+    Object.defineProperty(this, "name", { value: "KeqError" });
   }
-  get middlewares() {
-    return this[OrchestratorProperty].executors.map((exe) => exe.context);
+};
+
+// src/exception/type.exception.ts
+var TypeException = class extends Exception {
+  constructor(msg) {
+    super(msg || "Invalid Type");
   }
-  // NOTE: For Future
-  // get executing(): KeqMiddlewareContext {
-  //   const current = this[OrchestratorProperty].current
-  //   const executors = this[OrchestratorProperty].executors
-  //   const executor = executors[current]
-  //   return executor.context
-  // }
-  /**
-   * The middleware context of the current middleware
-   */
-  get middleware() {
-    return this[ExecutorProperty].context;
+};
+
+// src/exception/abort.exception.ts
+var AbortException = class _AbortException extends DOMException {
+  constructor(msg) {
+    super(msg, "AbortError");
+    Object.setPrototypeOf(this, _AbortException.prototype);
   }
-  fork() {
-    return this[OrchestratorProperty].fork();
+};
+
+// src/exception/timeout.exception.ts
+var TimeoutException = class extends AbortException {
+  constructor(msg) {
+    super(msg);
   }
-  merge(source) {
-    this[OrchestratorProperty].merge(source);
+};
+
+// src/exception/http-exceptions/request.exception.ts
+var RequestException = class extends Exception {
+  constructor(statusCode, message, options) {
+    super(message);
+    __publicField(this, "statusCode");
+    __publicField(this, "retry");
+    __publicField(this, "response");
+    this.statusCode = statusCode;
+    this.retry = !(options == null ? void 0 : options.fatal);
+    this.response = options == null ? void 0 : options.response;
+    Object.defineProperty(this, "name", { value: "RequestException" });
   }
 };
 
-// src/context/execution-context.ts
-var ContextOrchestratorProperty = /* @__PURE__ */ Symbol("protected context.orchestrator");
-var ContextOrchestrationProperty = /* @__PURE__ */ Symbol("protected context.orchestration");
-var _a2, _b2;
-_b2 = ContextOrchestratorProperty, _a2 = ContextOrchestrationProperty;
-var KeqExecutionContext = class {
-  constructor(orchestrator, executor) {
-    __publicField(this, _b2);
-    __publicField(this, _a2);
-    this[ContextOrchestratorProperty] = orchestrator;
-    this[ContextOrchestrationProperty] = new KeqOrchestratorContext(orchestrator, executor);
+// src/exception/http-exceptions/bad-request.exception.ts
+var BadRequestException = class extends RequestException {
+  constructor(message = "Bad Request", options) {
+    super(400, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", { value: "BadRequestException" });
   }
-  get orchestration() {
-    return this[ContextOrchestrationProperty];
+};
+
+// src/exception/http-exceptions/unauthorized.exception.ts
+var UnauthorizedException = class extends RequestException {
+  constructor(message = "Unauthorized", options) {
+    super(401, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", { value: "UnauthorizedException" });
   }
-  /**
-   * The unique identifier of the request's location in the code
-   */
-  get locationId() {
-    return this[ContextOrchestratorProperty].context.locationId;
+};
+
+// src/exception/http-exceptions/forbidden.exception.ts
+var ForbiddenException = class extends RequestException {
+  constructor(message = "Forbidden", options) {
+    super(403, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", { value: "ForbiddenException" });
   }
-  get request() {
-    return this[ContextOrchestratorProperty].context.request;
+};
+
+// src/exception/http-exceptions/not-founded.exception.ts
+var NotFoundedException = class extends RequestException {
+  constructor(message = "Not Founded", options) {
+    super(404, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", { value: "NotFoundedException" });
   }
-  get global() {
-    return this[ContextOrchestratorProperty].context.global;
+};
+
+// src/exception/http-exceptions/method-not-allowed.exception.ts
+var MethodNotAllowedException = class extends RequestException {
+  constructor(message = "Method Not Allowed", options) {
+    super(405, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", {
+      value: "MethodNotAllowedException"
+    });
   }
-  get emitter() {
-    return this[ContextOrchestratorProperty].context.emitter;
+};
+
+// src/exception/http-exceptions/not-acceptable.exception.ts
+var NotAcceptableException = class extends RequestException {
+  constructor(message = "Not Acceptable", options) {
+    super(406, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", { value: "NotAcceptableException" });
   }
-  get options() {
-    return this[ContextOrchestratorProperty].context.options;
+};
+
+// src/exception/http-exceptions/proxy-authentication-required.exception.ts
+var ProxyAuthenticationRequiredException = class extends RequestException {
+  constructor(message = "Proxy Authentication Required", options) {
+    super(407, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", {
+      value: "ProxyAuthenticationRequiredException"
+    });
   }
-  // The result get by user if resolveWith is set to 'intelligent' or not set
-  set output(value) {
-    if (this.options.resolveWith && this.options.resolveWith !== "intelligent") {
-      console.warn("The request is configured to resolve with ".concat(this.options.resolveWith, ", so setting context.output maybe no effect."));
-    }
-    this[ContextOrchestratorProperty].context.output = value;
+};
+
+// src/exception/http-exceptions/request-timeout.exception.ts
+var RequestTimeoutException = class extends RequestException {
+  constructor(message = "Request Timeout", options) {
+    super(408, message, { fatal: false, ...options });
+    Object.defineProperty(this, "name", {
+      value: "RequestTimeoutException"
+    });
   }
-  // The original response
-  get res() {
-    return this[ContextOrchestratorProperty].context.res;
+};
+
+// src/exception/http-exceptions/conflict.exception.ts
+var ConflictException = class extends RequestException {
+  constructor(message = "Conflict", options) {
+    super(409, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", { value: "ConflictException" });
   }
-  // The original response
-  set res(value) {
-    this[ContextOrchestratorProperty].context.res = value;
+};
+
+// src/exception/http-exceptions/precondition-failed.exception.ts
+var PreconditionFailedException = class extends RequestException {
+  constructor(message = "Precondition Failed", options) {
+    super(412, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", {
+      value: "PreconditionFailedException"
+    });
   }
-  // The request response
-  get response() {
-    return this[ContextOrchestratorProperty].context.response;
+};
+
+// src/exception/http-exceptions/content-too-large.exception.ts
+var ContentTooLargeException = class extends RequestException {
+  constructor(message = "Content Too Large", options) {
+    super(413, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", {
+      value: "ContentTooLargeException"
+    });
   }
-  // The properties extends by middleware
-  get data() {
-    return this[ContextOrchestratorProperty].context.data;
+};
+
+// src/exception/http-exceptions/uri-too-long.exception.ts
+var UriTooLongException = class extends RequestException {
+  constructor(message = "URI Too Long", options) {
+    super(414, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", { value: "UriTooLongException" });
   }
 };
 
-// src/context/shared-context.ts
-var import_mitt = __toESM(require("mitt"));
+// src/exception/http-exceptions/unsupported-media-type.exception.ts
+var UnsupportedMediaTypeException = class extends RequestException {
+  constructor(message = "Unsupported Media Type", options) {
+    super(415, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", { value: "UnsupportedMediaTypeException" });
+  }
+};
+
+// src/exception/http-exceptions/im-a-teapot.exception.ts
+var ImATeapotException = class extends RequestException {
+  constructor(message = "I'm a teapot", options) {
+    super(418, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", { value: "ImATeapotException" });
+  }
+};
+
+// src/exception/http-exceptions/too-many-requests.exception.ts
+var TooManyRequestsException = class extends RequestException {
+  constructor(message = "Too Many Requests", options) {
+    super(429, message, { fatal: false, ...options });
+    Object.defineProperty(this, "name", { value: "TooManyRequestsException" });
+  }
+};
+
+// src/exception/http-exceptions/internal-server-error.exception.ts
+var InternalServerErrorException = class extends RequestException {
+  constructor(message = "Internal Server Error", options) {
+    super(500, message, { fatal: false, ...options });
+    Object.defineProperty(this, "name", {
+      value: "InternalServerErrorException"
+    });
+  }
+};
+
+// src/exception/http-exceptions/not-implemented.exception.ts
+var NotImplementedException = class extends RequestException {
+  constructor(message = "Not Implemented", options) {
+    super(501, message, { fatal: true, ...options });
+    Object.defineProperty(this, "name", { value: "NotImplementedException" });
+  }
+};
+
+// src/exception/http-exceptions/bad-gateway.exception.ts
+var BadGatewayException = class extends RequestException {
+  constructor(message = "Bad Gateway", options) {
+    super(502, message, { fatal: false, ...options });
+    Object.defineProperty(this, "name", { value: "BadGatewayException" });
+  }
+};
+
+// src/exception/http-exceptions/service-unavailable.exception.ts
+var ServiceUnavailableException = class extends RequestException {
+  constructor(message = "Service Unavailable", options) {
+    super(503, message, { fatal: false, ...options });
+    Object.defineProperty(this, "name", {
+      value: "ServiceUnavailableException"
+    });
+  }
+};
+
+// src/exception/http-exceptions/gateway-timeout.exception.ts
+var GatewayTimeoutException = class extends RequestException {
+  constructor(message = "Gateway Timeout", options) {
+    super(504, message, { fatal: false, ...options });
+    Object.defineProperty(this, "name", { value: "GatewayTimeoutException" });
+  }
+};
+
+// src/utils/base64.ts
+var base64Encode = globalThis.btoa || ((str) => Buffer.from(str).toString("base64"));
+var base64Decode = globalThis.atob || ((str) => Buffer.from(str, "base64").toString("utf8"));
 
 // src/validator/validator.ts
 var Validator = class _Validator {
@@ -286,14 +407,10 @@ function shallowClone(obj) {
   return obj;
 }
 
-// src/exception/exception.ts
-var import_ts_custom_error = require("ts-custom-error");
-var Exception = class extends import_ts_custom_error.CustomError {
-  constructor(message) {
-    super(message);
-    Object.defineProperty(this, "name", { value: "KeqError" });
-  }
-};
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/request-init/utils/clone-body.ts
 function cloneBody(obj) {
@@ -409,8 +526,8 @@ function cloneRequestInit(init) {
 
 // src/request-init/request-init.ts
 var AbortControllerProperty = /* @__PURE__ */ Symbol("context.request.abortController");
-var _a3;
-_a3 = AbortControllerProperty;
+var _a;
+_a = AbortControllerProperty;
 var KeqRequestInit = class {
   constructor(options) {
     __publicField(this, "url");
@@ -426,7 +543,7 @@ var KeqRequestInit = class {
     __publicField(this, "redirect");
     __publicField(this, "referrer");
     __publicField(this, "referrerPolicy");
-    __publicField(this, _a3, new AbortController());
+    __publicField(this, _a, new AbortController());
     this.url = new URL(options.url.href);
     this.pathParameters = shallowClone(options.pathParameters);
     this.method = options.method;
@@ -463,54 +580,151 @@ var KeqRequestInit = class {
     if (typeof this.body === "object") return "application/json";
     return void 0;
   }
-  toFetchBody(contentType) {
-    const body = this.body;
-    if (body === void 0) return;
-    if (body === null) return null;
-    if (Validator.isBodyInit(body)) return body;
-    if (!contentType || contentType === "application/json") {
-      return JSON.stringify(body);
-    }
-    if (contentType === "application/x-www-form-urlencoded") {
-      if (Array.isArray(body)) {
-        throw new Exception("request.body is an array, that cannot be serialized as application/x-www-form-urlencoded format");
-      }
-      return toUrlSearchParams(body);
-    }
-    if (contentType === "multipart/form-data") {
-      if (Array.isArray(body)) {
-        throw new Exception("FormData cannot send array");
-      }
-      return toFormData(body);
+  toFetchBody(contentType) {
+    const body = this.body;
+    if (body === void 0) return;
+    if (body === null) return null;
+    if (Validator.isBodyInit(body)) return body;
+    if (!contentType || contentType === "application/json") {
+      return JSON.stringify(body);
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      if (Array.isArray(body)) {
+        throw new Exception("request.body is an array, that cannot be serialized as application/x-www-form-urlencoded format");
+      }
+      return toUrlSearchParams(body);
+    }
+    if (contentType === "multipart/form-data") {
+      if (Array.isArray(body)) {
+        throw new Exception("FormData cannot send array");
+      }
+      return toFormData(body);
+    }
+    throw new Exception("Cannot auto serialize request.body with Content-Type: ".concat(contentType));
+  }
+  toFetchArguments() {
+    const contentType = this.getContentType();
+    const headers = cloneHeaders(this.headers);
+    if (contentType) headers.set("Content-Type", contentType);
+    const body = this.toFetchBody(contentType);
+    if (contentType === "multipart/form-data") {
+      headers.delete("Content-Type");
+    }
+    const requestInit = {
+      method: this.method.toUpperCase(),
+      headers,
+      body,
+      cache: this.cache,
+      credentials: this.credentials,
+      integrity: this.integrity,
+      keepalive: this.keepalive,
+      mode: this.mode,
+      redirect: this.redirect,
+      referrer: this.referrer,
+      referrerPolicy: this.referrerPolicy,
+      signal: this.signal
+    };
+    return [this.__url__.href, requestInit];
+  }
+};
+
+// src/context/orchestrator-context.ts
+var OrchestratorProperty = /* @__PURE__ */ Symbol("protected context.orchestration.orchestrator");
+var ExecutorProperty = /* @__PURE__ */ Symbol("protected context.orchestration.executor");
+var _a2, _b;
+_b = OrchestratorProperty, _a2 = ExecutorProperty;
+var KeqOrchestratorContext = class {
+  constructor(orchestrator, executor) {
+    __publicField(this, _b);
+    __publicField(this, _a2);
+    this[OrchestratorProperty] = orchestrator;
+    this[ExecutorProperty] = executor;
+  }
+  get middlewares() {
+    return this[OrchestratorProperty].executors.map((exe) => exe.context);
+  }
+  // NOTE: For Future
+  // get executing(): KeqMiddlewareContext {
+  //   const current = this[OrchestratorProperty].current
+  //   const executors = this[OrchestratorProperty].executors
+  //   const executor = executors[current]
+  //   return executor.context
+  // }
+  /**
+   * The middleware context of the current middleware
+   */
+  get middleware() {
+    return this[ExecutorProperty].context;
+  }
+  fork() {
+    return this[OrchestratorProperty].fork();
+  }
+  merge(source) {
+    this[OrchestratorProperty].merge(source);
+  }
+};
+
+// src/context/execution-context.ts
+var ContextOrchestratorProperty = /* @__PURE__ */ Symbol("protected context.orchestrator");
+var ContextOrchestrationProperty = /* @__PURE__ */ Symbol("protected context.orchestration");
+var _a3, _b2;
+_b2 = ContextOrchestratorProperty, _a3 = ContextOrchestrationProperty;
+var KeqExecutionContext = class {
+  constructor(orchestrator, executor) {
+    __publicField(this, _b2);
+    __publicField(this, _a3);
+    this[ContextOrchestratorProperty] = orchestrator;
+    this[ContextOrchestrationProperty] = new KeqOrchestratorContext(orchestrator, executor);
+  }
+  get orchestration() {
+    return this[ContextOrchestrationProperty];
+  }
+  /**
+   * The unique identifier of the request's location in the code
+   */
+  get locationId() {
+    return this[ContextOrchestratorProperty].context.locationId;
+  }
+  get request() {
+    return this[ContextOrchestratorProperty].context.request;
+  }
+  get global() {
+    return this[ContextOrchestratorProperty].context.global;
+  }
+  get emitter() {
+    return this[ContextOrchestratorProperty].context.emitter;
+  }
+  get options() {
+    return this[ContextOrchestratorProperty].context.options;
+  }
+  // The result get by user if resolveWith is set to 'intelligent' or not set
+  set output(value) {
+    if (this.options.resolveWith && this.options.resolveWith !== "intelligent") {
+      console.warn("The request is configured to resolve with ".concat(this.options.resolveWith, ", so setting context.output maybe no effect."));
     }
-    throw new Exception("Cannot auto serialize request.body with Content-Type: ".concat(contentType));
+    this[ContextOrchestratorProperty].context.output = value;
   }
-  toFetchArguments() {
-    const contentType = this.getContentType();
-    const headers = cloneHeaders(this.headers);
-    if (contentType) headers.set("Content-Type", contentType);
-    const body = this.toFetchBody(contentType);
-    if (contentType === "multipart/form-data") {
-      headers.delete("Content-Type");
-    }
-    const requestInit = {
-      method: this.method.toUpperCase(),
-      headers,
-      body,
-      cache: this.cache,
-      credentials: this.credentials,
-      integrity: this.integrity,
-      keepalive: this.keepalive,
-      mode: this.mode,
-      redirect: this.redirect,
-      referrer: this.referrer,
-      referrerPolicy: this.referrerPolicy,
-      signal: this.signal
-    };
-    return [this.__url__.href, requestInit];
+  // The original response
+  get res() {
+    return this[ContextOrchestratorProperty].context.res;
+  }
+  // The original response
+  set res(value) {
+    this[ContextOrchestratorProperty].context.res = value;
+  }
+  // The request response
+  get response() {
+    return this[ContextOrchestratorProperty].context.response;
+  }
+  // The properties extends by middleware
+  get data() {
+    return this[ContextOrchestratorProperty].context.data;
   }
 };
 
+// src/context/shared-context.ts
+var import_mitt = __toESM(require("mitt"));
+
 // src/context/utils/watch-object.ts
 function watchObject(obj, listeners) {
   return new Proxy(obj, {
@@ -731,223 +945,6 @@ var KeqSharedContext = class {
   }
 };
 
-// src/exception/type.exception.ts
-var TypeException = class extends Exception {
-  constructor(msg) {
-    super(msg || "Invalid Type");
-  }
-};
-
-// src/exception/abort.exception.ts
-var AbortException = class _AbortException extends DOMException {
-  constructor(msg) {
-    super(msg, "AbortError");
-    Object.setPrototypeOf(this, _AbortException.prototype);
-  }
-};
-
-// src/exception/timeout.exception.ts
-var TimeoutException = class extends AbortException {
-  constructor(msg) {
-    super(msg);
-  }
-};
-
-// src/exception/http-exceptions/request.exception.ts
-var RequestException = class extends Exception {
-  constructor(statusCode, message, retry = true) {
-    super(message);
-    __publicField(this, "statusCode");
-    __publicField(this, "retry");
-    this.statusCode = statusCode;
-    this.retry = retry;
-    Object.defineProperty(this, "name", { value: "RequestException" });
-  }
-};
-
-// src/exception/http-exceptions/bad-request.exception.ts
-var BadRequestException = class extends RequestException {
-  constructor(message = "Bad Request", retry = false) {
-    super(400, message, retry);
-    Object.defineProperty(this, "name", { value: "BadRequestException" });
-  }
-};
-
-// src/exception/http-exceptions/unauthorized.exception.ts
-var UnauthorizedException = class extends RequestException {
-  constructor(message = "Unauthorized", retry = false) {
-    super(401, message, retry);
-    Object.defineProperty(this, "name", { value: "UnauthorizedException" });
-  }
-};
-
-// src/exception/http-exceptions/forbidden.exception.ts
-var ForbiddenException = class extends RequestException {
-  constructor(message = "Forbidden", retry = false) {
-    super(403, message, retry);
-    Object.defineProperty(this, "name", { value: "ForbiddenException" });
-  }
-};
-
-// src/exception/http-exceptions/not-founded.exception.ts
-var NotFoundedException = class extends RequestException {
-  constructor(message = "Not Founded", retry = false) {
-    super(404, message, retry);
-    Object.defineProperty(this, "name", { value: "NotFoundedException" });
-  }
-};
-
-// src/exception/http-exceptions/method-not-allowed.exception.ts
-var MethodNotAllowedException = class extends RequestException {
-  constructor(message = "Method Not Allowed", retry = false) {
-    super(405, message, retry);
-    Object.defineProperty(this, "name", {
-      value: "MethodNotAllowedException"
-    });
-  }
-};
-
-// src/exception/http-exceptions/not-acceptable.exception.ts
-var NotAcceptableException = class extends RequestException {
-  constructor(message = "Not Acceptable", retry = false) {
-    super(406, message, retry);
-    Object.defineProperty(this, "name", { value: "NotAcceptableException" });
-  }
-};
-
-// src/exception/http-exceptions/proxy-authentication-required.exception.ts
-var ProxyAuthenticationRequiredException = class extends RequestException {
-  constructor(message = "Proxy Authentication Required", retry = false) {
-    super(407, message, retry);
-    Object.defineProperty(this, "name", {
-      value: "ProxyAuthenticationRequiredException"
-    });
-  }
-};
-
-// src/exception/http-exceptions/request-timeout.exception.ts
-var RequestTimeoutException = class extends RequestException {
-  constructor(message = "Request Timeout", retry = true) {
-    super(408, message, retry);
-    Object.defineProperty(this, "name", {
-      value: "RequestTimeoutException"
-    });
-  }
-};
-
-// src/exception/http-exceptions/conflict.exception.ts
-var ConflictException = class extends RequestException {
-  constructor(message = "Conflict", retry = false) {
-    super(409, message, retry);
-    Object.defineProperty(this, "name", { value: "ConflictException" });
-  }
-};
-
-// src/exception/http-exceptions/precondition-failed.exception.ts
-var PreconditionFailedException = class extends RequestException {
-  constructor(message = "Precondition Failed", retry = false) {
-    super(412, message, retry);
-    Object.defineProperty(this, "name", {
-      value: "PreconditionFailedException"
-    });
-  }
-};
-
-// src/exception/http-exceptions/content-too-large.exception.ts
-var ContentTooLargeException = class extends RequestException {
-  constructor(message = "Content Too Large", retry = false) {
-    super(413, message, retry);
-    Object.defineProperty(this, "name", {
-      value: "ContentTooLargeException"
-    });
-  }
-};
-
-// src/exception/http-exceptions/uri-too-long.exception.ts
-var UriTooLongException = class extends RequestException {
-  constructor(message = "URI Too Long", retry = false) {
-    super(414, message, retry);
-    Object.defineProperty(this, "name", { value: "UriTooLongException" });
-  }
-};
-
-// src/exception/http-exceptions/unsupported-media-type.exception.ts
-var UnsupportedMediaTypeException = class extends RequestException {
-  constructor(message = "Unsupported Media Type", retry = false) {
-    super(415, message, retry);
-    Object.defineProperty(this, "name", { value: "UnsupportedMediaTypeException" });
-  }
-};
-
-// src/exception/http-exceptions/im-a-teapot.exception.ts
-var ImATeapotException = class extends RequestException {
-  constructor(message = "I'm a teapot", retry = false) {
-    super(418, message, retry);
-    Object.defineProperty(this, "name", { value: "ImATeapotException" });
-  }
-};
-
-// src/exception/http-exceptions/too-many-requests.exception.ts
-var TooManyRequestsException = class extends RequestException {
-  constructor(message = "Too Many Requests", retry = true) {
-    super(429, message, retry);
-    Object.defineProperty(this, "name", { value: "TooManyRequestsException" });
-  }
-};
-
-// src/exception/http-exceptions/internal-server-error.exception.ts
-var InternalServerErrorException = class extends RequestException {
-  constructor(message = "Internal Server Error", retry = true) {
-    super(500, message, retry);
-    Object.defineProperty(this, "name", {
-      value: "InternalServerErrorException"
-    });
-  }
-};
-
-// src/exception/http-exceptions/not-implemented.exception.ts
-var NotImplementedException = class extends RequestException {
-  constructor(message = "Not Implemented", retry = false) {
-    super(501, message, retry);
-    Object.defineProperty(this, "name", { value: "NotImplementedException" });
-  }
-};
-
-// src/exception/http-exceptions/bad-gateway.exception.ts
-var BadGatewayException = class extends RequestException {
-  constructor(message = "Bad Gateway", retry = true) {
-    super(502, message, retry);
-    Object.defineProperty(this, "name", { value: "BadGatewayException" });
-  }
-};
-
-// src/exception/http-exceptions/service-unavailable.exception.ts
-var ServiceUnavailableException = class extends RequestException {
-  constructor(message = "Service Unavailable", retry = true) {
-    super(503, message, retry);
-    Object.defineProperty(this, "name", {
-      value: "ServiceUnavailableException"
-    });
-  }
-};
-
-// src/exception/http-exceptions/gateway-timeout.exception.ts
-var GatewayTimeoutException = class extends RequestException {
-  constructor(message = "Gateway Timeout", retry = true) {
-    super(504, message, retry);
-    Object.defineProperty(this, "name", { value: "GatewayTimeoutException" });
-  }
-};
-
-// src/utils/base64.ts
-var base64Encode = globalThis.btoa || ((str) => Buffer.from(str).toString("base64"));
-var base64Decode = globalThis.atob || ((str) => Buffer.from(str, "base64").toString("utf8"));
-
-// src/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 // src/middleware/utils/get-middleware-name.ts
 function getMiddlewareName(middleware) {
   return middleware.__keqMiddlewareName__ || middleware.name || "anonymous";
@@ -1164,6 +1161,22 @@ function getLocationId(depth = 0) {
   return stackLine.trim();
 }
 
+// src/request/utils/resolve-with.ts
+var import_stream = require("eventsource-parser/stream");
+async function resolveWith(response, mode) {
+  if (mode === "response") return response.clone();
+  if (mode === "text") return await response.text();
+  if (mode === "json") return unwrap(await response.json());
+  if (mode === "form-data") return await response.formData();
+  if (mode === "blob") return await response.blob();
+  if (mode === "array-buffer") return await response.arrayBuffer();
+  if (mode === "sse") {
+    if (!response.body) return response.body;
+    return response.clone().body.pipeThrough(new TextDecoderStream()).pipeThrough(new import_stream.EventSourceParserStream());
+  }
+  return void 0;
+}
+
 // src/request/utils/intelligent-parse-response.ts
 async function intelligentParseResponse(response) {
   if (!response) return void 0;
@@ -1172,15 +1185,18 @@ async function intelligentParseResponse(response) {
   }
   const contentType = response.headers.get("content-type") || "";
   try {
-    if (contentType.includes("application/json")) {
-      return unwrap(await response.json());
+    if (contentType.match(/^application\/(.+\+)?json/)) {
+      return resolveWith(response, "json");
     } else if (contentType.includes("multipart/form-data")) {
-      return await response.formData();
+      return resolveWith(response, "form-data");
     } else if (contentType.includes("plain/text")) {
-      return await response.text();
+      return resolveWith(response, "text");
+    } else if (contentType.includes("text/event-stream")) {
+      return resolveWith(response, "sse");
     }
-  } catch (e) {
-    console.warn("Failed to auto parse response body", e);
+  } catch (err) {
+    console.warn("Failed to intelligent parse response body: ".concat(response.url), err);
+    throw err;
   }
   return void 0;
 }
@@ -1386,33 +1402,26 @@ var Core = class {
   async end() {
     var _a6;
     const coreContext = await this.run();
-    if (coreContext.options.resolveWith === "response") {
+    const resolveWithMode = coreContext.options.resolveWith;
+    if (resolveWithMode === "response") {
       return (_a6 = coreContext.response) == null ? void 0 : _a6.clone();
     }
     const response = coreContext.response;
-    if (coreContext.options.resolveWith && coreContext.options.resolveWith !== "intelligent" && !response) {
+    if (!resolveWithMode || resolveWithMode === "intelligent") {
+      const output = coreContext.output;
+      if (output !== void 0) {
+        return output;
+      }
+      return await intelligentParseResponse(response);
+    }
+    if (!response) {
       throw new Exception([
-        "Unable to process the response with '".concat(coreContext.options.resolveWith, "'. Possible causes:"),
+        "Unable to process the response with '".concat(resolveWithMode, "'. Possible causes:"),
         "1. The request was never initiated or sent",
         "2. The request failed before a response was received."
       ].join("\n"));
     }
-    if (coreContext.options.resolveWith === "text") {
-      return await response.text();
-    } else if (coreContext.options.resolveWith === "json") {
-      return unwrap(await response.json());
-    } else if (coreContext.options.resolveWith === "form-data") {
-      return await response.formData();
-    } else if (coreContext.options.resolveWith === "blob") {
-      return await response.blob();
-    } else if (coreContext.options.resolveWith === "array-buffer") {
-      return await response.arrayBuffer();
-    }
-    const output = coreContext.output;
-    if (output !== void 0) {
-      return output;
-    }
-    return await intelligentParseResponse(response);
+    return await resolveWith(response, resolveWithMode);
   }
   /**
    * Attaches callbacks for the resolution and/or rejection of the Promise.
@@ -1658,11 +1667,11 @@ function keqPathnameRoute(pathname) {
 }
 
 // src/router/keq-router.ts
-var KeqRouter = class {
+var KeqRouter = class _KeqRouter {
   constructor(middlewares = []) {
     this.middlewares = middlewares;
   }
-  buildMiddleware(route, middlewares) {
+  static buildMiddleware(route, middlewares) {
     if (middlewares.length === 0) {
       throw new TypeException("At least one middleware is required to build a route middleware");
     }
@@ -1673,42 +1682,72 @@ var KeqRouter = class {
     };
     return middleware;
   }
-  route(route, ...middlewares) {
-    const middleware = this.buildMiddleware(route, middlewares);
-    middleware.__keqMiddlewareName__ = "route(".concat(route.__keqRouteName__ || route.name, ", ").concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  route(route, middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.route(route, middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
-  host(host, ...middlewares) {
-    const middleware = this.buildMiddleware(keqHostRoute(host), middlewares);
-    middleware.__keqMiddlewareName__ = "host(".concat(JSON.stringify(host), ", ").concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  host(host, middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.host(host, middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
-  method(method, ...middlewares) {
-    const middleware = this.buildMiddleware(keqMethodRoute(method), middlewares);
-    middleware.__keqMiddlewareName__ = "method(".concat(JSON.stringify(method), ", ").concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  method(method, middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.method(method, middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
-  pathname(pathname, ...middlewares) {
-    const middleware = this.buildMiddleware(keqPathnameRoute(pathname), middlewares);
-    middleware.__keqMiddlewareName__ = "pathname(".concat(JSON.stringify(pathname), ", ").concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  pathname(pathname, middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.pathname(pathname, middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
-  location(...middlewares) {
-    const middleware = this.buildMiddleware(keqLocationRoute(), middlewares);
-    middleware.__keqMiddlewareName__ = "location(".concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  location(middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.location(middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
-  module(moduleName, ...middlewares) {
-    const middleware = this.buildMiddleware(keqModuleRoute(moduleName), middlewares);
-    middleware.__keqMiddlewareName__ = "module(".concat(JSON.stringify(moduleName), ", ").concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  module(moduleName, middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.module(moduleName, middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
+  static route(route, middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(route, list);
+    mid.__keqMiddlewareName__ = "route(".concat(route.__keqRouteName__ || route.name, ", ").concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
+  static host(host, middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(keqHostRoute(host), list);
+    mid.__keqMiddlewareName__ = "host(".concat(JSON.stringify(host), ", ").concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
+  static method(method, middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(keqMethodRoute(method), list);
+    mid.__keqMiddlewareName__ = "method(".concat(JSON.stringify(method), ", ").concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
+  static pathname(pathname, middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(keqPathnameRoute(pathname), list);
+    mid.__keqMiddlewareName__ = "pathname(".concat(JSON.stringify(pathname), ", ").concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
+  static location(middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(keqLocationRoute(), list);
+    mid.__keqMiddlewareName__ = "location(".concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
+  static module(moduleName, middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(keqModuleRoute(moduleName), list);
+    mid.__keqMiddlewareName__ = "module(".concat(JSON.stringify(moduleName), ", ").concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
 };
 
 // src/middlewares/timeout-middleware/index.ts
@@ -1910,6 +1949,14 @@ var KeqRequest = class {
   useRouter() {
     return new KeqRouter(this.preMiddlewares);
   }
+  on(event, listener) {
+    const middleware = async (context, next) => {
+      context.emitter.on(event, listener);
+      await next();
+    };
+    this.use(middleware);
+    return this;
+  }
 };
 var request = new KeqRequest();