{
  "version": 3,
  "sources": ["../src/metadata/index.ts", "../src/metadata/decorators.ts", "../src/types/index.ts", "../src/types/advanced.ts", "../src/types/constants.ts", "../src/container/Container.ts", "../src/container/ContainerFactory.ts"],
  "sourcesContent": ["// Metadata collection system for Modern Decorators\n\nexport interface MetadataKey<T = any> {\n  readonly key: symbol;\n  readonly description: string;\n}\n\nexport interface ClassMetadata {\n  dependencies?: Array<MetadataKey | string>;\n  scope?: 'singleton' | 'prototype' | 'transient';\n  injectable?: boolean;\n  providers?: Array<{ token: MetadataKey | string; value: any }>;\n}\n\nexport interface PropertyMetadata {\n  token?: MetadataKey | string | undefined;\n  optional?: boolean;\n  inject?: boolean;\n}\n\nexport interface MethodMetadata {\n  parameterTypes?: Array<MetadataKey | string>;\n  returnType?: MetadataKey | string;\n  lifecycle?: 'postConstruct' | 'preDestroy';\n}\n\n// Memory-efficient storage using WeakMap\nconst classMetadataStore = new WeakMap<Function, ClassMetadata>();\nconst propertyMetadataStore = new WeakMap<object, Map<string | symbol, PropertyMetadata>>();\nconst methodMetadataStore = new WeakMap<object, Map<string | symbol, MethodMetadata>>();\n\n/**\n * Creates a metadata key for type-safe metadata operations\n */\nexport function createMetadataKey<T = any>(description: string): MetadataKey<T> {\n  return {\n    key: Symbol(description),\n    description\n  };\n}\n\n/**\n * Sets metadata for a class\n */\nexport function setClassMetadata(target: Function, metadata: ClassMetadata): void {\n  const existing = classMetadataStore.get(target) || {};\n  classMetadataStore.set(target, { ...existing, ...metadata });\n}\n\n/**\n * Gets metadata for a class\n */\nexport function getClassMetadata(target: Function): ClassMetadata | undefined {\n  return classMetadataStore.get(target);\n}\n\n/**\n * Sets metadata for a class property\n */\nexport function setPropertyMetadata(\n  target: object,\n  propertyKey: string | symbol,\n  metadata: PropertyMetadata\n): void {\n  let targetMetadata = propertyMetadataStore.get(target);\n  if (!targetMetadata) {\n    targetMetadata = new Map();\n    propertyMetadataStore.set(target, targetMetadata);\n  }\n  \n  const existing = targetMetadata.get(propertyKey) || {};\n  targetMetadata.set(propertyKey, { ...existing, ...metadata });\n}\n\n/**\n * Gets metadata for a class property\n */\nexport function getPropertyMetadata(\n  target: object,\n  propertyKey: string | symbol\n): PropertyMetadata | undefined {\n  const targetMetadata = propertyMetadataStore.get(target);\n  return targetMetadata?.get(propertyKey);\n}\n\n/**\n * Sets metadata for a class method\n */\nexport function setMethodMetadata(\n  target: object,\n  methodKey: string | symbol,\n  metadata: MethodMetadata\n): void {\n  let targetMetadata = methodMetadataStore.get(target);\n  if (!targetMetadata) {\n    targetMetadata = new Map();\n    methodMetadataStore.set(target, targetMetadata);\n  }\n  \n  const existing = targetMetadata.get(methodKey) || {};\n  targetMetadata.set(methodKey, { ...existing, ...metadata });\n}\n\n/**\n * Gets metadata for a class method\n */\nexport function getMethodMetadata(\n  target: object,\n  methodKey: string | symbol\n): MethodMetadata | undefined {\n  const targetMetadata = methodMetadataStore.get(target);\n  return targetMetadata?.get(methodKey);\n}\n\n/**\n * Gets all property metadata for a class\n */\nexport function getAllPropertyMetadata(target: object): Map<string | symbol, PropertyMetadata> | undefined {\n  return propertyMetadataStore.get(target);\n}\n\n/**\n * Gets all method metadata for a class\n */\nexport function getAllMethodMetadata(target: object): Map<string | symbol, MethodMetadata> | undefined {\n  return methodMetadataStore.get(target);\n}\n\n/**\n * Checks if a class has any metadata\n */\nexport function hasClassMetadata(target: Function): boolean {\n  return classMetadataStore.has(target);\n}\n\n/**\n * Checks if a property has metadata\n */\nexport function hasPropertyMetadata(target: object, propertyKey: string | symbol): boolean {\n  const targetMetadata = propertyMetadataStore.get(target);\n  return targetMetadata?.has(propertyKey) ?? false;\n}\n\n/**\n * Checks if a method has metadata\n */\nexport function hasMethodMetadata(target: object, methodKey: string | symbol): boolean {\n  const targetMetadata = methodMetadataStore.get(target);\n  return targetMetadata?.has(methodKey) ?? false;\n}\n\n/**\n * Clears all metadata for a class (useful for testing)\n */\nexport function clearClassMetadata(target: Function): void {\n  classMetadataStore.delete(target);\n  propertyMetadataStore.delete(target.prototype);\n  methodMetadataStore.delete(target.prototype);\n}", "// Modern Decorator implementations using the metadata system\n\nimport {\n  setClassMetadata,\n  setPropertyMetadata,\n  setMethodMetadata,\n  createMetadataKey,\n  type MetadataKey\n} from './index';\n\n/**\n * Marks a class as injectable for dependency injection\n */\nexport function Injectable(scope: 'singleton' | 'prototype' | 'transient' = 'singleton') {\n  return function <T extends new (...args: any[]) => any>(\n    target: T,\n    context: ClassDecoratorContext\n  ): T {\n    setClassMetadata(target, {\n      injectable: true,\n      scope\n    });\n    \n    return target;\n  };\n}\n\n/**\n * Marks a property for dependency injection\n */\nexport function Inject(token?: MetadataKey | string, optional: boolean = false) {\n  return function (\n    target: undefined,\n    context: ClassFieldDecoratorContext | ClassAccessorDecoratorContext\n  ) {\n    context.addInitializer(function (this: any) {\n      setPropertyMetadata(this.constructor.prototype, context.name, {\n        token,\n        optional,\n        inject: true\n      });\n    });\n  };\n}\n\n/**\n * Marks a class as singleton scope\n */\nexport function Singleton<T extends new (...args: any[]) => any>(\n  target: T,\n  context: ClassDecoratorContext\n): T {\n  setClassMetadata(target, {\n    scope: 'singleton'\n  });\n  \n  return target;\n}\n\n/**\n * Sets a custom scope for a class\n */\nexport function Scope(scope: 'singleton' | 'prototype' | 'transient') {\n  return function <T extends new (...args: any[]) => any>(\n    target: T,\n    context: ClassDecoratorContext\n  ): T {\n    setClassMetadata(target, {\n      scope\n    });\n    \n    return target;\n  };\n}\n\n/**\n * Marks a method to be called after instance construction\n */\nexport function PostConstruct(\n  target: Function,\n  context: ClassMethodDecoratorContext\n): Function {\n  context.addInitializer(function (this: any) {\n    setMethodMetadata(this.constructor.prototype, context.name, {\n      lifecycle: 'postConstruct'\n    });\n  });\n  \n  return target;\n}\n\n/**\n * Marks a method to be called before instance destruction\n */\nexport function PreDestroy(\n  target: Function,\n  context: ClassMethodDecoratorContext\n): Function {\n  context.addInitializer(function (this: any) {\n    setMethodMetadata(this.constructor.prototype, context.name, {\n      lifecycle: 'preDestroy'\n    });\n  });\n  \n  return target;\n}\n\n/**\n * Provides a service with a specific token\n */\nexport function Provide(token: MetadataKey | string, value: any) {\n  return function <T extends new (...args: any[]) => any>(\n    target: T,\n    context: ClassDecoratorContext\n  ): T {\n    const providers = [{ token, value }];\n    \n    setClassMetadata(target, {\n      providers\n    });\n    \n    return target;\n  };\n}\n\n// Commonly used metadata keys\nexport const DESIGN_TYPE = createMetadataKey<Function>('design:type');\nexport const DESIGN_PARAM_TYPES = createMetadataKey<Function[]>('design:paramtypes');\nexport const DESIGN_RETURN_TYPE = createMetadataKey<Function>('design:returntype');", "// Core types and interfaces for the DI/IoC Framework\n\nimport type { MetadataKey } from '../metadata';\n\n/**\n * Service identifier type - can be a constructor, string, symbol, or MetadataKey\n */\nexport type ServiceIdentifier<T = any> = \n  | (new (...args: any[]) => T)\n  | string \n  | symbol \n  | MetadataKey<T>;\n\n/**\n * Service scope enumeration\n */\nexport enum ServiceScope {\n  SINGLETON = 'singleton',\n  PROTOTYPE = 'prototype', \n  TRANSIENT = 'transient'\n}\n\n/**\n * Service lifecycle hooks\n */\nexport enum ServiceLifecycle {\n  POST_CONSTRUCT = 'postConstruct',\n  PRE_DESTROY = 'preDestroy'\n}\n\n/**\n * Provider types for different service registration patterns\n */\nexport interface ClassProvider<T = any> {\n  type: 'class';\n  token: ServiceIdentifier<T>;\n  useClass: new (...args: any[]) => T;\n  scope?: ServiceScope;\n}\n\nexport interface ValueProvider<T = any> {\n  type: 'value';\n  token: ServiceIdentifier<T>;\n  useValue: T;\n}\n\nexport interface FactoryProvider<T = any> {\n  type: 'factory';\n  token: ServiceIdentifier<T>;\n  useFactory: (...deps: any[]) => T;\n  deps?: ServiceIdentifier[];\n  scope?: ServiceScope;\n}\n\nexport interface ExistingProvider<T = any> {\n  type: 'existing';\n  token: ServiceIdentifier<T>;\n  useExisting: ServiceIdentifier<T>;\n}\n\n/**\n * Union type for all provider types\n */\nexport type Provider<T = any> = \n  | ClassProvider<T>\n  | ValueProvider<T> \n  | FactoryProvider<T>\n  | ExistingProvider<T>;\n\n/**\n * Service registration options\n */\nexport interface ServiceOptions {\n  scope?: ServiceScope;\n  lazy?: boolean;\n  tags?: string[];\n  onActivation?: (instance: any) => any;\n  onDeactivation?: (instance: any) => void;\n}\n\n/**\n * Dependency injection information\n */\nexport interface DependencyInfo {\n  token: ServiceIdentifier;\n  optional: boolean;\n  parameterIndex?: number;\n  propertyKey?: string | symbol;\n}\n\n/**\n * Service registration metadata\n */\nexport interface ServiceRegistration<T = any> {\n  token: ServiceIdentifier<T>;\n  provider: Provider<T>;\n  options: ServiceOptions;\n  dependencies: DependencyInfo[];\n  metadata: {\n    registeredAt: Date;\n    sourceLocation?: string;\n  };\n}\n\n/**\n * Container configuration options\n */\nexport interface ContainerOptions {\n  defaultScope?: ServiceScope;\n  autoBindInjectable?: boolean;\n  skipBaseClassChecks?: boolean;\n  throwOnMissingDependencies?: boolean;\n  enableCaching?: boolean;\n  maxCacheSize?: number;\n}\n\n/**\n * Container interface for dependency injection operations\n */\nexport interface IContainer {\n  /**\n   * Register a service with the container\n   */\n  register<T>(provider: Provider<T>, options?: ServiceOptions): this;\n  \n  /**\n   * Register a class as a service\n   */\n  bind<T>(token: ServiceIdentifier<T>): IBindingBuilder<T>;\n  \n  /**\n   * Resolve a service instance\n   */\n  resolve<T>(token: ServiceIdentifier<T>): T;\n  \n  /**\n   * Try to resolve a service, return undefined if not found\n   */\n  tryResolve<T>(token: ServiceIdentifier<T>): T | undefined;\n  \n  /**\n   * Check if a service is registered\n   */\n  has(token: ServiceIdentifier): boolean;\n  \n  /**\n   * Unbind a service from the container\n   */\n  unbind(token: ServiceIdentifier): boolean;\n  \n  /**\n   * Create a child container\n   */\n  createChild(options?: Partial<ContainerOptions>): IContainer;\n  \n  /**\n   * Get the parent container\n   */\n  getParent(): IContainer | undefined;\n  \n  /**\n   * Get all registered service tokens\n   */\n  getServices(): ServiceIdentifier[];\n  \n  /**\n   * Clear all registrations\n   */\n  clear(): void;\n  \n  /**\n   * Dispose the container and all singleton instances\n   */\n  dispose(): Promise<void>;\n}\n\n/**\n * Fluent binding builder interface\n */\nexport interface IBindingBuilder<T> {\n  to(implementation: new (...args: any[]) => T): IBindingOptions<T>;\n  toValue(value: T): IBindingFinalized<T>;\n  toFactory(factory: (...deps: any[]) => T): IBindingFactoryOptions<T>;\n  toExisting(token: ServiceIdentifier<T>): IBindingFinalized<T>;\n  toSelf(): IBindingOptions<T>;\n}\n\nexport interface IBindingOptions<T> {\n  inSingletonScope(): IBindingFinalized<T>;\n  inPrototypeScope(): IBindingFinalized<T>;\n  inTransientScope(): IBindingFinalized<T>;\n  inScope(scope: ServiceScope): IBindingFinalized<T>;\n  withOptions(options: ServiceOptions): IBindingFinalized<T>;\n}\n\nexport interface IBindingFactoryOptions<T> {\n  withDependencies(...deps: ServiceIdentifier[]): IBindingFinalized<T>;\n  inSingletonScope(): IBindingFinalized<T>;\n  inPrototypeScope(): IBindingFinalized<T>;\n  inTransientScope(): IBindingFinalized<T>;\n  inScope(scope: ServiceScope): IBindingFinalized<T>;\n  withOptions(options: ServiceOptions): IBindingFinalized<T>;\n}\n\nexport interface IBindingFinalized<T> {\n  // Marker interface for completed bindings\n}\n\n/**\n * Resolution context for tracking dependency resolution\n */\nexport interface ResolutionContext {\n  container: IContainer;\n  resolutionStack: ServiceIdentifier[];\n  cache: Map<ServiceIdentifier, any>;\n  isOptional: boolean;\n}\n\n/**\n * Service instance metadata\n */\nexport interface ServiceInstance<T = any> {\n  instance: T;\n  scope: ServiceScope;\n  createdAt: Date;\n  lastAccessed: Date;\n  accessCount: number;\n  disposed: boolean;\n}\n\n/**\n * Container events\n */\nexport enum ContainerEvent {\n  SERVICE_REGISTERED = 'service:registered',\n  SERVICE_RESOLVED = 'service:resolved',\n  SERVICE_CREATED = 'service:created',\n  SERVICE_DISPOSED = 'service:disposed',\n  CONTAINER_DISPOSED = 'container:disposed'\n}\n\n/**\n * Event data for container events\n */\nexport interface ContainerEventData {\n  token: ServiceIdentifier;\n  instance?: any;\n  container: IContainer;\n  timestamp: Date;\n}\n\n/**\n * Event listener type\n */\nexport type ContainerEventListener = (data: ContainerEventData) => void;\n\n/**\n * Container snapshot for debugging/testing\n */\nexport interface ContainerSnapshot {\n  registrations: ServiceRegistration[];\n  instances: Map<ServiceIdentifier, ServiceInstance>;\n  childContainers: IContainer[];\n  options: ContainerOptions;\n  createdAt: Date;\n}\n\n/**\n * Error types for container operations\n */\nexport class ContainerError extends Error {\n  constructor(message: string, public readonly token?: ServiceIdentifier) {\n    super(message);\n    this.name = 'ContainerError';\n  }\n}\n\nexport class CircularDependencyError extends ContainerError {\n  constructor(\n    public readonly dependencyChain: ServiceIdentifier[],\n    token?: ServiceIdentifier\n  ) {\n    super(\n      `Circular dependency detected: ${dependencyChain.map(t => String(t)).join(' -> ')}`,\n      token\n    );\n    this.name = 'CircularDependencyError';\n  }\n}\n\nexport class ServiceNotFoundError extends ContainerError {\n  constructor(token: ServiceIdentifier) {\n    super(`Service not found: ${String(token)}`, token);\n    this.name = 'ServiceNotFoundError';\n  }\n}\n\nexport class InvalidProviderError extends ContainerError {\n  constructor(message: string, token?: ServiceIdentifier) {\n    super(message, token);\n    this.name = 'InvalidProviderError';\n  }\n}\n\n/**\n * Type guards for provider types\n */\nexport function isClassProvider(provider: Provider): provider is ClassProvider {\n  return provider.type === 'class';\n}\n\nexport function isValueProvider(provider: Provider): provider is ValueProvider {\n  return provider.type === 'value';\n}\n\nexport function isFactoryProvider(provider: Provider): provider is FactoryProvider {\n  return provider.type === 'factory';\n}\n\nexport function isExistingProvider(provider: Provider): provider is ExistingProvider {\n  return provider.type === 'existing';\n}\n\n/**\n * Utility types for improved type inference\n */\nexport type ConstructorParameters<T extends new (...args: any[]) => any> = \n  T extends new (...args: infer P) => any ? P : never;\n\nexport type InstanceType<T extends new (...args: any[]) => any> = \n  T extends new (...args: any[]) => infer R ? R : any;\n\nexport type InferServiceType<T extends ServiceIdentifier> = \n  T extends new (...args: any[]) => infer R ? R :\n  T extends MetadataKey<infer R> ? R :\n  any;", "// Advanced types and utilities for enhanced type safety\n\nimport type { ServiceIdentifier, Provider, ServiceScope } from './index';\n\n/**\n * Conditional types for improved decorator type inference\n */\nexport type DecoratorTarget<T> = T extends ClassDecorator \n  ? new (...args: any[]) => any\n  : T extends PropertyDecorator \n  ? any\n  : T extends MethodDecorator\n  ? (...args: any[]) => any\n  : T extends ParameterDecorator\n  ? any\n  : never;\n\n/**\n * Extract constructor parameter types for dependency injection\n */\nexport type ExtractConstructorParams<T extends new (...args: any[]) => any> = \n  T extends new (...args: infer P) => any ? P : never;\n\n/**\n * Type-safe dependency array for factory providers\n */\nexport type DependencyArray<T extends readonly ServiceIdentifier[]> = {\n  readonly [K in keyof T]: T[K] extends ServiceIdentifier<infer U> ? U : any;\n};\n\n/**\n * Factory function type with typed dependencies\n */\nexport type TypedFactory<T, TDeps extends readonly ServiceIdentifier[] = readonly ServiceIdentifier[]> = \n  (...deps: DependencyArray<TDeps>) => T;\n\n/**\n * Enhanced factory provider with typed dependencies\n */\nexport interface TypedFactoryProvider<T, TDeps extends readonly ServiceIdentifier[] = readonly ServiceIdentifier[]> {\n  type: 'factory';\n  token: ServiceIdentifier<T>;\n  useFactory: TypedFactory<T, TDeps>;\n  deps: TDeps;\n  scope?: ServiceScope;\n}\n\n/**\n * Service registration with compile-time type checking\n */\nexport type TypedServiceRegistration<T> = {\n  [K in keyof Provider<T>]: Provider<T>[K];\n} & {\n  __serviceType?: T; // Phantom type for compile-time checking\n};\n\n/**\n * Container interface with enhanced type safety\n */\nexport interface ITypedContainer {\n  /**\n   * Register with enhanced type checking\n   */\n  registerTyped<T>(registration: TypedServiceRegistration<T>): this;\n  \n  /**\n   * Resolve with guaranteed return type\n   */\n  resolveTyped<T>(token: ServiceIdentifier<T>): T;\n  \n  /**\n   * Register a factory with typed dependencies\n   */\n  registerFactory<T, TDeps extends readonly ServiceIdentifier[]>(\n    token: ServiceIdentifier<T>,\n    factory: TypedFactory<T, TDeps>,\n    deps: TDeps,\n    scope?: ServiceScope\n  ): this;\n}\n\n/**\n * Decorator context types for Modern Decorators\n */\nexport type InjectableDecoratorContext = ClassDecoratorContext;\nexport type InjectDecoratorContext = ClassFieldDecoratorContext | ClassAccessorDecoratorContext;\nexport type LifecycleDecoratorContext = ClassMethodDecoratorContext;\n\n/**\n * Metadata extraction utilities\n */\nexport type ExtractMetadata<T> = T extends { __metadata: infer M } ? M : never;\n\n/**\n * Service collection builder for bulk registrations\n */\nexport interface IServiceCollection {\n  addSingleton<T>(token: ServiceIdentifier<T>, implementation?: new (...args: any[]) => T): this;\n  addTransient<T>(token: ServiceIdentifier<T>, implementation?: new (...args: any[]) => T): this;\n  addScoped<T>(token: ServiceIdentifier<T>, implementation?: new (...args: any[]) => T): this;\n  addInstance<T>(token: ServiceIdentifier<T>, instance: T): this;\n  addFactory<T>(token: ServiceIdentifier<T>, factory: (...deps: any[]) => T, deps?: ServiceIdentifier[]): this;\n  build(): Provider[];\n}\n\n/**\n * Module definition for organizing services\n */\nexport interface ModuleMetadata {\n  providers?: Provider[];\n  imports?: ModuleClass[];\n  exports?: ServiceIdentifier[];\n}\n\nexport interface ModuleClass {\n  new (...args: any[]): any;\n}\n\n/**\n * Async service resolution for lazy loading\n */\nexport interface IAsyncContainer {\n  resolveAsync<T>(token: ServiceIdentifier<T>): Promise<T>;\n  registerAsync<T>(token: ServiceIdentifier<T>, factory: () => Promise<T>): this;\n}\n\n/**\n * Conditional types for service validation\n */\nexport type ValidateService<T> = T extends abstract new (...args: any[]) => any\n  ? 'Abstract classes cannot be used as concrete services'\n  : T extends new (...args: any[]) => any\n  ? T\n  : 'Only constructable types can be used as services';\n\n/**\n * Service interface extraction\n */\nexport type ServiceInterface<T> = T extends new (...args: any[]) => infer I ? I : never;\n\n/**\n * Dependency graph types\n */\nexport interface DependencyNode {\n  token: ServiceIdentifier;\n  dependencies: Set<ServiceIdentifier>;\n  dependents: Set<ServiceIdentifier>;\n  depth: number;\n}\n\nexport type DependencyGraph = Map<ServiceIdentifier, DependencyNode>;\n\n/**\n * Resolution strategy types\n */\nexport enum ResolutionStrategy {\n  THROW_ON_MISSING = 'throw',\n  RETURN_UNDEFINED = 'undefined',\n  USE_DEFAULT = 'default'\n}\n\n/**\n * Interceptor types for AOP support\n */\nexport interface IInterceptor {\n  intercept(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): PropertyDescriptor;\n}\n\nexport type InterceptorFactory = (...args: any[]) => IInterceptor;\n\n/**\n * Service proxy types for lazy loading and interception\n */\nexport interface ServiceProxy<T> {\n  readonly __isProxy: true;\n  readonly __target: ServiceIdentifier<T>;\n  readonly __container: any; // Avoid circular dependency\n}\n\n/**\n * Compile-time service validation\n */\nexport type EnsureService<T> = T extends new (...args: any[]) => any \n  ? T \n  : never;\n\n/**\n * Union type for all possible injection tokens\n */\nexport type InjectionToken<T = any> = \n  | ServiceIdentifier<T>\n  | string \n  | symbol\n  | { toString(): string };\n\n/**\n * Helper type for optional dependencies\n */\nexport type Optional<T> = T | undefined;\n\n/**\n * Container hierarchy types\n */\nexport interface ContainerHierarchy {\n  root: any; // Avoid circular dependency\n  current: any;\n  path: any[];\n}\n\n/**\n * Service lifecycle state\n */\nexport enum ServiceState {\n  REGISTERED = 'registered',\n  CREATING = 'creating', \n  CREATED = 'created',\n  DISPOSED = 'disposed'\n}\n\n/**\n * Enhanced error types with generic support\n */\nexport class TypedContainerError<T = any> extends Error {\n  constructor(\n    message: string,\n    public readonly token?: ServiceIdentifier<T>,\n    public readonly serviceType?: T\n  ) {\n    super(message);\n    this.name = 'TypedContainerError';\n  }\n}", "// Constants and predefined tokens for the DI framework\n\nimport { createMetadataKey } from '../metadata';\nimport type { ContainerOptions, ServiceScope } from './index';\n\n/**\n * Predefined metadata keys for common scenarios\n */\nexport const PREDEFINED_TOKENS = {\n  // Container and infrastructure\n  CONTAINER: createMetadataKey<any>('DI_CONTAINER'),\n  LOGGER: createMetadataKey<any>('DI_LOGGER'),\n  CONFIG: createMetadataKey<any>('DI_CONFIG'),\n  \n  // Common service interfaces\n  HTTP_CLIENT: createMetadataKey<any>('HTTP_CLIENT'),\n  DATABASE: createMetadataKey<any>('DATABASE'),\n  CACHE: createMetadataKey<any>('CACHE'),\n  EVENT_BUS: createMetadataKey<any>('EVENT_BUS'),\n  \n  // Framework internals\n  METADATA_READER: createMetadataKey<any>('METADATA_READER'),\n  LIFECYCLE_MANAGER: createMetadataKey<any>('LIFECYCLE_MANAGER'),\n  DEPENDENCY_RESOLVER: createMetadataKey<any>('DEPENDENCY_RESOLVER')\n} as const;\n\n/**\n * String tokens for common services\n */\nexport const STRING_TOKENS = {\n  // Environment and configuration\n  NODE_ENV: 'NODE_ENV',\n  PORT: 'PORT',\n  DATABASE_URL: 'DATABASE_URL',\n  API_KEY: 'API_KEY',\n  \n  // Application services\n  USER_SERVICE: 'UserService',\n  AUTH_SERVICE: 'AuthService',\n  EMAIL_SERVICE: 'EmailService',\n  \n  // Infrastructure\n  REDIS_CLIENT: 'RedisClient',\n  MONGO_CLIENT: 'MongoClient',\n  MYSQL_CLIENT: 'MySQLClient'\n} as const;\n\n/**\n * Symbol tokens for unique identification\n */\nexport const SYMBOL_TOKENS = {\n  // Core container symbols\n  CONTAINER_ID: Symbol('DI_CONTAINER_ID'),\n  PARENT_CONTAINER: Symbol('DI_PARENT_CONTAINER'),\n  CHILD_CONTAINERS: Symbol('DI_CHILD_CONTAINERS'),\n  \n  // Metadata symbols\n  INJECTABLE_METADATA: Symbol('INJECTABLE_METADATA'),\n  DEPENDENCIES_METADATA: Symbol('DEPENDENCIES_METADATA'),\n  SCOPE_METADATA: Symbol('SCOPE_METADATA'),\n  \n  // Lifecycle symbols\n  POST_CONSTRUCT: Symbol('POST_CONSTRUCT'),\n  PRE_DESTROY: Symbol('PRE_DESTROY'),\n  \n  // Special tokens\n  SELF: Symbol('DI_SELF'),\n  OPTIONAL: Symbol('DI_OPTIONAL'),\n  MULTIPLE: Symbol('DI_MULTIPLE')\n} as const;\n\n/**\n * Default container configuration\n */\nexport const DEFAULT_CONTAINER_OPTIONS: ContainerOptions = {\n  defaultScope: 'singleton' as ServiceScope,\n  autoBindInjectable: true,\n  skipBaseClassChecks: false,\n  throwOnMissingDependencies: true,\n  enableCaching: true,\n  maxCacheSize: 1000\n};\n\n/**\n * Default service scopes\n */\nexport const DEFAULT_SCOPES = {\n  SINGLETON: 'singleton' as const,\n  PROTOTYPE: 'prototype' as const, \n  TRANSIENT: 'transient' as const\n};\n\n/**\n * Container event names as constants\n */\nexport const CONTAINER_EVENTS = {\n  SERVICE_REGISTERED: 'service:registered',\n  SERVICE_RESOLVED: 'service:resolved', \n  SERVICE_CREATED: 'service:created',\n  SERVICE_DISPOSED: 'service:disposed',\n  CONTAINER_DISPOSED: 'container:disposed',\n  DEPENDENCY_RESOLVED: 'dependency:resolved',\n  CIRCULAR_DEPENDENCY: 'circular:dependency',\n  MISSING_DEPENDENCY: 'missing:dependency'\n} as const;\n\n/**\n * Decorator metadata keys\n */\nexport const DECORATOR_KEYS = {\n  INJECTABLE: 'design:injectable',\n  INJECT: 'design:inject',\n  SCOPE: 'design:scope',\n  POST_CONSTRUCT: 'design:postconstruct',\n  PRE_DESTROY: 'design:predestroy',\n  OPTIONAL: 'design:optional',\n  SELF: 'design:self',\n  MULTIPLE: 'design:multiple'\n} as const;\n\n/**\n * Error messages for common scenarios\n */\nexport const ERROR_MESSAGES = {\n  SERVICE_NOT_FOUND: (token: string) => `Service not found: ${token}`,\n  CIRCULAR_DEPENDENCY: (chain: string[]) => `Circular dependency detected: ${chain.join(' -> ')}`,\n  INVALID_PROVIDER: (reason: string) => `Invalid provider: ${reason}`,\n  CONTAINER_DISPOSED: 'Container has been disposed',\n  INVALID_SCOPE: (scope: string) => `Invalid scope: ${scope}`,\n  ABSTRACT_CLASS: (name: string) => `Cannot instantiate abstract class: ${name}`,\n  MISSING_DEPENDENCY: (token: string, target: string) => `Missing dependency ${token} in ${target}`,\n  INVALID_TOKEN: (token: string) => `Invalid service token: ${token}`,\n  REGISTRATION_FAILED: (token: string, reason: string) => `Failed to register ${token}: ${reason}`,\n  RESOLUTION_FAILED: (token: string, reason: string) => `Failed to resolve ${token}: ${reason}`\n} as const;\n\n/**\n * Performance and debugging constants\n */\nexport const PERFORMANCE_CONSTANTS = {\n  MAX_RESOLUTION_DEPTH: 100,\n  MAX_CIRCULAR_REFERENCES: 10,\n  DEFAULT_CACHE_SIZE: 1000,\n  DEFAULT_TIMEOUT_MS: 5000,\n  GC_INTERVAL_MS: 60000, // 1 minute\n  STATS_COLLECTION_INTERVAL_MS: 30000 // 30 seconds\n} as const;\n\n/**\n * Feature flags for optional functionality\n */\nexport const FEATURE_FLAGS = {\n  ENABLE_ASYNC_RESOLUTION: true,\n  ENABLE_LAZY_LOADING: true,\n  ENABLE_PROXY_SERVICES: true,\n  ENABLE_AOP_SUPPORT: false,\n  ENABLE_PERFORMANCE_MONITORING: true,\n  ENABLE_DEBUG_LOGGING: false,\n  ENABLE_STRICT_MODE: true\n} as const;\n\n/**\n * Type-safe access to all constants\n */\nexport const CONSTANTS = {\n  TOKENS: {\n    ...PREDEFINED_TOKENS,\n    ...STRING_TOKENS,\n    ...SYMBOL_TOKENS\n  },\n  DEFAULTS: {\n    CONTAINER_OPTIONS: DEFAULT_CONTAINER_OPTIONS,\n    SCOPES: DEFAULT_SCOPES\n  },\n  EVENTS: CONTAINER_EVENTS,\n  DECORATORS: DECORATOR_KEYS,\n  ERRORS: ERROR_MESSAGES,\n  PERFORMANCE: PERFORMANCE_CONSTANTS,\n  FEATURES: FEATURE_FLAGS\n} as const;", "// Core IoC Container implementation\n\nimport {\n  ServiceIdentifier,\n  ServiceScope,\n  Provider,\n  FactoryProvider,\n  IContainer,\n  ServiceOptions,\n  ContainerOptions,\n  ServiceRegistration,\n  ResolutionContext,\n  ServiceInstance,\n  ContainerError,\n  CircularDependencyError,\n  ServiceNotFoundError,\n  InvalidProviderError,\n  isClassProvider,\n  isValueProvider,\n  isFactoryProvider,\n  isExistingProvider,\n  IBindingBuilder,\n  IBindingOptions,\n  IBindingFactoryOptions,\n  IBindingFinalized\n} from '../types';\n\nimport {\n  getClassMetadata,\n  getPropertyMetadata,\n  getAllPropertyMetadata,\n  getMethodMetadata,\n  getAllMethodMetadata\n} from '../metadata';\n\nimport { DEFAULT_CONTAINER_OPTIONS } from '../types/constants';\n\n/**\n * Core IoC Container implementation\n */\nexport class Container implements IContainer {\n  private readonly registrations = new Map<ServiceIdentifier, ServiceRegistration>();\n  private readonly instances = new Map<ServiceIdentifier, ServiceInstance>();\n  private readonly children = new Set<Container>();\n  private readonly options: ContainerOptions;\n  private readonly parent: Container | undefined;\n  private disposed = false;\n\n  constructor(options: Partial<ContainerOptions> = {}, parent?: Container) {\n    this.options = { ...DEFAULT_CONTAINER_OPTIONS, ...options };\n    this.parent = parent;\n    if (parent) {\n      parent.children.add(this);\n    }\n  }\n\n  /**\n   * Register a service with the container\n   */\n  register<T>(provider: Provider<T>, options: ServiceOptions = {}): this {\n    this.throwIfDisposed();\n    \n    if (!provider || !provider.token) {\n      throw new InvalidProviderError('Provider must have a valid token');\n    }\n\n    // Validate provider based on type\n    this.validateProvider(provider);\n\n    // Create registration metadata\n    const registration: ServiceRegistration<T> = {\n      token: provider.token,\n      provider,\n      options: {\n        scope: options.scope || (provider as any).scope || this.options.defaultScope || ServiceScope.SINGLETON,\n        lazy: options.lazy ?? true,\n        tags: options.tags || [],\n        ...(options.onActivation && { onActivation: options.onActivation }),\n        ...(options.onDeactivation && { onDeactivation: options.onDeactivation })\n      },\n      dependencies: this.extractDependencies(provider),\n      metadata: (() => {\n        const location = this.getSourceLocation();\n        return {\n          registeredAt: new Date(),\n          ...(location && { sourceLocation: location })\n        };\n      })()\n    };\n\n    this.registrations.set(provider.token, registration);\n    \n    // Auto-bind injectable classes if enabled\n    if (this.options.autoBindInjectable && isClassProvider(provider)) {\n      this.autoBindInjectableClass(provider.useClass);\n    }\n\n    return this;\n  }\n\n  /**\n   * Create a fluent binding builder\n   */\n  bind<T>(token: ServiceIdentifier<T>): IBindingBuilder<T> {\n    return new BindingBuilder<T>(token, this);\n  }\n\n  /**\n   * Resolve a service instance\n   */\n  resolve<T>(token: ServiceIdentifier<T>): T {\n    this.throwIfDisposed();\n    \n    const context: ResolutionContext = {\n      container: this,\n      resolutionStack: [],\n      cache: new Map(),\n      isOptional: false\n    };\n\n    return this.resolveWithContext<T>(token, context);\n  }\n\n  /**\n   * Try to resolve a service, return undefined if not found\n   */\n  tryResolve<T>(token: ServiceIdentifier<T>): T | undefined {\n    try {\n      return this.resolve<T>(token);\n    } catch (error) {\n      if (error instanceof ServiceNotFoundError) {\n        return undefined;\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Check if a service is registered\n   */\n  has(token: ServiceIdentifier): boolean {\n    return this.registrations.has(token) || (this.parent?.has(token) ?? false);\n  }\n\n  /**\n   * Unbind a service from the container\n   */\n  unbind(token: ServiceIdentifier): boolean {\n    this.throwIfDisposed();\n    \n    const instance = this.instances.get(token);\n    if (instance) {\n      this.disposeInstance(instance, token);\n      this.instances.delete(token);\n    }\n    \n    return this.registrations.delete(token);\n  }\n\n  /**\n   * Create a child container\n   */\n  createChild(options: Partial<ContainerOptions> = {}): IContainer {\n    this.throwIfDisposed();\n    return new Container(options, this);\n  }\n\n  /**\n   * Get the parent container\n   */\n  getParent(): IContainer | undefined {\n    return this.parent;\n  }\n\n  /**\n   * Get all registered service tokens\n   */\n  getServices(): ServiceIdentifier[] {\n    const tokens = Array.from(this.registrations.keys());\n    if (this.parent) {\n      tokens.push(...this.parent.getServices());\n    }\n    return [...new Set(tokens)]; // Remove duplicates\n  }\n\n  /**\n   * Clear all registrations\n   */\n  clear(): void {\n    this.throwIfDisposed();\n    \n    // Dispose all instances\n    for (const [token, instance] of this.instances) {\n      this.disposeInstance(instance, token);\n    }\n    \n    this.instances.clear();\n    this.registrations.clear();\n  }\n\n  /**\n   * Dispose the container and all singleton instances\n   */\n  async dispose(): Promise<void> {\n    if (this.disposed) return;\n    \n    this.disposed = true;\n    \n    // Dispose all child containers first\n    for (const child of this.children) {\n      await child.dispose();\n    }\n    this.children.clear();\n    \n    // Dispose all instances\n    for (const [token, instance] of this.instances) {\n      this.disposeInstance(instance, token);\n    }\n    \n    this.instances.clear();\n    this.registrations.clear();\n    \n    // Remove from parent\n    if (this.parent) {\n      this.parent.children.delete(this);\n    }\n  }\n\n  // Private helper methods\n\n  private resolveWithContext<T>(token: ServiceIdentifier<T>, context: ResolutionContext): T {\n    // Check for circular dependencies\n    if (context.resolutionStack.includes(token)) {\n      throw new CircularDependencyError([...context.resolutionStack, token], token);\n    }\n\n    // Check cache first (only for circular dependency prevention during this resolution)\n    if (context.cache.has(token)) {\n      return context.cache.get(token);\n    }\n\n    // Find registration\n    const registration = this.findRegistration(token);\n    if (!registration) {\n      if (this.options.throwOnMissingDependencies && !context.isOptional) {\n        throw new ServiceNotFoundError(token);\n      }\n      return undefined as any;\n    }\n\n    const scope = registration.options.scope || ServiceScope.SINGLETON;\n\n    // For prototype and transient scopes, don't check for existing instances\n    // Only singletons should be cached\n    if (scope === ServiceScope.SINGLETON) {\n      const existingInstance = this.instances.get(token);\n      if (existingInstance) {\n        existingInstance.lastAccessed = new Date();\n        existingInstance.accessCount++;\n        return existingInstance.instance;\n      }\n    }\n\n    // Add to resolution stack\n    context.resolutionStack.push(token);\n\n    try {\n      // Create instance\n      const instance = this.createInstance<T>(registration, context);\n      \n      // Cache singleton instances only\n      if (scope === ServiceScope.SINGLETON) {\n        const serviceInstance: ServiceInstance<T> = {\n          instance,\n          scope,\n          createdAt: new Date(),\n          lastAccessed: new Date(),\n          accessCount: 1,\n          disposed: false\n        };\n        this.instances.set(token, serviceInstance);\n      }\n\n      // Add to resolution cache for circular dependency prevention \n      // (only during active resolution of this token)\n      context.cache.set(token, instance);\n\n      // Call activation hook if defined\n      if (registration.options.onActivation) {\n        registration.options.onActivation(instance);\n      }\n\n      return instance;\n    } finally {\n      // Remove from resolution stack\n      context.resolutionStack.pop();\n    }\n  }\n\n  private createInstance<T>(registration: ServiceRegistration<T>, context: ResolutionContext): T {\n    const { provider } = registration;\n\n    if (isClassProvider(provider)) {\n      return this.createClassInstance(provider.useClass, context);\n    }\n\n    if (isValueProvider(provider)) {\n      return provider.useValue;\n    }\n\n    if (isFactoryProvider(provider)) {\n      const dependencies = this.resolveDependencies(provider.deps || [], context);\n      return provider.useFactory(...dependencies);\n    }\n\n    if (isExistingProvider(provider)) {\n      return this.resolveWithContext(provider.useExisting, context);\n    }\n\n    throw new InvalidProviderError(`Unknown provider type for token: ${String((provider as any).token)}`, (provider as any).token);\n  }\n\n  private createClassInstance<T>(constructor: new (...args: any[]) => T, context: ResolutionContext): T {\n    // Get constructor dependencies from metadata\n    const dependencies = this.getConstructorDependencies(constructor);\n    const resolvedDependencies = this.resolveDependencies(dependencies, context);\n\n    // Create instance\n    const instance = new constructor(...resolvedDependencies);\n\n    // Inject properties\n    this.injectProperties(instance, context);\n\n    // Call PostConstruct methods\n    this.callLifecycleMethods(instance, 'postConstruct');\n\n    return instance;\n  }\n\n  private getConstructorDependencies(constructor: Function): ServiceIdentifier[] {\n    const metadata = getClassMetadata(constructor);\n    return metadata?.dependencies || [];\n  }\n\n  private resolveDependencies(tokens: ServiceIdentifier[], context: ResolutionContext): any[] {\n    return tokens.map(token => {\n      const childContext = { ...context, isOptional: false };\n      return this.resolveWithContext(token, childContext);\n    });\n  }\n\n  private injectProperties(instance: any, context: ResolutionContext): void {\n    const propertiesMetadata = getAllPropertyMetadata(instance.constructor.prototype);\n    if (!propertiesMetadata) return;\n\n    for (const [propertyKey, metadata] of propertiesMetadata) {\n      if (metadata.inject && metadata.token) {\n        try {\n          const childContext = { ...context, isOptional: metadata.optional || false };\n          const dependency = this.resolveWithContext(metadata.token, childContext);\n          if (dependency !== undefined) {\n            instance[propertyKey] = dependency;\n          }\n        } catch (error) {\n          if (!metadata.optional) {\n            throw error;\n          }\n        }\n      }\n    }\n  }\n\n  private callLifecycleMethods(instance: any, lifecycle: 'postConstruct' | 'preDestroy'): void {\n    const methodsMetadata = getAllMethodMetadata(instance.constructor.prototype);\n    if (!methodsMetadata) return;\n\n    for (const [methodName, metadata] of methodsMetadata) {\n      if (metadata.lifecycle === lifecycle) {\n        const method = instance[methodName];\n        if (typeof method === 'function') {\n          method.call(instance);\n        }\n      }\n    }\n  }\n\n  private findRegistration(token: ServiceIdentifier): ServiceRegistration | undefined {\n    const registration = this.registrations.get(token);\n    if (registration) return registration;\n\n    // Check parent container\n    if (this.parent) {\n      return (this.parent as Container).findRegistration(token);\n    }\n\n    return undefined;\n  }\n\n  private validateProvider(provider: Provider): void {\n    if (isClassProvider(provider)) {\n      if (!provider.useClass || typeof provider.useClass !== 'function') {\n        throw new InvalidProviderError('ClassProvider must have a valid useClass constructor');\n      }\n    } else if (isFactoryProvider(provider)) {\n      if (!provider.useFactory || typeof provider.useFactory !== 'function') {\n        throw new InvalidProviderError('FactoryProvider must have a valid useFactory function');\n      }\n    } else if (isExistingProvider(provider)) {\n      if (!provider.useExisting) {\n        throw new InvalidProviderError('ExistingProvider must have a valid useExisting token');\n      }\n    }\n  }\n\n  private extractDependencies(provider: Provider): any[] {\n    if (isClassProvider(provider)) {\n      return this.getConstructorDependencies(provider.useClass);\n    }\n    if (isFactoryProvider(provider)) {\n      return provider.deps || [];\n    }\n    return [];\n  }\n\n  private autoBindInjectableClass(constructor: Function): void {\n    const metadata = getClassMetadata(constructor);\n    if (metadata?.injectable) {\n      // Auto-register injectable dependencies\n      const dependencies = metadata.dependencies || [];\n      dependencies.forEach(dep => {\n        if (typeof dep === 'function' && !this.has(dep)) {\n          this.register({\n            type: 'class',\n            token: dep,\n            useClass: dep as any\n          });\n        }\n      });\n    }\n  }\n\n  private disposeInstance(instance: ServiceInstance, token: ServiceIdentifier): void {\n    if (instance.disposed) return;\n\n    // Call PreDestroy methods\n    this.callLifecycleMethods(instance.instance, 'preDestroy');\n\n    // Call deactivation hook if defined\n    const registration = this.registrations.get(token);\n    if (registration?.options.onDeactivation) {\n      registration.options.onDeactivation(instance.instance);\n    }\n\n    instance.disposed = true;\n  }\n\n  private getSourceLocation(): string | undefined {\n    const stack = new Error().stack;\n    if (stack) {\n      const lines = stack.split('\\n');\n      for (let i = 3; i < lines.length; i++) {\n        const line = lines[i];\n        if (line && !line.includes('Container.ts') && !line.includes('node_modules')) {\n          return line.trim();\n        }\n      }\n    }\n    return undefined;\n  }\n\n  private throwIfDisposed(): void {\n    if (this.disposed) {\n      throw new ContainerError('Container has been disposed');\n    }\n  }\n}\n\n/**\n * Fluent binding builder implementation\n */\nclass BindingBuilder<T> implements IBindingBuilder<T> {\n  constructor(\n    private readonly token: ServiceIdentifier<T>,\n    private readonly container: Container\n  ) {}\n\n  to(implementation: new (...args: any[]) => T) {\n    return new BindingOptions<T>(this.token, this.container, {\n      type: 'class',\n      token: this.token,\n      useClass: implementation\n    });\n  }\n\n  toValue(value: T) {\n    this.container.register({\n      type: 'value',\n      token: this.token,\n      useValue: value\n    });\n    return new BindingFinalized<T>();\n  }\n\n  toFactory(factory: (...deps: any[]) => T) {\n    return new BindingFactoryOptions<T>(this.token, this.container, factory);\n  }\n\n  toExisting(token: ServiceIdentifier<T>) {\n    this.container.register({\n      type: 'existing',\n      token: this.token,\n      useExisting: token\n    });\n    return new BindingFinalized<T>();\n  }\n\n  toSelf() {\n    if (typeof this.token !== 'function') {\n      throw new InvalidProviderError('toSelf() can only be used with class tokens');\n    }\n    return this.to(this.token as any);\n  }\n}\n\nclass BindingOptions<T> implements IBindingOptions<T> {\n  constructor(\n    private readonly token: ServiceIdentifier<T>,\n    private readonly container: Container,\n    private provider: Provider<T>\n  ) {}\n\n  inSingletonScope() {\n    this.container.register(this.provider, { scope: ServiceScope.SINGLETON });\n    return new BindingFinalized<T>();\n  }\n\n  inPrototypeScope() {\n    this.container.register(this.provider, { scope: ServiceScope.PROTOTYPE });\n    return new BindingFinalized<T>();\n  }\n\n  inTransientScope() {\n    this.container.register(this.provider, { scope: ServiceScope.TRANSIENT });\n    return new BindingFinalized<T>();\n  }\n\n  inScope(scope: ServiceScope) {\n    this.container.register(this.provider, { scope });\n    return new BindingFinalized<T>();\n  }\n\n  withOptions(options: ServiceOptions) {\n    this.container.register(this.provider, options);\n    return new BindingFinalized<T>();\n  }\n}\n\nclass BindingFactoryOptions<T> implements IBindingFactoryOptions<T> {\n  private deps: ServiceIdentifier[] = [];\n\n  constructor(\n    private readonly token: ServiceIdentifier<T>,\n    private readonly container: Container,\n    private readonly factory: (...deps: any[]) => T\n  ) {}\n\n  withDependencies(...deps: ServiceIdentifier[]) {\n    this.deps = deps;\n    // Register immediately with default scope\n    this.container.register({\n      type: 'factory',\n      token: this.token,\n      useFactory: this.factory,\n      deps: this.deps\n    });\n    return new BindingFinalized<T>();\n  }\n\n  inSingletonScope() {\n    this.container.register({\n      type: 'factory',\n      token: this.token,\n      useFactory: this.factory,\n      deps: this.deps,\n      scope: ServiceScope.SINGLETON\n    });\n    return new BindingFinalized<T>();\n  }\n\n  inPrototypeScope() {\n    this.container.register({\n      type: 'factory',\n      token: this.token,\n      useFactory: this.factory,\n      deps: this.deps,\n      scope: ServiceScope.PROTOTYPE\n    });\n    return new BindingFinalized<T>();\n  }\n\n  inTransientScope() {\n    this.container.register({\n      type: 'factory',\n      token: this.token,\n      useFactory: this.factory,\n      deps: this.deps,\n      scope: ServiceScope.TRANSIENT\n    });\n    return new BindingFinalized<T>();\n  }\n\n  inScope(scope: ServiceScope) {\n    this.container.register({\n      type: 'factory',\n      token: this.token,\n      useFactory: this.factory,\n      deps: this.deps,\n      scope\n    });\n    return new BindingFinalized<T>();\n  }\n\n  withOptions(options: ServiceOptions) {\n    this.container.register({\n      type: 'factory',\n      token: this.token,\n      useFactory: this.factory,\n      deps: this.deps\n    }, options);\n    return new BindingFinalized<T>();\n  }\n}\n\nclass BindingFinalized<T> implements IBindingFinalized<T> {\n  // Marker class for completed bindings\n}", "// Container factory for creating and configuring containers\n\nimport { Container } from './Container';\nimport { IContainer, ContainerOptions, ServiceScope } from '../types';\n\n/**\n * Factory for creating and configuring containers\n */\nexport class ContainerFactory {\n  /**\n   * Create a new container with default configuration\n   */\n  static create(options?: Partial<ContainerOptions>): IContainer {\n    return new Container(options);\n  }\n\n  /**\n   * Create a container optimized for singleton services\n   */\n  static createSingletonContainer(): IContainer {\n    return new Container({\n      defaultScope: ServiceScope.SINGLETON,\n      enableCaching: true,\n      autoBindInjectable: true,\n      throwOnMissingDependencies: true\n    });\n  }\n\n  /**\n   * Create a container optimized for prototype services\n   */\n  static createPrototypeContainer(): IContainer {\n    return new Container({\n      defaultScope: ServiceScope.PROTOTYPE,\n      enableCaching: false,\n      autoBindInjectable: true,\n      throwOnMissingDependencies: true\n    });\n  }\n\n  /**\n   * Create a testing container with relaxed validation\n   */\n  static createTestContainer(): IContainer {\n    return new Container({\n      defaultScope: ServiceScope.SINGLETON,\n      enableCaching: true,\n      autoBindInjectable: false,\n      throwOnMissingDependencies: false,\n      skipBaseClassChecks: true\n    });\n  }\n\n  /**\n   * Create a strict container with enhanced validation\n   */\n  static createStrictContainer(): IContainer {\n    return new Container({\n      defaultScope: ServiceScope.SINGLETON,\n      enableCaching: true,\n      autoBindInjectable: true,\n      throwOnMissingDependencies: true,\n      skipBaseClassChecks: false,\n      maxCacheSize: 500\n    });\n  }\n\n  /**\n   * Create a high-performance container\n   */\n  static createHighPerformanceContainer(): IContainer {\n    return new Container({\n      defaultScope: ServiceScope.SINGLETON,\n      enableCaching: true,\n      autoBindInjectable: true,\n      throwOnMissingDependencies: true,\n      maxCacheSize: 2000\n    });\n  }\n}"],
  "mappings": "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",
  "names": ["classMetadataStore", "propertyMetadataStore", "methodMetadataStore", "createMetadataKey", "description", "setClassMetadata", "target", "metadata", "existing", "getClassMetadata", "setPropertyMetadata", "propertyKey", "targetMetadata", "getPropertyMetadata", "setMethodMetadata", "methodKey", "getMethodMetadata", "getAllPropertyMetadata", "getAllMethodMetadata", "hasClassMetadata", "hasPropertyMetadata", "hasMethodMetadata", "clearClassMetadata", "Injectable", "scope", "target", "context", "setClassMetadata", "Inject", "token", "optional", "setPropertyMetadata", "Singleton", "Scope", "PostConstruct", "setMethodMetadata", "PreDestroy", "Provide", "value", "DESIGN_TYPE", "createMetadataKey", "DESIGN_PARAM_TYPES", "DESIGN_RETURN_TYPE", "ServiceScope", "ServiceLifecycle", "ContainerEvent", "ContainerError", "message", "token", "CircularDependencyError", "dependencyChain", "t", "ServiceNotFoundError", "InvalidProviderError", "isClassProvider", "provider", "isValueProvider", "isFactoryProvider", "isExistingProvider", "ResolutionStrategy", "ServiceState", "TypedContainerError", "message", "token", "serviceType", "PREDEFINED_TOKENS", "createMetadataKey", "STRING_TOKENS", "SYMBOL_TOKENS", "DEFAULT_CONTAINER_OPTIONS", "DEFAULT_SCOPES", "CONTAINER_EVENTS", "DECORATOR_KEYS", "ERROR_MESSAGES", "token", "chain", "reason", "scope", "name", "target", "PERFORMANCE_CONSTANTS", "FEATURE_FLAGS", "CONSTANTS", "Container", "_Container", "options", "parent", "__publicField", "DEFAULT_CONTAINER_OPTIONS", "provider", "InvalidProviderError", "registration", "location", "isClassProvider", "token", "BindingBuilder", "context", "error", "ServiceNotFoundError", "instance", "tokens", "child", "CircularDependencyError", "scope", "existingInstance", "serviceInstance", "isValueProvider", "isFactoryProvider", "dependencies", "isExistingProvider", "constructor", "resolvedDependencies", "getClassMetadata", "childContext", "propertiesMetadata", "getAllPropertyMetadata", "propertyKey", "metadata", "dependency", "lifecycle", "methodsMetadata", "getAllMethodMetadata", "methodName", "method", "dep", "stack", "lines", "line", "ContainerError", "container", "implementation", "BindingOptions", "value", "BindingFinalized", "factory", "BindingFactoryOptions", "deps", "ContainerFactory", "options", "Container"]
}