opticore-catch-exception-error 1.0.12 → 1.0.14

package/dist/index.js

@@ -1,15 +1,42 @@
 // src/domains/constants/errorName.constant.ts
 var CErrorName = {
+  assertionError: "AssertionError",
+  beforeExit: "beforeExit",
+  eacces: "EACCES",
+  eaddrinuse: "EADDRINUSE",
+  econnrefused: "ECONNREFUSED",
+  econnreset: "ECONNRESET",
+  eexist: "EEXIST",
+  error: "Error",
+  eisdir: "EISDIR",
+  emfile: "EMFILE",
+  enoent: "ENOENT",
+  enotdir: "ENOTDIR",
+  enotEmpty: "ENOTEMPTY",
+  eperm: "EPERM",
+  epipe: "EPIPE",
+  etimedout: "ETIMEDOUT",
   evalError: "EvalError",
-  syntaxError: "SyntaxError",
+  errOsslEvpUnsupported: "ERR_OSSL_EVP_UNSUPPORTED",
+  errOsslBadDecrypt: "ERR_OSSL_BAD_DECRYPT",
+  errOsslWrongFinalBlockLength: "ERR_OSSL_WRONG_FINAL_BLOCK_LENGTH",
+  errInvalidArgType: "ERR_INVALID_ARG_TYPE",
+  errInvalidCallback: "ERR_INVALID_CALLBACK",
+  errHttpHeadersSent: "ERR_HTTP_HEADERS_SENT",
+  errStreamDestroyed: "ERR_STREAM_DESTROYED",
+  errTlsCertAltnameInvalid: "ERR_TLS_CERT_ALTNAME_INVALID",
+  errUnsupportedEsmUrlScheme: "ERR_UNSUPPORTED_ESM_URL_SCHEME",
+  exit: "exit",
+  generalError: "GeneralError",
+  openSSLError: "OpenSSLError",
   rangeError: "RangeError",
   referenceError: "ReferenceError",
+  systemError: "SystemError",
+  syntaxError: "SyntaxError",
   typeError: "TypeError",
   uriError: "URIError",
-  systemError: "SystemError",
-  assertionError: "AssertionError",
-  openSSLError: "OpenSSLError",
-  generalError: "GeneralError"
+  uncaughtException: "uncaughtException",
+  unhandledRejection: "unhandledRejection"
 };
 
 // src/domains/constants/event.constant.ts
@@ -65,7 +92,7 @@ var StackTraceError = class extends Error {
 import { HttpStatusCode as status } from "opticore-http-response";
 var StackTraceAssertionError = class extends StackTraceError {
   constructor(message) {
-    super(message, CErrorName.evalError, status.INTERNAL_SERVER_ERROR, true);
+    super(message, CErrorName.assertionError, status.INTERNAL_SERVER_ERROR, true);
   }
 };
 
@@ -81,7 +108,7 @@ var StackTraceEvalError = class extends StackTraceError {
 import { HttpStatusCode as status3 } from "opticore-http-response";
 var StackTraceGeneralError = class extends StackTraceError {
   constructor(message) {
-    super(message, CErrorName.evalError, status3.INTERNAL_SERVER_ERROR, false);
+    super(message, CErrorName.generalError, status3.INTERNAL_SERVER_ERROR, false);
   }
 };
 
@@ -89,7 +116,7 @@ var StackTraceGeneralError = class extends StackTraceError {
 import { HttpStatusCode as status4 } from "opticore-http-response";
 var StackTraceOpenSSLError = class extends StackTraceError {
   constructor(message) {
-    super(message, CErrorName.evalError, status4.INTERNAL_SERVER_ERROR, false);
+    super(message, CErrorName.openSSLError, status4.INTERNAL_SERVER_ERROR, false);
   }
 };
 
@@ -97,7 +124,7 @@ var StackTraceOpenSSLError = class extends StackTraceError {
 import { HttpStatusCode as status5 } from "opticore-http-response";
 var StackTraceRangeError = class extends StackTraceError {
   constructor(message) {
-    super(message, CErrorName.evalError, status5.BAD_REQUEST, true);
+    super(message, CErrorName.rangeError, status5.BAD_REQUEST, true);
   }
 };
 
@@ -105,7 +132,7 @@ var StackTraceRangeError = class extends StackTraceError {
 import { HttpStatusCode as status6 } from "opticore-http-response";
 var StackTraceReferenceError = class extends StackTraceError {
   constructor(message) {
-    super(message, CErrorName.evalError, status6.BAD_REQUEST, true);
+    super(message, CErrorName.referenceError, status6.BAD_REQUEST, true);
   }
 };
 
@@ -113,7 +140,7 @@ var StackTraceReferenceError = class extends StackTraceError {
 import { HttpStatusCode as status7 } from "opticore-http-response";
 var StackTraceSyntaxError = class extends StackTraceError {
   constructor(message) {
-    super(message, CErrorName.evalError, status7.BAD_REQUEST, true);
+    super(message, CErrorName.syntaxError, status7.BAD_REQUEST, true);
   }
 };
 
@@ -130,7 +157,7 @@ var StackTraceSystemError = class extends StackTraceError {
 import { HttpStatusCode as status9 } from "opticore-http-response";
 var StackTraceTypeError = class extends StackTraceError {
   constructor(message) {
-    super(message, CErrorName.evalError, status9.BAD_REQUEST, true);
+    super(message, CErrorName.typeError, status9.BAD_REQUEST, true);
   }
 };
 
@@ -138,7 +165,7 @@ var StackTraceTypeError = class extends StackTraceError {
 import { HttpStatusCode as status10 } from "opticore-http-response";
 var StackTraceURIError = class extends StackTraceError {
   constructor(message) {
-    super(message, CErrorName.evalError, status10.BAD_REQUEST, true);
+    super(message, CErrorName.uriError, status10.BAD_REQUEST, true);
   }
 };
 
@@ -148,14 +175,11 @@ import colors from "ansi-colors";
 import chalk from "chalk";
 import { LoggerCore } from "opticore-logger";
 import { HttpStatusCode as status11 } from "opticore-http-response";
-import { CLocal, TranslationLoader as TranslationLoader2 } from "opticore-translator";
+import { TranslationLoader as TranslationLoader2 } from "opticore-translator";
 
 // src/utils/dateTimeFormatted.utils.ts
 var dateTimeFormatted = `${(/* @__PURE__ */ new Date()).getMonth()}-${(/* @__PURE__ */ new Date()).getDate()}-${(/* @__PURE__ */ new Date()).getFullYear()} ${(/* @__PURE__ */ new Date()).getHours()}:${(/* @__PURE__ */ new Date()).getMinutes()}:${(/* @__PURE__ */ new Date()).getSeconds()}`;
 
-// src/core/errors/events/serverListen.event.error.ts
-import { getEnvVariable } from "opticore-env-access";
-
 // src/core/config/loaders/translateLanguage.loader.ts
 import path from "path";
 import { createRequire } from "module";
@@ -169,43 +193,46 @@ var translateCatchExceptionErrorLanguageLoader = (defaultLocalLang) => {
 
 // src/core/errors/events/serverListen.event.error.ts
 var ServerListenEventError = class {
-  static logger = new LoggerCore();
-  static stackTrace;
-  static __init(defaultLocalLang) {
+  logger = new LoggerCore();
+  stackTrace;
+  localeLanguage;
+  constructor(defaultLocalLang) {
+    this.localeLanguage = defaultLocalLang;
     translateCatchExceptionErrorLanguageLoader(defaultLocalLang);
-    return this;
   }
   /**
+   * @param appPort
    *
    */
-  static hostPortUndefined() {
+  hostPortUndefined(appPort) {
     this.stackTrace = this.traceError(
-      TranslationLoader2.t("errorHostUrl", CLocal),
-      TranslationLoader2.t("listening", CLocal),
+      TranslationLoader2.t("errorHostUrl", this.localeLanguage),
+      TranslationLoader2.t("listening", this.localeLanguage),
       status11.BAD_REQUEST
     );
     this.logger.error(
       this.stackTrace.message,
-      TranslationLoader2.t("webServer", CLocal),
-      TranslationLoader2.t("badPort", CLocal, { badPort: getEnvVariable.appPort }),
+      TranslationLoader2.t("webServer", this.localeLanguage),
+      TranslationLoader2.t("badPort", this.localeLanguage, { badPort: appPort }),
       this.stackTrace.stack,
       status11.BAD_REQUEST
     );
     process.exit();
   }
   /**
+   * @param appHost
    *
    */
-  static hostUndefined() {
+  hostUndefined(appHost) {
     this.stackTrace = this.traceError(
-      TranslationLoader2.t("badHost", CLocal, { badHost: getEnvVariable.appHost }),
-      TranslationLoader2.t("listening", CLocal),
+      TranslationLoader2.t("badHost", this.localeLanguage, { badHost: appHost }),
+      TranslationLoader2.t("listening", this.localeLanguage),
       status11.BAD_REQUEST
     );
     this.logger.error(
       this.stackTrace.message,
-      TranslationLoader2.t("webServer", CLocal),
-      TranslationLoader2.t("badHost", CLocal),
+      TranslationLoader2.t("webServer", this.localeLanguage),
+      TranslationLoader2.t("badHost", this.localeLanguage),
       this.stackTrace.stack,
       status11.BAD_REQUEST
     );
@@ -214,30 +241,30 @@ var ServerListenEventError = class {
   /**
    *
    */
-  static portUndefined() {
+  portUndefined() {
     this.stackTrace = this.traceError(
-      TranslationLoader2.t("badPort", CLocal),
-      TranslationLoader2.t("listening", CLocal),
+      TranslationLoader2.t("badPort", this.localeLanguage),
+      TranslationLoader2.t("listening", this.localeLanguage),
       status11.BAD_REQUEST
     );
     this.logger.error(
       this.stackTrace.message,
-      TranslationLoader2.t("webServer", CLocal),
-      TranslationLoader2.t("badHost", CLocal),
+      TranslationLoader2.t("webServer", this.localeLanguage),
+      TranslationLoader2.t("badHost", this.localeLanguage),
       this.stackTrace.stack,
       status11.BAD_REQUEST
     );
     process.exit();
   }
   /**
-   *
    * @param err
+   *
    */
-  static onEventError(err) {
+  onEventError(err) {
     this.logger.error(
-      TranslationLoader2.t(err.message, CLocal),
-      TranslationLoader2.t("serverStart", CLocal),
-      TranslationLoader2.t("serverStartError", CLocal, { err }),
+      TranslationLoader2.t(err.message, this.localeLanguage),
+      TranslationLoader2.t("serverStart", this.localeLanguage),
+      TranslationLoader2.t("serverStartError", this.localeLanguage, { err }),
       err.stack,
       status11.SERVICE_UNAVAILABLE
     );
@@ -246,7 +273,7 @@ var ServerListenEventError = class {
    *
    * @param error
    */
-  static listenerError(error) {
+  listenerError(error) {
     this.stackTrace = this.traceError(
       error.message,
       error.name,
@@ -261,19 +288,19 @@ var ServerListenEventError = class {
     );
   }
   /**
-   *
    * @param code
+   *
    */
-  static processBeforeExit(code) {
+  processBeforeExit(code) {
     this.stackTrace = this.traceError(
-      TranslationLoader2.t("processExitCode", CLocal, { processExitCode: code }),
-      TranslationLoader2.t("beforeExit", CLocal),
+      TranslationLoader2.t("processExitCode", this.localeLanguage, { processExitCode: code }),
+      TranslationLoader2.t("beforeExit", this.localeLanguage),
       status11.SERVICE_UNAVAILABLE
     );
     this.logger.error(
       this.stackTrace.message,
-      TranslationLoader2.t("beforeExit", CLocal),
-      TranslationLoader2.t("processBeforeExit", CLocal),
+      TranslationLoader2.t("beforeExit", this.localeLanguage),
+      TranslationLoader2.t("processBeforeExit", this.localeLanguage),
       this.stackTrace.stack,
       status11.SERVICE_UNAVAILABLE
     );
@@ -282,16 +309,16 @@ var ServerListenEventError = class {
   /**
    *
    */
-  static processDisconnected() {
+  processDisconnected() {
     this.stackTrace = this.traceError(
-      TranslationLoader2.t("childProcessDiscon", CLocal),
-      TranslationLoader2.t("processDiscon", CLocal),
+      TranslationLoader2.t("childProcessDiscon", this.localeLanguage),
+      TranslationLoader2.t("processDiscon", this.localeLanguage),
       status11.SERVICE_UNAVAILABLE
     );
     this.logger.error(
       this.stackTrace.message,
-      TranslationLoader2.t("disconnected"),
-      TranslationLoader2.t("processDiscon"),
+      TranslationLoader2.t("disconnected", this.localeLanguage),
+      TranslationLoader2.t("processDiscon", this.localeLanguage),
       this.stackTrace.stack,
       status11.SERVICE_UNAVAILABLE
     );
@@ -301,29 +328,29 @@ var ServerListenEventError = class {
    *
    * @param code
    */
-  static exited(code) {
+  exited(code) {
     switch (code) {
       case 0:
         this.logger.success(
-          TranslationLoader2.t("completed", CLocal, { code }),
-          TranslationLoader2.t("finishingProcessWell", CLocal, { code })
+          TranslationLoader2.t("completed", this.localeLanguage, { code }),
+          TranslationLoader2.t("finishingProcessWell", this.localeLanguage, { code })
         );
         console.log("");
         const paddingLength = 35;
         const msg0 = " ".padEnd(paddingLength, " ");
         console.log(chalk.bgGreen.white(msg0.padEnd(paddingLength, " ")));
-        console.log(`${colors.bgGreen(` ${TranslationLoader2.t("serverStopped", CLocal)}     `)}`);
+        console.log(`${colors.bgGreen(` ${TranslationLoader2.t("serverStopped", this.localeLanguage)}     `)}`);
         console.log(chalk.bgGreen.white(msg0.padEnd(paddingLength, " ")));
         break;
       case 1:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("somethingWentWrong", CLocal),
-          TranslationLoader2.t("genErrors", CLocal),
+          TranslationLoader2.t("somethingWentWrong", this.localeLanguage),
+          TranslationLoader2.t("genErrors", this.localeLanguage),
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
           "General Errors",
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
@@ -331,27 +358,27 @@ var ServerListenEventError = class {
         break;
       case 2:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("incorrectCmd", CLocal),
-          TranslationLoader2.t("misuseShell", CLocal),
+          TranslationLoader2.t("incorrectCmd", this.localeLanguage),
+          TranslationLoader2.t("misuseShell", this.localeLanguage),
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
-          TranslationLoader2.t("incorrectCmd", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
+          TranslationLoader2.t("incorrectCmd", this.localeLanguage),
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
         );
         break;
       case 126:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("incorrectCmd", CLocal),
-          TranslationLoader2.t("cmdNotExecutable", CLocal),
+          TranslationLoader2.t("incorrectCmd", this.localeLanguage),
+          TranslationLoader2.t("cmdNotExecutable", this.localeLanguage),
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
           this.stackTrace.name,
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
@@ -359,13 +386,13 @@ var ServerListenEventError = class {
         break;
       case 127:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("cmdNotFound", CLocal),
-          TranslationLoader2.t("cmdNotFoundInSystemPath", CLocal),
+          TranslationLoader2.t("cmdNotFound", this.localeLanguage),
+          TranslationLoader2.t("cmdNotFoundInSystemPath", this.localeLanguage),
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
           this.stackTrace.name,
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
@@ -373,13 +400,13 @@ var ServerListenEventError = class {
         break;
       case 128:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("cmdNotFoundInSystemPath", CLocal),
-          TranslationLoader2.t("argInvalid", CLocal),
+          TranslationLoader2.t("cmdNotFoundInSystemPath", this.localeLanguage),
+          TranslationLoader2.t("argInvalid", this.localeLanguage),
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
           this.stackTrace.name,
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
@@ -387,13 +414,13 @@ var ServerListenEventError = class {
         break;
       case 130:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("scriptEndedManuallyByCtrlC", CLocal),
-          TranslationLoader2.t("scriptEnded", CLocal),
+          TranslationLoader2.t("scriptEndedManuallyByCtrlC", this.localeLanguage),
+          TranslationLoader2.t("scriptEnded", this.localeLanguage),
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
           this.stackTrace.name,
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
@@ -401,13 +428,13 @@ var ServerListenEventError = class {
         break;
       case 137:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("processEndedBySIGKILL", CLocal),
+          TranslationLoader2.t("processEndedBySIGKILL", this.localeLanguage),
           "SIGKILL",
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
           this.stackTrace.name,
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
@@ -415,13 +442,13 @@ var ServerListenEventError = class {
         break;
       case 139:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("accessProcessIllegally", CLocal),
-          TranslationLoader2.t("defaultSegment", CLocal),
+          TranslationLoader2.t("accessProcessIllegally", this.localeLanguage),
+          TranslationLoader2.t("defaultSegment", this.localeLanguage),
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
           this.stackTrace.name,
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
@@ -429,13 +456,13 @@ var ServerListenEventError = class {
         break;
       case 143:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("processReceivedSigtermSignal", CLocal),
-          TranslationLoader2.t("processReceived", CLocal),
+          TranslationLoader2.t("processReceivedSigtermSignal", this.localeLanguage),
+          TranslationLoader2.t("processReceived", this.localeLanguage),
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
           this.stackTrace.name,
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
@@ -443,13 +470,13 @@ var ServerListenEventError = class {
         break;
       case 255:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("exitCode", CLocal),
-          TranslationLoader2.t("outRange", CLocal),
+          TranslationLoader2.t("exitCode", this.localeLanguage),
+          TranslationLoader2.t("outRange", this.localeLanguage),
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
           this.stackTrace.name,
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
@@ -457,13 +484,13 @@ var ServerListenEventError = class {
         break;
       default:
         this.stackTrace = this.traceError(
-          TranslationLoader2.t("errorOccurring", CLocal),
-          TranslationLoader2.t("errors", CLocal),
+          TranslationLoader2.t("errorOccurring", this.localeLanguage),
+          TranslationLoader2.t("errors", this.localeLanguage),
           status11.SERVICE_UNAVAILABLE
         );
         this.logger.error(
           this.stackTrace.message,
-          TranslationLoader2.t("exited", CLocal),
+          TranslationLoader2.t("exited", this.localeLanguage),
           this.stackTrace.name,
           this.stackTrace.stack,
           status11.SERVICE_UNAVAILABLE
@@ -475,11 +502,11 @@ var ServerListenEventError = class {
    *
    * @param promise
    */
-  static promiseRejectionHandled(promise) {
+  promiseRejectionHandled(promise) {
     try {
       this.stackTrace = this.traceError(
-        TranslationLoader2.t("promise", CLocal, { promise }),
-        TranslationLoader2.t("rejectionPromise", CLocal, { promise }),
+        TranslationLoader2.t("promise", this.localeLanguage, { promise }),
+        TranslationLoader2.t("rejectionPromise", this.localeLanguage, { promise }),
         status11.SERVICE_UNAVAILABLE
       );
       this.logger.error(
@@ -496,13 +523,13 @@ var ServerListenEventError = class {
    *
    * @param error
    */
-  static uncaughtException(error) {
+  uncaughtException(error) {
     if (error.message === "'app.router' is deprecated!\nPlease see the 3.x to 4.x migration guide for details on how to update your app.") {
       console.log("");
     } else {
       this.stackTrace = this.traceError(
-        TranslationLoader2.t(error.message),
-        TranslationLoader2.t("uncaughtExceptionHandled", CLocal),
+        TranslationLoader2.t(error.message, this.localeLanguage, { error: error.stack }),
+        TranslationLoader2.t("uncaughtExceptionHandled", this.localeLanguage),
         status11.SERVICE_UNAVAILABLE
       );
       this.logger.error(
@@ -518,7 +545,7 @@ var ServerListenEventError = class {
    *
    * @param error
    */
-  static uncaughtExceptionMonitor(error) {
+  uncaughtExceptionMonitor(error) {
     if (error.message === "'app.router' is deprecated!\nPlease see the 3.x to 4.x migration guide for details on how to update your app.") {
       console.log("");
     }
@@ -528,10 +555,10 @@ var ServerListenEventError = class {
    * @param reason
    * @param promise
    */
-  static unhandledRejection(reason, promise) {
+  unhandledRejection(reason, promise) {
     this.stackTrace = this.traceError(
-      TranslationLoader2.t("unhandledRejectionAtPromise", CLocal, { promise, reason }),
-      TranslationLoader2.t("unhandledRejection", CLocal, { promise, reason }),
+      TranslationLoader2.t("unhandledRejectionAtPromise", this.localeLanguage, { promise, reason }),
+      TranslationLoader2.t("unhandledRejection", this.localeLanguage, { promise, reason }),
       status11.SERVICE_UNAVAILABLE
     );
     this.logger.error(
@@ -546,15 +573,15 @@ var ServerListenEventError = class {
    *
    * @param warning
    */
-  static warning(warning) {
+  warning(warning) {
     this.stackTrace = this.traceError(
-      TranslationLoader2.t(warning.message, CLocal),
+      TranslationLoader2.t(warning.message, this.localeLanguage),
       "warning",
       status11.SERVICE_UNAVAILABLE
     );
     this.logger.error(
       this.stackTrace.message,
-      TranslationLoader2.t("warning", CLocal, { warning }),
+      TranslationLoader2.t("warning", this.localeLanguage, { warning }),
       this.stackTrace.name,
       this.stackTrace.stack,
       status11.SERVICE_UNAVAILABLE
@@ -564,10 +591,10 @@ var ServerListenEventError = class {
    *
    * @param message
    */
-  static message(message) {
+  message(message) {
     this.stackTrace = this.traceError(
-      TranslationLoader2.t("processGotMsg", CLocal, { message }),
-      TranslationLoader2.t("msgException", CLocal, { message }),
+      TranslationLoader2.t("processGotMsg", this.localeLanguage, { message }),
+      TranslationLoader2.t("msgException", this.localeLanguage, { message }),
       status11.SERVICE_UNAVAILABLE
     );
     this.logger.error(
@@ -584,10 +611,10 @@ var ServerListenEventError = class {
    * @param promise
    * @param reason
    */
-  static multipleResolves(type, promise, reason) {
+  multipleResolves(type, promise, reason) {
     this.stackTrace = this.traceError(
-      TranslationLoader2.t("promiseReason", CLocal, { promise, reason }),
-      TranslationLoader2.t("multipleResolvesDetected", CLocal, { type, promise, reason }),
+      TranslationLoader2.t("promiseReason", this.localeLanguage, { promise, reason }),
+      TranslationLoader2.t("multipleResolvesDetected", this.localeLanguage, { type, promise, reason }),
       status11.SERVICE_UNAVAILABLE
     );
     this.logger.error(
@@ -601,17 +628,21 @@ var ServerListenEventError = class {
   /**
    *
    */
-  static processInterrupted() {
-    this.logger.success(TranslationLoader2.t("okSuccess", CLocal), TranslationLoader2.t("serverWebStopped", CLocal));
+  processInterrupted() {
+    this.logger.success(
+      TranslationLoader2.t("okSuccess", this.localeLanguage),
+      TranslationLoader2.t("serverWebStopped", this.localeLanguage)
+    );
     process.exit(0);
   }
   /**
    *
    * @param signal
+   * @param defaultLocalLang
    */
-  static sigtermSignalReceived(signal) {
+  sigtermSignalReceived(signal, defaultLocalLang) {
     this.stackTrace = this.traceError(
-      TranslationLoader2.t("processPIDReceivedSignal", CLocal, { signal: signal.toString() }),
+      TranslationLoader2.t("processPIDReceivedSignal", defaultLocalLang, { signal: signal.toString() }),
       "SIGTERM",
       status11.NOT_ACCEPTABLE
     );
@@ -627,16 +658,16 @@ var ServerListenEventError = class {
   /**
    *
    */
-  static serverClosing() {
-    console.log(`${colors.bgCyanBright(` ${colors.bold(`${colors.white(` INFO `)}`)}`)} ${TranslationLoader2.t("allProcessStopped", CLocal)}`);
-    console.log(`       ${TranslationLoader2.t("serverClosed", CLocal)}`);
+  serverClosing() {
+    console.log(`${colors.bgCyanBright(` ${colors.bold(`${colors.white(` INFO `)}`)}`)} ${TranslationLoader2.t("allProcessStopped", this.localeLanguage)}`);
+    console.log(`       ${TranslationLoader2.t("serverClosed", this.localeLanguage)}`);
     process.exit();
   }
   /**
    *
    */
-  static dropNewConnection() {
-    console.log(`${colors.cyan(`\u24D8`)} ${colors.bgCyan(` ${colors.bold(`${colors.white(` ${TranslationLoader2.t("serverMaxCon", CLocal)} `)}`)} `)}  ${dateTimeFormatted} | ${colors.bgCyan(`${colors.white(` Info `)}`)} ${TranslationLoader2.t("serverDroppedCon", CLocal)}`);
+  dropNewConnection() {
+    console.log(`${colors.cyan(`\u24D8`)} ${colors.bgCyan(` ${colors.bold(`${colors.white(` ${TranslationLoader2.t("serverMaxCon", this.localeLanguage)} `)}`)} `)}  ${dateTimeFormatted} | ${colors.bgCyan(`${colors.white(` Info `)}`)} ${TranslationLoader2.t("serverDroppedCon", this.localeLanguage)}`);
   }
   /**
    *
@@ -646,28 +677,28 @@ var ServerListenEventError = class {
    * @param res
    * @param next
    */
-  static expressErrorHandlingMiddleware(errorEmitter, err, req, res, next) {
+  expressErrorHandlingMiddleware(errorEmitter, err, req, res, next) {
     if (err) {
       errorEmitter.emit(CEventNameError.error, err);
       if (typeof res.status === "function") {
-        res.status(500).send(TranslationLoader2.t("internalServerError", CLocal, { err }));
+        res.status(500).send(TranslationLoader2.t("internalServerError", this.localeLanguage, { err }));
       } else {
         this.logger.error(
-          TranslationLoader2.t("resStatusNotFunc", CLocal, { err }),
+          TranslationLoader2.t("resStatusNotFunc", this.localeLanguage, { err }),
           "response status",
-          TranslationLoader2.t("respndNotFunc", CLocal, { err }),
+          TranslationLoader2.t("respndNotFunc", this.localeLanguage, { err }),
           err.stack,
           status11.NOT_ACCEPTABLE
         );
       }
       this.stackTrace = this.traceError(
         err.message,
-        TranslationLoader2.t("expressError", CLocal, { err }),
+        TranslationLoader2.t("expressError", this.localeLanguage, { err }),
         status11.NOT_ACCEPTABLE
       );
       this.logger.error(
         this.stackTrace.message,
-        TranslationLoader2.t("expressErrorHandlingMiddleware", CLocal, { err }),
+        TranslationLoader2.t("expressErrorHandlingMiddleware", this.localeLanguage, { err }),
         this.stackTrace.name,
         this.stackTrace.stack,
         status11.SERVICE_UNAVAILABLE
@@ -676,8 +707,216 @@ var ServerListenEventError = class {
       next();
     }
   }
-  static traceError(props, name, status12) {
-    return new StackTraceError(props, name, status12, true);
+  traceError(props, name, status38) {
+    return new StackTraceError(props, name, status38, true);
+  }
+};
+
+// src/core/errors/stackTraceEACCES.ts
+import { HttpStatusCode as status12 } from "opticore-http-response";
+var StackTraceEACCES = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.eacces, status12.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceEADDRINUSE.ts
+import { HttpStatusCode as status13 } from "opticore-http-response";
+var StackTraceEADDRINUSE = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.eaddrinuse, status13.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceECONNREFUSED.ts
+import { HttpStatusCode as status14 } from "opticore-http-response";
+var StackTraceECONNREFUSED = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.econnrefused, status14.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceECONNRESET.ts
+import { HttpStatusCode as status15 } from "opticore-http-response";
+var StackTraceECONNRESET = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.econnreset, status15.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceEEXIST.ts
+import { HttpStatusCode as status16 } from "opticore-http-response";
+var StackTraceEEXIST = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.eexist, status16.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceEISDIR.ts
+import { HttpStatusCode as status17 } from "opticore-http-response";
+var StackTraceEISDIR = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.eisdir, status17.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceEMFILE.ts
+import { HttpStatusCode as status18 } from "opticore-http-response";
+var StackTraceEMFILE = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.emfile, status18.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceENOENT.ts
+import { HttpStatusCode as status19 } from "opticore-http-response";
+var StackTraceENOENT = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.enoent, status19.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceENOTDIR.ts
+import { HttpStatusCode as status20 } from "opticore-http-response";
+var StackTraceENOTDIR = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.enotdir, status20.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceENOTEMPTY.ts
+import { HttpStatusCode as status21 } from "opticore-http-response";
+var StackTraceENOTEMPTY = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.enotEmpty, status21.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceEPERM.ts
+import { HttpStatusCode as status22 } from "opticore-http-response";
+var StackTraceEPERM = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.eperm, status22.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceEPIPE.ts
+import { HttpStatusCode as status23 } from "opticore-http-response";
+var StackTraceEPIPE = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.epipe, status23.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceETIMEDOUT.ts
+import { HttpStatusCode as status24 } from "opticore-http-response";
+var StackTraceETIMEDOUT = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.etimedout, status24.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceERR_OSSL_EVP_UNSUPPORTED.ts
+import { HttpStatusCode as status25 } from "opticore-http-response";
+var StackTraceERR_OSSL_EVP_UNSUPPORTED = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.errOsslEvpUnsupported, status25.NOT_ACCEPTABLE, true);
+  }
+};
+
+// src/core/errors/stackTraceERR_OSSL_BAD_DECRYPT.ts
+import { HttpStatusCode as status26 } from "opticore-http-response";
+var StackTraceERR_OSSL_BAD_DECRYPT = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.errOsslBadDecrypt, status26.BAD_REQUEST, true);
+  }
+};
+
+// src/core/errors/stackTraceERR_OSSL_WRONG_FINAL_BLOCK_LENGTH.ts
+import { HttpStatusCode as status27 } from "opticore-http-response";
+var StackTraceERR_OSSL_WRONG_FINAL_BLOCK_LENGTH = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.errOsslWrongFinalBlockLength, status27.NOT_ACCEPTABLE, true);
+  }
+};
+
+// src/core/errors/stackTraceERR_INVALID_ARG_TYPE.ts
+import { HttpStatusCode as status28 } from "opticore-http-response";
+var StackTraceERR_INVALID_ARG_TYPE = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.errInvalidArgType, status28.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceERR_INVALID_CALLBACK.ts
+import { HttpStatusCode as status29 } from "opticore-http-response";
+var StackTraceERR_INVALID_CALLBACK = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.errInvalidCallback, status29.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceERR_HTTP_HEADERS_SENT.ts
+import { HttpStatusCode as status30 } from "opticore-http-response";
+var StackTraceERR_HTTP_HEADERS_SENT = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.errHttpHeadersSent, status30.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceERR_STREAM_DESTROYED.ts
+import { HttpStatusCode as status31 } from "opticore-http-response";
+var StackTraceERR_STREAM_DESTROYED = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.errStreamDestroyed, status31.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceERR_TLS_CERT_ALTNAME_INVALID.ts
+import { HttpStatusCode as status32 } from "opticore-http-response";
+var StackTraceERR_TLS_CERT_ALTNAME_INVALID = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.errTlsCertAltnameInvalid, status32.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceERR_UNSUPPORTED_ESM_URL_SCHEME.ts
+import { HttpStatusCode as status33 } from "opticore-http-response";
+var StackTraceERR_UNSUPPORTED_ESM_URL_SCHEME = class extends StackTraceError {
+  constructor(message) {
+    super(message, CErrorName.errUnsupportedEsmUrlScheme, status33.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceUncaughtException.ts
+import { HttpStatusCode as status34 } from "opticore-http-response";
+var StackTraceUncaughtException = class extends StackTraceError {
+  constructor(message) {
+    super(message, CEvent.uncaughtException, status34.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceUnhandledRejection.ts
+import { HttpStatusCode as status35 } from "opticore-http-response";
+var StackTraceUnhandledRejection = class extends StackTraceError {
+  constructor(message) {
+    super(message, CEvent.unhandledRejection, status35.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceBeforeExit.ts
+import { HttpStatusCode as status36 } from "opticore-http-response";
+var StackTraceBeforeExit = class extends StackTraceError {
+  constructor(message) {
+    super(message, CEvent.beforeExit, status36.INTERNAL_SERVER_ERROR, true);
+  }
+};
+
+// src/core/errors/stackTraceExit.ts
+import { HttpStatusCode as status37 } from "opticore-http-response";
+var StackTraceExit = class extends StackTraceError {
+  constructor(message) {
+    super(message, CEvent.exit, status37.INTERNAL_SERVER_ERROR, true);
   }
 };
 export {
@@ -686,8 +925,32 @@ export {
   CEventNameError,
   ServerListenEventError,
   StackTraceAssertionError,
+  StackTraceBeforeExit,
+  StackTraceEACCES,
+  StackTraceEADDRINUSE,
+  StackTraceECONNREFUSED,
+  StackTraceECONNRESET,
+  StackTraceEEXIST,
+  StackTraceEISDIR,
+  StackTraceEMFILE,
+  StackTraceENOENT,
+  StackTraceENOTDIR,
+  StackTraceENOTEMPTY,
+  StackTraceEPERM,
+  StackTraceEPIPE,
+  StackTraceERR_HTTP_HEADERS_SENT,
+  StackTraceERR_INVALID_ARG_TYPE,
+  StackTraceERR_INVALID_CALLBACK,
+  StackTraceERR_OSSL_BAD_DECRYPT,
+  StackTraceERR_OSSL_EVP_UNSUPPORTED,
+  StackTraceERR_OSSL_WRONG_FINAL_BLOCK_LENGTH,
+  StackTraceERR_STREAM_DESTROYED,
+  StackTraceERR_TLS_CERT_ALTNAME_INVALID,
+  StackTraceERR_UNSUPPORTED_ESM_URL_SCHEME,
+  StackTraceETIMEDOUT,
   StackTraceError,
   StackTraceEvalError,
+  StackTraceExit,
   StackTraceGeneralError,
   StackTraceOpenSSLError,
   StackTraceRangeError,
@@ -695,5 +958,7 @@ export {
   StackTraceSyntaxError,
   StackTraceSystemError,
   StackTraceTypeError,
-  StackTraceURIError
+  StackTraceURIError,
+  StackTraceUncaughtException,
+  StackTraceUnhandledRejection
 };