@hono-di/core 0.0.7 → 0.0.9

package/dist/index.js

@@ -3,14 +3,8 @@ import { Hono } from 'hono';
 import { Observable, from, lastValueFrom } from 'rxjs';
 import { mergeMap } from 'rxjs/operators';
 
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (decorator(result)) || result;
-  return result;
-};
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/constants.ts
 var METADATA_KEYS = {
@@ -40,15 +34,15 @@ var METADATA_KEYS = {
 };
 
 // src/injector/scope.ts
-var Scope = /* @__PURE__ */ ((Scope2) => {
+var Scope = /* @__PURE__ */ (function(Scope2) {
   Scope2[Scope2["DEFAULT"] = 0] = "DEFAULT";
   Scope2[Scope2["TRANSIENT"] = 1] = "TRANSIENT";
   Scope2[Scope2["REQUEST"] = 2] = "REQUEST";
   return Scope2;
-})(Scope || {});
+})({});
 
 // src/interfaces.ts
-var RequestMethod = /* @__PURE__ */ ((RequestMethod2) => {
+var RequestMethod = /* @__PURE__ */ (function(RequestMethod2) {
   RequestMethod2["GET"] = "get";
   RequestMethod2["POST"] = "post";
   RequestMethod2["PUT"] = "put";
@@ -58,7 +52,7 @@ var RequestMethod = /* @__PURE__ */ ((RequestMethod2) => {
   RequestMethod2["OPTIONS"] = "options";
   RequestMethod2["HEAD"] = "head";
   return RequestMethod2;
-})(RequestMethod || {});
+})({});
 
 // src/decorators.ts
 function Global() {
@@ -66,22 +60,28 @@ function Global() {
     Reflect.defineMetadata(METADATA_KEYS.GLOBAL, true, target);
   };
 }
+__name(Global, "Global");
 function Module(options) {
   return (target) => {
     Reflect.defineMetadata(METADATA_KEYS.MODULE, options, target);
   };
 }
+__name(Module, "Module");
 function Injectable(options) {
   return (target) => {
-    Reflect.defineMetadata(METADATA_KEYS.SCOPE, options?.scope ?? 0 /* DEFAULT */, target);
+    Reflect.defineMetadata(METADATA_KEYS.SCOPE, options?.scope ?? Scope.DEFAULT, target);
   };
 }
+__name(Injectable, "Injectable");
 function Controller(prefix = "") {
   return (target) => {
-    Reflect.defineMetadata(METADATA_KEYS.CONTROLLER, { prefix }, target);
-    Reflect.defineMetadata(METADATA_KEYS.SCOPE, 0 /* DEFAULT */, target);
+    Reflect.defineMetadata(METADATA_KEYS.CONTROLLER, {
+      prefix
+    }, target);
+    Reflect.defineMetadata(METADATA_KEYS.SCOPE, Scope.DEFAULT, target);
   };
 }
+__name(Controller, "Controller");
 function createRouteDecorator(method) {
   return (path = "/") => {
     return (target, propertyKey, descriptor) => {
@@ -98,20 +98,22 @@ function createRouteDecorator(method) {
     };
   };
 }
-var Get = createRouteDecorator("get" /* GET */);
-var Post = createRouteDecorator("post" /* POST */);
-var Put = createRouteDecorator("put" /* PUT */);
-var Delete = createRouteDecorator("delete" /* DELETE */);
-var Patch = createRouteDecorator("patch" /* PATCH */);
-var Options = createRouteDecorator("options" /* OPTIONS */);
-var Head = createRouteDecorator("head" /* HEAD */);
-var All = createRouteDecorator("all" /* ALL */);
+__name(createRouteDecorator, "createRouteDecorator");
+var Get = createRouteDecorator(RequestMethod.GET);
+var Post = createRouteDecorator(RequestMethod.POST);
+var Put = createRouteDecorator(RequestMethod.PUT);
+var Delete = createRouteDecorator(RequestMethod.DELETE);
+var Patch = createRouteDecorator(RequestMethod.PATCH);
+var Options = createRouteDecorator(RequestMethod.OPTIONS);
+var Head = createRouteDecorator(RequestMethod.HEAD);
+var All = createRouteDecorator(RequestMethod.ALL);
 function Catch(...exceptions) {
   return (target) => {
     Reflect.defineMetadata(METADATA_KEYS.FILTER_CATCH, exceptions, target);
-    Reflect.defineMetadata(METADATA_KEYS.SCOPE, 0 /* DEFAULT */, target);
+    Reflect.defineMetadata(METADATA_KEYS.SCOPE, Scope.DEFAULT, target);
   };
 }
+__name(Catch, "Catch");
 function UseFilters(...filters) {
   return (target, propertyKey, descriptor) => {
     if (descriptor) {
@@ -122,6 +124,7 @@ function UseFilters(...filters) {
     return target;
   };
 }
+__name(UseFilters, "UseFilters");
 function Inject(token) {
   return (target, propertyKey, parameterIndex) => {
     if (parameterIndex !== void 0) {
@@ -130,11 +133,15 @@ function Inject(token) {
       Reflect.defineMetadata(METADATA_KEYS.INJECTIONS, injections, target);
     } else {
       const properties = Reflect.getMetadata(METADATA_KEYS.PROPERTY_DEPS, target.constructor) || [];
-      properties.push({ key: propertyKey, token });
+      properties.push({
+        key: propertyKey,
+        token
+      });
       Reflect.defineMetadata(METADATA_KEYS.PROPERTY_DEPS, properties, target.constructor);
     }
   };
 }
+__name(Inject, "Inject");
 function Optional() {
   return (target, propertyKey, parameterIndex) => {
     if (parameterIndex !== void 0) {
@@ -148,6 +155,7 @@ function Optional() {
     }
   };
 }
+__name(Optional, "Optional");
 function UseGuards(...guards) {
   return (target, propertyKey, descriptor) => {
     if (descriptor) {
@@ -158,6 +166,7 @@ function UseGuards(...guards) {
     return target;
   };
 }
+__name(UseGuards, "UseGuards");
 function UseInterceptors(...interceptors) {
   return (target, propertyKey, descriptor) => {
     if (descriptor) {
@@ -168,6 +177,7 @@ function UseInterceptors(...interceptors) {
     return target;
   };
 }
+__name(UseInterceptors, "UseInterceptors");
 function UsePipes(...pipes) {
   return (target, propertyKey, descriptor) => {
     if (descriptor) {
@@ -178,7 +188,8 @@ function UsePipes(...pipes) {
     return target;
   };
 }
-var RouteParamtypes = /* @__PURE__ */ ((RouteParamtypes2) => {
+__name(UsePipes, "UsePipes");
+var RouteParamtypes = /* @__PURE__ */ (function(RouteParamtypes2) {
   RouteParamtypes2[RouteParamtypes2["REQUEST"] = 0] = "REQUEST";
   RouteParamtypes2[RouteParamtypes2["RESPONSE"] = 1] = "RESPONSE";
   RouteParamtypes2[RouteParamtypes2["NEXT"] = 2] = "NEXT";
@@ -194,7 +205,7 @@ var RouteParamtypes = /* @__PURE__ */ ((RouteParamtypes2) => {
   RouteParamtypes2[RouteParamtypes2["CONTEXT"] = 12] = "CONTEXT";
   RouteParamtypes2[RouteParamtypes2["CUSTOM"] = 13] = "CUSTOM";
   return RouteParamtypes2;
-})(RouteParamtypes || {});
+})({});
 function assignMetadata(args, paramtype, index, data, ...pipes) {
   return {
     ...args,
@@ -206,53 +217,50 @@ function assignMetadata(args, paramtype, index, data, ...pipes) {
     }
   };
 }
+__name(assignMetadata, "assignMetadata");
 function createRouteParamDecorator(paramtype) {
   return (data) => {
     return (target, key, index) => {
       const args = Reflect.getMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, target.constructor, key) || {};
-      Reflect.defineMetadata(
-        METADATA_KEYS.ROUTE_ARGS_METADATA,
-        assignMetadata(args, paramtype, index, data),
-        target.constructor,
-        key
-      );
+      Reflect.defineMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, assignMetadata(args, paramtype, index, data), target.constructor, key);
     };
   };
 }
+__name(createRouteParamDecorator, "createRouteParamDecorator");
 function createPipesRouteParamDecorator(paramtype) {
   return (data, ...pipes) => {
     return (target, key, index) => {
       const args = Reflect.getMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, target.constructor, key) || {};
-      Reflect.defineMetadata(
-        METADATA_KEYS.ROUTE_ARGS_METADATA,
-        assignMetadata(args, paramtype, index, data, ...pipes),
-        target.constructor,
-        key
-      );
+      Reflect.defineMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, assignMetadata(args, paramtype, index, data, ...pipes), target.constructor, key);
     };
   };
 }
-var Request = createRouteParamDecorator(0 /* REQUEST */);
-var Response2 = createRouteParamDecorator(1 /* RESPONSE */);
-var Next = createRouteParamDecorator(2 /* NEXT */);
-var Session = createRouteParamDecorator(7 /* SESSION */);
-var FileParam = createRouteParamDecorator(8 /* FILE */);
-var Files = createRouteParamDecorator(9 /* FILES */);
-var Ip = createRouteParamDecorator(11 /* IP */);
-var HostParam = createRouteParamDecorator(10 /* HOST */);
-var Ctx = createRouteParamDecorator(12 /* CONTEXT */);
+__name(createPipesRouteParamDecorator, "createPipesRouteParamDecorator");
+var Request = createRouteParamDecorator(0);
+var Response2 = createRouteParamDecorator(1);
+var Next = createRouteParamDecorator(2);
+var Session = createRouteParamDecorator(7);
+var FileParam = createRouteParamDecorator(8);
+var Files = createRouteParamDecorator(9);
+var Ip = createRouteParamDecorator(11);
+var HostParam = createRouteParamDecorator(10);
+var Ctx = createRouteParamDecorator(12);
 function Body(property, ...pipes) {
-  return createPipesRouteParamDecorator(3 /* BODY */)(property, ...pipes);
+  return createPipesRouteParamDecorator(3)(property, ...pipes);
 }
+__name(Body, "Body");
 function Query(property, ...pipes) {
-  return createPipesRouteParamDecorator(4 /* QUERY */)(property, ...pipes);
+  return createPipesRouteParamDecorator(4)(property, ...pipes);
 }
+__name(Query, "Query");
 function Param(property, ...pipes) {
-  return createPipesRouteParamDecorator(5 /* PARAM */)(property, ...pipes);
+  return createPipesRouteParamDecorator(5)(property, ...pipes);
 }
+__name(Param, "Param");
 function Headers(property, ...pipes) {
-  return createPipesRouteParamDecorator(6 /* HEADERS */)(property, ...pipes);
+  return createPipesRouteParamDecorator(6)(property, ...pipes);
 }
+__name(Headers, "Headers");
 function SetMetadata(metadataKey, metadataValue) {
   return (target, key, descriptor) => {
     if (descriptor) {
@@ -263,26 +271,36 @@ function SetMetadata(metadataKey, metadataValue) {
     return target;
   };
 }
+__name(SetMetadata, "SetMetadata");
 function HttpCode(statusCode) {
   return (target, key, descriptor) => {
     Reflect.defineMetadata(METADATA_KEYS.HTTP_CODE, statusCode, descriptor.value);
     return descriptor;
   };
 }
+__name(HttpCode, "HttpCode");
 function Header(name, value) {
   return (target, key, descriptor) => {
     const headers = Reflect.getMetadata(METADATA_KEYS.HEADERS, descriptor.value) || [];
-    headers.push({ name, value });
+    headers.push({
+      name,
+      value
+    });
     Reflect.defineMetadata(METADATA_KEYS.HEADERS, headers, descriptor.value);
     return descriptor;
   };
 }
+__name(Header, "Header");
 function Redirect(url, statusCode = 302) {
   return (target, key, descriptor) => {
-    Reflect.defineMetadata(METADATA_KEYS.REDIRECT, { url, statusCode }, descriptor.value);
+    Reflect.defineMetadata(METADATA_KEYS.REDIRECT, {
+      url,
+      statusCode
+    }, descriptor.value);
     return descriptor;
   };
 }
+__name(Redirect, "Redirect");
 function applyDecorators(...decorators) {
   return (target, propertyKey, descriptor) => {
     for (const decorator of decorators) {
@@ -298,31 +316,33 @@ function applyDecorators(...decorators) {
     }
   };
 }
+__name(applyDecorators, "applyDecorators");
 function createParamDecorator(factory) {
-  const paramtype = 13 /* CUSTOM */;
+  const paramtype = 13;
   return (data) => {
     return (target, key, index) => {
       const args = Reflect.getMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, target.constructor, key) || {};
-      Reflect.defineMetadata(
-        METADATA_KEYS.ROUTE_ARGS_METADATA,
-        assignMetadata(args, paramtype, index, data, factory),
-        target.constructor,
-        key
-      );
+      Reflect.defineMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, assignMetadata(args, paramtype, index, data, factory), target.constructor, key);
     };
   };
 }
+__name(createParamDecorator, "createParamDecorator");
 
 // src/injector/module.ts
 var Module2 = class {
-  constructor(metatype, token) {
-    this.metatype = metatype;
-    this.token = token;
+  static {
+    __name(this, "Module");
   }
+  metatype;
+  token;
   _providers = /* @__PURE__ */ new Map();
   _imports = /* @__PURE__ */ new Set();
   _exports = /* @__PURE__ */ new Set();
   _controllers = /* @__PURE__ */ new Map();
+  constructor(metatype, token) {
+    this.metatype = metatype;
+    this.token = token;
+  }
   get providers() {
     return this._providers;
   }
@@ -357,6 +377,9 @@ var Module2 = class {
 
 // src/injector/container.ts
 var Container = class {
+  static {
+    __name(this, "Container");
+  }
   modules = /* @__PURE__ */ new Map();
   globalModules = /* @__PURE__ */ new Set();
   addModule(moduleMeta, token) {
@@ -383,6 +406,9 @@ var Container = class {
 
 // src/injector/context-id.ts
 var ContextId = class _ContextId {
+  static {
+    __name(this, "ContextId");
+  }
   static idCounter = 0;
   id;
   constructor() {
@@ -393,27 +419,37 @@ new ContextId();
 
 // src/injector/module-ref.ts
 var ModuleRef = class {
+  static {
+    __name(this, "ModuleRef");
+  }
 };
 var ModuleRefImpl = class extends ModuleRef {
+  static {
+    __name(this, "ModuleRefImpl");
+  }
+  container;
+  injector;
+  moduleRef;
   constructor(container, injector, moduleRef) {
-    super();
-    this.container = container;
-    this.injector = injector;
-    this.moduleRef = moduleRef;
+    super(), this.container = container, this.injector = injector, this.moduleRef = moduleRef;
   }
-  get(typeOrToken, options = { strict: true }) {
+  get(typeOrToken, options = {
+    strict: true
+  }) {
     const token = typeOrToken;
     let wrapper = this.moduleRef.getProvider(token);
     if (!wrapper && !options.strict) ;
     if (!wrapper) {
       throw new Error(`ModuleRef cannot find provider for ${token.toString()}`);
     }
-    if (wrapper.scope !== 0 /* DEFAULT */) {
+    if (wrapper.scope !== Scope.DEFAULT) {
       throw new Error(`Cannot use get() for scoped provider ${token.toString()}. Use resolve() instead.`);
     }
     return wrapper.instance;
   }
-  async resolve(typeOrToken, contextId, options = { strict: true }) {
+  async resolve(typeOrToken, contextId, options = {
+    strict: true
+  }) {
     const token = typeOrToken;
     const wrapper = this.moduleRef.getProvider(token);
     if (!wrapper) {
@@ -425,17 +461,24 @@ var ModuleRefImpl = class extends ModuleRef {
 
 // src/injector/injector.ts
 var Injector = class {
+  static {
+    __name(this, "Injector");
+  }
+  container;
   constructor(container) {
     this.container = container;
   }
   async resolveConstructorParams(wrapper, module, inject, callback, contextId = new ContextId(), inquire = [], parentInquire = []) {
-    if (inquire.some((item) => item === wrapper) && wrapper.scope === 0 /* DEFAULT */) {
+    if (inquire.some((item) => item === wrapper) && wrapper.scope === Scope.DEFAULT) {
       throw new Error(`Circular dependency detected: ${wrapper.name}`);
     }
     const args = [];
     for (const [index, token] of inject.entries()) {
       const isOptional = wrapper.isOptional ? wrapper.isOptional[index] : false;
-      const paramWrapper = await this.resolveSingleParam(token, module, contextId, [...inquire, wrapper], isOptional);
+      const paramWrapper = await this.resolveSingleParam(token, module, contextId, [
+        ...inquire,
+        wrapper
+      ], isOptional);
       args.push(paramWrapper);
     }
     return args;
@@ -458,11 +501,11 @@ var Injector = class {
     }
     if (isForwardRef) {
       return new Proxy({}, {
-        get: (target, prop) => {
+        get: /* @__PURE__ */ __name((target, prop) => {
           if (prop === "then") return void 0;
           if (!wrapper.instance) ;
           return wrapper.instance?.[prop];
-        }
+        }, "get")
       });
     }
     return this.loadInstance(wrapper, contextId, inquire);
@@ -495,17 +538,17 @@ var Injector = class {
     return void 0;
   }
   async loadInstance(wrapper, contextId, inquire = []) {
-    if (wrapper.isResolved && wrapper.scope === 0 /* DEFAULT */) {
+    if (wrapper.isResolved && wrapper.scope === Scope.DEFAULT) {
       return wrapper.instance;
     }
-    if (wrapper.scope === 2 /* REQUEST */) {
+    if (wrapper.scope === Scope.REQUEST) {
       const existing = wrapper.getInstanceByContextId(contextId);
       if (existing) return existing;
     }
     if (wrapper.isAlias) {
       const targetToken = wrapper.useExisting;
       const instance2 = await this.resolveSingleParam(targetToken, wrapper.host, contextId, inquire);
-      if (wrapper.scope === 0 /* DEFAULT */) {
+      if (wrapper.scope === Scope.DEFAULT) {
         wrapper.instance = instance2;
         wrapper.isResolved = true;
       } else {
@@ -520,17 +563,10 @@ var Injector = class {
     }
     if (wrapper.useFactory) {
       const dependencies2 = wrapper.inject || [];
-      const args = await this.resolveConstructorParams(
-        wrapper,
-        wrapper.host,
-        dependencies2,
-        (args2) => {
-        },
-        contextId,
-        inquire
-      );
+      const args = await this.resolveConstructorParams(wrapper, wrapper.host, dependencies2, (args2) => {
+      }, contextId, inquire);
       const instance2 = await wrapper.useFactory(...args);
-      if (wrapper.scope === 0 /* DEFAULT */) {
+      if (wrapper.scope === Scope.DEFAULT) {
         wrapper.instance = instance2;
         wrapper.isResolved = true;
       } else {
@@ -543,31 +579,18 @@ var Injector = class {
       throw new Error("Invalid metatype");
     }
     let dependencies = wrapper.inject || [];
-    const constructorArgs = await this.resolveConstructorParams(
-      wrapper,
-      wrapper.host,
-      dependencies,
-      (args) => {
-      },
-      contextId,
-      inquire
-    );
+    const constructorArgs = await this.resolveConstructorParams(wrapper, wrapper.host, dependencies, (args) => {
+    }, contextId, inquire);
     const instance = new metatype(...constructorArgs);
     if (wrapper.properties) {
       for (const prop of wrapper.properties) {
-        const propInstance = await this.resolveSingleParam(
-          prop.token,
-          wrapper.host,
-          contextId,
-          inquire,
-          prop.isOptional
-        );
+        const propInstance = await this.resolveSingleParam(prop.token, wrapper.host, contextId, inquire, prop.isOptional);
         if (propInstance !== void 0) {
           instance[prop.key] = propInstance;
         }
       }
     }
-    if (wrapper.scope === 0 /* DEFAULT */) {
+    if (wrapper.scope === Scope.DEFAULT) {
       wrapper.instance = instance;
       wrapper.isResolved = true;
     } else {
@@ -579,22 +602,22 @@ var Injector = class {
 
 // src/injector/instance-wrapper.ts
 var InstanceWrapper = class {
+  static {
+    __name(this, "InstanceWrapper");
+  }
   id;
   token;
   name;
   metatype;
-  scope = 0 /* DEFAULT */;
+  scope = Scope.DEFAULT;
   host;
-  // Generic logic
   inject;
   isOptional;
   properties;
   instance;
-  // Singleton instance
   instancesPerContext = /* @__PURE__ */ new Map();
   isResolved = false;
   isPending = false;
-  // For circular dependency detection
   isAlias = false;
   useFactory;
   useValue;
@@ -603,7 +626,7 @@ var InstanceWrapper = class {
     this.token = metadata.token;
     this.name = metadata.name;
     this.metatype = metadata.metatype;
-    this.scope = metadata.scope ?? 0 /* DEFAULT */;
+    this.scope = metadata.scope ?? Scope.DEFAULT;
     this.host = metadata.host;
     this.instance = metadata.instance;
     this.inject = metadata.inject;
@@ -615,18 +638,18 @@ var InstanceWrapper = class {
     this.id = Math.random().toString(36).substring(7);
   }
   getInstanceByContextId(contextId) {
-    if (this.scope === 1 /* TRANSIENT */) {
+    if (this.scope === Scope.TRANSIENT) {
       return void 0;
     }
-    if (this.scope === 0 /* DEFAULT */) {
+    if (this.scope === Scope.DEFAULT) {
       return this.instance;
     }
     return this.instancesPerContext.get(contextId);
   }
   setInstanceByContextId(contextId, instance) {
-    if (this.scope === 0 /* DEFAULT */) {
+    if (this.scope === Scope.DEFAULT) {
       this.instance = instance;
-    } else if (this.scope === 2 /* REQUEST */) {
+    } else if (this.scope === Scope.REQUEST) {
       this.instancesPerContext.set(contextId, instance);
     }
   }
@@ -640,6 +663,9 @@ var InstanceWrapper = class {
 
 // src/services/logger.service.ts
 var Logger = class _Logger {
+  static {
+    __name(this, "Logger");
+  }
   static lastTimestamp;
   static instance;
   context;
@@ -694,10 +720,8 @@ var Logger = class _Logger {
       red: "\x1B[31m",
       green: "\x1B[32m",
       yellow: "\x1B[33m"};
-    process.stdout.write(
-      `${C.green}[Hono] ${pid}${C.reset} - ${timestamp}${color}${level.toUpperCase().padStart(7)}${C.reset} ${C.yellow}${contextMessage}${C.reset}${C.green}${output}${C.reset} ${C.yellow}${timeDiff}${C.reset}
-`
-    );
+    process.stdout.write(`${C.green}[Hono] ${pid}${C.reset} - ${timestamp}${color}${level.toUpperCase().padStart(7)}${C.reset} ${C.yellow}${contextMessage}${C.reset}${C.green}${output}${C.reset} ${C.yellow}${timeDiff}${C.reset}
+`);
     if (trace) {
       process.stdout.write(`${C.red}${trace}${C.reset}
 `);
@@ -736,6 +760,10 @@ var Logger = class _Logger {
 
 // src/scanner.ts
 var HonoDiScanner = class {
+  static {
+    __name(this, "HonoDiScanner");
+  }
+  container;
   constructor(container) {
     this.container = container;
   }
@@ -762,7 +790,7 @@ var HonoDiScanner = class {
       name: moduleClass.name,
       metatype: moduleClass,
       host: moduleRef,
-      scope: 0 /* DEFAULT */
+      scope: Scope.DEFAULT
     });
     this.scanDependencies(moduleWrapper);
     moduleRef.addProvider(moduleWrapper);
@@ -774,10 +802,22 @@ var HonoDiScanner = class {
     const options = {
       ...decoratorOptions,
       ...dynamicMetadata,
-      imports: [...decoratorOptions.imports || [], ...dynamicMetadata.imports || []],
-      providers: [...decoratorOptions.providers || [], ...dynamicMetadata.providers || []],
-      exports: [...decoratorOptions.exports || [], ...dynamicMetadata.exports || []],
-      controllers: [...decoratorOptions.controllers || [], ...dynamicMetadata.controllers || []]
+      imports: [
+        ...decoratorOptions.imports || [],
+        ...dynamicMetadata.imports || []
+      ],
+      providers: [
+        ...decoratorOptions.providers || [],
+        ...dynamicMetadata.providers || []
+      ],
+      exports: [
+        ...decoratorOptions.exports || [],
+        ...dynamicMetadata.exports || []
+      ],
+      controllers: [
+        ...decoratorOptions.controllers || [],
+        ...dynamicMetadata.controllers || []
+      ]
     };
     if (options.imports) {
       for (const importedModule of options.imports) {
@@ -785,7 +825,10 @@ var HonoDiScanner = class {
         if (importedModule && typeof importedModule.forwardRef === "function") {
           actualImport = importedModule.forwardRef();
         }
-        const importedRef = await this.scanModule(actualImport, [...scope, moduleClass]);
+        const importedRef = await this.scanModule(actualImport, [
+          ...scope,
+          moduleClass
+        ]);
         if (importedRef) {
           moduleRef.addImport(importedRef);
         }
@@ -818,7 +861,7 @@ var HonoDiScanner = class {
         name: token2.name,
         metatype: provider,
         host: moduleRef,
-        scope: 0 /* DEFAULT */
+        scope: Scope.DEFAULT
       });
       this.scanDependencies(wrapper2);
       moduleRef.addProvider(wrapper2);
@@ -829,7 +872,7 @@ var HonoDiScanner = class {
       token,
       name: token && token.name ? token.name : typeof token === "string" ? token : "CustomProvider",
       host: moduleRef,
-      scope: provider.scope || 0 /* DEFAULT */
+      scope: provider.scope || Scope.DEFAULT
     });
     if (provider.useValue !== void 0) {
       wrapper.useValue = provider.useValue;
@@ -852,7 +895,7 @@ var HonoDiScanner = class {
       name: token.name,
       metatype: controller,
       host: moduleRef,
-      scope: 0 /* DEFAULT */
+      scope: Scope.DEFAULT
     });
     this.scanDependencies(wrapper);
     moduleRef.addController(wrapper);
@@ -883,6 +926,9 @@ var HonoDiScanner = class {
 
 // src/execution-context-host.ts
 var ExecutionContextHost = class {
+  static {
+    __name(this, "ExecutionContextHost");
+  }
   args;
   constructorRef;
   handler;
@@ -909,20 +955,24 @@ var ExecutionContextHost = class {
   }
   switchToHttp() {
     return {
-      getRequest: () => this.context.req,
-      getResponse: () => this.context,
-      getNext: () => this.next ?? (() => Promise.resolve()),
-      getContext: () => this.context
+      getRequest: /* @__PURE__ */ __name(() => this.context.req, "getRequest"),
+      getResponse: /* @__PURE__ */ __name(() => this.context, "getResponse"),
+      getNext: /* @__PURE__ */ __name(() => this.next ?? (() => Promise.resolve()), "getNext"),
+      getContext: /* @__PURE__ */ __name(() => this.context, "getContext")
     };
   }
 };
 
 // src/middleware/builder.ts
 var MiddlewareBuilder = class {
+  static {
+    __name(this, "MiddlewareBuilder");
+  }
+  module;
+  configs = [];
   constructor(module) {
     this.module = module;
   }
-  configs = [];
   apply(...middleware) {
     return new MiddlewareConfigProxyImpl(this, middleware);
   }
@@ -938,12 +988,17 @@ var MiddlewareBuilder = class {
     return this.configs;
   }
 };
-var MiddlewareConfigProxyImpl = class {
+var MiddlewareConfigProxyImpl = class MiddlewareConfigProxyImpl2 {
+  static {
+    __name(this, "MiddlewareConfigProxyImpl");
+  }
+  builder;
+  middleware;
+  excludes = [];
   constructor(builder, middleware) {
     this.builder = builder;
     this.middleware = middleware;
   }
-  excludes = [];
   exclude(...routes) {
     this.excludes = routes;
     return this;
@@ -956,10 +1011,13 @@ var MiddlewareConfigProxyImpl = class {
 
 // src/common/exceptions/http.exception.ts
 var HttpException = class extends Error {
+  static {
+    __name(this, "HttpException");
+  }
+  response;
+  status;
   constructor(response, status) {
-    super();
-    this.response = response;
-    this.status = status;
+    super(), this.response = response, this.status = status;
     this.message = typeof response === "string" ? response : JSON.stringify(response);
   }
   getResponse() {
@@ -970,89 +1028,144 @@ var HttpException = class extends Error {
   }
   static createBody(message, error, statusCode) {
     if (!message) {
-      return { statusCode, error };
+      return {
+        statusCode,
+        error
+      };
     }
-    return typeof message === "object" && !Array.isArray(message) ? message : { statusCode, error, message };
+    return typeof message === "object" && !Array.isArray(message) ? message : {
+      statusCode,
+      error,
+      message
+    };
   }
 };
 
 // src/common/exceptions/index.ts
 var BadRequestException = class extends HttpException {
+  static {
+    __name(this, "BadRequestException");
+  }
   constructor(message, error = "Bad Request") {
     super(HttpException.createBody(message, error, 400), 400);
   }
 };
 var UnauthorizedException = class extends HttpException {
+  static {
+    __name(this, "UnauthorizedException");
+  }
   constructor(message, error = "Unauthorized") {
     super(HttpException.createBody(message, error, 401), 401);
   }
 };
 var NotFoundException = class extends HttpException {
+  static {
+    __name(this, "NotFoundException");
+  }
   constructor(message, error = "Not Found") {
     super(HttpException.createBody(message, error, 404), 404);
   }
 };
 var ForbiddenException = class extends HttpException {
+  static {
+    __name(this, "ForbiddenException");
+  }
   constructor(message, error = "Forbidden") {
     super(HttpException.createBody(message, error, 403), 403);
   }
 };
 var NotAcceptableException = class extends HttpException {
+  static {
+    __name(this, "NotAcceptableException");
+  }
   constructor(message, error = "Not Acceptable") {
     super(HttpException.createBody(message, error, 406), 406);
   }
 };
 var RequestTimeoutException = class extends HttpException {
+  static {
+    __name(this, "RequestTimeoutException");
+  }
   constructor(message, error = "Request Timeout") {
     super(HttpException.createBody(message, error, 408), 408);
   }
 };
 var ConflictException = class extends HttpException {
+  static {
+    __name(this, "ConflictException");
+  }
   constructor(message, error = "Conflict") {
     super(HttpException.createBody(message, error, 409), 409);
   }
 };
 var GoneException = class extends HttpException {
+  static {
+    __name(this, "GoneException");
+  }
   constructor(message, error = "Gone") {
     super(HttpException.createBody(message, error, 410), 410);
   }
 };
 var PayloadTooLargeException = class extends HttpException {
+  static {
+    __name(this, "PayloadTooLargeException");
+  }
   constructor(message, error = "Payload Too Large") {
     super(HttpException.createBody(message, error, 413), 413);
   }
 };
 var UnsupportedMediaTypeException = class extends HttpException {
+  static {
+    __name(this, "UnsupportedMediaTypeException");
+  }
   constructor(message, error = "Unsupported Media Type") {
     super(HttpException.createBody(message, error, 415), 415);
   }
 };
 var UnprocessableEntityException = class extends HttpException {
+  static {
+    __name(this, "UnprocessableEntityException");
+  }
   constructor(message, error = "Unprocessable Entity") {
     super(HttpException.createBody(message, error, 422), 422);
   }
 };
 var InternalServerErrorException = class extends HttpException {
+  static {
+    __name(this, "InternalServerErrorException");
+  }
   constructor(message, error = "Internal Server Error") {
     super(HttpException.createBody(message, error, 500), 500);
   }
 };
 var NotImplementedException = class extends HttpException {
+  static {
+    __name(this, "NotImplementedException");
+  }
   constructor(message, error = "Not Implemented") {
     super(HttpException.createBody(message, error, 501), 501);
   }
 };
 var BadGatewayException = class extends HttpException {
+  static {
+    __name(this, "BadGatewayException");
+  }
   constructor(message, error = "Bad Gateway") {
     super(HttpException.createBody(message, error, 502), 502);
   }
 };
 var ServiceUnavailableException = class extends HttpException {
+  static {
+    __name(this, "ServiceUnavailableException");
+  }
   constructor(message, error = "Service Unavailable") {
     super(HttpException.createBody(message, error, 503), 503);
   }
 };
 var GatewayTimeoutException = class extends HttpException {
+  static {
+    __name(this, "GatewayTimeoutException");
+  }
   constructor(message, error = "Gateway Timeout") {
     super(HttpException.createBody(message, error, 504), 504);
   }
@@ -1060,15 +1173,21 @@ var GatewayTimeoutException = class extends HttpException {
 
 // src/application.ts
 var HonoDiApplication = class {
-  constructor(app, container, injector) {
-    this.app = app;
-    this.container = container;
-    this.injector = injector;
+  static {
+    __name(this, "HonoDiApplication");
   }
+  app;
+  container;
+  injector;
   globalFilters = [];
   globalPipes = [];
   globalGuards = [];
   globalInterceptors = [];
+  constructor(app, container, injector) {
+    this.app = app;
+    this.container = container;
+    this.injector = injector;
+  }
   useGlobalFilters(...filters) {
     this.globalFilters.push(...filters);
     return this;
@@ -1153,7 +1272,9 @@ var HonoDiApplication = class {
       const fullPath = this.combinePaths(globalPrefix, this.combinePaths(prefix, route.path));
       app[route.requestMethod](fullPath, async (c) => {
         const contextId = new ContextId();
-        const executionContext = new ExecutionContextHost([c], controllerClass, controllerClass.prototype[route.methodName]);
+        const executionContext = new ExecutionContextHost([
+          c
+        ], controllerClass, controllerClass.prototype[route.methodName]);
         try {
           const wrapper = moduleRef.getProvider(controllerClass) || moduleRef.controllers.get(controllerClass);
           if (!wrapper) {
@@ -1161,49 +1282,33 @@ var HonoDiApplication = class {
           }
           const controllerInstance = await this.injector.loadInstance(wrapper, contextId);
           const handler = controllerInstance[route.methodName].bind(controllerInstance);
-          const guards = await this.resolveContextItems(
-            [
-              ...this.globalGuards,
-              ...Reflect.getMetadata(METADATA_KEYS.USE_GUARDS, controllerClass) || [],
-              ...Reflect.getMetadata(METADATA_KEYS.USE_GUARDS, controllerInstance[route.methodName]) || []
-            ],
-            moduleRef,
-            contextId
-          );
+          const guards = await this.resolveContextItems([
+            ...this.globalGuards,
+            ...Reflect.getMetadata(METADATA_KEYS.USE_GUARDS, controllerClass) || [],
+            ...Reflect.getMetadata(METADATA_KEYS.USE_GUARDS, controllerInstance[route.methodName]) || []
+          ], moduleRef, contextId);
           if (!await this.runGuards(guards, executionContext)) {
             c.status(403);
-            return c.json({ statusCode: 403, message: "Forbidden resource" });
+            return c.json({
+              statusCode: 403,
+              message: "Forbidden resource"
+            });
           }
-          const interceptors = await this.resolveContextItems(
-            [
-              ...this.globalInterceptors,
-              ...Reflect.getMetadata(METADATA_KEYS.USE_INTERCEPTORS, controllerClass) || [],
-              ...Reflect.getMetadata(METADATA_KEYS.USE_INTERCEPTORS, controllerInstance[route.methodName]) || []
-            ],
-            moduleRef,
-            contextId
-          );
-          const pipes = await this.resolveContextItems(
-            [
-              ...this.globalPipes,
-              ...Reflect.getMetadata(METADATA_KEYS.USE_PIPES, controllerClass) || [],
-              ...Reflect.getMetadata(METADATA_KEYS.USE_PIPES, controllerInstance[route.methodName]) || []
-            ],
-            moduleRef,
-            contextId
-          );
-          const args = await this.resolveArgs(
-            contextId,
-            executionContext,
-            controllerClass,
-            route.methodName,
-            moduleRef,
-            pipes
-          );
+          const interceptors = await this.resolveContextItems([
+            ...this.globalInterceptors,
+            ...Reflect.getMetadata(METADATA_KEYS.USE_INTERCEPTORS, controllerClass) || [],
+            ...Reflect.getMetadata(METADATA_KEYS.USE_INTERCEPTORS, controllerInstance[route.methodName]) || []
+          ], moduleRef, contextId);
+          const pipes = await this.resolveContextItems([
+            ...this.globalPipes,
+            ...Reflect.getMetadata(METADATA_KEYS.USE_PIPES, controllerClass) || [],
+            ...Reflect.getMetadata(METADATA_KEYS.USE_PIPES, controllerInstance[route.methodName]) || []
+          ], moduleRef, contextId);
+          const args = await this.resolveArgs(contextId, executionContext, controllerClass, route.methodName, moduleRef, pipes);
           if (args.length === 0 && !Reflect.hasMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, controllerClass, route.methodName)) {
             args.push(c);
           }
-          const interceptorChain = async (index) => {
+          const interceptorChain = /* @__PURE__ */ __name(async (index) => {
             if (index >= interceptors.length) {
               return new Observable((subscriber) => {
                 try {
@@ -1223,9 +1328,9 @@ var HonoDiApplication = class {
               });
             }
             return interceptors[index].intercept(executionContext, {
-              handle: () => from(interceptorChain(index + 1)).pipe(mergeMap((obs2) => obs2))
+              handle: /* @__PURE__ */ __name(() => from(interceptorChain(index + 1)).pipe(mergeMap((obs2) => obs2)), "handle")
             });
-          };
+          }, "interceptorChain");
           const obs = await interceptorChain(0);
           const result = await lastValueFrom(obs);
           const httpCode = Reflect.getMetadata(METADATA_KEYS.HTTP_CODE, controllerInstance[route.methodName]);
@@ -1258,19 +1363,17 @@ var HonoDiApplication = class {
     });
   }
   async handleException(exception, c, controllerClass, methodName, moduleRef, contextId) {
-    const filters = await this.resolveContextItems(
-      [
-        ...Reflect.getMetadata(METADATA_KEYS.USE_FILTERS, moduleRef.controllers.get(controllerClass)?.instance?.[methodName]) || [],
-        ...Reflect.getMetadata(METADATA_KEYS.USE_FILTERS, controllerClass) || [],
-        ...this.globalFilters
-      ],
-      moduleRef,
-      contextId
-    );
+    const filters = await this.resolveContextItems([
+      ...Reflect.getMetadata(METADATA_KEYS.USE_FILTERS, moduleRef.controllers.get(controllerClass)?.instance?.[methodName]) || [],
+      ...Reflect.getMetadata(METADATA_KEYS.USE_FILTERS, controllerClass) || [],
+      ...this.globalFilters
+    ], moduleRef, contextId);
     for (const filter of filters) {
       const catchExceptions = Reflect.getMetadata(METADATA_KEYS.FILTER_CATCH, filter.constructor) || [];
       if (catchExceptions.length === 0 || catchExceptions.some((e) => exception instanceof e)) {
-        const host = new ExecutionContextHost([c], controllerClass, moduleRef.controllers.get(controllerClass)?.instance?.[methodName]);
+        const host = new ExecutionContextHost([
+          c
+        ], controllerClass, moduleRef.controllers.get(controllerClass)?.instance?.[methodName]);
         return await filter.catch(exception, host);
       }
     }
@@ -1302,7 +1405,7 @@ var HonoDiApplication = class {
             name: item.name,
             metatype: item,
             host: moduleRef,
-            scope: 1 /* TRANSIENT */
+            scope: Scope.TRANSIENT
           });
           scanner.scanDependencies(wrapper);
         }
@@ -1323,19 +1426,19 @@ var HonoDiApplication = class {
       let value;
       const { index, data, pipes, paramtype } = arg;
       switch (paramtype) {
-        case 0 /* REQUEST */:
+        case RouteParamtypes.REQUEST:
           value = c.req;
           break;
-        case 1 /* RESPONSE */:
+        case RouteParamtypes.RESPONSE:
           value = c;
           break;
-        case 2 /* NEXT */:
+        case RouteParamtypes.NEXT:
           value = context.getArgs()[1];
           break;
-        case 12 /* CONTEXT */:
+        case RouteParamtypes.CONTEXT:
           value = c;
           break;
-        case 3 /* BODY */:
+        case RouteParamtypes.BODY:
           if (data && c.req.parseBody) {
             const body = await c.req.parseBody();
             value = body[data];
@@ -1348,19 +1451,19 @@ var HonoDiApplication = class {
             }
           }
           break;
-        case 4 /* QUERY */:
+        case RouteParamtypes.QUERY:
           value = data ? c.req.query(data) : c.req.query();
           break;
-        case 5 /* PARAM */:
+        case RouteParamtypes.PARAM:
           value = data ? c.req.param(data) : c.req.param();
           break;
-        case 6 /* HEADERS */:
+        case RouteParamtypes.HEADERS:
           value = data ? c.req.header(data) : c.req.header();
           break;
-        case 11 /* IP */:
+        case RouteParamtypes.IP:
           value = c.req.header("x-forwarded-for") || "127.0.0.1";
           break;
-        case 13 /* CUSTOM */:
+        case RouteParamtypes.CUSTOM:
           const factory = arg.pipes[0];
           if (typeof factory === "function") {
             value = factory(data, context);
@@ -1370,9 +1473,16 @@ var HonoDiApplication = class {
           value = null;
       }
       const paramPipeInstances = await this.resolveContextItems(pipes || [], moduleRef, contextId);
-      const allPipes = [...methodPipes, ...paramPipeInstances];
+      const allPipes = [
+        ...methodPipes,
+        ...paramPipeInstances
+      ];
       for (const pipe of allPipes) {
-        value = await pipe.transform(value, { type: "custom", metatype: null, data });
+        value = await pipe.transform(value, {
+          type: "custom",
+          metatype: null,
+          data
+        });
       }
       args[index] = value;
     }
@@ -1410,7 +1520,7 @@ var HonoDiApplication = class {
             token: m,
             name: m.name,
             metatype: m,
-            scope: 1 /* TRANSIENT */
+            scope: Scope.TRANSIENT
           });
           const scanner = new HonoDiScanner(this.container);
           scanner.scanDependencies(wrapper);
@@ -1420,7 +1530,10 @@ var HonoDiApplication = class {
           instances.push(instance);
         }
       }
-      resolvedConfigs.push({ ...config, instances });
+      resolvedConfigs.push({
+        ...config,
+        instances
+      });
     }
     this.app.use("*", async (c, next) => {
       const path = c.req.path;
@@ -1435,14 +1548,14 @@ var HonoDiApplication = class {
       if (matchingMiddleware.length === 0) {
         return await next();
       }
-      const executeChain = async (index, finalNext) => {
+      const executeChain = /* @__PURE__ */ __name(async (index, finalNext) => {
         if (index >= matchingMiddleware.length) {
           return await finalNext();
         }
         const middleware = matchingMiddleware[index];
         return new Promise((resolve, reject) => {
           let nextCalled = false;
-          const nextFn = async () => {
+          const nextFn = /* @__PURE__ */ __name(async () => {
             nextCalled = true;
             try {
               await executeChain(index + 1, finalNext);
@@ -1450,7 +1563,7 @@ var HonoDiApplication = class {
             } catch (e) {
               reject(e);
             }
-          };
+          }, "nextFn");
           try {
             const useFn = middleware.use ? middleware.use.bind(middleware) : middleware;
             const result = useFn(c, nextFn);
@@ -1465,7 +1578,7 @@ var HonoDiApplication = class {
             reject(e);
           }
         });
-      };
+      }, "executeChain");
       await executeChain(0, next);
     });
   }
@@ -1476,7 +1589,7 @@ var HonoDiApplication = class {
         if (normalizedRoute === "*" || path.startsWith(normalizedRoute)) return true;
         if (path === normalizedRoute) return true;
       } else if (typeof route === "object" && route.path && route.method) {
-        if (route.method !== -1 && route.method !== "all" /* ALL */ && route.method !== method.toLowerCase()) {
+        if (route.method !== -1 && route.method !== RequestMethod.ALL && route.method !== method.toLowerCase()) {
           continue;
         }
         if (route.path === "*" || path === route.path) return true;
@@ -1533,6 +1646,9 @@ var HonoDiApplication = class {
 
 // src/factory.ts
 var HonoDiFactory = class {
+  static {
+    __name(this, "HonoDiFactory");
+  }
   static logger = new Logger("HonoDiFactory");
   static async create(rootModule, appOrOptions) {
     let app;
@@ -1567,12 +1683,12 @@ var HonoDiFactory = class {
     const globalContextId = new ContextId();
     for (const module of modules.values()) {
       for (const wrapper of module.providers.values()) {
-        if (wrapper.scope === 0 /* DEFAULT */) {
+        if (wrapper.scope === Scope.DEFAULT) {
           await injector.loadInstance(wrapper, globalContextId);
         }
       }
       for (const wrapper of module.controllers.values()) {
-        if (wrapper.scope === 0 /* DEFAULT */) {
+        if (wrapper.scope === Scope.DEFAULT) {
           await injector.loadInstance(wrapper, globalContextId);
         }
       }
@@ -1597,11 +1713,24 @@ var HonoDiFactory = class {
 
 // src/utils.ts
 function forwardRef(fn) {
-  return { forwardRef: fn };
+  return {
+    forwardRef: fn
+  };
 }
+__name(forwardRef, "forwardRef");
 
 // src/services/reflector.service.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
 var Reflector = class {
+  static {
+    __name(this, "Reflector");
+  }
   get(metadataKey, target) {
     return Reflect.getMetadata(metadataKey, target);
   }
@@ -1629,12 +1758,22 @@ var Reflector = class {
     return result;
   }
 };
-Reflector = __decorateClass([
+Reflector = _ts_decorate([
   Injectable()
 ], Reflector);
 
 // src/common/pipes/index.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
 var ParseIntPipe = class {
+  static {
+    __name(this, "ParseIntPipe");
+  }
   transform(value, metadata) {
     const isNumeric = !isNaN(parseFloat(value)) && isFinite(value);
     if (!isNumeric) {
@@ -1643,10 +1782,13 @@ var ParseIntPipe = class {
     return parseInt(value, 10);
   }
 };
-ParseIntPipe = __decorateClass([
+ParseIntPipe = _ts_decorate2([
   Injectable()
 ], ParseIntPipe);
 var ParseFloatPipe = class {
+  static {
+    __name(this, "ParseFloatPipe");
+  }
   transform(value, metadata) {
     const isNumeric = !isNaN(parseFloat(value)) && isFinite(value);
     if (!isNumeric) {
@@ -1655,10 +1797,13 @@ var ParseFloatPipe = class {
     return parseFloat(value);
   }
 };
-ParseFloatPipe = __decorateClass([
+ParseFloatPipe = _ts_decorate2([
   Injectable()
 ], ParseFloatPipe);
 var ParseBoolPipe = class {
+  static {
+    __name(this, "ParseBoolPipe");
+  }
   transform(value, metadata) {
     if (value === true || value === "true") {
       return true;
@@ -1669,50 +1814,71 @@ var ParseBoolPipe = class {
     throw new BadRequestException("Validation failed (boolean string is expected)");
   }
 };
-ParseBoolPipe = __decorateClass([
+ParseBoolPipe = _ts_decorate2([
   Injectable()
 ], ParseBoolPipe);
 var ValidationPipe = class {
+  static {
+    __name(this, "ValidationPipe");
+  }
   transform(value, metadata) {
     return value;
   }
 };
-ValidationPipe = __decorateClass([
+ValidationPipe = _ts_decorate2([
   Injectable()
 ], ValidationPipe);
 
 // src/common/errors/AppError.ts
 var AppError = class _AppError extends Error {
+  static {
+    __name(this, "AppError");
+  }
+  statusCode;
+  message;
+  isOperational;
   constructor(statusCode, message, isOperational = true) {
-    super(message);
-    this.statusCode = statusCode;
-    this.message = message;
-    this.isOperational = isOperational;
+    super(message), this.statusCode = statusCode, this.message = message, this.isOperational = isOperational;
     Object.setPrototypeOf(this, _AppError.prototype);
     Error.captureStackTrace(this, this.constructor);
   }
 };
 var NotFoundError = class extends AppError {
+  static {
+    __name(this, "NotFoundError");
+  }
   constructor(message = "Resource not found") {
     super(404, message);
   }
 };
 var BadRequestError = class extends AppError {
+  static {
+    __name(this, "BadRequestError");
+  }
   constructor(message = "Bad request") {
     super(400, message);
   }
 };
 var UnauthorizedError = class extends AppError {
+  static {
+    __name(this, "UnauthorizedError");
+  }
   constructor(message = "Unauthorized") {
     super(401, message);
   }
 };
 var ForbiddenError = class extends AppError {
+  static {
+    __name(this, "ForbiddenError");
+  }
   constructor(message = "Forbidden") {
     super(403, message);
   }
 };
 var ConflictError = class extends AppError {
+  static {
+    __name(this, "ConflictError");
+  }
   constructor(message = "Resource already exists") {
     super(409, message);
   }
@@ -1720,10 +1886,13 @@ var ConflictError = class extends AppError {
 
 // src/common/exceptions/HttpException.ts
 var HttpException2 = class extends Error {
+  static {
+    __name(this, "HttpException");
+  }
+  response;
+  status;
   constructor(response, status) {
-    super();
-    this.response = response;
-    this.status = status;
+    super(), this.response = response, this.status = status;
     this.message = typeof response === "string" ? response : JSON.stringify(response);
   }
   getResponse() {
@@ -1734,14 +1903,31 @@ var HttpException2 = class extends Error {
   }
   static createBody(message, error, statusCode) {
     if (!message) {
-      return { statusCode, error };
+      return {
+        statusCode,
+        error
+      };
     }
-    return typeof message === "object" && !Array.isArray(message) ? message : { statusCode, error, message };
+    return typeof message === "object" && !Array.isArray(message) ? message : {
+      statusCode,
+      error,
+      message
+    };
   }
 };
 
 // src/common/filters/BaseExceptionFilter.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
 var BaseExceptionFilter = class {
+  static {
+    __name(this, "BaseExceptionFilter");
+  }
   catch(exception, host) {
     const ctx = host.switchToHttp();
     ctx.getResponse();
@@ -1760,7 +1946,7 @@ var BaseExceptionFilter = class {
     });
   }
 };
-BaseExceptionFilter = __decorateClass([
+BaseExceptionFilter = _ts_decorate3([
   Catch()
 ], BaseExceptionFilter);