@hono-di/core 0.0.7 → 0.0.9

package/dist/index.cjs

@@ -5,14 +5,8 @@ var hono = require('hono');
 var rxjs = require('rxjs');
 var operators = require('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 = {
@@ -42,15 +36,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";
@@ -60,7 +54,7 @@ var RequestMethod = /* @__PURE__ */ ((RequestMethod2) => {
   RequestMethod2["OPTIONS"] = "options";
   RequestMethod2["HEAD"] = "head";
   return RequestMethod2;
-})(RequestMethod || {});
+})({});
 
 // src/decorators.ts
 function Global() {
@@ -68,22 +62,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) => {
@@ -100,20 +100,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) {
@@ -124,6 +126,7 @@ function UseFilters(...filters) {
     return target;
   };
 }
+__name(UseFilters, "UseFilters");
 function Inject(token) {
   return (target, propertyKey, parameterIndex) => {
     if (parameterIndex !== void 0) {
@@ -132,11 +135,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) {
@@ -150,6 +157,7 @@ function Optional() {
     }
   };
 }
+__name(Optional, "Optional");
 function UseGuards(...guards) {
   return (target, propertyKey, descriptor) => {
     if (descriptor) {
@@ -160,6 +168,7 @@ function UseGuards(...guards) {
     return target;
   };
 }
+__name(UseGuards, "UseGuards");
 function UseInterceptors(...interceptors) {
   return (target, propertyKey, descriptor) => {
     if (descriptor) {
@@ -170,6 +179,7 @@ function UseInterceptors(...interceptors) {
     return target;
   };
 }
+__name(UseInterceptors, "UseInterceptors");
 function UsePipes(...pipes) {
   return (target, propertyKey, descriptor) => {
     if (descriptor) {
@@ -180,7 +190,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";
@@ -196,7 +207,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,
@@ -208,53 +219,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) {
@@ -265,26 +273,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) {
@@ -300,31 +318,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;
   }
@@ -359,6 +379,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) {
@@ -385,6 +408,9 @@ var Container = class {
 
 // src/injector/context-id.ts
 var ContextId = class _ContextId {
+  static {
+    __name(this, "ContextId");
+  }
   static idCounter = 0;
   id;
   constructor() {
@@ -395,27 +421,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) {
@@ -427,17 +463,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;
@@ -460,11 +503,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);
@@ -497,17 +540,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 {
@@ -522,17 +565,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 {
@@ -545,31 +581,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 {
@@ -581,22 +604,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;
@@ -605,7 +628,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;
@@ -617,18 +640,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);
     }
   }
@@ -642,6 +665,9 @@ var InstanceWrapper = class {
 
 // src/services/logger.service.ts
 var Logger = class _Logger {
+  static {
+    __name(this, "Logger");
+  }
   static lastTimestamp;
   static instance;
   context;
@@ -696,10 +722,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}
 `);
@@ -738,6 +762,10 @@ var Logger = class _Logger {
 
 // src/scanner.ts
 var HonoDiScanner = class {
+  static {
+    __name(this, "HonoDiScanner");
+  }
+  container;
   constructor(container) {
     this.container = container;
   }
@@ -764,7 +792,7 @@ var HonoDiScanner = class {
       name: moduleClass.name,
       metatype: moduleClass,
       host: moduleRef,
-      scope: 0 /* DEFAULT */
+      scope: Scope.DEFAULT
     });
     this.scanDependencies(moduleWrapper);
     moduleRef.addProvider(moduleWrapper);
@@ -776,10 +804,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) {
@@ -787,7 +827,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);
         }
@@ -820,7 +863,7 @@ var HonoDiScanner = class {
         name: token2.name,
         metatype: provider,
         host: moduleRef,
-        scope: 0 /* DEFAULT */
+        scope: Scope.DEFAULT
       });
       this.scanDependencies(wrapper2);
       moduleRef.addProvider(wrapper2);
@@ -831,7 +874,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;
@@ -854,7 +897,7 @@ var HonoDiScanner = class {
       name: token.name,
       metatype: controller,
       host: moduleRef,
-      scope: 0 /* DEFAULT */
+      scope: Scope.DEFAULT
     });
     this.scanDependencies(wrapper);
     moduleRef.addController(wrapper);
@@ -885,6 +928,9 @@ var HonoDiScanner = class {
 
 // src/execution-context-host.ts
 var ExecutionContextHost = class {
+  static {
+    __name(this, "ExecutionContextHost");
+  }
   args;
   constructorRef;
   handler;
@@ -911,20 +957,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);
   }
@@ -940,12 +990,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;
@@ -958,10 +1013,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() {
@@ -972,89 +1030,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);
   }
@@ -1062,15 +1175,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;
@@ -1155,7 +1274,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) {
@@ -1163,49 +1284,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 rxjs.Observable((subscriber) => {
                 try {
@@ -1225,9 +1330,9 @@ var HonoDiApplication = class {
               });
             }
             return interceptors[index].intercept(executionContext, {
-              handle: () => rxjs.from(interceptorChain(index + 1)).pipe(operators.mergeMap((obs2) => obs2))
+              handle: /* @__PURE__ */ __name(() => rxjs.from(interceptorChain(index + 1)).pipe(operators.mergeMap((obs2) => obs2)), "handle")
             });
-          };
+          }, "interceptorChain");
           const obs = await interceptorChain(0);
           const result = await rxjs.lastValueFrom(obs);
           const httpCode = Reflect.getMetadata(METADATA_KEYS.HTTP_CODE, controllerInstance[route.methodName]);
@@ -1260,19 +1365,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);
       }
     }
@@ -1304,7 +1407,7 @@ var HonoDiApplication = class {
             name: item.name,
             metatype: item,
             host: moduleRef,
-            scope: 1 /* TRANSIENT */
+            scope: Scope.TRANSIENT
           });
           scanner.scanDependencies(wrapper);
         }
@@ -1325,19 +1428,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];
@@ -1350,19 +1453,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);
@@ -1372,9 +1475,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;
     }
@@ -1412,7 +1522,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);
@@ -1422,7 +1532,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;
@@ -1437,14 +1550,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);
@@ -1452,7 +1565,7 @@ var HonoDiApplication = class {
             } catch (e) {
               reject(e);
             }
-          };
+          }, "nextFn");
           try {
             const useFn = middleware.use ? middleware.use.bind(middleware) : middleware;
             const result = useFn(c, nextFn);
@@ -1467,7 +1580,7 @@ var HonoDiApplication = class {
             reject(e);
           }
         });
-      };
+      }, "executeChain");
       await executeChain(0, next);
     });
   }
@@ -1478,7 +1591,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;
@@ -1535,6 +1648,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;
@@ -1569,12 +1685,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);
         }
       }
@@ -1599,11 +1715,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");
 exports.Reflector = class Reflector {
+  static {
+    __name(this, "Reflector");
+  }
   get(metadataKey, target) {
     return Reflect.getMetadata(metadataKey, target);
   }
@@ -1631,12 +1760,22 @@ exports.Reflector = class Reflector {
     return result;
   }
 };
-exports.Reflector = __decorateClass([
+exports.Reflector = _ts_decorate([
   Injectable()
 ], exports.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");
 exports.ParseIntPipe = class ParseIntPipe {
+  static {
+    __name(this, "ParseIntPipe");
+  }
   transform(value, metadata) {
     const isNumeric = !isNaN(parseFloat(value)) && isFinite(value);
     if (!isNumeric) {
@@ -1645,10 +1784,13 @@ exports.ParseIntPipe = class ParseIntPipe {
     return parseInt(value, 10);
   }
 };
-exports.ParseIntPipe = __decorateClass([
+exports.ParseIntPipe = _ts_decorate2([
   Injectable()
 ], exports.ParseIntPipe);
 exports.ParseFloatPipe = class ParseFloatPipe {
+  static {
+    __name(this, "ParseFloatPipe");
+  }
   transform(value, metadata) {
     const isNumeric = !isNaN(parseFloat(value)) && isFinite(value);
     if (!isNumeric) {
@@ -1657,10 +1799,13 @@ exports.ParseFloatPipe = class ParseFloatPipe {
     return parseFloat(value);
   }
 };
-exports.ParseFloatPipe = __decorateClass([
+exports.ParseFloatPipe = _ts_decorate2([
   Injectable()
 ], exports.ParseFloatPipe);
 exports.ParseBoolPipe = class ParseBoolPipe {
+  static {
+    __name(this, "ParseBoolPipe");
+  }
   transform(value, metadata) {
     if (value === true || value === "true") {
       return true;
@@ -1671,50 +1816,71 @@ exports.ParseBoolPipe = class ParseBoolPipe {
     throw new BadRequestException("Validation failed (boolean string is expected)");
   }
 };
-exports.ParseBoolPipe = __decorateClass([
+exports.ParseBoolPipe = _ts_decorate2([
   Injectable()
 ], exports.ParseBoolPipe);
 exports.ValidationPipe = class ValidationPipe {
+  static {
+    __name(this, "ValidationPipe");
+  }
   transform(value, metadata) {
     return value;
   }
 };
-exports.ValidationPipe = __decorateClass([
+exports.ValidationPipe = _ts_decorate2([
   Injectable()
 ], exports.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);
   }
@@ -1722,10 +1888,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() {
@@ -1736,14 +1905,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");
 exports.BaseExceptionFilter = class BaseExceptionFilter {
+  static {
+    __name(this, "BaseExceptionFilter");
+  }
   catch(exception, host) {
     const ctx = host.switchToHttp();
     ctx.getResponse();
@@ -1762,7 +1948,7 @@ exports.BaseExceptionFilter = class BaseExceptionFilter {
     });
   }
 };
-exports.BaseExceptionFilter = __decorateClass([
+exports.BaseExceptionFilter = _ts_decorate3([
   Catch()
 ], exports.BaseExceptionFilter);