@ragemp-mango/core 1.1.0 → 1.2.0

package/dist/chunk-CYKAWXQO.js

@@ -0,0 +1,1869 @@
+import {
+  Module,
+  ModuleContainer,
+  ModuleMetadataReader
+} from "./chunk-OLMOKTKA.js";
+import {
+  ExecutionContextBase,
+  MangoRequestBase,
+  MangoResponseBase
+} from "./chunk-XIBSYLJ4.js";
+import {
+  Tree,
+  TreeNode
+} from "./chunk-RYOUF322.js";
+import {
+  validateControllerOptions,
+  validateErrorFilter,
+  validateGuard,
+  validateInjectableMetadata,
+  validateInjectionToken,
+  validateInterceptor,
+  validateModuleOptions,
+  validatePipe
+} from "./chunk-PGWRESZG.js";
+import {
+  Controller,
+  ControllerEventHandler,
+  ControllerFlowHandler,
+  ControllerMetadataReader,
+  ControllerRPCHandler,
+  PipelineHandler
+} from "./chunk-X5HSQNOE.js";
+import {
+  CONTAINER_OPTIONS,
+  ENABLE_SHUTDOWN_HOOKS,
+  EXECUTION_CONTEXT_FACTORY,
+  GLOBAL_APP_CONTAINER,
+  GLOBAL_ERROR_FILTERS,
+  GLOBAL_GUARDS,
+  GLOBAL_INTERCEPTORS,
+  GLOBAL_PIPES,
+  INTERNAL_APP_CONTAINER,
+  MANGO_REQUEST_FACTORY,
+  MANGO_RESPONSE_FACTORY,
+  MULTIPLAYER_SERVICE,
+  PLUGINS
+} from "./chunk-HK7QTFPA.js";
+import {
+  CoreMetadataKey,
+  MethodParamType
+} from "./chunk-TBWHLT75.js";
+import {
+  ErrorMessage
+} from "./chunk-DXPVUDXD.js";
+import {
+  generateRandomId,
+  isEmpty,
+  isNil,
+  isNumber,
+  isObject,
+  isString
+} from "./chunk-E6IQL4S6.js";
+import {
+  LOGGER_SERVICE,
+  MODULE_CONTAINER,
+  REFLECTOR_SERVICE,
+  TIMER_SERVICE
+} from "./chunk-DJZCOYB3.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/services/reflector.service.ts
+import { injectable as injectable8 } from "inversify";
+
+// src/decorators/core/controller.decorator.ts
+import { injectable } from "inversify";
+function Controller2(options) {
+  return (target) => {
+    if (Reflect.hasMetadata(CoreMetadataKey.Controller, target)) {
+      throw new Error(ErrorMessage.DuplicateDecoratorUsage);
+    }
+    const { valid, value, error } = validateControllerOptions(options);
+    if (!valid) throw new Error(error);
+    Reflect.defineMetadata(CoreMetadataKey.Controller, value, target);
+    return injectable()(target);
+  };
+}
+__name(Controller2, "Controller");
+
+// src/decorators/core/global.decorator.ts
+function Global() {
+  return (target) => {
+    Reflect.defineMetadata(CoreMetadataKey.GlobalModule, true, target);
+    return target;
+  };
+}
+__name(Global, "Global");
+
+// src/decorators/core/inject.decorator.ts
+import { inject } from "inversify";
+function Inject(key) {
+  return (target, propertyKey, paramIndex) => {
+    if (!isNil(key) && !validateInjectionToken(key).valid) {
+      throw new Error(ErrorMessage.InvalidInjectionTokenSpecified);
+    }
+    const token = key ?? Reflect.getMetadata("design:type", target, propertyKey);
+    if (!token) {
+      throw new Error(ErrorMessage.InjectionTokenNotFound);
+    }
+    inject(token)(target, propertyKey, paramIndex);
+  };
+}
+__name(Inject, "Inject");
+
+// src/decorators/core/injectable.decorator.ts
+import { injectable as injectable2 } from "inversify";
+function Injectable(options) {
+  return (target) => {
+    if (Reflect.hasMetadata(CoreMetadataKey.Injectable, target)) {
+      throw new Error(ErrorMessage.DuplicateDecoratorUsage);
+    }
+    const { valid, value, error } = validateInjectableMetadata(options);
+    if (!valid) throw new Error(error);
+    Reflect.defineMetadata(CoreMetadataKey.Injectable, value, target);
+    return injectable2()(target);
+  };
+}
+__name(Injectable, "Injectable");
+
+// src/decorators/core/module.decorator.ts
+import { injectable as injectable3 } from "inversify";
+function Module2(options) {
+  return (target) => {
+    if (Reflect.hasMetadata(CoreMetadataKey.Module, target)) {
+      throw new Error(ErrorMessage.DuplicateDecoratorUsage);
+    }
+    const { valid, value, error } = validateModuleOptions(options);
+    if (!valid) throw new Error(error);
+    Reflect.defineMetadata(CoreMetadataKey.Module, value, target);
+    return injectable3()(target);
+  };
+}
+__name(Module2, "Module");
+
+// src/decorators/core/optional.decorator.ts
+import { optional } from "inversify";
+function Optional() {
+  return (target, propertyKey, paramIndex) => {
+    return optional()(target, propertyKey, paramIndex);
+  };
+}
+__name(Optional, "Optional");
+
+// src/decorators/core/set-metadata.decorator.ts
+function SetMetadata(key, value) {
+  const decoratorFactory = /* @__PURE__ */ __name((target, _method, descriptor) => {
+    if (descriptor) {
+      Reflect.defineMetadata(key, value, descriptor.value);
+      return descriptor;
+    }
+    Reflect.defineMetadata(key, value, target);
+    return target;
+  }, "decoratorFactory");
+  decoratorFactory.KEY = key;
+  return decoratorFactory;
+}
+__name(SetMetadata, "SetMetadata");
+
+// src/decorators/errors/catch.decorator.ts
+function Catch(...exceptions) {
+  return (target) => {
+    if (Reflect.hasMetadata(CoreMetadataKey.Catch, target)) {
+      throw new Error(ErrorMessage.DuplicateDecoratorUsage);
+    }
+    const duplicates = exceptions.filter((exception, index) => exceptions.indexOf(exception) !== index);
+    if (duplicates.length) {
+      throw new Error(ErrorMessage.ExceptionHandlingConflict);
+    }
+    Reflect.defineMetadata(CoreMetadataKey.Catch, exceptions, target);
+    return target;
+  };
+}
+__name(Catch, "Catch");
+
+// src/decorators/errors/use-filters.decorator.ts
+function UseFilters(...filters) {
+  return (target, method, descriptor) => {
+    const validatedFilters = [];
+    for (const filter of filters) {
+      const { valid, value, error } = validateErrorFilter(filter);
+      if (!valid) throw new Error(error);
+      validatedFilters.push(value);
+    }
+    if (!isNil(descriptor) && !isNil(descriptor.value)) {
+      if (filters.length === 0) {
+        throw new Error(ErrorMessage.AtLeastOneFilterRequired);
+      }
+      const methodFilters = Reflect.getMetadata(CoreMetadataKey.ErrorFilters, target.constructor, method) || [];
+      if (!isNil(methodFilters.find((filter) => filters.includes(filter)))) {
+        throw new Error(ErrorMessage.DuplicateErrorFilterDetected);
+      }
+      Reflect.defineMetadata(CoreMetadataKey.ErrorFilters, [
+        ...validatedFilters,
+        ...methodFilters
+      ], target.constructor, method);
+      return descriptor;
+    }
+    if (filters.length === 0) {
+      throw new Error(ErrorMessage.AtLeastOneFilterRequired);
+    }
+    const classFilters = Reflect.getMetadata(CoreMetadataKey.ErrorFilters, target) || [];
+    if (!isNil(classFilters.find((filter) => filters.includes(filter)))) {
+      throw new Error(ErrorMessage.DuplicateErrorFilterDetected);
+    }
+    Reflect.defineMetadata(CoreMetadataKey.ErrorFilters, [
+      ...validatedFilters,
+      ...classFilters
+    ], target);
+    return target;
+  };
+}
+__name(UseFilters, "UseFilters");
+
+// src/app/module-tree/app-runtime.ts
+import { inject as inject2, injectable as injectable4, optional as optional2 } from "inversify";
+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");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var AppRuntime = class {
+  static {
+    __name(this, "AppRuntime");
+  }
+  eventHandler;
+  rpcHandler;
+  globalGuards;
+  globalInterceptors;
+  globalPipes;
+  globalErrorFilters;
+  loggerService;
+  enableShutdownHooks;
+  async boot(resolvedTree) {
+    await resolvedTree.asyncTraverse(async (node) => {
+      const startTime = Date.now();
+      const module = node.value;
+      module.instance = module.container.get(module.metadata.classRef);
+      module.controllers.forEach((controller) => controller.instance = module.container.get(controller.metadata.classRef));
+      [
+        ...module.metadata.internalProviders,
+        ...module.metadata.externalProviders
+      ].forEach(([token]) => module.container.get(token));
+      this.loggerService.log(`Module ${module.metadata.classRef.name} loaded (${Date.now() - startTime}ms)`);
+      await this.runLifecycleMethod(module, "onModuleInit");
+    });
+    await this.runLifecycleMethods(resolvedTree, "onAppBootstrap");
+    resolvedTree.traverse((node) => {
+      const module = node.value;
+      module.controllers.forEach((controller) => {
+        const time = Date.now();
+        this.registerTimers(controller);
+        this.registerListeners(controller);
+        this.loggerService.log(`Controller ${controller.metadata.classRef.name} timers and listeners registered (${Date.now() - time}ms)`);
+      });
+    });
+  }
+  async shutdown(resolvedTree) {
+    if (this.enableShutdownHooks) {
+      await this.runLifecycleMethods(resolvedTree, "onModuleDestroy");
+      await this.runLifecycleMethods(resolvedTree, "beforeAppShutdown");
+    }
+    await resolvedTree.asyncTraverse(async (node) => {
+      const module = node.value;
+      module.controllers.forEach((controller) => {
+        const timerService = controller.owner.container.get(TIMER_SERVICE);
+        timerService.everyticks.forEach((timer) => timer.destroy());
+        timerService.intervals.forEach((timer) => timer.destroy());
+        timerService.timeouts.forEach((timer) => timer.destroy());
+        timerService.crons.forEach((cron) => cron.stop());
+        controller.eventHandlers.forEach((handler) => handler.destroy());
+        controller.rpcHandlers.forEach((handler) => handler.destroy());
+      });
+    });
+    if (this.enableShutdownHooks) {
+      await this.runLifecycleMethods(resolvedTree, "onAppShutdown");
+    }
+  }
+  registerListeners(controller) {
+    const module = controller.owner;
+    controller.metadata.events.forEach((event) => {
+      const guards = [
+        ...this.globalGuards,
+        ...module.metadata.guards,
+        ...controller.metadata.guards,
+        ...event.guards
+      ];
+      const interceptors = [
+        ...this.globalInterceptors,
+        ...module.metadata.interceptors,
+        ...controller.metadata.interceptors,
+        ...event.interceptors
+      ];
+      const pipes = [
+        ...this.globalPipes,
+        ...module.metadata.pipes,
+        ...controller.metadata.pipes,
+        ...event.pipes
+      ];
+      const mappedErrorFilters = this.mapErrorFilters([
+        ...this.globalErrorFilters,
+        ...module.metadata.errorFilters,
+        ...controller.metadata.errorFilters,
+        ...event.errorFilters
+      ]);
+      const handler = this.eventHandler.registerEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event);
+      controller.eventHandlers.push(handler);
+    });
+    controller.metadata.rpcs.forEach(async (rpc) => {
+      const guards = [
+        ...this.globalGuards,
+        ...module.metadata.guards,
+        ...controller.metadata.guards,
+        ...rpc.guards
+      ];
+      const interceptors = [
+        ...this.globalInterceptors,
+        ...module.metadata.interceptors,
+        ...controller.metadata.interceptors,
+        ...rpc.interceptors
+      ];
+      const pipes = [
+        ...this.globalPipes,
+        ...module.metadata.pipes,
+        ...controller.metadata.pipes,
+        ...rpc.pipes
+      ];
+      const mappedErrorFilters = this.mapErrorFilters([
+        ...this.globalErrorFilters,
+        ...module.metadata.errorFilters,
+        ...controller.metadata.errorFilters,
+        ...rpc.errorFilters
+      ]);
+      const handler = await this.rpcHandler.registerRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc);
+      controller.rpcHandlers.push(handler);
+    });
+  }
+  registerTimers(controller) {
+    const timerService = controller.owner.container.get(TIMER_SERVICE);
+    controller.metadata.timers.forEach((timer) => {
+      if (timer.type === "cron") {
+        timerService.createCronJob(controller.instance[timer.method].bind(controller.instance), timer.options);
+      } else if (timer.type === "everytick") {
+        timerService.createEveryTick(controller.instance[timer.method].bind(controller.instance), timer.name);
+      } else if (timer.type === "interval") {
+        timerService.createInterval(controller.instance[timer.method].bind(controller.instance), timer.options.timeout, timer.name);
+      } else if (timer.type === "timeout") {
+        timerService.createTimeout(controller.instance[timer.method].bind(controller.instance), timer.options.timeout, timer.name);
+      }
+    });
+  }
+  mapErrorFilters(errorFilters) {
+    const filterMap = [];
+    for (const filter of errorFilters) {
+      const errors = Reflect.getMetadata(CoreMetadataKey.Catch, filter) ?? [];
+      if (errors.length === 0) {
+        errors.push("MANGO_ANY_ERROR");
+      }
+      for (const error of errors) {
+        if (!isNil(filterMap.find((filterError) => filterError[0] === error))) {
+          this.loggerService.error("An error occurred while trying to map error filters.");
+          throw new Error(ErrorMessage.ErrorAlreadyHandledByFilter);
+        }
+        filterMap.push([
+          error,
+          filter
+        ]);
+      }
+    }
+    return filterMap;
+  }
+  async runLifecycleMethods(resolvedTree, method) {
+    return resolvedTree.asyncTraverse(async (node) => await this.runLifecycleMethod(node.value, method));
+  }
+  async runLifecycleMethod(module, method) {
+    await Promise.all(module.controllers.map(async (controller) => {
+      if (!isObject(controller.instance) || isNil(controller.instance[method])) return;
+      await controller.instance[method]();
+    }));
+    await Promise.all([
+      ...module.metadata.internalProviders,
+      ...module.metadata.externalProviders
+    ].map(async ([token]) => {
+      const providerInstance = module.container.get(token);
+      if (!isObject(providerInstance) || isNil(providerInstance[method])) return;
+      await providerInstance[method]();
+    }));
+    if (!isObject(module.instance) || isNil(module.instance[method])) return;
+    await module.instance[method]();
+  }
+};
+_ts_decorate([
+  inject2(ControllerEventHandler),
+  _ts_metadata("design:type", typeof ControllerEventHandler === "undefined" ? Object : ControllerEventHandler)
+], AppRuntime.prototype, "eventHandler", void 0);
+_ts_decorate([
+  inject2(ControllerRPCHandler),
+  _ts_metadata("design:type", typeof ControllerRPCHandler === "undefined" ? Object : ControllerRPCHandler)
+], AppRuntime.prototype, "rpcHandler", void 0);
+_ts_decorate([
+  inject2(GLOBAL_GUARDS),
+  _ts_metadata("design:type", Array)
+], AppRuntime.prototype, "globalGuards", void 0);
+_ts_decorate([
+  inject2(GLOBAL_INTERCEPTORS),
+  _ts_metadata("design:type", Array)
+], AppRuntime.prototype, "globalInterceptors", void 0);
+_ts_decorate([
+  inject2(GLOBAL_PIPES),
+  _ts_metadata("design:type", Array)
+], AppRuntime.prototype, "globalPipes", void 0);
+_ts_decorate([
+  inject2(GLOBAL_ERROR_FILTERS),
+  _ts_metadata("design:type", Array)
+], AppRuntime.prototype, "globalErrorFilters", void 0);
+_ts_decorate([
+  inject2(LOGGER_SERVICE),
+  _ts_metadata("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], AppRuntime.prototype, "loggerService", void 0);
+_ts_decorate([
+  inject2(ENABLE_SHUTDOWN_HOOKS),
+  optional2(),
+  _ts_metadata("design:type", Boolean)
+], AppRuntime.prototype, "enableShutdownHooks", void 0);
+AppRuntime = _ts_decorate([
+  injectable4()
+], AppRuntime);
+
+// src/app/module-tree/dependency-binder.ts
+import { Container, inject as inject3, injectable as injectable5, optional as optional3 } from "inversify";
+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");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var ModuleDependencyBinder = class {
+  static {
+    __name(this, "ModuleDependencyBinder");
+  }
+  globalAppContainer;
+  loggerService;
+  containerOptions;
+  async bind(resolvedTree) {
+    await resolvedTree.asyncTraverse(async (node) => {
+      const startTime = Date.now();
+      const module = node.value;
+      module.container = new ModuleContainer(module.metadata.container ?? this.containerOptions);
+      module.container.parent = this.globalAppContainer;
+      this.globalAppContainer.bind(module.metadata.classRef).toSelf().inSingletonScope();
+      if (module.metadata.global) {
+        for (const [_, provider] of module.metadata.externalProviders) {
+          this.bindProvider(provider, this.globalAppContainer);
+        }
+      } else {
+        for (const [token, provider] of module.metadata.externalProviders) {
+          this.bindProvider(provider, module.container);
+          module.parent?.container.bind(token).toDynamicValue(() => module.container.get(token));
+        }
+        for (const importModule of module.repetitiveImports) {
+          for (const [token] of importModule.metadata.externalProviders) {
+            module.container.bind(token).toDynamicValue(() => importModule.container.get(token));
+          }
+        }
+      }
+      for (const [_, provider] of module.metadata.internalProviders) {
+        this.bindProvider(provider, module.container);
+      }
+      module.container.bind(MODULE_CONTAINER).toConstantValue(module.container);
+      for (const classRef of module.metadata.controllers) {
+        module.container.bind(classRef).toSelf().inSingletonScope();
+      }
+      module.container.bind(TIMER_SERVICE).to(TimerService).inSingletonScope();
+      this.loggerService.log(`Module ${module.metadata.classRef.name} dependencies binded (${Date.now() - startTime}ms)`);
+    });
+  }
+  bindProvider(provider, container) {
+    if ("useValue" in provider) {
+      container.bind(provider.provide).toConstantValue(provider.useValue);
+    } else if ("useFactory" in provider) {
+      const binding = container.bind(provider.provide).toDynamicValue((ctx) => {
+        const deps = provider.inject?.map((dep) => {
+          if (isObject(dep) && "token" in dep && "optional" in dep) {
+            try {
+              return ctx.container.get(dep.token);
+            } catch (err) {
+              if (dep.optional) return void 0;
+              this.loggerService.error("An error occurred while trying to resolve a dependency.");
+              throw err;
+            }
+          }
+          return ctx.container.get(dep);
+        }) ?? [];
+        return provider.useFactory(...deps);
+      });
+      if (provider.scope === "transient") binding.inTransientScope();
+      else if (provider.scope === "request") binding.inRequestScope();
+      else binding.inSingletonScope();
+    } else if ("useClass" in provider) {
+      const binding = container.bind(provider.provide).to(provider.useClass);
+      if (provider.scope === "transient") binding.inTransientScope();
+      else if (provider.scope === "request") binding.inRequestScope();
+      else binding.inSingletonScope();
+    } else if ("useExisting" in provider) {
+      container.bind(provider.provide).toService(provider.useExisting);
+    }
+  }
+};
+_ts_decorate2([
+  inject3(GLOBAL_APP_CONTAINER),
+  _ts_metadata2("design:type", typeof Container === "undefined" ? Object : Container)
+], ModuleDependencyBinder.prototype, "globalAppContainer", void 0);
+_ts_decorate2([
+  inject3(LOGGER_SERVICE),
+  _ts_metadata2("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], ModuleDependencyBinder.prototype, "loggerService", void 0);
+_ts_decorate2([
+  optional3(),
+  inject3(CONTAINER_OPTIONS),
+  _ts_metadata2("design:type", typeof interfaces === "undefined" || typeof interfaces.ContainerOptions === "undefined" ? Object : interfaces.ContainerOptions)
+], ModuleDependencyBinder.prototype, "containerOptions", void 0);
+ModuleDependencyBinder = _ts_decorate2([
+  injectable5()
+], ModuleDependencyBinder);
+
+// src/app/module-tree/module-tree-scanner.ts
+import { inject as inject4, injectable as injectable6 } from "inversify";
+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");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var ModuleTreeScanner = class {
+  static {
+    __name(this, "ModuleTreeScanner");
+  }
+  moduleMetadataReader;
+  controllerMetadataReader;
+  loggerService;
+  async scan(classRef) {
+    const startTime = Date.now();
+    const moduleMetadata = await this.moduleMetadataReader.read(classRef);
+    const module = new Module();
+    module.metadata = moduleMetadata;
+    this.loggerService.log(`Module ${module.metadata.classRef.name} scanned (${Date.now() - startTime}ms)`);
+    await this.scanControllers(module);
+    const moduleTree = new Tree(module);
+    const scannedModules = /* @__PURE__ */ new Map();
+    scannedModules.set(classRef, module);
+    for (const importedModule of moduleMetadata.imports) {
+      await this.scanModules(moduleTree.root, importedModule, scannedModules);
+    }
+    return moduleTree;
+  }
+  async scanModules(parentNode, classRef, scannedModules = /* @__PURE__ */ new Map()) {
+    const scannedModule = scannedModules.get(classRef);
+    if (!isNil(scannedModule)) {
+      parentNode.value.repetitiveImports.add(scannedModule);
+      return;
+    }
+    const startTime = Date.now();
+    const moduleMetadata = await this.moduleMetadataReader.read(classRef);
+    this.checkCircularDependency(parentNode.value.metadata, moduleMetadata);
+    const module = new Module();
+    module.metadata = moduleMetadata;
+    module.parent = parentNode.value;
+    this.loggerService.log(`Module ${module.metadata.classRef.name} scanned (${Date.now() - startTime}ms)`);
+    await this.scanControllers(module);
+    const treeNode = new TreeNode(module);
+    parentNode.addChild(treeNode);
+    scannedModules.set(classRef, module);
+    for (const importModule of moduleMetadata.imports) {
+      await this.scanModules(treeNode, importModule, scannedModules);
+    }
+  }
+  async scanControllers(module) {
+    for (const classRef of module.metadata.controllers) {
+      const startTime = Date.now();
+      const controllerMetadata = await this.controllerMetadataReader.read(classRef);
+      const controller = new Controller();
+      controller.metadata = controllerMetadata;
+      controller.owner = module;
+      module.controllers.push(controller);
+      this.loggerService.log(`Controller ${classRef.name} scanned (${Date.now() - startTime}ms)`);
+    }
+  }
+  async checkCircularDependency(parentMetadata, moduleMetadata) {
+    if (moduleMetadata.imports.includes(parentMetadata.classRef)) {
+      throw new Error(ErrorMessage.CircularDependencyDetected);
+    }
+  }
+};
+_ts_decorate3([
+  inject4(ModuleMetadataReader),
+  _ts_metadata3("design:type", typeof ModuleMetadataReader === "undefined" ? Object : ModuleMetadataReader)
+], ModuleTreeScanner.prototype, "moduleMetadataReader", void 0);
+_ts_decorate3([
+  inject4(ControllerMetadataReader),
+  _ts_metadata3("design:type", typeof ControllerMetadataReader === "undefined" ? Object : ControllerMetadataReader)
+], ModuleTreeScanner.prototype, "controllerMetadataReader", void 0);
+_ts_decorate3([
+  inject4(LOGGER_SERVICE),
+  _ts_metadata3("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], ModuleTreeScanner.prototype, "loggerService", void 0);
+ModuleTreeScanner = _ts_decorate3([
+  injectable6()
+], ModuleTreeScanner);
+
+// src/app/multiplayer/ragemp/ragemp-script-event-handler.ts
+var RageMPScriptEvent = class {
+  static {
+    __name(this, "RageMPScriptEvent");
+  }
+  eventName;
+  listener;
+  constructor(eventName, listener) {
+    this.eventName = eventName;
+    this.listener = listener;
+  }
+  destroy() {
+    mp.events.remove(this.eventName, this.listener);
+  }
+};
+
+// src/app/multiplayer/ragemp/ragemp-event-emmiter.ts
+var RageMPEventEmmiter = class {
+  static {
+    __name(this, "RageMPEventEmmiter");
+  }
+  emit(eventName, ...args) {
+    mp.events.call(eventName, ...args);
+  }
+  on(eventName, listener) {
+    mp.events.add(eventName, listener);
+    return new RageMPScriptEvent(eventName, listener);
+  }
+  once(eventName, listener) {
+    const onceWrapper = /* @__PURE__ */ __name((...args) => {
+      mp.events.remove(eventName, onceWrapper);
+      listener(...args);
+    }, "onceWrapper");
+    mp.events.add(eventName, onceWrapper);
+    return new RageMPScriptEvent(eventName, onceWrapper);
+  }
+  off(eventName, listener) {
+    mp.events.remove(eventName, listener);
+  }
+};
+
+// src/app/multiplayer/ragemp/ragemp-timer.ts
+var RageMPTimer = class {
+  static {
+    __name(this, "RageMPTimer");
+  }
+  id;
+  interval;
+  once;
+  callback;
+  clearTimer;
+  lastTick = Date.now();
+  constructor(id, interval = 0, once, callback, clearTimer) {
+    this.id = id;
+    this.interval = interval;
+    this.once = once;
+    this.callback = callback;
+    this.clearTimer = clearTimer;
+  }
+  destroy() {
+    this.clearTimer();
+  }
+};
+
+// src/app/multiplayer/ragemp/ragemp-timers.ts
+var RageMPTimers = class {
+  static {
+    __name(this, "RageMPTimers");
+  }
+  timerIncrementer = 0;
+  timers = /* @__PURE__ */ new Map();
+  everyTickHandlers = /* @__PURE__ */ new Map();
+  isEveryTickRunning = false;
+  everyTickMainHandler = null;
+  get all() {
+    return [
+      ...this.timers.values()
+    ];
+  }
+  get warningThreshold() {
+    return 0;
+  }
+  set warningThreshold(_value) {
+  }
+  get sourceLocationFrameSkipCount() {
+    return 0;
+  }
+  set sourceLocationFrameSkipCount(_value) {
+  }
+  getByID(id) {
+    const timer = this.timers.get(id);
+    return timer ?? null;
+  }
+  createTimer(createTimer, clear, callback, interval, once, ...args) {
+    const callbackBind = callback.bind(this, ...Array.isArray(args) ? args : []);
+    const timerId = typeof interval === "number" ? createTimer(callbackBind, interval) : createTimer(callbackBind);
+    const id = this.timerIncrementer++;
+    const rageMPTimer = new RageMPTimer(id, interval ?? 0, once, callbackBind, () => {
+      clear(timerId);
+      this.timers.delete(id);
+    });
+    this.timers.set(id, rageMPTimer);
+    return rageMPTimer;
+  }
+  setInterval(callback, time, ...args) {
+    return this.createTimer((cb, interval) => setInterval(cb, interval), (id) => clearInterval(id), callback, time, false, ...args);
+  }
+  setTimeout(callback, time, ...args) {
+    const id = this.timerIncrementer++;
+    const callbackBind = callback.bind(this, ...Array.isArray(args) ? args : []);
+    const timerId = setTimeout(() => {
+      callbackBind();
+      this.timers.delete(id);
+    }, time);
+    const rageMPTimer = new RageMPTimer(id, time, true, callbackBind, () => {
+      clearTimeout(timerId);
+      this.timers.delete(id);
+    });
+    this.timers.set(id, rageMPTimer);
+    return rageMPTimer;
+  }
+  everyTick(callback, ...args) {
+    const id = this.timerIncrementer++;
+    const callbackBind = callback.bind(this, ...Array.isArray(args) ? args : []);
+    this.everyTickHandlers.set(id, {
+      callback,
+      bound: callbackBind
+    });
+    const isClientSide = typeof mp !== "undefined" && typeof mp.browsers !== "undefined";
+    if (!this.isEveryTickRunning) {
+      this.isEveryTickRunning = true;
+      if (isClientSide) {
+        this.everyTickMainHandler = () => {
+          for (const [, handler] of this.everyTickHandlers) {
+            try {
+              handler.bound();
+            } catch (e) {
+              mp.console.logError(`Error in everyTick handler: ${e}`);
+            }
+          }
+        };
+        mp.events.add("render", this.everyTickMainHandler);
+      } else {
+        const intervalHandler = /* @__PURE__ */ __name(() => {
+          for (const [, handler] of this.everyTickHandlers) {
+            try {
+              handler.bound();
+            } catch (e) {
+              mp.console.logError(`Error in everyTick handler: ${e}`);
+            }
+          }
+        }, "intervalHandler");
+        this._everyTickInterval = setInterval(intervalHandler, 0);
+      }
+    }
+    const rageMPTimer = new RageMPTimer(id, 0, false, callbackBind, () => {
+      this.everyTickHandlers.delete(id);
+      this.timers.delete(id);
+      if (this.everyTickHandlers.size === 0) {
+        if (isClientSide && this.everyTickMainHandler) {
+          mp.events.remove("render", this.everyTickMainHandler);
+          this.everyTickMainHandler = null;
+        } else if (this._everyTickInterval) {
+          clearInterval(this._everyTickInterval);
+          this._everyTickInterval = null;
+        }
+        this.isEveryTickRunning = false;
+      }
+    });
+    this.timers.set(id, rageMPTimer);
+    return rageMPTimer;
+  }
+  nextTick(callback, ...args) {
+    const id = this.timerIncrementer++;
+    const callbackBind = callback.bind(this, ...Array.isArray(args) ? args : []);
+    const isClientSide = typeof mp !== "undefined" && typeof mp.browsers !== "undefined";
+    let timerId;
+    if (isClientSide) {
+      const handler = /* @__PURE__ */ __name(() => {
+        try {
+          callbackBind();
+        } finally {
+          mp.events.remove("render", handler);
+          this.timers.delete(id);
+        }
+      }, "handler");
+      mp.events.add("render", handler);
+      const rageMPTimer = new RageMPTimer(id, 0, true, callbackBind, () => {
+        mp.events.remove("render", handler);
+        this.timers.delete(id);
+      });
+      this.timers.set(id, rageMPTimer);
+      return rageMPTimer;
+    } else {
+      timerId = setTimeout(() => {
+        try {
+          callbackBind();
+        } finally {
+          this.timers.delete(id);
+        }
+      }, 0);
+      const rageMPTimer = new RageMPTimer(id, 0, true, callbackBind, () => {
+        clearTimeout(timerId);
+        this.timers.delete(id);
+      });
+      this.timers.set(id, rageMPTimer);
+      return rageMPTimer;
+    }
+  }
+  time(_name) {
+  }
+  timeEnd(_name) {
+  }
+};
+
+// src/app/multiplayer/ragemp/ragemp-multiplayer.service.ts
+var RageMPMultiplayerService = class {
+  static {
+    __name(this, "RageMPMultiplayerService");
+  }
+  Timers;
+  Events;
+  constructor() {
+    this.Events = new RageMPEventEmmiter();
+    this.Timers = new RageMPTimers();
+  }
+  parseInternalArgs(...args) {
+    const player = isObject(args[0]) ? args[0] : void 0;
+    return {
+      player,
+      body: args
+    };
+  }
+  log(arg, ...args) {
+    const message = [
+      arg,
+      ...args
+    ].map((a) => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ");
+    mp.console.logInfo(message);
+  }
+  logError(arg, ...args) {
+    const message = [
+      arg,
+      ...args
+    ].map((a) => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ");
+    mp.console.logError(message);
+  }
+  logWarning(arg, ...args) {
+    const message = [
+      arg,
+      ...args
+    ].map((a) => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ");
+    mp.console.logWarning(message);
+  }
+  logDebug(arg, ...args) {
+    const message = [
+      arg,
+      ...args
+    ].map((a) => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ");
+    mp.console.logInfo(`[DEBUG] ${message}`);
+  }
+};
+
+// src/app/app-builder.ts
+import { Container as Container3 } from "inversify";
+
+// src/app/app.ts
+import { Container as Container2, inject as inject5, injectable as injectable7 } from "inversify";
+function _ts_decorate4(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_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+var App = class {
+  static {
+    __name(this, "App");
+  }
+  moduleTreeScanner;
+  moduleDependencyBinder;
+  appRuntime;
+  internalAppContainer;
+  plugins;
+  loggerService;
+  moduleTree;
+  loaded = false;
+  async start(rootModule) {
+    if (this.loaded) {
+      this.loggerService.error("Error occurred while starting the app.");
+      throw new Error(ErrorMessage.AppAlreadyLoaded);
+    }
+    this.loggerService.log("Starting app...");
+    await this.runPluginMethods("beforeStart");
+    this.loggerService.log("Scanning module tree...");
+    await this.runPluginMethods("beforeScan");
+    this.moduleTree = await this.moduleTreeScanner.scan(rootModule);
+    await this.runPluginMethods("afterScan");
+    this.loggerService.log("Binding module dependencies...");
+    await this.runPluginMethods("beforeBind");
+    await this.moduleDependencyBinder.bind(this.moduleTree);
+    await this.runPluginMethods("afterBind");
+    this.loggerService.log("Loading app...");
+    await this.runPluginMethods("beforeLoad");
+    await this.appRuntime.boot(this.moduleTree);
+    this.loaded = true;
+    await this.runPluginMethods("afterLoad");
+    this.loggerService.log("App loaded");
+    await this.runPluginMethods("afterStart");
+  }
+  async stop() {
+    if (!this.loaded) {
+      this.loggerService.error("Error occurred while stopping the app.");
+      throw new Error(ErrorMessage.AppNotLoaded);
+    }
+    await this.runPluginMethods("beforeStop");
+    this.loggerService.log("Stopping app...");
+    await this.appRuntime.shutdown(this.moduleTree);
+    this.loaded = false;
+    this.loggerService.log("App stopped");
+    await this.runPluginMethods("afterStop");
+  }
+  async runPluginMethods(method) {
+    await Promise.all(this.plugins.map(async (p) => {
+      const plugin = this.internalAppContainer.get(p);
+      if (!plugin[method]) return Promise.resolve();
+      return Promise.resolve(plugin[method]());
+    }));
+  }
+};
+_ts_decorate4([
+  inject5(ModuleTreeScanner),
+  _ts_metadata4("design:type", typeof ModuleTreeScanner === "undefined" ? Object : ModuleTreeScanner)
+], App.prototype, "moduleTreeScanner", void 0);
+_ts_decorate4([
+  inject5(ModuleDependencyBinder),
+  _ts_metadata4("design:type", typeof ModuleDependencyBinder === "undefined" ? Object : ModuleDependencyBinder)
+], App.prototype, "moduleDependencyBinder", void 0);
+_ts_decorate4([
+  inject5(AppRuntime),
+  _ts_metadata4("design:type", typeof AppRuntime === "undefined" ? Object : AppRuntime)
+], App.prototype, "appRuntime", void 0);
+_ts_decorate4([
+  inject5(INTERNAL_APP_CONTAINER),
+  _ts_metadata4("design:type", typeof Container2 === "undefined" ? Object : Container2)
+], App.prototype, "internalAppContainer", void 0);
+_ts_decorate4([
+  inject5(PLUGINS),
+  _ts_metadata4("design:type", Array)
+], App.prototype, "plugins", void 0);
+_ts_decorate4([
+  inject5(LOGGER_SERVICE),
+  _ts_metadata4("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], App.prototype, "loggerService", void 0);
+App = _ts_decorate4([
+  injectable7()
+], App);
+
+// src/app/app-builder.ts
+var AppBuilder = class {
+  static {
+    __name(this, "AppBuilder");
+  }
+  enviroment;
+  internalAppContainer;
+  multiplayerService;
+  plugins;
+  globalContainerOptions = {};
+  constructor(config) {
+    this.enviroment = config.enviroment;
+    this.internalAppContainer = config.internalAppContainer;
+    this.multiplayerService = config.multiplayerService;
+    this.plugins = config.plugins;
+  }
+  useGlobalGuards(...guards) {
+    const validatedGuards = [];
+    for (const guard of guards) {
+      const { valid, value, error } = validateGuard(guard);
+      if (!valid) throw new Error(error);
+      validatedGuards.push(value);
+    }
+    this.internalAppContainer.bind(GLOBAL_GUARDS).toConstantValue(validatedGuards);
+    return this;
+  }
+  useGlobalInterceptors(...interceptors) {
+    const validatedInterceptors = [];
+    for (const interceptor of interceptors) {
+      const { valid, value, error } = validateInterceptor(interceptor);
+      if (!valid) throw new Error(error);
+      validatedInterceptors.push(value);
+    }
+    this.internalAppContainer.bind(GLOBAL_INTERCEPTORS).toConstantValue(validatedInterceptors);
+    return this;
+  }
+  useGlobalPipes(...pipes) {
+    const validatedPipes = [];
+    for (const pipe of pipes) {
+      const { valid, value, error } = validatePipe(pipe);
+      if (!valid) throw new Error(error);
+      validatedPipes.push(value);
+    }
+    this.internalAppContainer.bind(GLOBAL_PIPES).toConstantValue(validatedPipes);
+    return this;
+  }
+  useGlobalFilters(...filters) {
+    const validatedFIlters = [];
+    for (const filter of filters) {
+      const { valid, value, error } = validateErrorFilter(filter);
+      if (!valid) throw new Error(error);
+      validatedFIlters.push(value);
+    }
+    this.internalAppContainer.bind(GLOBAL_ERROR_FILTERS).toConstantValue(validatedFIlters);
+    return this;
+  }
+  usePlugins(...plugins) {
+    plugins.forEach((p) => this.internalAppContainer.bind(p).toSelf().inSingletonScope());
+    const internalPlugins = this.internalAppContainer.get(PLUGINS);
+    this.internalAppContainer.rebind(PLUGINS).toConstantValue([
+      ...internalPlugins,
+      ...plugins
+    ]);
+    return this;
+  }
+  enableShutdownHooks() {
+    this.internalAppContainer.bind(ENABLE_SHUTDOWN_HOOKS).toConstantValue(true);
+    return this;
+  }
+  setContainerOptions(options, onlyGlobal = false) {
+    this.globalContainerOptions = options;
+    if (onlyGlobal) return this;
+    this.internalAppContainer.bind(CONTAINER_OPTIONS).toConstantValue(options);
+    return this;
+  }
+  async build() {
+    const globalAppContainer = new Container3(this.globalContainerOptions);
+    globalAppContainer.bind(REFLECTOR_SERVICE).toConstantValue(ReflectorService);
+    globalAppContainer.bind(ReflectorService).toService(REFLECTOR_SERVICE);
+    globalAppContainer.bind(MULTIPLAYER_SERVICE).toConstantValue(this.multiplayerService);
+    this.internalAppContainer.bind(App).toSelf().inSingletonScope();
+    this.internalAppContainer.bind(GLOBAL_APP_CONTAINER).toConstantValue(globalAppContainer);
+    this.internalAppContainer.bind(ModuleTreeScanner).toSelf().inSingletonScope();
+    this.internalAppContainer.bind(ModuleDependencyBinder).toSelf().inSingletonScope();
+    this.internalAppContainer.bind(AppRuntime).toSelf().inSingletonScope();
+    this.internalAppContainer.bind(PipelineHandler).toSelf().inSingletonScope();
+    this.internalAppContainer.bind(Module).toSelf().inTransientScope();
+    this.internalAppContainer.bind(ModuleMetadataReader).toSelf().inSingletonScope();
+    this.internalAppContainer.bind(Controller).toSelf().inTransientScope();
+    this.internalAppContainer.bind(ControllerMetadataReader).toSelf().inSingletonScope();
+    this.internalAppContainer.bind(ControllerFlowHandler).toSelf().inSingletonScope();
+    this.internalAppContainer.bind(ControllerEventHandler).toSelf().inSingletonScope();
+    this.internalAppContainer.bind(ControllerRPCHandler).toSelf().inSingletonScope();
+    this.internalAppContainer.bind(MangoRequestBase).toSelf().inTransientScope();
+    this.internalAppContainer.bind(MANGO_REQUEST_FACTORY).toFactory((context) => {
+      return (body, player) => {
+        const request = context.container.get(MangoRequestBase);
+        request.$body = body;
+        request.$player = player;
+        return request;
+      };
+    });
+    this.internalAppContainer.bind(MangoResponseBase).toSelf().inTransientScope();
+    this.internalAppContainer.bind(MANGO_RESPONSE_FACTORY).toFactory((context) => {
+      return () => {
+        return context.container.get(MangoResponseBase);
+      };
+    });
+    this.internalAppContainer.bind(ExecutionContextBase).toSelf().inTransientScope();
+    this.internalAppContainer.bind(EXECUTION_CONTEXT_FACTORY).toFactory((context) => {
+      return (type, classRef, handler, request, response, name) => {
+        const executionContext = context.container.get(ExecutionContextBase);
+        executionContext.$type = type;
+        executionContext.$request = request;
+        executionContext.$response = response;
+        executionContext.$handler = handler;
+        executionContext.$classRef = classRef;
+        executionContext.$name = name;
+        return executionContext;
+      };
+    });
+    for (const plugin of this.plugins) {
+      this.internalAppContainer.bind(plugin).toSelf().inSingletonScope();
+      const pluginInstance = this.internalAppContainer.get(plugin);
+      if (!pluginInstance.onBuild) continue;
+      await pluginInstance.onBuild();
+    }
+    if (!this.internalAppContainer.isBound(GLOBAL_GUARDS)) this.internalAppContainer.bind(GLOBAL_GUARDS).toConstantValue([]);
+    if (!this.internalAppContainer.isBound(GLOBAL_INTERCEPTORS)) this.internalAppContainer.bind(GLOBAL_INTERCEPTORS).toConstantValue([]);
+    if (!this.internalAppContainer.isBound(GLOBAL_PIPES)) this.internalAppContainer.bind(GLOBAL_PIPES).toConstantValue([]);
+    if (!this.internalAppContainer.isBound(GLOBAL_ERROR_FILTERS)) this.internalAppContainer.bind(GLOBAL_ERROR_FILTERS).toConstantValue([]);
+    return this.internalAppContainer.get(App);
+  }
+};
+
+// src/app/create-app.ts
+import { Container as Container4 } from "inversify";
+async function createAppBuilder({ enviroment, plugins, appBuilderInherit, multiplayerService }) {
+  const internalAppContainer = new Container4();
+  if (multiplayerService) internalAppContainer.bind(MULTIPLAYER_SERVICE).toConstantValue(multiplayerService);
+  internalAppContainer.bind(PLUGINS).toConstantValue(plugins);
+  return new appBuilderInherit({
+    enviroment,
+    internalAppContainer,
+    multiplayerService,
+    plugins
+  });
+}
+__name(createAppBuilder, "createAppBuilder");
+
+// src/decorators/create-event-decorator.ts
+function createEventDecorator(type, name, webViewId) {
+  return (target, method) => {
+    if (!isNil(name) && !isString(name)) {
+      throw new Error(ErrorMessage.EventNameMustBeString);
+    }
+    name = name ?? method;
+    const events = Reflect.getMetadata(CoreMetadataKey.ControllerEvents, target) ?? [];
+    if (events.some((event) => event.method === method && event.name === name && event.type === type)) {
+      throw new Error(ErrorMessage.EventNameMustBeUnique);
+    }
+    Reflect.defineMetadata(CoreMetadataKey.ControllerEvents, [
+      ...events,
+      {
+        method,
+        name,
+        type,
+        webViewId
+      }
+    ], target);
+  };
+}
+__name(createEventDecorator, "createEventDecorator");
+
+// src/decorators/events/on-internal.decorator.ts
+function OnInternal(eventName) {
+  return createEventDecorator("onInternal", eventName);
+}
+__name(OnInternal, "OnInternal");
+
+// src/decorators/events/on-webview.decorator.ts
+function OnWebView(id, eventName) {
+  return createEventDecorator("onWebView", eventName, id);
+}
+__name(OnWebView, "OnWebView");
+
+// src/decorators/events/on.decorator.ts
+function On(eventName) {
+  return createEventDecorator("on", eventName);
+}
+__name(On, "On");
+
+// src/decorators/events/once-internal.decorator.ts
+function OnceInternal(eventName) {
+  return createEventDecorator("onceInternal", eventName);
+}
+__name(OnceInternal, "OnceInternal");
+
+// src/decorators/events/once.decorator.ts
+function Once(eventName) {
+  return createEventDecorator("once", eventName);
+}
+__name(Once, "Once");
+
+// src/decorators/events/once-webview.decorator.ts
+function OnceWebView(id, eventName) {
+  return createEventDecorator("onceWebView", eventName, id);
+}
+__name(OnceWebView, "OnceWebView");
+
+// src/decorators/params/body.decorator.ts
+function Body(...pipes) {
+  return (target, method, index) => {
+    const validatedPipes = [];
+    for (const pipe of pipes) {
+      const { valid, value, error } = validatePipe(pipe);
+      if (!valid) throw new Error(error);
+      validatedPipes.push(value);
+    }
+    const params = Reflect.getMetadata(CoreMetadataKey.ControllerParams, target, method) ?? [];
+    if (params.some((param) => param.index === index)) {
+      throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);
+    }
+    const paramTypes = Reflect.getMetadata("design:paramtypes", target, method);
+    const metatype = Array.isArray(paramTypes) ? paramTypes[index] : void 0;
+    Reflect.defineMetadata(CoreMetadataKey.ControllerParams, [
+      ...params,
+      {
+        index,
+        method,
+        pipes: validatedPipes,
+        type: MethodParamType.Body,
+        data: void 0,
+        metatype
+      }
+    ], target, method);
+  };
+}
+__name(Body, "Body");
+
+// src/decorators/params/index.decorator.ts
+function Index(key, ...pipes) {
+  return (target, method, index) => {
+    if (!isNumber(key)) {
+      throw new Error(ErrorMessage.IndexKeyMustBeNumber);
+    }
+    const validatedPipes = [];
+    for (const pipe of pipes) {
+      const { valid, value, error } = validatePipe(pipe);
+      if (!valid) throw new Error(error);
+      validatedPipes.push(value);
+    }
+    const params = Reflect.getMetadata(CoreMetadataKey.ControllerParams, target, method) ?? [];
+    if (params.some((param) => param.index === index)) {
+      throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);
+    }
+    const paramTypes = Reflect.getMetadata("design:paramtypes", target, method);
+    const metatype = Array.isArray(paramTypes) ? paramTypes[index] : void 0;
+    Reflect.defineMetadata(CoreMetadataKey.ControllerParams, [
+      ...params,
+      {
+        index,
+        method,
+        pipes: validatedPipes,
+        type: MethodParamType.Index,
+        data: key,
+        metatype
+      }
+    ], target, method);
+  };
+}
+__name(Index, "Index");
+
+// src/decorators/params/request.decorator.ts
+function Request() {
+  return (target, method, index) => {
+    const params = Reflect.getMetadata(CoreMetadataKey.ControllerParams, target, method) ?? [];
+    if (params.some((param) => param.index === index)) {
+      throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);
+    }
+    const paramTypes = Reflect.getMetadata("design:paramtypes", target, method);
+    const metatype = Array.isArray(paramTypes) ? paramTypes[index] : void 0;
+    Reflect.defineMetadata(CoreMetadataKey.ControllerParams, [
+      ...params,
+      {
+        index,
+        method,
+        type: MethodParamType.Request,
+        data: void 0,
+        metatype
+      }
+    ], target, method);
+  };
+}
+__name(Request, "Request");
+function Req() {
+  return Request();
+}
+__name(Req, "Req");
+
+// src/decorators/params/param.decorator.ts
+function Param(key, ...pipes) {
+  return (target, method, index) => {
+    if (!isString(key)) {
+      throw new Error(ErrorMessage.ParamKeyMustBeString);
+    }
+    const validatedPipes = [];
+    for (const pipe of pipes) {
+      const { valid, value, error } = validatePipe(pipe);
+      if (!valid) throw new Error(error);
+      validatedPipes.push(value);
+    }
+    const params = Reflect.getMetadata(CoreMetadataKey.ControllerParams, target, method) ?? [];
+    if (params.some((param) => param.index === index)) {
+      throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);
+    }
+    const paramTypes = Reflect.getMetadata("design:paramtypes", target, method);
+    const metatype = Array.isArray(paramTypes) ? paramTypes[index] : void 0;
+    Reflect.defineMetadata(CoreMetadataKey.ControllerParams, [
+      ...params,
+      {
+        index,
+        method,
+        data: key,
+        pipes: validatedPipes,
+        type: MethodParamType.Param,
+        metatype
+      }
+    ], target, method);
+  };
+}
+__name(Param, "Param");
+
+// src/decorators/params/response.deorator.ts
+function Response() {
+  return (target, method, index) => {
+    const params = Reflect.getMetadata(CoreMetadataKey.ControllerParams, target, method) ?? [];
+    if (params.some((param) => param.index === index)) {
+      throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);
+    }
+    const paramTypes = Reflect.getMetadata("design:paramtypes", target, method);
+    const metatype = Array.isArray(paramTypes) ? paramTypes[index] : void 0;
+    Reflect.defineMetadata(CoreMetadataKey.ControllerParams, [
+      ...params,
+      {
+        index,
+        method,
+        type: MethodParamType.Response,
+        data: void 0,
+        metatype
+      }
+    ], target, method);
+  };
+}
+__name(Response, "Response");
+function Res() {
+  return Response();
+}
+__name(Res, "Res");
+
+// src/decorators/pipeline/use-guards.decorator.ts
+function UseGuards(...guards) {
+  return (target, method, descriptor) => {
+    const validatedGuards = [];
+    for (const guard of guards) {
+      const { valid, value, error } = validateGuard(guard);
+      if (!valid) throw new Error(error);
+      validatedGuards.push(value);
+    }
+    if (!isNil(descriptor) && !isNil(descriptor.value)) {
+      if (guards.length === 0) {
+        throw new Error(ErrorMessage.AtLeastOneGuardRequired);
+      }
+      const methodGuards = Reflect.getMetadata(CoreMetadataKey.Guards, target.constructor, method) || [];
+      Reflect.defineMetadata(CoreMetadataKey.Guards, [
+        ...validatedGuards,
+        ...methodGuards
+      ], target.constructor, method);
+      return descriptor;
+    }
+    if (guards.length === 0) {
+      throw new Error(ErrorMessage.AtLeastOneGuardRequired);
+    }
+    const classGuards = Reflect.getMetadata(CoreMetadataKey.Guards, target) || [];
+    Reflect.defineMetadata(CoreMetadataKey.Guards, [
+      ...validatedGuards,
+      ...classGuards
+    ], target);
+    return target;
+  };
+}
+__name(UseGuards, "UseGuards");
+
+// src/decorators/pipeline/use-interceptors.decorator.ts
+function UseInterceptors(...interceptors) {
+  return (target, method, descriptor) => {
+    const validatedInterceptors = [];
+    for (const interceptor of interceptors) {
+      const { valid, value, error } = validateInterceptor(interceptor);
+      if (!valid) throw new Error(error);
+      validatedInterceptors.push(value);
+    }
+    if (!isNil(descriptor) && !isNil(descriptor.value)) {
+      if (interceptors.length === 0) {
+        throw new Error(ErrorMessage.AtLeastOneInterceptorRequired);
+      }
+      const methodInterceptors = Reflect.getMetadata(CoreMetadataKey.Interceptors, target.constructor, method) || [];
+      Reflect.defineMetadata(CoreMetadataKey.Interceptors, [
+        ...validatedInterceptors,
+        ...methodInterceptors
+      ], target.constructor, method);
+      return descriptor;
+    }
+    if (interceptors.length === 0) {
+      throw new Error(ErrorMessage.AtLeastOneInterceptorRequired);
+    }
+    const classInterceptors = Reflect.getMetadata(CoreMetadataKey.Interceptors, target) || [];
+    Reflect.defineMetadata(CoreMetadataKey.Interceptors, [
+      ...validatedInterceptors,
+      ...classInterceptors
+    ], target);
+    return target;
+  };
+}
+__name(UseInterceptors, "UseInterceptors");
+
+// src/decorators/pipeline/use-pipes.decorator.ts
+function UsePipes(...pipes) {
+  return (target, method, descriptor) => {
+    const validatedPipes = [];
+    for (const pipe of pipes) {
+      const { valid, value, error } = validatePipe(pipe);
+      if (!valid) throw new Error(error);
+      validatedPipes.push(value);
+    }
+    if (!isNil(descriptor) && !isNil(descriptor.value)) {
+      if (pipes.length === 0) {
+        throw new Error(ErrorMessage.AtLeastOnePipeRequired);
+      }
+      const methodPipes = Reflect.getMetadata(CoreMetadataKey.Pipes, target.constructor, method) || [];
+      Reflect.defineMetadata(CoreMetadataKey.Pipes, [
+        ...validatedPipes,
+        ...methodPipes
+      ], target.constructor, method);
+      return descriptor;
+    }
+    if (pipes.length === 0) {
+      throw new Error(ErrorMessage.AtLeastOnePipeRequired);
+    }
+    const classPipes = Reflect.getMetadata(CoreMetadataKey.Pipes, target) || [];
+    Reflect.defineMetadata(CoreMetadataKey.Pipes, [
+      ...validatedPipes,
+      ...classPipes
+    ], target);
+    return target;
+  };
+}
+__name(UsePipes, "UsePipes");
+
+// src/decorators/create-rpc-decorator.ts
+function createRPCDecorator(type, name, webViewId) {
+  return (target, method) => {
+    if (!isNil(webViewId) && !isString(webViewId) && !isNumber(webViewId)) {
+      throw new Error(ErrorMessage.WebViewIdMustBeStringOrNumber);
+    }
+    if (!isNil(name) && !isString(name)) {
+      throw new Error(ErrorMessage.RPCNameMustBeString);
+    }
+    name = name ?? method;
+    const rpcs = Reflect.getMetadata(CoreMetadataKey.ControllerRPCs, target) ?? [];
+    if (rpcs.some((rpc) => rpc.method === method && rpc.name === name && rpc.type === type)) {
+      throw new Error(ErrorMessage.RPCNameMustBeUnique);
+    }
+    Reflect.defineMetadata(CoreMetadataKey.ControllerRPCs, [
+      ...rpcs,
+      {
+        method,
+        name,
+        type,
+        webViewId
+      }
+    ], target);
+  };
+}
+__name(createRPCDecorator, "createRPCDecorator");
+
+// src/decorators/rpc/on-request.decorator.ts
+function OnRequest(rpcName) {
+  return createRPCDecorator("onRequest", rpcName);
+}
+__name(OnRequest, "OnRequest");
+
+// src/decorators/rpc/on-webview-request.decorator.ts
+function OnWebViewRequest(id, rpcName) {
+  return createRPCDecorator("onWebViewRequest", rpcName, id);
+}
+__name(OnWebViewRequest, "OnWebViewRequest");
+
+// src/decorators/create-timer.decorator.ts
+function createTimerDecorator(type, name, options) {
+  return (target, method) => {
+    if (!isNil(name) && !isString(name)) {
+      throw new Error(ErrorMessage.TimerNameMustBeString);
+    }
+    name = name ?? method;
+    const timers = Reflect.getMetadata(CoreMetadataKey.Timers, target) ?? [];
+    if (timers.some((timer) => timer.method === method && timer.name === name && timer.type === type)) {
+      throw new Error(ErrorMessage.EventNameMustBeUnique);
+    }
+    Reflect.defineMetadata(CoreMetadataKey.Timers, [
+      ...timers,
+      {
+        method,
+        name,
+        type,
+        options
+      }
+    ], target);
+  };
+}
+__name(createTimerDecorator, "createTimerDecorator");
+
+// src/decorators/timers/cron.decorator.ts
+function Cron(pattern, options = {}) {
+  return createTimerDecorator("cron", options.name, {
+    pattern,
+    ...options
+  });
+}
+__name(Cron, "Cron");
+
+// src/decorators/timers/every-tick.decorator.ts
+function EveryTick(name) {
+  return createTimerDecorator("everytick", name);
+}
+__name(EveryTick, "EveryTick");
+
+// src/decorators/timers/interval.decorator.ts
+function Interval(nameOrTimeout, timeout) {
+  const [name, intervalTimeout] = isString(nameOrTimeout) ? [
+    nameOrTimeout,
+    timeout
+  ] : [
+    void 0,
+    nameOrTimeout
+  ];
+  return createTimerDecorator("interval", name, {
+    timeout: intervalTimeout
+  });
+}
+__name(Interval, "Interval");
+
+// src/decorators/timers/timeout.decorator.ts
+function Timeout(nameOrTimeout, timeout) {
+  const [name, intervalTimeout] = isString(nameOrTimeout) ? [
+    nameOrTimeout,
+    timeout
+  ] : [
+    void 0,
+    nameOrTimeout
+  ];
+  return createTimerDecorator("timeout", name, {
+    timeout: intervalTimeout
+  });
+}
+__name(Timeout, "Timeout");
+
+// src/decorators/apply-decorator.util.ts
+function applyDecorators(...decorators) {
+  return (target, propertyKey, descriptor) => {
+    for (const decorator of decorators) {
+      if (target instanceof Function && !descriptor) {
+        decorator(target);
+        continue;
+      }
+      decorator(target, propertyKey, descriptor);
+    }
+  };
+}
+__name(applyDecorators, "applyDecorators");
+
+// src/decorators/create-param.util.ts
+function createParamDecorator(factory) {
+  return (data, ...pipes) => {
+    return (target, method, index) => {
+      const validatedPipes = [];
+      for (const pipe of pipes) {
+        const { valid, value, error } = validatePipe(pipe);
+        if (!valid) throw new Error(error);
+        validatedPipes.push(value);
+      }
+      const params = Reflect.getMetadata(CoreMetadataKey.ControllerParams, target, method) ?? [];
+      if (params.some((param) => param.index === index)) {
+        throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);
+      }
+      const paramTypes = Reflect.getMetadata("design:paramtypes", target, method);
+      const metatype = Array.isArray(paramTypes) ? paramTypes[index] : void 0;
+      Reflect.defineMetadata(CoreMetadataKey.ControllerParams, [
+        ...params,
+        {
+          index,
+          method,
+          pipes: validatedPipes,
+          type: MethodParamType.Custom,
+          factory,
+          data,
+          metatype
+        }
+      ], target, method);
+    };
+  };
+}
+__name(createParamDecorator, "createParamDecorator");
+
+// src/decorators/forward-ref.util.ts
+import { LazyServiceIdentifier } from "inversify";
+function forwardRef(fn) {
+  return new LazyServiceIdentifier(fn);
+}
+__name(forwardRef, "forwardRef");
+
+// src/services/reflector.service.ts
+function _ts_decorate5(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_decorate5, "_ts_decorate");
+var ReflectorService = class {
+  static {
+    __name(this, "ReflectorService");
+  }
+  get(metadataKey, target) {
+    return Reflect.getMetadata(metadataKey, target);
+  }
+  getAll(metadataKey, targets) {
+    return (targets || []).map((target) => this.get(metadataKey, target));
+  }
+  getAllAndMerge(metadataKey, targets) {
+    const metadataCollection = this.getAll(metadataKey, targets).filter((item) => item !== void 0);
+    if (isEmpty(metadataCollection)) return metadataCollection;
+    return metadataCollection.reduce((a, b) => {
+      if (Array.isArray(a)) {
+        return a.concat(b);
+      }
+      if (isObject(a) && isObject(b)) {
+        return {
+          ...a,
+          ...b
+        };
+      }
+      return [
+        a,
+        b
+      ];
+    });
+  }
+  getAllAndOverride(metadataKey, targets) {
+    for (const target of targets) {
+      const result = this.get(metadataKey, target);
+      if (result !== void 0) return result;
+    }
+    return void 0;
+  }
+  static createDecorator(options = {}) {
+    const metadataKey = options.key ?? generateRandomId();
+    const decoratorFn = /* @__PURE__ */ __name((metadataValue) => (target, key, descriptor) => {
+      const value = options.transform ? options.transform(metadataValue) : metadataValue;
+      SetMetadata(metadataKey, value ?? {})(target, key, descriptor);
+    }, "decoratorFn");
+    decoratorFn.KEY = metadataKey;
+    return decoratorFn;
+  }
+};
+ReflectorService = _ts_decorate5([
+  injectable8()
+], ReflectorService);
+
+// src/services/timer.service.ts
+import { inject as inject6, injectable as injectable9 } from "inversify";
+import { Cron as Cron2 } from "croner";
+function _ts_decorate6(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_decorate6, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+var TimerService = class {
+  static {
+    __name(this, "TimerService");
+  }
+  multiplayerService;
+  $everyticks = /* @__PURE__ */ new Map();
+  $intervals = /* @__PURE__ */ new Map();
+  $timeouts = /* @__PURE__ */ new Map();
+  $crons = /* @__PURE__ */ new Map();
+  get all() {
+    return this.multiplayerService.Timers.all;
+  }
+  get everyticks() {
+    return [
+      ...this.$everyticks.values()
+    ];
+  }
+  get intervals() {
+    return [
+      ...this.$intervals.values()
+    ];
+  }
+  get timeouts() {
+    return [
+      ...this.$timeouts.values()
+    ];
+  }
+  get crons() {
+    return [
+      ...this.$crons.values()
+    ];
+  }
+  set warningThreshold(value) {
+    this.multiplayerService.Timers.warningThreshold = value;
+  }
+  get warningThreshold() {
+    return this.multiplayerService.Timers.warningThreshold;
+  }
+  set sourceLocationFrameSkipCount(value) {
+    this.multiplayerService.Timers.sourceLocationFrameSkipCount = value;
+  }
+  get sourceLocationFrameSkipCount() {
+    return this.multiplayerService.Timers.sourceLocationFrameSkipCount;
+  }
+  createCronJob(callback, options) {
+    const { pattern, ...cronOptions } = options;
+    const cron = Cron2(pattern, cronOptions, callback);
+    if (isString(options.name)) this.$crons.set(options.name, cron);
+    return cron;
+  }
+  createInterval(callback, interval, name) {
+    const timer = this.multiplayerService.Timers.setInterval(callback, interval);
+    if (isString(name)) this.$intervals.set(name, timer);
+    return timer;
+  }
+  createTimeout(callback, timeout, name) {
+    const timer = this.multiplayerService.Timers.setTimeout(callback, timeout);
+    if (isString(name)) this.$timeouts.set(name, timer);
+    return timer;
+  }
+  createEveryTick(callback, name) {
+    const timer = this.multiplayerService.Timers.everyTick(callback);
+    if (isString(name)) this.$everyticks.set(name, timer);
+    return timer;
+  }
+  delete(type, name) {
+    switch (type) {
+      case "cron":
+        const cronJob = this.$crons.get(name);
+        if (cronJob) {
+          cronJob.stop();
+          this.$crons.delete(name);
+        }
+        break;
+      case "everytick":
+        const everytick = this.$everyticks.get(name);
+        if (everytick) {
+          everytick.destroy();
+          this.$everyticks.delete(name);
+        }
+        break;
+      case "interval":
+        const interval = this.$intervals.get(name);
+        if (interval) {
+          interval.destroy();
+          this.$intervals.delete(name);
+        }
+        break;
+      case "timeout":
+        const timeout = this.$timeouts.get(name);
+        if (timeout) {
+          timeout.destroy();
+          this.$timeouts.delete(name);
+        }
+        break;
+    }
+  }
+  getByName(type, name) {
+    switch (type) {
+      case "cron":
+        return this.$crons.get(name);
+      case "everytick":
+        return this.$everyticks.get(name);
+      case "interval":
+        return this.$intervals.get(name);
+      case "timeout":
+        return this.$timeouts.get(name);
+    }
+  }
+  getById(id) {
+    return this.multiplayerService.Timers.getByID(id);
+  }
+  time(name) {
+    return this.multiplayerService.Timers.time(name);
+  }
+  timeEnd(name) {
+    return this.multiplayerService.Timers.timeEnd(name);
+  }
+};
+_ts_decorate6([
+  inject6(MULTIPLAYER_SERVICE),
+  _ts_metadata5("design:type", typeof MultiplayerService === "undefined" ? Object : MultiplayerService)
+], TimerService.prototype, "multiplayerService", void 0);
+TimerService = _ts_decorate6([
+  injectable9()
+], TimerService);
+
+export {
+  Controller2 as Controller,
+  Global,
+  Inject,
+  Injectable,
+  Module2 as Module,
+  Optional,
+  SetMetadata,
+  Catch,
+  UseFilters,
+  AppRuntime,
+  ReflectorService,
+  TimerService,
+  ModuleDependencyBinder,
+  ModuleTreeScanner,
+  RageMPScriptEvent,
+  RageMPEventEmmiter,
+  RageMPTimer,
+  RageMPTimers,
+  RageMPMultiplayerService,
+  App,
+  AppBuilder,
+  createAppBuilder,
+  createEventDecorator,
+  OnInternal,
+  OnWebView,
+  On,
+  OnceInternal,
+  Once,
+  OnceWebView,
+  Body,
+  Index,
+  Request,
+  Req,
+  Param,
+  Response,
+  Res,
+  UseGuards,
+  UseInterceptors,
+  UsePipes,
+  createRPCDecorator,
+  OnRequest,
+  OnWebViewRequest,
+  Cron,
+  EveryTick,
+  Interval,
+  Timeout,
+  applyDecorators,
+  createParamDecorator,
+  forwardRef
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/services/reflector.service.ts", "../src/decorators/core/controller.decorator.ts", "../src/decorators/core/global.decorator.ts", "../src/decorators/core/inject.decorator.ts", "../src/decorators/core/injectable.decorator.ts", "../src/decorators/core/module.decorator.ts", "../src/decorators/core/optional.decorator.ts", "../src/decorators/core/set-metadata.decorator.ts", "../src/decorators/errors/catch.decorator.ts", "../src/decorators/errors/use-filters.decorator.ts", "../src/app/module-tree/app-runtime.ts", "../src/app/module-tree/dependency-binder.ts", "../src/app/module-tree/module-tree-scanner.ts", "../src/app/multiplayer/ragemp/ragemp-script-event-handler.ts", "../src/app/multiplayer/ragemp/ragemp-event-emmiter.ts", "../src/app/multiplayer/ragemp/ragemp-timer.ts", "../src/app/multiplayer/ragemp/ragemp-timers.ts", "../src/app/multiplayer/ragemp/ragemp-multiplayer.service.ts", "../src/app/app-builder.ts", "../src/app/app.ts", "../src/app/create-app.ts", "../src/decorators/create-event-decorator.ts", "../src/decorators/events/on-internal.decorator.ts", "../src/decorators/events/on-webview.decorator.ts", "../src/decorators/events/on.decorator.ts", "../src/decorators/events/once-internal.decorator.ts", "../src/decorators/events/once.decorator.ts", "../src/decorators/events/once-webview.decorator.ts", "../src/decorators/params/body.decorator.ts", "../src/decorators/params/index.decorator.ts", "../src/decorators/params/request.decorator.ts", "../src/decorators/params/param.decorator.ts", "../src/decorators/params/response.deorator.ts", "../src/decorators/pipeline/use-guards.decorator.ts", "../src/decorators/pipeline/use-interceptors.decorator.ts", "../src/decorators/pipeline/use-pipes.decorator.ts", "../src/decorators/create-rpc-decorator.ts", "../src/decorators/rpc/on-request.decorator.ts", "../src/decorators/rpc/on-webview-request.decorator.ts", "../src/decorators/create-timer.decorator.ts", "../src/decorators/timers/cron.decorator.ts", "../src/decorators/timers/every-tick.decorator.ts", "../src/decorators/timers/interval.decorator.ts", "../src/decorators/timers/timeout.decorator.ts", "../src/decorators/apply-decorator.util.ts", "../src/decorators/create-param.util.ts", "../src/decorators/forward-ref.util.ts", "../src/services/timer.service.ts"],
  "sourcesContent": ["import { injectable } from 'inversify';\nimport { SetMetadata } from '../decorators';\nimport type { CreateDecoratorOptions, CreateDecoratorWithTransformOptions, ReflectableDecorator } from '../interfaces';\nimport type { Newable } from '../types';\nimport { generateRandomId, isEmpty, isObject } from '../utils';\n\n@injectable()\nexport class ReflectorService {\n    public get<TResult = unknown, TKey extends string | symbol = string>(metadataKey: TKey, target: Newable | Function) {\n        return Reflect.getMetadata<TResult>(metadataKey, target);\n    }\n\n    public getAll<TResult extends unknown[] = unknown[], TKey extends string | symbol = string>(\n        metadataKey: TKey,\n        targets: (Newable | Function)[],\n    ) {\n        return <TResult>(targets || []).map((target) => this.get(metadataKey, target));\n    }\n\n    public getAllAndMerge<TResult extends unknown[] = unknown[], TKey extends string | symbol = string>(\n        metadataKey: TKey,\n        targets: (Newable | Function)[],\n    ) {\n        const metadataCollection = this.getAll<TResult, TKey>(metadataKey, targets).filter((item) => item !== undefined);\n\n        if (isEmpty(metadataCollection)) return <TResult>metadataCollection;\n\n        return <TResult>metadataCollection.reduce((a, b) => {\n            if (Array.isArray(a)) {\n                return a.concat(b);\n            }\n            if (isObject(a) && isObject(b)) {\n                return {\n                    ...a,\n                    ...b,\n                };\n            }\n            return [a, b];\n        });\n    }\n\n    public getAllAndOverride<TResult = unknown, TKey extends string | symbol = string>(metadataKey: TKey, targets: (Newable | Function)[]) {\n        for (const target of targets) {\n            const result = this.get(metadataKey, target);\n            if (result !== undefined) return <TResult>result;\n        }\n        return undefined;\n    }\n\n    public static createDecorator<TParam>(options?: CreateDecoratorOptions<TParam>): ReflectableDecorator<TParam>;\n    public static createDecorator<TParam, TTransformed>(\n        options: CreateDecoratorWithTransformOptions<TParam, TTransformed>,\n    ): ReflectableDecorator<TParam, TTransformed>;\n    public static createDecorator<TParam, TTransformed = TParam>(\n        options: CreateDecoratorOptions<TParam, TTransformed> = {},\n    ): ReflectableDecorator<TParam, TTransformed> {\n        const metadataKey = options.key ?? generateRandomId();\n        const decoratorFn = (metadataValue: TParam) => (target: object | Function, key?: string | symbol, descriptor?: any) => {\n            const value = options.transform ? options.transform(metadataValue) : metadataValue;\n            SetMetadata(metadataKey, value ?? {})(target, key!, descriptor);\n        };\n\n        decoratorFn.KEY = metadataKey;\n        return decoratorFn as ReflectableDecorator<TParam, TTransformed>;\n    }\n}\n", "import { CoreMetadataKey } from '../../app/enums';\nimport type { ControllerOptions } from '../../interfaces';\nimport { validateControllerOptions } from '../../schemas';\nimport type { Newable } from '../../types';\nimport { injectable } from 'inversify';\nimport { ErrorMessage } from '../../enums';\n\nexport function Controller<T extends Newable>(options?: ControllerOptions) {\n    return (target: T) => {\n        if (Reflect.hasMetadata(CoreMetadataKey.Controller, target)) {\n            throw new Error(ErrorMessage.DuplicateDecoratorUsage);\n        }\n\n        const { valid, value, error } = validateControllerOptions(options);\n        if (!valid) throw new Error(error);\n        Reflect.defineMetadata(CoreMetadataKey.Controller, value, target);\n\n        return injectable()(target);\n    };\n}\n", "import { CoreMetadataKey } from '../../app/enums';\nimport type { Newable } from '../../types';\n\nexport function Global<T extends Newable>() {\n    return (target: T) => {\n        Reflect.defineMetadata(CoreMetadataKey.GlobalModule, true, target);\n        return target;\n    };\n}\n", "import { inject } from 'inversify';\nimport type { InjectionToken } from '../../types';\nimport { ErrorMessage } from '../../enums';\nimport { validateInjectionToken } from '../../schemas';\nimport { isNil } from '../../utils';\n\nexport function Inject<T = unknown>(key?: InjectionToken<T>) {\n    return <PropertyDecorator & ParameterDecorator>((target: Object, propertyKey: string, paramIndex?: number) => {\n        if (!isNil(key) && !validateInjectionToken(key).valid) {\n            throw new Error(ErrorMessage.InvalidInjectionTokenSpecified);\n        }\n\n        const token = key ?? Reflect.getMetadata<InjectionToken>('design:type', target, propertyKey);\n        if (!token) {\n            throw new Error(ErrorMessage.InjectionTokenNotFound);\n        }\n\n        inject(token)(target, propertyKey, paramIndex);\n    });\n}\n", "import { injectable } from 'inversify';\nimport type { Newable } from '../../types';\nimport { CoreMetadataKey } from '../../app/enums';\nimport type { InjectableOptions } from '../../interfaces';\nimport { ErrorMessage } from '../../enums';\nimport { validateInjectableMetadata } from '../../schemas';\n\nexport function Injectable<T extends Newable>(options?: InjectableOptions) {\n    return (target: T) => {\n        if (Reflect.hasMetadata(CoreMetadataKey.Injectable, target)) {\n            throw new Error(ErrorMessage.DuplicateDecoratorUsage);\n        }\n\n        const { valid, value, error } = validateInjectableMetadata(options);\n        if (!valid) throw new Error(error);\n        Reflect.defineMetadata(CoreMetadataKey.Injectable, value, target);\n\n        return injectable()(target);\n    };\n}\n", "import { CoreMetadataKey } from '../../app/enums';\nimport type { ModuleOptions } from '../../interfaces';\nimport type { Newable } from '../../types';\nimport { injectable } from 'inversify';\nimport { ErrorMessage } from '../../enums';\nimport { validateModuleOptions } from '../../schemas';\n\nexport function Module<T extends Newable>(options?: ModuleOptions) {\n    return (target: T) => {\n        if (Reflect.hasMetadata(CoreMetadataKey.Module, target)) {\n            throw new Error(ErrorMessage.DuplicateDecoratorUsage);\n        }\n\n        const { valid, value, error } = validateModuleOptions(options);\n        if (!valid) throw new Error(error!);\n        Reflect.defineMetadata(CoreMetadataKey.Module, value, target);\n\n        return injectable()(target);\n    };\n}\n", "import { optional } from 'inversify';\n\nexport function Optional() {\n    return <PropertyDecorator & ParameterDecorator>((target: Object, propertyKey: string, paramIndex?: number) => {\n        return optional()(target, propertyKey, paramIndex);\n    });\n}\n", "import type { CustomDecorator } from '../../types';\n\nexport function SetMetadata<K extends string = string, V = unknown>(key: K, value: V) {\n    const decoratorFactory = <CustomDecorator>((target: object, _method?: string, descriptor?: PropertyDescriptor) => {\n        if (descriptor) {\n            Reflect.defineMetadata(key, value, descriptor.value);\n            return descriptor;\n        }\n        Reflect.defineMetadata(key, value, target);\n        return target;\n    });\n    decoratorFactory.KEY = key;\n    return decoratorFactory;\n}\n", "import { CoreMetadataKey } from '../../app/enums';\nimport { ErrorMessage } from '../../enums';\nimport type { Newable } from '../../types';\n\nexport function Catch<T extends Newable>(...exceptions: unknown[]) {\n    return (target: T) => {\n        if (Reflect.hasMetadata(CoreMetadataKey.Catch, target)) {\n            throw new Error(ErrorMessage.DuplicateDecoratorUsage);\n        }\n\n        const duplicates = exceptions.filter((exception, index) => exceptions.indexOf(exception) !== index);\n        if (duplicates.length) {\n            throw new Error(ErrorMessage.ExceptionHandlingConflict);\n        }\n\n        Reflect.defineMetadata(CoreMetadataKey.Catch, exceptions, target);\n\n        return target;\n    };\n}\n", "import type { Newable } from '../../types';\nimport type { ErrorFilter } from '../../app/interfaces';\nimport { CoreMetadataKey } from '../../app/enums';\nimport { isNil } from '../../utils';\nimport { ErrorMessage } from '../../enums';\nimport { validateErrorFilter } from '../../schemas';\n\nexport function UseFilters(...filters: (Newable<ErrorFilter> | ErrorFilter)[]) {\n    return <ClassDecorator & MethodDecorator>((target: Object, method?: string, descriptor?: PropertyDescriptor) => {\n        const validatedFilters: (Newable<ErrorFilter> | ErrorFilter)[] = [];\n        for (const filter of filters) {\n            const { valid, value, error } = validateErrorFilter(filter);\n            if (!valid) throw new Error(error);\n            validatedFilters.push(value);\n        }\n\n        if (!isNil(descriptor) && !isNil(descriptor.value)) {\n            if (filters.length === 0) {\n                throw new Error(ErrorMessage.AtLeastOneFilterRequired);\n            }\n\n            const methodFilters =\n                Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, target.constructor, method) || [];\n            if (!isNil(methodFilters.find((filter) => filters.includes(filter)))) {\n                throw new Error(ErrorMessage.DuplicateErrorFilterDetected);\n            }\n            Reflect.defineMetadata(CoreMetadataKey.ErrorFilters, [...validatedFilters, ...methodFilters], target.constructor, method);\n            return descriptor;\n        }\n\n        if (filters.length === 0) {\n            throw new Error(ErrorMessage.AtLeastOneFilterRequired);\n        }\n\n        const classFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, target) || [];\n        if (!isNil(classFilters.find((filter) => filters.includes(filter)))) {\n            throw new Error(ErrorMessage.DuplicateErrorFilterDetected);\n        }\n        Reflect.defineMetadata(CoreMetadataKey.ErrorFilters, [...validatedFilters, ...classFilters], target);\n        return target;\n    });\n}\n", "import type { Newable } from '../../types';\nimport { isNil, isObject } from '../../utils';\nimport { ENABLE_SHUTDOWN_HOOKS, GLOBAL_ERROR_FILTERS, GLOBAL_GUARDS, GLOBAL_INTERCEPTORS, GLOBAL_PIPES } from '../constants';\nimport type { ErrorFilter, Guard, Interceptor } from '../interfaces';\nimport { Module } from '../module';\nimport { inject, injectable, optional } from 'inversify';\nimport { Controller, ControllerEventHandler, ControllerRPCHandler } from '../controller';\nimport { LOGGER_SERVICE, TIMER_SERVICE } from '../../constants';\nimport { CoreMetadataKey } from '../enums';\nimport { ErrorMessage } from '../../enums';\nimport type { LoggerService, Pipe } from '../../interfaces';\nimport type { Tree } from '../utils';\nimport type { TimerService } from '../../services';\n\n@injectable()\nexport class AppRuntime {\n    @inject(ControllerEventHandler) private readonly eventHandler: ControllerEventHandler;\n    @inject(ControllerRPCHandler) private readonly rpcHandler: ControllerRPCHandler;\n    @inject(GLOBAL_GUARDS) private readonly globalGuards: (Newable<Guard> | Guard)[];\n    @inject(GLOBAL_INTERCEPTORS) private readonly globalInterceptors: (Newable<Interceptor> | Interceptor)[];\n    @inject(GLOBAL_PIPES) private readonly globalPipes: (Newable<Pipe> | Pipe)[];\n    @inject(GLOBAL_ERROR_FILTERS) private readonly globalErrorFilters: (Newable<ErrorFilter> | ErrorFilter)[];\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(ENABLE_SHUTDOWN_HOOKS) @optional() private readonly enableShutdownHooks: boolean;\n\n    public async boot(resolvedTree: Tree<Module>) {\n        await resolvedTree.asyncTraverse(async (node) => {\n            const startTime = Date.now();\n            // Initialize module, controllers and providers.\n            const module = node.value;\n            module.instance = module.container.get<{ [key: string]: Function }>(module.metadata.classRef);\n            module.controllers.forEach(\n                (controller) => (controller.instance = module.container.get<{ [key: string]: Function }>(controller.metadata.classRef)),\n            );\n            [...module.metadata.internalProviders, ...module.metadata.externalProviders].forEach(([token]) =>\n                module.container.get<any>(token),\n            );\n\n            // Log module loaded.\n            this.loggerService.log(`Module ${module.metadata.classRef.name} loaded (${Date.now() - startTime}ms)`);\n            await this.runLifecycleMethod(module, 'onModuleInit');\n        });\n        // await this.runLifecycleMethods(resolvedTree, 'onModuleInit');\n        await this.runLifecycleMethods(resolvedTree, 'onAppBootstrap');\n\n        // Register event and rpc listeners.\n        resolvedTree.traverse((node) => {\n            const module = node.value;\n            module.controllers.forEach((controller) => {\n                const time = Date.now();\n                this.registerTimers(controller);\n                this.registerListeners(controller);\n                this.loggerService.log(\n                    `Controller ${controller.metadata.classRef.name} timers and listeners registered (${Date.now() - time}ms)`,\n                );\n            });\n        });\n    }\n\n    public async shutdown(resolvedTree: Tree<Module>) {\n        if (this.enableShutdownHooks) {\n            await this.runLifecycleMethods(resolvedTree, 'onModuleDestroy');\n            await this.runLifecycleMethods(resolvedTree, 'beforeAppShutdown');\n        }\n\n        await resolvedTree.asyncTraverse(async (node) => {\n            const module = node.value;\n            module.controllers.forEach((controller) => {\n                const timerService = controller.owner.container.get<TimerService>(TIMER_SERVICE);\n\n                // Destroy all timers.\n                timerService.everyticks.forEach((timer) => timer.destroy());\n                timerService.intervals.forEach((timer) => timer.destroy());\n                timerService.timeouts.forEach((timer) => timer.destroy());\n                timerService.crons.forEach((cron) => cron.stop());\n\n                // Destroy all script event handlers.\n                controller.eventHandlers.forEach((handler) => handler.destroy());\n                controller.rpcHandlers.forEach((handler) => handler.destroy());\n            });\n        });\n\n        // // Destroy all timers.\n        // this.timerService.everyticks.forEach((timer) => timer.destroy());\n        // this.timerService.intervals.forEach((timer) => timer.destroy());\n        // this.timerService.timeouts.forEach((timer) => timer.destroy());\n        // this.timerService.cronJobs.forEach((cronJob) => cronJob.stop());\n\n        // // Destroy all script event handlers.\n        // this.eventService.$localHandlers.forEach((handler) => handler.destroy());\n        // this.eventService.$internalHandlers.forEach((handler) => handler.destroy());\n        // this.eventService.$remoteHandlers.forEach((handler) => handler.destroy());\n\n        if (this.enableShutdownHooks) {\n            await this.runLifecycleMethods(resolvedTree, 'onAppShutdown');\n        }\n    }\n\n    private registerListeners(controller: Controller) {\n        const module = controller.owner;\n        controller.metadata.events.forEach((event) => {\n            const guards = [...this.globalGuards, ...module.metadata.guards, ...controller.metadata.guards, ...event.guards];\n            const interceptors = [\n                ...this.globalInterceptors,\n                ...module.metadata.interceptors,\n                ...controller.metadata.interceptors,\n                ...event.interceptors,\n            ];\n            const pipes = [...this.globalPipes, ...module.metadata.pipes, ...controller.metadata.pipes, ...event.pipes];\n            const mappedErrorFilters = this.mapErrorFilters([\n                ...this.globalErrorFilters,\n                ...module.metadata.errorFilters,\n                ...controller.metadata.errorFilters,\n                ...event.errorFilters,\n            ]);\n\n            const handler = this.eventHandler.registerEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event);\n            controller.eventHandlers.push(handler);\n        });\n\n        controller.metadata.rpcs.forEach(async (rpc) => {\n            const guards = [...this.globalGuards, ...module.metadata.guards, ...controller.metadata.guards, ...rpc.guards];\n            const interceptors = [\n                ...this.globalInterceptors,\n                ...module.metadata.interceptors,\n                ...controller.metadata.interceptors,\n                ...rpc.interceptors,\n            ];\n            const pipes = [...this.globalPipes, ...module.metadata.pipes, ...controller.metadata.pipes, ...rpc.pipes];\n            const mappedErrorFilters = this.mapErrorFilters([\n                ...this.globalErrorFilters,\n                ...module.metadata.errorFilters,\n                ...controller.metadata.errorFilters,\n                ...rpc.errorFilters,\n            ]);\n\n            const handler = await this.rpcHandler.registerRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc);\n            controller.rpcHandlers.push(handler);\n        });\n    }\n\n    public registerTimers(controller: Controller) {\n        const timerService = controller.owner.container.get<TimerService>(TIMER_SERVICE);\n\n        controller.metadata.timers.forEach((timer) => {\n            if (timer.type === 'cron') {\n                timerService.createCronJob(controller.instance[timer.method]!.bind(controller.instance), timer.options);\n            } else if (timer.type === 'everytick') {\n                timerService.createEveryTick(controller.instance[timer.method]!.bind(controller.instance), timer.name);\n            } else if (timer.type === 'interval') {\n                timerService.createInterval(\n                    controller.instance[timer.method]!.bind(controller.instance),\n                    timer.options.timeout,\n                    timer.name,\n                );\n            } else if (timer.type === 'timeout') {\n                timerService.createTimeout(controller.instance[timer.method]!.bind(controller.instance), timer.options.timeout, timer.name);\n            }\n        });\n    }\n\n    private mapErrorFilters(errorFilters: (Newable<ErrorFilter> | ErrorFilter)[]) {\n        const filterMap: [unknown | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][] = [];\n\n        for (const filter of errorFilters) {\n            const errors = Reflect.getMetadata<any[]>(CoreMetadataKey.Catch, filter) ?? [];\n            if (errors.length === 0) {\n                errors.push('MANGO_ANY_ERROR');\n            }\n            for (const error of errors) {\n                if (!isNil(filterMap.find((filterError) => filterError[0] === error))) {\n                    this.loggerService.error('An error occurred while trying to map error filters.');\n                    throw new Error(ErrorMessage.ErrorAlreadyHandledByFilter);\n                }\n                filterMap.push([error, filter]);\n            }\n        }\n\n        return filterMap;\n    }\n\n    private async runLifecycleMethods(\n        resolvedTree: Tree<Module>,\n        method: 'onModuleInit' | 'onModuleDestroy' | 'onAppBootstrap' | 'beforeAppShutdown' | 'onAppShutdown',\n    ) {\n        return resolvedTree.asyncTraverse(async (node) => await this.runLifecycleMethod(node.value, method));\n    }\n\n    private async runLifecycleMethod(\n        module: Module,\n        method: 'onModuleInit' | 'onModuleDestroy' | 'onAppBootstrap' | 'beforeAppShutdown' | 'onAppShutdown',\n    ) {\n        await Promise.all(\n            module.controllers.map(async (controller) => {\n                if (!isObject(controller.instance) || isNil(controller.instance[method])) return;\n                await controller.instance[method]!();\n            }),\n        );\n        await Promise.all(\n            [...module.metadata.internalProviders, ...module.metadata.externalProviders].map(async ([token]) => {\n                const providerInstance = <{ [key: string]: Function }>module.container.get(token);\n                if (!isObject(providerInstance) || isNil(providerInstance[method])) return;\n                await providerInstance[method]!();\n            }),\n        );\n        if (!isObject(module.instance) || isNil(module.instance[method])) return;\n        await module.instance[method]!();\n    }\n}\n", "import type { LoggerService, Provider } from '../../interfaces';\nimport type { Newable } from '../../types';\nimport { isObject } from '../../utils';\nimport { CONTAINER_OPTIONS, GLOBAL_APP_CONTAINER } from '../constants';\nimport { Module, ModuleContainer } from '../module';\nimport { Container, inject, injectable, optional, type interfaces } from 'inversify';\nimport { LOGGER_SERVICE, MODULE_CONTAINER, TIMER_SERVICE } from '../../constants';\nimport type { Tree } from '../utils';\nimport { TimerService } from '../../services';\n\n@injectable()\nexport class ModuleDependencyBinder {\n    @inject(GLOBAL_APP_CONTAINER) private readonly globalAppContainer: Container;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @optional() @inject(CONTAINER_OPTIONS) private readonly containerOptions?: interfaces.ContainerOptions;\n\n    public async bind(resolvedTree: Tree<Module>) {\n        await resolvedTree.asyncTraverse(async (node) => {\n            const startTime = Date.now();\n\n            const module = node.value;\n            module.container = new ModuleContainer(module.metadata.container ?? this.containerOptions);\n            // Attach the global container to the module container, so it can be used to resolve dependencies.\n            module.container.parent = this.globalAppContainer;\n            this.globalAppContainer.bind(module.metadata.classRef).toSelf().inSingletonScope();\n\n            // If the module is global, we want to bind it to the global container.\n            if (module.metadata.global) {\n                // Bind external providers to the global container, so they can be injected in other modules.\n                for (const [_, provider] of module.metadata.externalProviders) {\n                    this.bindProvider(provider, this.globalAppContainer);\n                }\n            } else {\n                // If the module is not global, we want to bind it to its own container.\n                for (const [token, provider] of module.metadata.externalProviders) {\n                    this.bindProvider(provider, module.container);\n                    module.parent?.container.bind(token).toDynamicValue(() => module.container.get(token));\n                }\n                for (const importModule of module.repetitiveImports) {\n                    for (const [token] of importModule.metadata.externalProviders) {\n                        module.container.bind(token).toDynamicValue(() => importModule.container.get(token));\n                    }\n                }\n            }\n\n            // Bind internal providers.\n            for (const [_, provider] of module.metadata.internalProviders) {\n                this.bindProvider(provider, module.container);\n            }\n\n            // Bind container to itself so it can be injected.\n            module.container.bind(MODULE_CONTAINER).toConstantValue(module.container);\n\n            // Bind controllers to the container.\n            for (const classRef of module.metadata.controllers) {\n                module.container.bind(classRef).toSelf().inSingletonScope();\n            }\n\n            // Bind services to the container.\n            module.container.bind(TIMER_SERVICE).to(TimerService).inSingletonScope();\n\n            this.loggerService.log(\n                `Module ${module.metadata.classRef.name} dependencies binded (${Date.now() - startTime}ms)`,\n            );\n        });\n    }\n\n    private bindProvider(provider: Exclude<Provider, Newable>, container: Container) {\n        if ('useValue' in provider) {\n            container.bind(provider.provide).toConstantValue(provider.useValue);\n        } else if ('useFactory' in provider) {\n            const binding = container.bind(provider.provide).toDynamicValue((ctx) => {\n                const deps =\n                    provider.inject?.map((dep) => {\n                        if (isObject(dep) && 'token' in dep && 'optional' in dep) {\n                            try {\n                                return ctx.container.get(dep.token);\n                            } catch (err) {\n                                if (dep.optional) return undefined;\n                                this.loggerService.error('An error occurred while trying to resolve a dependency.');\n                                throw err;\n                            }\n                        }\n                        return ctx.container.get(dep);\n                    }) ?? [];\n                return provider.useFactory(...deps);\n            });\n            if (provider.scope === 'transient') binding.inTransientScope();\n            else if (provider.scope === 'request') binding.inRequestScope();\n            else binding.inSingletonScope();\n        } else if ('useClass' in provider) {\n            const binding = container.bind(provider.provide).to(provider.useClass);\n            if (provider.scope === 'transient') binding.inTransientScope();\n            else if (provider.scope === 'request') binding.inRequestScope();\n            else binding.inSingletonScope();\n        } else if ('useExisting' in provider) {\n            container.bind(provider.provide).toService(provider.useExisting);\n        }\n    }\n}\n", "import type { DynamicModule, LoggerService } from '../../interfaces';\nimport type { Newable } from '../../types';\nimport { Controller, ControllerMetadataReader } from '../controller';\nimport { Module, ModuleMetadataReader } from '../module';\nimport { inject, injectable } from 'inversify';\nimport { ErrorMessage } from '../../enums';\nimport { Tree, TreeNode } from '../utils';\nimport { LOGGER_SERVICE } from '../../constants';\nimport type { ModuleMetadata } from '../interfaces';\nimport { isNil } from '../../utils';\n\n@injectable()\nexport class ModuleTreeScanner {\n    @inject(ModuleMetadataReader) private readonly moduleMetadataReader: ModuleMetadataReader;\n    @inject(ControllerMetadataReader) private readonly controllerMetadataReader: ControllerMetadataReader;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async scan(classRef: Newable | DynamicModule | Promise<DynamicModule>) {\n        const startTime = Date.now();\n        // Read module metadata\n        const moduleMetadata = await this.moduleMetadataReader.read(classRef);\n        // Create module instance and set metadata to it\n        const module = new Module();\n        module.metadata = moduleMetadata;\n        // Log module info\n        this.loggerService.log(`Module ${module.metadata.classRef.name} scanned (${Date.now() - startTime}ms)`);\n        // Scan controllers in module\n        await this.scanControllers(module);\n        // Scan controllers in module\n        const moduleTree = new Tree(module);\n        const scannedModules = new Map<Newable | DynamicModule | Promise<DynamicModule>, Module>();\n        scannedModules.set(classRef, module);\n        // Scan imported modules\n        for (const importedModule of moduleMetadata.imports) {\n            await this.scanModules(moduleTree.root, importedModule, scannedModules);\n        }\n        return moduleTree;\n    }\n\n    private async scanModules(\n        parentNode: TreeNode<Module>,\n        classRef: Newable | DynamicModule | Promise<DynamicModule>,\n        scannedModules = new Map<Newable | DynamicModule | Promise<DynamicModule>, Module>(),\n    ) {\n        // Check if module is already imported\n        const scannedModule = scannedModules.get(classRef);\n        if (!isNil(scannedModule)) {\n            parentNode.value.repetitiveImports.add(scannedModule);\n            return;\n        }\n\n        const startTime = Date.now();\n\n        // Read module metadata\n        const moduleMetadata = await this.moduleMetadataReader.read(classRef);\n        // Check if there is a circular dependency\n        this.checkCircularDependency(parentNode.value.metadata, moduleMetadata);\n        // Create module instance\n        const module = new Module();\n        module.metadata = moduleMetadata;\n        module.parent = parentNode.value;\n        // Log module info\n        this.loggerService.log(`Module ${module.metadata.classRef.name} scanned (${Date.now() - startTime}ms)`);\n        // Scan controllers in module\n        await this.scanControllers(module);\n        // Add module to tree\n        const treeNode = new TreeNode(module);\n        parentNode.addChild(treeNode);\n        // Add module to imported modules set to prevent unnecessary scanning\n        scannedModules.set(classRef, module);\n        // Scan imported modules recursively\n        for (const importModule of moduleMetadata.imports) {\n            await this.scanModules(treeNode, importModule, scannedModules);\n        }\n    }\n\n    private async scanControllers(module: Module) {\n        // Scan controllers\n        for (const classRef of module.metadata.controllers) {\n            const startTime = Date.now();\n            const controllerMetadata = await this.controllerMetadataReader.read(classRef);\n            const controller = new Controller();\n            controller.metadata = controllerMetadata;\n            controller.owner = module;\n            module.controllers.push(controller);\n\n            this.loggerService.log(`Controller ${classRef.name} scanned (${Date.now() - startTime}ms)`);\n        }\n    }\n\n    private async checkCircularDependency(parentMetadata: ModuleMetadata, moduleMetadata: ModuleMetadata) {\n        // Check if parent module is imported in module\n        if (moduleMetadata.imports.includes(parentMetadata.classRef)) {\n            // this.loggerService.error('An error occurred while scanning the module tree.');\n            throw new Error(ErrorMessage.CircularDependencyDetected);\n        }\n    }\n}\n", "import type { ScriptEventHandler } from '../../interfaces';\n\nexport class RageMPScriptEvent implements ScriptEventHandler {\n    constructor(\n        private eventName: string,\n        private listener: (...args: any[]) => void,\n    ) {}\n\n    destroy(): void {\n        mp.events.remove(this.eventName, this.listener);\n    }\n}\n", "import type { EventEmmiter, ScriptEventHandler } from '../../interfaces';\nimport { RageMPScriptEvent } from './ragemp-script-event-handler';\n\nexport class RageMPEventEmmiter implements EventEmmiter {\n    emit(eventName: string, ...args: any[]): void {\n        mp.events.call(eventName, ...args);\n    }\n\n    on(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        mp.events.add(eventName, listener);\n        return new RageMPScriptEvent(eventName, listener);\n    }\n\n    once(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        const onceWrapper = (...args: any[]) => {\n            mp.events.remove(eventName, onceWrapper);\n            listener(...args);\n        };\n        mp.events.add(eventName, onceWrapper);\n        return new RageMPScriptEvent(eventName, onceWrapper);\n    }\n\n    off(eventName: string, listener: (...args: any[]) => void): void {\n        mp.events.remove(eventName, listener);\n    }\n}\n", "import type { MultiplayerTimer } from '../../interfaces';\n\nexport class RageMPTimer implements MultiplayerTimer {\n    public lastTick = Date.now();\n    constructor(\n        public id: number,\n        public interval: number = 0,\n        public once: boolean,\n        public callback: Function,\n        private clearTimer: Function,\n    ) {}\n\n    destroy() {\n        this.clearTimer();\n    }\n}\n", "import type { MultiplayerTimer, MultiplayerTimers } from '../../interfaces';\nimport { RageMPTimer } from './ragemp-timer';\n\nexport class RageMPTimers implements MultiplayerTimers {\n    private timerIncrementer: number = 0;\n    private timers = new Map<number, MultiplayerTimer>();\n    private everyTickHandlers = new Map<number, { callback: Function; bound: Function }>();\n    private isEveryTickRunning = false;\n    private everyTickMainHandler: (() => void) | null = null;\n\n    public get all(): MultiplayerTimer[] {\n        return [...this.timers.values()];\n    }\n\n    public get warningThreshold(): number {\n        // RageMP doesn't have this feature\n        return 0;\n    }\n\n    public set warningThreshold(_value: number) {\n        // RageMP doesn't have this feature\n    }\n\n    public get sourceLocationFrameSkipCount(): number {\n        // RageMP doesn't have this feature\n        return 0;\n    }\n\n    public set sourceLocationFrameSkipCount(_value: number) {\n        // RageMP doesn't have this feature\n    }\n\n    getByID(id: number): MultiplayerTimer | null {\n        const timer = this.timers.get(id);\n        return timer ?? null;\n    }\n\n    private createTimer(\n        createTimer: (...args: any[]) => number,\n        clear: (id: number) => void,\n        callback: Function,\n        interval: number | undefined,\n        once: boolean,\n        ...args: unknown[]\n    ) {\n        const callbackBind = callback.bind(this, ...(Array.isArray(args) ? args : []));\n        const timerId = typeof interval === 'number' ? createTimer(callbackBind, interval) : createTimer(callbackBind);\n        const id = this.timerIncrementer++;\n\n        const rageMPTimer = new RageMPTimer(id, interval ?? 0, once, callbackBind, () => {\n            clear(timerId);\n            this.timers.delete(id);\n        });\n        this.timers.set(id, rageMPTimer);\n        return rageMPTimer;\n    }\n\n    setInterval(callback: Function, time: number, ...args: unknown[]) {\n        return this.createTimer(\n            (cb: Function, interval: number) => setInterval(cb as () => void, interval) as unknown as number,\n            (id: number) => clearInterval(id),\n            callback,\n            time,\n            false,\n            ...args\n        );\n    }\n\n    setTimeout(callback: Function, time: number, ...args: unknown[]) {\n        const id = this.timerIncrementer++;\n        const callbackBind = callback.bind(this, ...(Array.isArray(args) ? args : []));\n\n        const timerId = setTimeout(() => {\n            callbackBind();\n            this.timers.delete(id);\n        }, time) as unknown as number;\n\n        const rageMPTimer = new RageMPTimer(id, time, true, callbackBind, () => {\n            clearTimeout(timerId);\n            this.timers.delete(id);\n        });\n        this.timers.set(id, rageMPTimer);\n        return rageMPTimer;\n    }\n\n    everyTick(callback: Function, ...args: unknown[]) {\n        const id = this.timerIncrementer++;\n        const callbackBind = callback.bind(this, ...(Array.isArray(args) ? args : []));\n\n        this.everyTickHandlers.set(id, { callback, bound: callbackBind });\n\n        // Check if we're on client-side (render event exists) or server-side\n        const isClientSide = typeof mp !== 'undefined' && typeof (mp as any).browsers !== 'undefined';\n\n        // Start the tick loop if not already running\n        if (!this.isEveryTickRunning) {\n            this.isEveryTickRunning = true;\n\n            if (isClientSide) {\n                // Client-side: use render event for frame-accurate ticking\n                this.everyTickMainHandler = () => {\n                    for (const [, handler] of this.everyTickHandlers) {\n                        try {\n                            handler.bound();\n                        } catch (e) {\n                            mp.console.logError(`Error in everyTick handler: ${e}`);\n                        }\n                    }\n                };\n                mp.events.add('render', this.everyTickMainHandler);\n            } else {\n                // Server-side: use setInterval with minimal delay as approximation\n                const intervalHandler = () => {\n                    for (const [, handler] of this.everyTickHandlers) {\n                        try {\n                            handler.bound();\n                        } catch (e) {\n                            mp.console.logError(`Error in everyTick handler: ${e}`);\n                        }\n                    }\n                };\n                (this as any)._everyTickInterval = setInterval(intervalHandler, 0);\n            }\n        }\n\n        const rageMPTimer = new RageMPTimer(id, 0, false, callbackBind, () => {\n            this.everyTickHandlers.delete(id);\n            this.timers.delete(id);\n\n            // Stop the tick loop if no more handlers\n            if (this.everyTickHandlers.size === 0) {\n                if (isClientSide && this.everyTickMainHandler) {\n                    mp.events.remove('render', this.everyTickMainHandler);\n                    this.everyTickMainHandler = null;\n                } else if ((this as any)._everyTickInterval) {\n                    clearInterval((this as any)._everyTickInterval);\n                    (this as any)._everyTickInterval = null;\n                }\n                this.isEveryTickRunning = false;\n            }\n        });\n        this.timers.set(id, rageMPTimer);\n        return rageMPTimer;\n    }\n\n    nextTick(callback: Function, ...args: unknown[]) {\n        const id = this.timerIncrementer++;\n        const callbackBind = callback.bind(this, ...(Array.isArray(args) ? args : []));\n\n        // Check if we're on client-side (render event exists) or server-side\n        const isClientSide = typeof mp !== 'undefined' && typeof (mp as any).browsers !== 'undefined';\n\n        let timerId: any;\n\n        if (isClientSide) {\n            // Client-side: use render event for next frame\n            const handler = () => {\n                try {\n                    callbackBind();\n                } finally {\n                    mp.events.remove('render', handler);\n                    this.timers.delete(id);\n                }\n            };\n            mp.events.add('render', handler);\n\n            const rageMPTimer = new RageMPTimer(id, 0, true, callbackBind, () => {\n                mp.events.remove('render', handler);\n                this.timers.delete(id);\n            });\n            this.timers.set(id, rageMPTimer);\n            return rageMPTimer;\n        } else {\n            // Server-side: use setImmediate or setTimeout(0) for next tick\n            timerId = setTimeout(() => {\n                try {\n                    callbackBind();\n                } finally {\n                    this.timers.delete(id);\n                }\n            }, 0);\n\n            const rageMPTimer = new RageMPTimer(id, 0, true, callbackBind, () => {\n                clearTimeout(timerId);\n                this.timers.delete(id);\n            });\n            this.timers.set(id, rageMPTimer);\n            return rageMPTimer;\n        }\n    }\n\n    time(_name?: string) {\n        // RageMP doesn't have console.time equivalent\n        // Could implement custom timing if needed\n    }\n\n    timeEnd(_name?: string) {\n        // RageMP doesn't have console.timeEnd equivalent\n    }\n}\n", "import type { EventEmmiter, MultiplayerService, MultiplayerTimers } from '../../interfaces';\nimport { RageMPEventEmmiter } from './ragemp-event-emmiter';\nimport { RageMPTimers } from './ragemp-timers';\nimport { isObject } from '../../../utils';\n\nexport class RageMPMultiplayerService implements MultiplayerService {\n    readonly Timers: MultiplayerTimers;\n    readonly Events: EventEmmiter;\n\n    constructor() {\n        this.Events = new RageMPEventEmmiter();\n        this.Timers = new RageMPTimers();\n    }\n\n    parseInternalArgs<U = unknown, T = unknown>(\n        ...args: any\n    ): {\n        player?: U;\n        body?: T;\n    } {\n        const player = (isObject(args[0]) ? args[0] : undefined) as U;\n\n        return {\n            player,\n            body: args,\n        };\n    }\n\n    log(arg: any, ...args: any[]): void {\n        const message = [arg, ...args].map(a =>\n            typeof a === 'object' ? JSON.stringify(a) : String(a)\n        ).join(' ');\n        mp.console.logInfo(message);\n    }\n\n    logError(arg: any, ...args: any[]): void {\n        const message = [arg, ...args].map(a =>\n            typeof a === 'object' ? JSON.stringify(a) : String(a)\n        ).join(' ');\n        mp.console.logError(message);\n    }\n\n    logWarning(arg: any, ...args: any[]): void {\n        const message = [arg, ...args].map(a =>\n            typeof a === 'object' ? JSON.stringify(a) : String(a)\n        ).join(' ');\n        mp.console.logWarning(message);\n    }\n\n    logDebug(arg: any, ...args: any[]): void {\n        // RageMP doesn't have a dedicated debug log, use info\n        const message = [arg, ...args].map(a =>\n            typeof a === 'object' ? JSON.stringify(a) : String(a)\n        ).join(' ');\n        mp.console.logInfo(`[DEBUG] ${message}`);\n    }\n}\n", "import { validateErrorFilter, validateGuard, validateInterceptor, validatePipe } from '../schemas/events';\nimport {\n    GLOBAL_ERROR_FILTERS,\n    GLOBAL_GUARDS,\n    GLOBAL_INTERCEPTORS,\n    GLOBAL_PIPES,\n    ENABLE_SHUTDOWN_HOOKS,\n    PLUGINS,\n    GLOBAL_APP_CONTAINER,\n    MANGO_REQUEST_FACTORY,\n    MANGO_RESPONSE_FACTORY,\n    EXECUTION_CONTEXT_FACTORY,\n    CONTAINER_OPTIONS,\n    MULTIPLAYER_SERVICE,\n} from './constants';\nimport type { Newable } from '../types';\nimport { Container } from 'inversify';\nimport type { interfaces } from 'inversify';\nimport { App } from './app';\nimport type { ErrorFilter, Guard, Interceptor, MangoPlugin, MultiplayerService } from './interfaces';\nimport type { Pipe } from '../interfaces';\nimport {\n    ControllerEventHandler,\n    ControllerFlowHandler,\n    ControllerMetadataReader,\n    ControllerRPCHandler,\n    PipelineHandler,\n} from './controller';\nimport { Module, ModuleMetadataReader } from './module';\nimport { AppRuntime, ModuleDependencyBinder, ModuleTreeScanner } from './module-tree';\nimport { Controller } from './controller';\nimport { ExecutionContextBase, MangoRequestBase, MangoResponseBase } from './pipeline';\nimport type { AppEnviroment, ExecutionContextType } from './enums';\nimport { REFLECTOR_SERVICE } from '../constants';\nimport { ReflectorService } from '../services';\nimport type { AppBuilderConfig } from '../interfaces/core/app-builder-config.interface';\n\nexport class AppBuilder<G extends Guard = Guard, I extends Interceptor = Interceptor, EF extends ErrorFilter = ErrorFilter> {\n    protected readonly enviroment: AppEnviroment;\n    protected readonly internalAppContainer: Container;\n    protected readonly multiplayerService: MultiplayerService;\n    protected readonly plugins: Newable<MangoPlugin>[];\n    private globalContainerOptions: interfaces.ContainerOptions = {};\n\n    constructor(config: AppBuilderConfig) {\n        this.enviroment = config.enviroment;\n        this.internalAppContainer = config.internalAppContainer;\n        this.multiplayerService = config.multiplayerService;\n        this.plugins = config.plugins;\n    }\n\n    public useGlobalGuards(...guards: (Newable<G> | G)[]) {\n        const validatedGuards: (Newable<G> | G)[] = [];\n        for (const guard of guards) {\n            const { valid, value, error } = validateGuard(guard);\n            if (!valid) throw new Error(error);\n            validatedGuards.push(value);\n        }\n\n        this.internalAppContainer.bind(GLOBAL_GUARDS).toConstantValue(validatedGuards);\n        return this;\n    }\n\n    public useGlobalInterceptors(...interceptors: (Newable<I> | I)[]) {\n        const validatedInterceptors: (Newable<I> | I)[] = [];\n        for (const interceptor of interceptors) {\n            const { valid, value, error } = validateInterceptor(interceptor);\n            if (!valid) throw new Error(error);\n            validatedInterceptors.push(value);\n        }\n\n        this.internalAppContainer.bind(GLOBAL_INTERCEPTORS).toConstantValue(validatedInterceptors);\n        return this;\n    }\n\n    public useGlobalPipes(...pipes: (Newable<Pipe> | Pipe)[]) {\n        const validatedPipes: (Newable<Pipe> | Pipe)[] = [];\n        for (const pipe of pipes) {\n            const { valid, value, error } = validatePipe(pipe);\n            if (!valid) throw new Error(error);\n            validatedPipes.push(value);\n        }\n\n        this.internalAppContainer.bind(GLOBAL_PIPES).toConstantValue(validatedPipes);\n        return this;\n    }\n\n    public useGlobalFilters(...filters: (Newable<EF> | EF)[]) {\n        const validatedFIlters: (Newable<EF> | EF)[] = [];\n        for (const filter of filters) {\n            const { valid, value, error } = validateErrorFilter(filter);\n            if (!valid) throw new Error(error);\n            validatedFIlters.push(value);\n        }\n\n        this.internalAppContainer.bind(GLOBAL_ERROR_FILTERS).toConstantValue(validatedFIlters);\n        return this;\n    }\n\n    public usePlugins(...plugins: Newable<MangoPlugin>[]) {\n        plugins.forEach((p) => this.internalAppContainer.bind(p).toSelf().inSingletonScope());\n        const internalPlugins = this.internalAppContainer.get<Newable<MangoPlugin>[]>(PLUGINS);\n        this.internalAppContainer.rebind(PLUGINS).toConstantValue([...internalPlugins, ...plugins]);\n        return this;\n    }\n\n    public enableShutdownHooks() {\n        this.internalAppContainer.bind(ENABLE_SHUTDOWN_HOOKS).toConstantValue(true);\n        return this;\n    }\n\n    public setContainerOptions(options: interfaces.ContainerOptions, onlyGlobal = false) {\n        this.globalContainerOptions = options;\n        if (onlyGlobal) return this;\n        this.internalAppContainer.bind(CONTAINER_OPTIONS).toConstantValue(options);\n        return this;\n    }\n\n    public async build() {\n        const globalAppContainer = new Container(this.globalContainerOptions);\n        // GLobal service bindings\n        globalAppContainer.bind(REFLECTOR_SERVICE).toConstantValue(ReflectorService);\n        globalAppContainer.bind(ReflectorService).toService(REFLECTOR_SERVICE);\n\n        // Multiplayer service bindings\n        globalAppContainer.bind(MULTIPLAYER_SERVICE).toConstantValue(this.multiplayerService);\n \n        // App bindings\n        this.internalAppContainer.bind(App).toSelf().inSingletonScope();\n        this.internalAppContainer.bind(GLOBAL_APP_CONTAINER).toConstantValue(globalAppContainer);\n\n        // Module tree bindings\n        this.internalAppContainer.bind(ModuleTreeScanner).toSelf().inSingletonScope();\n        this.internalAppContainer.bind(ModuleDependencyBinder).toSelf().inSingletonScope();\n        this.internalAppContainer.bind(AppRuntime).toSelf().inSingletonScope();\n\n        // App bindings\n        this.internalAppContainer.bind(PipelineHandler).toSelf().inSingletonScope();\n\n        // Module bindings\n        this.internalAppContainer.bind(Module).toSelf().inTransientScope();\n        this.internalAppContainer.bind(ModuleMetadataReader).toSelf().inSingletonScope();\n\n        // Controller bindings\n        this.internalAppContainer.bind(Controller).toSelf().inTransientScope();\n        this.internalAppContainer.bind(ControllerMetadataReader).toSelf().inSingletonScope();\n        this.internalAppContainer.bind(ControllerFlowHandler).toSelf().inSingletonScope();\n        this.internalAppContainer.bind(ControllerEventHandler).toSelf().inSingletonScope();\n        this.internalAppContainer.bind(ControllerRPCHandler).toSelf().inSingletonScope();\n\n        // Mango Request and Response bindings\n        this.internalAppContainer.bind(MangoRequestBase).toSelf().inTransientScope();\n        this.internalAppContainer.bind(MANGO_REQUEST_FACTORY).toFactory((context) => {\n            return (body: unknown, player: PlayerMp) => {\n                const request = context.container.get(MangoRequestBase);\n                request.$body = body;\n                request.$player = player;\n                return request;\n            };\n        });\n        this.internalAppContainer.bind(MangoResponseBase).toSelf().inTransientScope();\n        this.internalAppContainer.bind(MANGO_RESPONSE_FACTORY).toFactory((context) => {\n            return () => {\n                return context.container.get(MangoResponseBase);\n            };\n        });\n        this.internalAppContainer.bind(ExecutionContextBase).toSelf().inTransientScope();\n        this.internalAppContainer.bind(EXECUTION_CONTEXT_FACTORY).toFactory((context) => {\n            return (\n                type: ExecutionContextType,\n                classRef: Newable,\n                handler: Function,\n                request: MangoRequestBase,\n                response: MangoResponseBase,\n                name: string,\n            ) => {\n                const executionContext = context.container.get(ExecutionContextBase);\n                executionContext.$type = type;\n                executionContext.$request = request;\n                executionContext.$response = response;\n                executionContext.$handler = handler;\n                executionContext.$classRef = classRef;\n                executionContext.$name = name;\n                return executionContext;\n            };\n        });\n\n        // Plugins bindings\n        for (const plugin of this.plugins) {\n            this.internalAppContainer.bind(plugin).toSelf().inSingletonScope();\n            const pluginInstance = this.internalAppContainer.get(plugin);\n            if (!pluginInstance.onBuild) continue;\n            await pluginInstance.onBuild();\n        }\n\n        if (!this.internalAppContainer.isBound(GLOBAL_GUARDS)) this.internalAppContainer.bind(GLOBAL_GUARDS).toConstantValue([]);\n        if (!this.internalAppContainer.isBound(GLOBAL_INTERCEPTORS))\n            this.internalAppContainer.bind(GLOBAL_INTERCEPTORS).toConstantValue([]);\n        if (!this.internalAppContainer.isBound(GLOBAL_PIPES)) this.internalAppContainer.bind(GLOBAL_PIPES).toConstantValue([]);\n        if (!this.internalAppContainer.isBound(GLOBAL_ERROR_FILTERS))\n            this.internalAppContainer.bind(GLOBAL_ERROR_FILTERS).toConstantValue([]);\n\n        return this.internalAppContainer.get(App);\n    }\n}\n", "import { Container, inject, injectable } from 'inversify';\nimport { ModuleDependencyBinder, ModuleTreeScanner } from './module-tree';\nimport { Module } from './module/module';\nimport type { Newable } from '../types';\nimport { INTERNAL_APP_CONTAINER, PLUGINS } from './constants';\nimport { AppRuntime } from './module-tree';\nimport type { MangoPlugin } from './interfaces/core/mango-plugin.interface';\nimport { ErrorMessage } from '../enums';\nimport type { Tree } from './utils';\nimport { type LoggerService } from '../interfaces';\nimport { LOGGER_SERVICE } from '../constants';\n\n@injectable()\nexport class App {\n    @inject(ModuleTreeScanner) private readonly moduleTreeScanner: ModuleTreeScanner;\n    @inject(ModuleDependencyBinder) private readonly moduleDependencyBinder: ModuleDependencyBinder;\n    @inject(AppRuntime) private readonly appRuntime: AppRuntime;\n    @inject(INTERNAL_APP_CONTAINER) private readonly internalAppContainer: Container;\n    @inject(PLUGINS) private readonly plugins: Newable<MangoPlugin>[];\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    private moduleTree: Tree<Module>;\n    private loaded = false;\n\n    public async start<T>(rootModule: Newable<T>) {\n        if (this.loaded) {\n            this.loggerService.error('Error occurred while starting the app.');\n            throw new Error(ErrorMessage.AppAlreadyLoaded);\n        }\n        this.loggerService.log('Starting app...');\n        await this.runPluginMethods('beforeStart');\n\n        this.loggerService.log('Scanning module tree...');\n        await this.runPluginMethods('beforeScan');\n        this.moduleTree = await this.moduleTreeScanner.scan(rootModule);\n        await this.runPluginMethods('afterScan');\n\n        this.loggerService.log('Binding module dependencies...');\n        await this.runPluginMethods('beforeBind');\n        await this.moduleDependencyBinder.bind(this.moduleTree);\n        await this.runPluginMethods('afterBind');\n\n        this.loggerService.log('Loading app...');\n        await this.runPluginMethods('beforeLoad');\n        await this.appRuntime.boot(this.moduleTree);\n        this.loaded = true;\n        await this.runPluginMethods('afterLoad');\n\n        this.loggerService.log('App loaded');\n\n        await this.runPluginMethods('afterStart');\n    }\n\n    public async stop() {\n        if (!this.loaded) {\n            this.loggerService.error('Error occurred while stopping the app.');\n            throw new Error(ErrorMessage.AppNotLoaded);\n        }\n        await this.runPluginMethods('beforeStop');\n        this.loggerService.log('Stopping app...');\n        await this.appRuntime.shutdown(this.moduleTree);\n        this.loaded = false;\n        this.loggerService.log('App stopped');\n        await this.runPluginMethods('afterStop');\n    }\n\n    private async runPluginMethods(method: keyof MangoPlugin) {\n        await Promise.all(\n            this.plugins.map(async (p) => {\n                const plugin = this.internalAppContainer.get(p);\n                if (!plugin[method]) return Promise.resolve();\n                return Promise.resolve(plugin[method]!());\n            }),\n        );\n    }\n}\n", "import { Container } from 'inversify';\nimport { MULTIPLAYER_SERVICE, PLUGINS } from './constants';\nimport type { Newable } from '../types';\nimport type { MangoPlugin, MultiplayerService } from './interfaces';\nimport type { AppEnviroment } from './enums';\nimport type { AppBuilder } from './app-builder';\nimport type { AppBuilderConfig } from '../interfaces/core/app-builder-config.interface';\n\nexport async function createAppBuilder<T extends AppBuilder>({\n    enviroment,\n    plugins,\n    appBuilderInherit,\n    multiplayerService,\n}: {\n    enviroment: AppEnviroment;\n    plugins: Newable<MangoPlugin>[];\n    appBuilderInherit: new (config: AppBuilderConfig) => T;\n    multiplayerService?: MultiplayerService;\n}): Promise<T> {\n    const internalAppContainer = new Container();\n\n    if (multiplayerService) internalAppContainer.bind(MULTIPLAYER_SERVICE).toConstantValue(multiplayerService);\n    internalAppContainer.bind(PLUGINS).toConstantValue(plugins);\n\n    return new appBuilderInherit({\n        enviroment,\n        internalAppContainer,\n        multiplayerService: multiplayerService!,\n        plugins,\n    });\n}", "import { isNil, isString } from '../utils';\nimport { CoreMetadataKey, type EventMetadata, type PipelineMetadata } from '../app';\nimport { ErrorMessage } from '../enums';\n\nexport function createEventDecorator(type: EventMetadata['type'], name?: string, webViewId?: string | number) {\n    return <MethodDecorator>((target: Object, method: string) => {\n        if (!isNil(name) && !isString(name)) {\n            throw new Error(ErrorMessage.EventNameMustBeString);\n        }\n\n        name = name ?? method;\n\n        const events =\n            Reflect.getMetadata<Omit<EventMetadata, 'params' | keyof PipelineMetadata>[]>(CoreMetadataKey.ControllerEvents, target) ?? [];\n\n        if (events.some((event) => event.method === method && event.name === name && event.type === type)) {\n            throw new Error(ErrorMessage.EventNameMustBeUnique);\n        }\n\n        Reflect.defineMetadata<Omit<EventMetadata, 'params' | keyof PipelineMetadata>[]>(\n            CoreMetadataKey.ControllerEvents,\n            [...events, { method, name, type, webViewId }],\n            target,\n        );\n    });\n}\n", "import { createEventDecorator } from '../create-event-decorator';\n\nexport function OnInternal(eventName: string) {\n    return createEventDecorator('onInternal', eventName);\n}\n", "import { createEventDecorator } from '../create-event-decorator';\n\nexport function OnWebView(id: string | number, eventName?: string) {\n    return createEventDecorator('onWebView', eventName, id);\n}\n", "import { createEventDecorator } from '../create-event-decorator';\n\nexport function On(eventName?: string) {\n    return createEventDecorator('on', eventName);\n}\n", "import { createEventDecorator } from '../create-event-decorator';\n\nexport function OnceInternal(eventName: string) {\n    return createEventDecorator('onceInternal', eventName);\n}\n", "import { createEventDecorator } from '../create-event-decorator';\n\nexport function Once(eventName?: string) {\n    return createEventDecorator('once', eventName);\n}\n", "import { createEventDecorator } from '../create-event-decorator';\n\nexport function OnceWebView(id: string | number, eventName?: string) {\n    return createEventDecorator('onceWebView', eventName, id);\n}\n", "import { CoreMetadataKey } from '../../app/enums';\nimport type { Newable } from '../../types';\nimport type { MethodParameter } from '../../app/interfaces';\nimport { MethodParamType } from '../../app/enums';\nimport { ErrorMessage } from '../../enums';\nimport type { Pipe } from '../../interfaces';\nimport { validatePipe } from '../../schemas';\n\nexport function Body(...pipes: (Newable<Pipe> | Pipe)[]) {\n    return <ParameterDecorator>((target: Object, method: string, index: number) => {\n        const validatedPipes: (Newable<Pipe> | Pipe)[] = [];\n        for (const pipe of pipes) {\n            const { valid, value, error } = validatePipe(pipe);\n            if (!valid) throw new Error(error);\n            validatedPipes.push(value);\n        }\n\n        const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, target, method) ?? [];\n\n        if (params.some((param) => param.index === index)) {\n            throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);\n        }\n\n        const paramTypes = Reflect.getMetadata<Newable[]>('design:paramtypes', target, method);\n        const metatype = Array.isArray(paramTypes) ? paramTypes[index] : undefined;\n\n        Reflect.defineMetadata<MethodParameter[]>(\n            CoreMetadataKey.ControllerParams,\n            [...params, { index, method, pipes: validatedPipes, type: MethodParamType.Body, data: undefined, metatype }],\n            target,\n            method,\n        );\n    });\n}\n", "import { CoreMetadataKey } from '../../app/enums';\nimport type { Newable } from '../../types';\nimport type { MethodParameter } from '../../app/interfaces';\nimport { MethodParamType } from '../../app/enums';\nimport { ErrorMessage } from '../../enums';\nimport type { Pipe } from '../../interfaces';\nimport { isNumber } from '../../utils';\nimport { validatePipe } from '../../schemas';\n\nexport function Index(key: number, ...pipes: (Newable<Pipe> | Pipe)[]) {\n    return <ParameterDecorator>((target: Object, method: string, index: number) => {\n        if (!isNumber(key)) {\n            throw new Error(ErrorMessage.IndexKeyMustBeNumber);\n        }\n        const validatedPipes: (Newable<Pipe> | Pipe)[] = [];\n        for (const pipe of pipes) {\n            const { valid, value, error } = validatePipe(pipe);\n            if (!valid) throw new Error(error);\n            validatedPipes.push(value);\n        }\n\n        const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, target, method) ?? [];\n\n        if (params.some((param) => param.index === index)) {\n            throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);\n        }\n\n        const paramTypes = Reflect.getMetadata<Newable[]>('design:paramtypes', target, method);\n        const metatype = Array.isArray(paramTypes) ? paramTypes[index] : undefined;\n\n        Reflect.defineMetadata<MethodParameter[]>(\n            CoreMetadataKey.ControllerParams,\n            [...params, { index, method, pipes: validatedPipes, type: MethodParamType.Index, data: key, metatype }],\n            target,\n            method,\n        );\n    });\n}\n", "import { CoreMetadataKey } from '../../app/enums';\nimport type { Newable } from '../../types';\nimport type { MethodParameter } from '../../app/interfaces';\nimport { MethodParamType } from '../../app/enums';\nimport { ErrorMessage } from '../../enums';\n\nexport function Request() {\n    return <ParameterDecorator>((target: Object, method: string, index: number) => {\n        const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, target, method) ?? [];\n\n        if (params.some((param) => param.index === index)) {\n            throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);\n        }\n\n        const paramTypes = Reflect.getMetadata<Newable[]>('design:paramtypes', target, method);\n        const metatype = Array.isArray(paramTypes) ? paramTypes[index] : undefined;\n\n        Reflect.defineMetadata<MethodParameter[]>(\n            CoreMetadataKey.ControllerParams,\n            [...params, { index, method, type: MethodParamType.Request, data: undefined, metatype }],\n            target,\n            method,\n        );\n    });\n}\n\nexport function Req() {\n    return Request();\n}\n", "import { CoreMetadataKey } from '../../app/enums';\nimport type { Newable } from '../../types';\nimport type { MethodParameter } from '../../app/interfaces';\nimport { MethodParamType } from '../../app/enums';\nimport { isString } from '../../utils';\nimport { ErrorMessage } from '../../enums';\nimport type { Pipe } from '../../interfaces';\nimport { validatePipe } from '../../schemas';\n\nexport function Param(key: string, ...pipes: (Newable<Pipe> | Pipe)[]) {\n    return <ParameterDecorator>((target: Object, method: string, index: number) => {\n        if (!isString(key)) {\n            throw new Error(ErrorMessage.ParamKeyMustBeString);\n        }\n        const validatedPipes: (Newable<Pipe> | Pipe)[] = [];\n        for (const pipe of pipes) {\n            const { valid, value, error } = validatePipe(pipe);\n            if (!valid) throw new Error(error);\n            validatedPipes.push(value);\n        }\n\n        const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, target, method) ?? [];\n\n        if (params.some((param) => param.index === index)) {\n            throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);\n        }\n\n        const paramTypes = Reflect.getMetadata<Newable[]>('design:paramtypes', target, method);\n        const metatype = Array.isArray(paramTypes) ? paramTypes[index] : undefined;\n\n        Reflect.defineMetadata<MethodParameter[]>(\n            CoreMetadataKey.ControllerParams,\n            [...params, { index, method, data: key, pipes: validatedPipes, type: MethodParamType.Param, metatype }],\n            target,\n            method,\n        );\n    });\n}\n", "import { CoreMetadataKey } from '../../app/enums';\nimport type { MethodParameter } from '../../app/interfaces';\nimport { MethodParamType } from '../../app/enums';\nimport { ErrorMessage } from '../../enums';\nimport type { Newable } from '../../types';\n\nexport function Response() {\n    return <ParameterDecorator>((target: Object, method: string, index: number) => {\n        const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, target, method) ?? [];\n\n        if (params.some((param) => param.index === index)) {\n            throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);\n        }\n\n        const paramTypes = Reflect.getMetadata<Newable[]>('design:paramtypes', target, method);\n        const metatype = Array.isArray(paramTypes) ? paramTypes[index] : undefined;\n\n        Reflect.defineMetadata<MethodParameter[]>(\n            CoreMetadataKey.ControllerParams,\n            [...params, { index, method, type: MethodParamType.Response, data: undefined, metatype }],\n            target,\n            method,\n        );\n    });\n}\n\nexport function Res() {\n    return Response();\n}\n", "import type { Guard } from '../../app/interfaces';\nimport type { Newable } from '../../types';\nimport { isNil } from '../../utils';\nimport { CoreMetadataKey } from '../../app/enums';\nimport { ErrorMessage } from '../../enums';\nimport { validateGuard } from '../../schemas';\n\nexport function UseGuards(...guards: (Newable<Guard> | Guard)[]) {\n    return <ClassDecorator & MethodDecorator>((target: Object, method?: string, descriptor?: PropertyDescriptor) => {\n        const validatedGuards: (Newable<Guard> | Guard)[] = [];\n        for (const guard of guards) {\n            const { valid, value, error } = validateGuard(guard);\n            if (!valid) throw new Error(error);\n            validatedGuards.push(value);\n        }\n\n        if (!isNil(descriptor) && !isNil(descriptor.value)) {\n            if (guards.length === 0) {\n                throw new Error(ErrorMessage.AtLeastOneGuardRequired);\n            }\n\n            const methodGuards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, target.constructor, method) || [];\n            Reflect.defineMetadata(CoreMetadataKey.Guards, [...validatedGuards, ...methodGuards], target.constructor, method);\n            return descriptor;\n        }\n\n        if (guards.length === 0) {\n            throw new Error(ErrorMessage.AtLeastOneGuardRequired);\n        }\n\n        const classGuards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, target) || [];\n        Reflect.defineMetadata(CoreMetadataKey.Guards, [...validatedGuards, ...classGuards], target);\n        return target;\n    });\n}\n", "import type { Newable } from '../../types';\nimport type { Interceptor } from '../../app/interfaces';\nimport { isNil } from '../../utils';\nimport { CoreMetadataKey } from '../../app/enums';\nimport { ErrorMessage } from '../../enums';\nimport { validateInterceptor } from '../../schemas';\n\nexport function UseInterceptors(...interceptors: (Newable<Interceptor> | Interceptor)[]) {\n    return <ClassDecorator & MethodDecorator>((target: Object, method?: string, descriptor?: PropertyDescriptor) => {\n        const validatedInterceptors: (Newable<Interceptor> | Interceptor)[] = [];\n        for (const interceptor of interceptors) {\n            const { valid, value, error } = validateInterceptor(interceptor);\n            if (!valid) throw new Error(error);\n            validatedInterceptors.push(value);\n        }\n\n        if (!isNil(descriptor) && !isNil(descriptor.value)) {\n            if (interceptors.length === 0) {\n                throw new Error(ErrorMessage.AtLeastOneInterceptorRequired);\n            }\n\n            const methodInterceptors =\n                Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, target.constructor, method) || [];\n            Reflect.defineMetadata(\n                CoreMetadataKey.Interceptors,\n                [...validatedInterceptors, ...methodInterceptors],\n                target.constructor,\n                method,\n            );\n            return descriptor;\n        }\n\n        if (interceptors.length === 0) {\n            throw new Error(ErrorMessage.AtLeastOneInterceptorRequired);\n        }\n\n        const classInterceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, target) || [];\n        Reflect.defineMetadata(CoreMetadataKey.Interceptors, [...validatedInterceptors, ...classInterceptors], target);\n        return target;\n    });\n}\n", "import type { Newable } from '../../types';\nimport { isNil } from '../../utils';\nimport { CoreMetadataKey } from '../../app/enums';\nimport { ErrorMessage } from '../../enums';\nimport type { Pipe } from '../../interfaces';\nimport { validatePipe } from '../../schemas';\n\nexport function UsePipes(...pipes: (Newable<Pipe> | Pipe)[]) {\n    return <ClassDecorator & MethodDecorator>((target: Object, method?: string, descriptor?: PropertyDescriptor) => {\n        const validatedPipes: (Newable<Pipe> | Pipe)[] = [];\n        for (const pipe of pipes) {\n            const { valid, value, error } = validatePipe(pipe);\n            if (!valid) throw new Error(error);\n            validatedPipes.push(value);\n        }\n\n        if (!isNil(descriptor) && !isNil(descriptor.value)) {\n            if (pipes.length === 0) {\n                throw new Error(ErrorMessage.AtLeastOnePipeRequired);\n            }\n\n            const methodPipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, target.constructor, method) || [];\n            Reflect.defineMetadata(CoreMetadataKey.Pipes, [...validatedPipes, ...methodPipes], target.constructor, method);\n            return descriptor;\n        }\n\n        if (pipes.length === 0) {\n            throw new Error(ErrorMessage.AtLeastOnePipeRequired);\n        }\n\n        const classPipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, target) || [];\n        Reflect.defineMetadata(CoreMetadataKey.Pipes, [...validatedPipes, ...classPipes], target);\n        return target;\n    });\n}\n", "import { isNil, isNumber, isString } from '../utils';\nimport { CoreMetadataKey, type PipelineMetadata, type RPCMetadata } from '../app';\nimport { ErrorMessage } from '../enums';\n\nexport function createRPCDecorator(type: RPCMetadata['type'], name?: string, webViewId?: string | number) {\n    return <MethodDecorator>((target: Object, method: string) => {\n        if (!isNil(webViewId) && !isString(webViewId) && !isNumber(webViewId)) {\n            throw new Error(ErrorMessage.WebViewIdMustBeStringOrNumber);\n        }\n\n        if (!isNil(name) && !isString(name)) {\n            throw new Error(ErrorMessage.RPCNameMustBeString);\n        }\n\n        name = name ?? method;\n\n        const rpcs =\n            Reflect.getMetadata<Omit<RPCMetadata, 'params' | keyof PipelineMetadata>[]>(CoreMetadataKey.ControllerRPCs, target) ?? [];\n\n        if (rpcs.some((rpc) => rpc.method === method && rpc.name === name && rpc.type === type)) {\n            throw new Error(ErrorMessage.RPCNameMustBeUnique);\n        }\n\n        Reflect.defineMetadata<Omit<RPCMetadata, 'params' | keyof PipelineMetadata>[]>(\n            CoreMetadataKey.ControllerRPCs,\n            [...rpcs, { method, name, type, webViewId }],\n            target,\n        );\n    });\n}\n", "import { createRPCDecorator } from '../create-rpc-decorator';\n\nexport function OnRequest(rpcName?: string) {\n    return createRPCDecorator('onRequest', rpcName);\n}\n", "import { createRPCDecorator } from '../create-rpc-decorator';\n\nexport function OnWebViewRequest(id: string | number, rpcName?: string) {\n    return createRPCDecorator('onWebViewRequest', rpcName, id);\n}\n", "import { CoreMetadataKey, type TimerMetadata } from '../app';\nimport { ErrorMessage } from '../enums';\nimport { isNil, isString } from '../utils';\n\nexport function createTimerDecorator(type: TimerMetadata['type'], name?: string, options?: TimerMetadata['options']) {\n    return <MethodDecorator>((target: Object, method: string) => {\n        if (!isNil(name) && !isString(name)) {\n            throw new Error(ErrorMessage.TimerNameMustBeString);\n        }\n\n        name = name ?? method;\n\n        const timers = Reflect.getMetadata<TimerMetadata[]>(CoreMetadataKey.Timers, target) ?? [];\n\n        if (timers.some((timer) => timer.method === method && timer.name === name && timer.type === type)) {\n            throw new Error(ErrorMessage.EventNameMustBeUnique);\n        }\n\n        Reflect.defineMetadata<TimerMetadata[]>(\n            CoreMetadataKey.Timers,\n            [...timers, <TimerMetadata>{ method, name, type, options }],\n            target,\n        );\n    });\n}\n", "import type { CronOptions } from 'croner';\nimport { createTimerDecorator } from '../create-timer.decorator';\n\nexport function Cron(pattern: string | Date, options: CronOptions = {}) {\n    return createTimerDecorator('cron', options.name, { pattern, ...options });\n}\n", "import { createTimerDecorator } from '../create-timer.decorator';\n\nexport function EveryTick(name?: string) {\n    return createTimerDecorator('everytick', name);\n}\n", "import { isString } from '../../utils';\nimport { createTimerDecorator } from '../create-timer.decorator';\n\nexport function Interval(timeout: number): MethodDecorator;\nexport function Interval(name: string, timeout: number): MethodDecorator;\nexport function Interval(nameOrTimeout: string | number, timeout?: number): MethodDecorator {\n    const [name, intervalTimeout] = isString(nameOrTimeout) ? [nameOrTimeout, timeout] : [undefined, nameOrTimeout];\n    return createTimerDecorator('interval', name, { timeout: intervalTimeout! });\n}\n", "import { isString } from '../../utils';\nimport { createTimerDecorator } from '../create-timer.decorator';\n\nexport function Timeout(timeout: number): MethodDecorator;\nexport function Timeout(name: string, value: number): MethodDecorator;\nexport function Timeout(nameOrTimeout: string | number, timeout?: number): MethodDecorator {\n    const [name, intervalTimeout] = isString(nameOrTimeout) ? [nameOrTimeout, timeout] : [undefined, nameOrTimeout];\n    return createTimerDecorator('timeout', name, { timeout: intervalTimeout! });\n}\n", "export function applyDecorators(...decorators: (ClassDecorator | MethodDecorator | PropertyDecorator)[]) {\n    return <TFunction extends Function, Y>(\n        target: TFunction | Object,\n        propertyKey: string | symbol,\n        descriptor: TypedPropertyDescriptor<Y>,\n    ) => {\n        for (const decorator of decorators) {\n            if (target instanceof Function && !descriptor) {\n                (<ClassDecorator>decorator)(target);\n                continue;\n            }\n            (<MethodDecorator | PropertyDecorator>decorator)(target, propertyKey, descriptor);\n        }\n    };\n}\n", "import type { ExecutionContext, MethodParameter } from '../app/interfaces';\nimport { CoreMetadataKey } from '../app/enums';\nimport type { Newable } from '../types';\nimport { MethodParamType } from '../app/enums';\nimport { ErrorMessage } from '../enums';\nimport type { Pipe } from '../interfaces';\nimport { validatePipe } from '../schemas';\n\nexport function createParamDecorator<TInput = unknown, TOutput = unknown>(factory: (data: TInput, ctx: ExecutionContext) => TOutput) {\n    return <TInput = unknown>(data?: TInput, ...pipes: (Newable<Pipe> | Pipe)[]) => {\n        return <ParameterDecorator>((target: Object, method: string, index: number) => {\n            const validatedPipes: (Newable<Pipe> | Pipe)[] = [];\n            for (const pipe of pipes) {\n                const { valid, value, error } = validatePipe(pipe);\n                if (!valid) throw new Error(error);\n                validatedPipes.push(value);\n            }\n\n            const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, target, method) ?? [];\n\n            if (params.some((param) => param.index === index)) {\n                throw new Error(ErrorMessage.MultipleDecoratorsOnSingleParameterNotAllowed);\n            }\n\n            const paramTypes = Reflect.getMetadata<Newable[]>('design:paramtypes', target, method);\n            const metatype = Array.isArray(paramTypes) ? paramTypes[index] : undefined;\n\n            Reflect.defineMetadata<MethodParameter[]>(\n                CoreMetadataKey.ControllerParams,\n                [\n                    ...params,\n                    {\n                        index,\n                        method,\n                        pipes: validatedPipes,\n                        type: MethodParamType.Custom,\n                        factory: <(data: unknown, context: ExecutionContext) => unknown>factory,\n                        data,\n                        metatype,\n                    },\n                ],\n                target,\n                method,\n            );\n        });\n    };\n}\n", "import { LazyServiceIdentifier, type interfaces } from 'inversify';\n\nexport function forwardRef<T = unknown>(fn: () => interfaces.ServiceIdentifier<T>) {\n    return new LazyServiceIdentifier<T>(fn);\n}", "import { inject, injectable } from 'inversify';\nimport { isString } from '../utils';\nimport { Cron, type CronOptions } from 'croner';\nimport { MULTIPLAYER_SERVICE, type MultiplayerService, type MultiplayerTimer } from '../app';\n\n@injectable()\nexport class TimerService {\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayerService: MultiplayerService;\n    private readonly $everyticks = new Map<string, MultiplayerTimer>();\n    private readonly $intervals = new Map<string, MultiplayerTimer>();\n    private readonly $timeouts = new Map<string, MultiplayerTimer>();\n    private readonly $crons = new Map<string, Cron>();\n\n    public get all() {\n        return this.multiplayerService.Timers.all;\n    }\n\n    public get everyticks() {\n        return [...this.$everyticks.values()];\n    }\n\n    public get intervals() {\n        return [...this.$intervals.values()];\n    }\n\n    public get timeouts() {\n        return [...this.$timeouts.values()];\n    }\n\n    public get crons() {\n        return [...this.$crons.values()];\n    }\n\n    public set warningThreshold(value: number) {\n        this.multiplayerService.Timers.warningThreshold = value;\n    }\n\n    public get warningThreshold() {\n        return this.multiplayerService.Timers.warningThreshold;\n    }\n\n    public set sourceLocationFrameSkipCount(value: number) {\n        this.multiplayerService.Timers.sourceLocationFrameSkipCount = value;\n    }\n\n    public get sourceLocationFrameSkipCount() {\n        return this.multiplayerService.Timers.sourceLocationFrameSkipCount;\n    }\n\n    public createCronJob(callback: Function, options: CronOptions & { pattern: string | Date }) {\n        const { pattern, ...cronOptions } = options;\n\n        const cron = Cron(pattern, cronOptions, callback);\n        if (isString(options.name)) this.$crons.set(options.name, cron);\n\n        return cron;\n    }\n\n    public createInterval(callback: Function, interval: number, name?: string) {\n        const timer = this.multiplayerService.Timers.setInterval(callback, interval);\n        if (isString(name)) this.$intervals.set(name, timer);\n        return timer;\n    }\n\n    public createTimeout(callback: Function, timeout: number, name?: string) {\n        const timer = this.multiplayerService.Timers.setTimeout(callback, timeout);\n        if (isString(name)) this.$timeouts.set(name, timer);\n        return timer;\n    }\n\n    public createEveryTick(callback: Function, name?: string) {\n        const timer = this.multiplayerService.Timers.everyTick(callback);\n        if (isString(name)) this.$everyticks.set(name, timer);\n        return timer;\n    }\n\n    public delete(type: 'cron' | 'everytick' | 'timeout' | 'interval', name: string) {\n        switch (type) {\n            case 'cron':\n                const cronJob = this.$crons.get(name);\n                if (cronJob) {\n                    cronJob.stop();\n                    this.$crons.delete(name);\n                }\n                break;\n            case 'everytick':\n                const everytick = this.$everyticks.get(name);\n                if (everytick) {\n                    everytick.destroy();\n                    this.$everyticks.delete(name);\n                }\n                break;\n            case 'interval':\n                const interval = this.$intervals.get(name);\n                if (interval) {\n                    interval.destroy();\n                    this.$intervals.delete(name);\n                }\n                break;\n            case 'timeout':\n                const timeout = this.$timeouts.get(name);\n                if (timeout) {\n                    timeout.destroy();\n                    this.$timeouts.delete(name);\n                }\n                break;\n        }\n    }\n\n    public getByName(type: 'cron' | 'everytick' | 'timeout' | 'interval', name: string) {\n        switch (type) {\n            case 'cron':\n                return this.$crons.get(name);\n            case 'everytick':\n                return this.$everyticks.get(name);\n            case 'interval':\n                return this.$intervals.get(name);\n            case 'timeout':\n                return this.$timeouts.get(name);\n        }\n    }\n\n    public getById(id: number) {\n        return this.multiplayerService.Timers.getByID(id);\n    }\n\n    public time(name?: string) {\n        return this.multiplayerService.Timers.time(name);\n    }\n\n    public timeEnd(name?: string) {\n        return this.multiplayerService.Timers.timeEnd(name);\n    }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAASA,cAAAA,mBAAkB;;;ACI3B,SAASC,kBAAkB;AAGpB,SAASC,YAA8BC,SAA2B;AACrE,SAAO,CAACC,WAAAA;AACJ,QAAIC,QAAQC,YAAYC,gBAAgBL,YAAYE,MAAAA,GAAS;AACzD,YAAM,IAAII,MAAMC,aAAaC,uBAAuB;IACxD;AAEA,UAAM,EAAEC,OAAOC,OAAOC,MAAK,IAAKC,0BAA0BX,OAAAA;AAC1D,QAAI,CAACQ,MAAO,OAAM,IAAIH,MAAMK,KAAAA;AAC5BR,YAAQU,eAAeR,gBAAgBL,YAAYU,OAAOR,MAAAA;AAE1D,WAAOY,WAAAA,EAAaZ,MAAAA;EACxB;AACJ;AAZgBF,OAAAA,aAAAA;;;ACJT,SAASe,SAAAA;AACZ,SAAO,CAACC,WAAAA;AACJC,YAAQC,eAAeC,gBAAgBC,cAAc,MAAMJ,MAAAA;AAC3D,WAAOA;EACX;AACJ;AALgBD;;;ACHhB,SAASM,cAAc;AAMhB,SAASC,OAAoBC,KAAuB;AACvD,SAAgD,CAACC,QAAgBC,aAAqBC,eAAAA;AAClF,QAAI,CAACC,MAAMJ,GAAAA,KAAQ,CAACK,uBAAuBL,GAAAA,EAAKM,OAAO;AACnD,YAAM,IAAIC,MAAMC,aAAaC,8BAA8B;IAC/D;AAEA,UAAMC,QAAQV,OAAOW,QAAQC,YAA4B,eAAeX,QAAQC,WAAAA;AAChF,QAAI,CAACQ,OAAO;AACR,YAAM,IAAIH,MAAMC,aAAaK,sBAAsB;IACvD;AAEAC,WAAOJ,KAAAA,EAAOT,QAAQC,aAAaC,UAAAA;EACvC;AACJ;AAbgBJ;;;ACNhB,SAASgB,cAAAA,mBAAkB;AAOpB,SAASC,WAA8BC,SAA2B;AACrE,SAAO,CAACC,WAAAA;AACJ,QAAIC,QAAQC,YAAYC,gBAAgBL,YAAYE,MAAAA,GAAS;AACzD,YAAM,IAAII,MAAMC,aAAaC,uBAAuB;IACxD;AAEA,UAAM,EAAEC,OAAOC,OAAOC,MAAK,IAAKC,2BAA2BX,OAAAA;AAC3D,QAAI,CAACQ,MAAO,OAAM,IAAIH,MAAMK,KAAAA;AAC5BR,YAAQU,eAAeR,gBAAgBL,YAAYU,OAAOR,MAAAA;AAE1D,WAAOY,YAAAA,EAAaZ,MAAAA;EACxB;AACJ;AAZgBF;;;ACJhB,SAASe,cAAAA,mBAAkB;AAIpB,SAASC,QAA0BC,SAAuB;AAC7D,SAAO,CAACC,WAAAA;AACJ,QAAIC,QAAQC,YAAYC,gBAAgBL,QAAQE,MAAAA,GAAS;AACrD,YAAM,IAAII,MAAMC,aAAaC,uBAAuB;IACxD;AAEA,UAAM,EAAEC,OAAOC,OAAOC,MAAK,IAAKC,sBAAsBX,OAAAA;AACtD,QAAI,CAACQ,MAAO,OAAM,IAAIH,MAAMK,KAAAA;AAC5BR,YAAQU,eAAeR,gBAAgBL,QAAQU,OAAOR,MAAAA;AAEtD,WAAOY,YAAAA,EAAaZ,MAAAA;EACxB;AACJ;AAZgBF,OAAAA,SAAAA;;;ACPhB,SAASe,gBAAgB;AAElB,SAASC,WAAAA;AACZ,SAAgD,CAACC,QAAgBC,aAAqBC,eAAAA;AAClF,WAAOC,SAAAA,EAAWH,QAAQC,aAAaC,UAAAA;EAC3C;AACJ;AAJgBH;;;ACAT,SAASK,YAAoDC,KAAQC,OAAQ;AAChF,QAAMC,mBAAqC,wBAACC,QAAgBC,SAAkBC,eAAAA;AAC1E,QAAIA,YAAY;AACZC,cAAQC,eAAeP,KAAKC,OAAOI,WAAWJ,KAAK;AACnD,aAAOI;IACX;AACAC,YAAQC,eAAeP,KAAKC,OAAOE,MAAAA;AACnC,WAAOA;EACX,GAP2C;AAQ3CD,mBAAiBM,MAAMR;AACvB,SAAOE;AACX;AAXgBH;;;ACET,SAASU,SAA4BC,YAAqB;AAC7D,SAAO,CAACC,WAAAA;AACJ,QAAIC,QAAQC,YAAYC,gBAAgBL,OAAOE,MAAAA,GAAS;AACpD,YAAM,IAAII,MAAMC,aAAaC,uBAAuB;IACxD;AAEA,UAAMC,aAAaR,WAAWS,OAAO,CAACC,WAAWC,UAAUX,WAAWY,QAAQF,SAAAA,MAAeC,KAAAA;AAC7F,QAAIH,WAAWK,QAAQ;AACnB,YAAM,IAAIR,MAAMC,aAAaQ,yBAAyB;IAC1D;AAEAZ,YAAQa,eAAeX,gBAAgBL,OAAOC,YAAYC,MAAAA;AAE1D,WAAOA;EACX;AACJ;AAfgBF;;;ACGT,SAASiB,cAAcC,SAA+C;AACzE,SAA0C,CAACC,QAAgBC,QAAiBC,eAAAA;AACxE,UAAMC,mBAA2D,CAAA;AACjE,eAAWC,UAAUL,SAAS;AAC1B,YAAM,EAAEM,OAAOC,OAAOC,MAAK,IAAKC,oBAAoBJ,MAAAA;AACpD,UAAI,CAACC,MAAO,OAAM,IAAII,MAAMF,KAAAA;AAC5BJ,uBAAiBO,KAAKJ,KAAAA;IAC1B;AAEA,QAAI,CAACK,MAAMT,UAAAA,KAAe,CAACS,MAAMT,WAAWI,KAAK,GAAG;AAChD,UAAIP,QAAQa,WAAW,GAAG;AACtB,cAAM,IAAIH,MAAMI,aAAaC,wBAAwB;MACzD;AAEA,YAAMC,gBACFC,QAAQC,YAAoCC,gBAAgBC,cAAcnB,OAAO,aAAaC,MAAAA,KAAW,CAAA;AAC7G,UAAI,CAACU,MAAMI,cAAcK,KAAK,CAAChB,WAAWL,QAAQsB,SAASjB,MAAAA,CAAAA,CAAAA,GAAW;AAClE,cAAM,IAAIK,MAAMI,aAAaS,4BAA4B;MAC7D;AACAN,cAAQO,eAAeL,gBAAgBC,cAAc;WAAIhB;WAAqBY;SAAgBf,OAAO,aAAaC,MAAAA;AAClH,aAAOC;IACX;AAEA,QAAIH,QAAQa,WAAW,GAAG;AACtB,YAAM,IAAIH,MAAMI,aAAaC,wBAAwB;IACzD;AAEA,UAAMU,eAAeR,QAAQC,YAAoCC,gBAAgBC,cAAcnB,MAAAA,KAAW,CAAA;AAC1G,QAAI,CAACW,MAAMa,aAAaJ,KAAK,CAAChB,WAAWL,QAAQsB,SAASjB,MAAAA,CAAAA,CAAAA,GAAW;AACjE,YAAM,IAAIK,MAAMI,aAAaS,4BAA4B;IAC7D;AACAN,YAAQO,eAAeL,gBAAgBC,cAAc;SAAIhB;SAAqBqB;OAAexB,MAAAA;AAC7F,WAAOA;EACX;AACJ;AAlCgBF;;;ACFhB,SAAS2B,UAAAA,SAAQC,cAAAA,aAAYC,YAAAA,iBAAgB;;;;;;;;;;;;AAUtC,IAAMC,aAAN,MAAMA;SAAAA;;;EACwCC;EACFC;EACPC;EACMC;EACPC;EACQC;EACNC;EACmBC;EAE5D,MAAaC,KAAKC,cAA4B;AAC1C,UAAMA,aAAaC,cAAc,OAAOC,SAAAA;AACpC,YAAMC,YAAYC,KAAKC,IAAG;AAE1B,YAAMC,SAASJ,KAAKK;AACpBD,aAAOE,WAAWF,OAAOG,UAAUC,IAAiCJ,OAAOK,SAASC,QAAQ;AAC5FN,aAAOO,YAAYC,QACf,CAACC,eAAgBA,WAAWP,WAAWF,OAAOG,UAAUC,IAAiCK,WAAWJ,SAASC,QAAQ,CAAA;AAEzH;WAAIN,OAAOK,SAASK;WAAsBV,OAAOK,SAASM;QAAmBH,QAAQ,CAAC,CAACI,KAAAA,MACnFZ,OAAOG,UAAUC,IAASQ,KAAAA,CAAAA;AAI9B,WAAKrB,cAAcsB,IAAI,UAAUb,OAAOK,SAASC,SAASQ,IAAI,YAAYhB,KAAKC,IAAG,IAAKF,SAAAA,KAAc;AACrG,YAAM,KAAKkB,mBAAmBf,QAAQ,cAAA;IAC1C,CAAA;AAEA,UAAM,KAAKgB,oBAAoBtB,cAAc,gBAAA;AAG7CA,iBAAauB,SAAS,CAACrB,SAAAA;AACnB,YAAMI,SAASJ,KAAKK;AACpBD,aAAOO,YAAYC,QAAQ,CAACC,eAAAA;AACxB,cAAMS,OAAOpB,KAAKC,IAAG;AACrB,aAAKoB,eAAeV,UAAAA;AACpB,aAAKW,kBAAkBX,UAAAA;AACvB,aAAKlB,cAAcsB,IACf,cAAcJ,WAAWJ,SAASC,SAASQ,IAAI,qCAAqChB,KAAKC,IAAG,IAAKmB,IAAAA,KAAS;MAElH,CAAA;IACJ,CAAA;EACJ;EAEA,MAAaG,SAAS3B,cAA4B;AAC9C,QAAI,KAAKF,qBAAqB;AAC1B,YAAM,KAAKwB,oBAAoBtB,cAAc,iBAAA;AAC7C,YAAM,KAAKsB,oBAAoBtB,cAAc,mBAAA;IACjD;AAEA,UAAMA,aAAaC,cAAc,OAAOC,SAAAA;AACpC,YAAMI,SAASJ,KAAKK;AACpBD,aAAOO,YAAYC,QAAQ,CAACC,eAAAA;AACxB,cAAMa,eAAeb,WAAWc,MAAMpB,UAAUC,IAAkBoB,aAAAA;AAGlEF,qBAAaG,WAAWjB,QAAQ,CAACkB,UAAUA,MAAMC,QAAO,CAAA;AACxDL,qBAAaM,UAAUpB,QAAQ,CAACkB,UAAUA,MAAMC,QAAO,CAAA;AACvDL,qBAAaO,SAASrB,QAAQ,CAACkB,UAAUA,MAAMC,QAAO,CAAA;AACtDL,qBAAaQ,MAAMtB,QAAQ,CAACuB,SAASA,KAAKC,KAAI,CAAA;AAG9CvB,mBAAWwB,cAAczB,QAAQ,CAAC0B,YAAYA,QAAQP,QAAO,CAAA;AAC7DlB,mBAAW0B,YAAY3B,QAAQ,CAAC0B,YAAYA,QAAQP,QAAO,CAAA;MAC/D,CAAA;IACJ,CAAA;AAaA,QAAI,KAAKnC,qBAAqB;AAC1B,YAAM,KAAKwB,oBAAoBtB,cAAc,eAAA;IACjD;EACJ;EAEQ0B,kBAAkBX,YAAwB;AAC9C,UAAMT,SAASS,WAAWc;AAC1Bd,eAAWJ,SAAS+B,OAAO5B,QAAQ,CAAC6B,UAAAA;AAChC,YAAMC,SAAS;WAAI,KAAKnD;WAAiBa,OAAOK,SAASiC;WAAW7B,WAAWJ,SAASiC;WAAWD,MAAMC;;AACzG,YAAMC,eAAe;WACd,KAAKnD;WACLY,OAAOK,SAASkC;WAChB9B,WAAWJ,SAASkC;WACpBF,MAAME;;AAEb,YAAMC,QAAQ;WAAI,KAAKnD;WAAgBW,OAAOK,SAASmC;WAAU/B,WAAWJ,SAASmC;WAAUH,MAAMG;;AACrG,YAAMC,qBAAqB,KAAKC,gBAAgB;WACzC,KAAKpD;WACLU,OAAOK,SAASsC;WAChBlC,WAAWJ,SAASsC;WACpBN,MAAMM;OACZ;AAED,YAAMT,UAAU,KAAKjD,aAAa2D,cAAcN,QAAQC,cAAcC,OAAOC,oBAAoBhC,YAAY4B,KAAAA;AAC7G5B,iBAAWwB,cAAcY,KAAKX,OAAAA;IAClC,CAAA;AAEAzB,eAAWJ,SAASyC,KAAKtC,QAAQ,OAAOuC,QAAAA;AACpC,YAAMT,SAAS;WAAI,KAAKnD;WAAiBa,OAAOK,SAASiC;WAAW7B,WAAWJ,SAASiC;WAAWS,IAAIT;;AACvG,YAAMC,eAAe;WACd,KAAKnD;WACLY,OAAOK,SAASkC;WAChB9B,WAAWJ,SAASkC;WACpBQ,IAAIR;;AAEX,YAAMC,QAAQ;WAAI,KAAKnD;WAAgBW,OAAOK,SAASmC;WAAU/B,WAAWJ,SAASmC;WAAUO,IAAIP;;AACnG,YAAMC,qBAAqB,KAAKC,gBAAgB;WACzC,KAAKpD;WACLU,OAAOK,SAASsC;WAChBlC,WAAWJ,SAASsC;WACpBI,IAAIJ;OACV;AAED,YAAMT,UAAU,MAAM,KAAKhD,WAAW8D,YAAYV,QAAQC,cAAcC,OAAOC,oBAAoBhC,YAAYsC,GAAAA;AAC/GtC,iBAAW0B,YAAYU,KAAKX,OAAAA;IAChC,CAAA;EACJ;EAEOf,eAAeV,YAAwB;AAC1C,UAAMa,eAAeb,WAAWc,MAAMpB,UAAUC,IAAkBoB,aAAAA;AAElEf,eAAWJ,SAAS4C,OAAOzC,QAAQ,CAACkB,UAAAA;AAChC,UAAIA,MAAMwB,SAAS,QAAQ;AACvB5B,qBAAa6B,cAAc1C,WAAWP,SAASwB,MAAM0B,MAAM,EAAGC,KAAK5C,WAAWP,QAAQ,GAAGwB,MAAM4B,OAAO;MAC1G,WAAW5B,MAAMwB,SAAS,aAAa;AACnC5B,qBAAaiC,gBAAgB9C,WAAWP,SAASwB,MAAM0B,MAAM,EAAGC,KAAK5C,WAAWP,QAAQ,GAAGwB,MAAMZ,IAAI;MACzG,WAAWY,MAAMwB,SAAS,YAAY;AAClC5B,qBAAakC,eACT/C,WAAWP,SAASwB,MAAM0B,MAAM,EAAGC,KAAK5C,WAAWP,QAAQ,GAC3DwB,MAAM4B,QAAQG,SACd/B,MAAMZ,IAAI;MAElB,WAAWY,MAAMwB,SAAS,WAAW;AACjC5B,qBAAaoC,cAAcjD,WAAWP,SAASwB,MAAM0B,MAAM,EAAGC,KAAK5C,WAAWP,QAAQ,GAAGwB,MAAM4B,QAAQG,SAAS/B,MAAMZ,IAAI;MAC9H;IACJ,CAAA;EACJ;EAEQ4B,gBAAgBC,cAAsD;AAC1E,UAAMgB,YAAiF,CAAA;AAEvF,eAAWC,UAAUjB,cAAc;AAC/B,YAAMkB,SAASC,QAAQC,YAAmBC,gBAAgBC,OAAOL,MAAAA,KAAW,CAAA;AAC5E,UAAIC,OAAOK,WAAW,GAAG;AACrBL,eAAOhB,KAAK,iBAAA;MAChB;AACA,iBAAWsB,SAASN,QAAQ;AACxB,YAAI,CAACO,MAAMT,UAAUU,KAAK,CAACC,gBAAgBA,YAAY,CAAA,MAAOH,KAAAA,CAAAA,GAAS;AACnE,eAAK5E,cAAc4E,MAAM,sDAAA;AACzB,gBAAM,IAAII,MAAMC,aAAaC,2BAA2B;QAC5D;AACAd,kBAAUd,KAAK;UAACsB;UAAOP;SAAO;MAClC;IACJ;AAEA,WAAOD;EACX;EAEA,MAAc3C,oBACVtB,cACA0D,QACF;AACE,WAAO1D,aAAaC,cAAc,OAAOC,SAAS,MAAM,KAAKmB,mBAAmBnB,KAAKK,OAAOmD,MAAAA,CAAAA;EAChG;EAEA,MAAcrC,mBACVf,QACAoD,QACF;AACE,UAAMsB,QAAQC,IACV3E,OAAOO,YAAYqE,IAAI,OAAOnE,eAAAA;AAC1B,UAAI,CAACoE,SAASpE,WAAWP,QAAQ,KAAKkE,MAAM3D,WAAWP,SAASkD,MAAAA,CAAO,EAAG;AAC1E,YAAM3C,WAAWP,SAASkD,MAAAA,EAAO;IACrC,CAAA,CAAA;AAEJ,UAAMsB,QAAQC,IACV;SAAI3E,OAAOK,SAASK;SAAsBV,OAAOK,SAASM;MAAmBiE,IAAI,OAAO,CAAChE,KAAAA,MAAM;AAC3F,YAAMkE,mBAAgD9E,OAAOG,UAAUC,IAAIQ,KAAAA;AAC3E,UAAI,CAACiE,SAASC,gBAAAA,KAAqBV,MAAMU,iBAAiB1B,MAAAA,CAAO,EAAG;AACpE,YAAM0B,iBAAiB1B,MAAAA,EAAO;IAClC,CAAA,CAAA;AAEJ,QAAI,CAACyB,SAAS7E,OAAOE,QAAQ,KAAKkE,MAAMpE,OAAOE,SAASkD,MAAAA,CAAO,EAAG;AAClE,UAAMpD,OAAOE,SAASkD,MAAAA,EAAO;EACjC;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3MA,SAAS2B,WAAWC,UAAAA,SAAQC,cAAAA,aAAYC,YAAAA,iBAAiC;;;;;;;;;;;;AAMlE,IAAMC,yBAAN,MAAMA;SAAAA;;;EACsCC;EACNC;EACeC;EAExD,MAAaC,KAAKC,cAA4B;AAC1C,UAAMA,aAAaC,cAAc,OAAOC,SAAAA;AACpC,YAAMC,YAAYC,KAAKC,IAAG;AAE1B,YAAMC,SAASJ,KAAKK;AACpBD,aAAOE,YAAY,IAAIC,gBAAgBH,OAAOI,SAASF,aAAa,KAAKV,gBAAgB;AAEzFQ,aAAOE,UAAUG,SAAS,KAAKf;AAC/B,WAAKA,mBAAmBG,KAAKO,OAAOI,SAASE,QAAQ,EAAEC,OAAM,EAAGC,iBAAgB;AAGhF,UAAIR,OAAOI,SAASK,QAAQ;AAExB,mBAAW,CAACC,GAAGC,QAAAA,KAAaX,OAAOI,SAASQ,mBAAmB;AAC3D,eAAKC,aAAaF,UAAU,KAAKrB,kBAAkB;QACvD;MACJ,OAAO;AAEH,mBAAW,CAACwB,OAAOH,QAAAA,KAAaX,OAAOI,SAASQ,mBAAmB;AAC/D,eAAKC,aAAaF,UAAUX,OAAOE,SAAS;AAC5CF,iBAAOK,QAAQH,UAAUT,KAAKqB,KAAAA,EAAOC,eAAe,MAAMf,OAAOE,UAAUc,IAAIF,KAAAA,CAAAA;QACnF;AACA,mBAAWG,gBAAgBjB,OAAOkB,mBAAmB;AACjD,qBAAW,CAACJ,KAAAA,KAAUG,aAAab,SAASQ,mBAAmB;AAC3DZ,mBAAOE,UAAUT,KAAKqB,KAAAA,EAAOC,eAAe,MAAME,aAAaf,UAAUc,IAAIF,KAAAA,CAAAA;UACjF;QACJ;MACJ;AAGA,iBAAW,CAACJ,GAAGC,QAAAA,KAAaX,OAAOI,SAASe,mBAAmB;AAC3D,aAAKN,aAAaF,UAAUX,OAAOE,SAAS;MAChD;AAGAF,aAAOE,UAAUT,KAAK2B,gBAAAA,EAAkBC,gBAAgBrB,OAAOE,SAAS;AAGxE,iBAAWI,YAAYN,OAAOI,SAASkB,aAAa;AAChDtB,eAAOE,UAAUT,KAAKa,QAAAA,EAAUC,OAAM,EAAGC,iBAAgB;MAC7D;AAGAR,aAAOE,UAAUT,KAAK8B,aAAAA,EAAeC,GAAGC,YAAAA,EAAcjB,iBAAgB;AAEtE,WAAKjB,cAAcmC,IACf,UAAU1B,OAAOI,SAASE,SAASqB,IAAI,yBAAyB7B,KAAKC,IAAG,IAAKF,SAAAA,KAAc;IAEnG,CAAA;EACJ;EAEQgB,aAAaF,UAAsCT,WAAsB;AAC7E,QAAI,cAAcS,UAAU;AACxBT,gBAAUT,KAAKkB,SAASiB,OAAO,EAAEP,gBAAgBV,SAASkB,QAAQ;IACtE,WAAW,gBAAgBlB,UAAU;AACjC,YAAMmB,UAAU5B,UAAUT,KAAKkB,SAASiB,OAAO,EAAEb,eAAe,CAACgB,QAAAA;AAC7D,cAAMC,OACFrB,SAASsB,QAAQC,IAAI,CAACC,QAAAA;AAClB,cAAIC,SAASD,GAAAA,KAAQ,WAAWA,OAAO,cAAcA,KAAK;AACtD,gBAAI;AACA,qBAAOJ,IAAI7B,UAAUc,IAAImB,IAAIrB,KAAK;YACtC,SAASuB,KAAK;AACV,kBAAIF,IAAIG,SAAU,QAAOC;AACzB,mBAAKhD,cAAciD,MAAM,yDAAA;AACzB,oBAAMH;YACV;UACJ;AACA,iBAAON,IAAI7B,UAAUc,IAAImB,GAAAA;QAC7B,CAAA,KAAM,CAAA;AACV,eAAOxB,SAAS8B,WAAU,GAAIT,IAAAA;MAClC,CAAA;AACA,UAAIrB,SAAS+B,UAAU,YAAaZ,SAAQa,iBAAgB;eACnDhC,SAAS+B,UAAU,UAAWZ,SAAQc,eAAc;UACxDd,SAAQtB,iBAAgB;IACjC,WAAW,cAAcG,UAAU;AAC/B,YAAMmB,UAAU5B,UAAUT,KAAKkB,SAASiB,OAAO,EAAEJ,GAAGb,SAASkC,QAAQ;AACrE,UAAIlC,SAAS+B,UAAU,YAAaZ,SAAQa,iBAAgB;eACnDhC,SAAS+B,UAAU,UAAWZ,SAAQc,eAAc;UACxDd,SAAQtB,iBAAgB;IACjC,WAAW,iBAAiBG,UAAU;AAClCT,gBAAUT,KAAKkB,SAASiB,OAAO,EAAEkB,UAAUnC,SAASoC,WAAW;IACnE;EACJ;AACJ;;;;;;;;;;;;sFArF0F,qBAAA,cAAA,SAAA,WAAA,gBAAA;;;;;;;ACV1F,SAASC,UAAAA,SAAQC,cAAAA,mBAAkB;;;;;;;;;;;;AAQ5B,IAAMC,oBAAN,MAAMA;SAAAA;;;EACsCC;EACIC;EACVC;EAEzC,MAAaC,KAAKC,UAA4D;AAC1E,UAAMC,YAAYC,KAAKC,IAAG;AAE1B,UAAMC,iBAAiB,MAAM,KAAKR,qBAAqBS,KAAKL,QAAAA;AAE5D,UAAMM,SAAS,IAAIC,OAAAA;AACnBD,WAAOE,WAAWJ;AAElB,SAAKN,cAAcW,IAAI,UAAUH,OAAOE,SAASR,SAASU,IAAI,aAAaR,KAAKC,IAAG,IAAKF,SAAAA,KAAc;AAEtG,UAAM,KAAKU,gBAAgBL,MAAAA;AAE3B,UAAMM,aAAa,IAAIC,KAAKP,MAAAA;AAC5B,UAAMQ,iBAAiB,oBAAIC,IAAAA;AAC3BD,mBAAeE,IAAIhB,UAAUM,MAAAA;AAE7B,eAAWW,kBAAkBb,eAAec,SAAS;AACjD,YAAM,KAAKC,YAAYP,WAAWQ,MAAMH,gBAAgBH,cAAAA;IAC5D;AACA,WAAOF;EACX;EAEA,MAAcO,YACVE,YACArB,UACAc,iBAAiB,oBAAIC,IAAAA,GACvB;AAEE,UAAMO,gBAAgBR,eAAeS,IAAIvB,QAAAA;AACzC,QAAI,CAACwB,MAAMF,aAAAA,GAAgB;AACvBD,iBAAWI,MAAMC,kBAAkBC,IAAIL,aAAAA;AACvC;IACJ;AAEA,UAAMrB,YAAYC,KAAKC,IAAG;AAG1B,UAAMC,iBAAiB,MAAM,KAAKR,qBAAqBS,KAAKL,QAAAA;AAE5D,SAAK4B,wBAAwBP,WAAWI,MAAMjB,UAAUJ,cAAAA;AAExD,UAAME,SAAS,IAAIC,OAAAA;AACnBD,WAAOE,WAAWJ;AAClBE,WAAOuB,SAASR,WAAWI;AAE3B,SAAK3B,cAAcW,IAAI,UAAUH,OAAOE,SAASR,SAASU,IAAI,aAAaR,KAAKC,IAAG,IAAKF,SAAAA,KAAc;AAEtG,UAAM,KAAKU,gBAAgBL,MAAAA;AAE3B,UAAMwB,WAAW,IAAIC,SAASzB,MAAAA;AAC9Be,eAAWW,SAASF,QAAAA;AAEpBhB,mBAAeE,IAAIhB,UAAUM,MAAAA;AAE7B,eAAW2B,gBAAgB7B,eAAec,SAAS;AAC/C,YAAM,KAAKC,YAAYW,UAAUG,cAAcnB,cAAAA;IACnD;EACJ;EAEA,MAAcH,gBAAgBL,QAAgB;AAE1C,eAAWN,YAAYM,OAAOE,SAAS0B,aAAa;AAChD,YAAMjC,YAAYC,KAAKC,IAAG;AAC1B,YAAMgC,qBAAqB,MAAM,KAAKtC,yBAAyBQ,KAAKL,QAAAA;AACpE,YAAMoC,aAAa,IAAIC,WAAAA;AACvBD,iBAAW5B,WAAW2B;AACtBC,iBAAWE,QAAQhC;AACnBA,aAAO4B,YAAYK,KAAKH,UAAAA;AAExB,WAAKtC,cAAcW,IAAI,cAAcT,SAASU,IAAI,aAAaR,KAAKC,IAAG,IAAKF,SAAAA,KAAc;IAC9F;EACJ;EAEA,MAAc2B,wBAAwBY,gBAAgCpC,gBAAgC;AAElG,QAAIA,eAAec,QAAQuB,SAASD,eAAexC,QAAQ,GAAG;AAE1D,YAAM,IAAI0C,MAAMC,aAAaC,0BAA0B;IAC3D;EACJ;AACJ;;;;;;;;;;;;;;;;;;AC/FO,IAAMC,oBAAN,MAAMA;EAAb,OAAaA;;;;;EACT,YACYC,WACAC,UACV;SAFUD,YAAAA;SACAC,WAAAA;EACT;EAEHC,UAAgB;AACZC,OAAGC,OAAOC,OAAO,KAAKL,WAAW,KAAKC,QAAQ;EAClD;AACJ;;;ACRO,IAAMK,qBAAN,MAAMA;EAFb,OAEaA;;;EACTC,KAAKC,cAAsBC,MAAmB;AAC1CC,OAAGC,OAAOC,KAAKJ,WAAAA,GAAcC,IAAAA;EACjC;EAEAI,GAAGL,WAAmBM,UAAwD;AAC1EJ,OAAGC,OAAOI,IAAIP,WAAWM,QAAAA;AACzB,WAAO,IAAIE,kBAAkBR,WAAWM,QAAAA;EAC5C;EAEAG,KAAKT,WAAmBM,UAAwD;AAC5E,UAAMI,cAAc,2BAAIT,SAAAA;AACpBC,SAAGC,OAAOQ,OAAOX,WAAWU,WAAAA;AAC5BJ,eAAAA,GAAYL,IAAAA;IAChB,GAHoB;AAIpBC,OAAGC,OAAOI,IAAIP,WAAWU,WAAAA;AACzB,WAAO,IAAIF,kBAAkBR,WAAWU,WAAAA;EAC5C;EAEAE,IAAIZ,WAAmBM,UAA0C;AAC7DJ,OAAGC,OAAOQ,OAAOX,WAAWM,QAAAA;EAChC;AACJ;;;ACvBO,IAAMO,cAAN,MAAMA;EAAb,OAAaA;;;;;;;;EACFC,WAAWC,KAAKC,IAAG;EAC1B,YACWC,IACAC,WAAmB,GACnBC,MACAC,UACCC,YACV;SALSJ,KAAAA;SACAC,WAAAA;SACAC,OAAAA;SACAC,WAAAA;SACCC,aAAAA;EACT;EAEHC,UAAU;AACN,SAAKD,WAAU;EACnB;AACJ;;;ACZO,IAAME,eAAN,MAAMA;EAFb,OAEaA;;;EACDC,mBAA2B;EAC3BC,SAAS,oBAAIC,IAAAA;EACbC,oBAAoB,oBAAID,IAAAA;EACxBE,qBAAqB;EACrBC,uBAA4C;EAEpD,IAAWC,MAA0B;AACjC,WAAO;SAAI,KAAKL,OAAOM,OAAM;;EACjC;EAEA,IAAWC,mBAA2B;AAElC,WAAO;EACX;EAEA,IAAWA,iBAAiBC,QAAgB;EAE5C;EAEA,IAAWC,+BAAuC;AAE9C,WAAO;EACX;EAEA,IAAWA,6BAA6BD,QAAgB;EAExD;EAEAE,QAAQC,IAAqC;AACzC,UAAMC,QAAQ,KAAKZ,OAAOa,IAAIF,EAAAA;AAC9B,WAAOC,SAAS;EACpB;EAEQE,YACJA,aACAC,OACAC,UACAC,UACAC,SACGC,MACL;AACE,UAAMC,eAAeJ,SAASK,KAAK,MAAI,GAAMC,MAAMC,QAAQJ,IAAAA,IAAQA,OAAO,CAAA,CAAE;AAC5E,UAAMK,UAAU,OAAOP,aAAa,WAAWH,YAAYM,cAAcH,QAAAA,IAAYH,YAAYM,YAAAA;AACjG,UAAMT,KAAK,KAAKZ;AAEhB,UAAM0B,cAAc,IAAIC,YAAYf,IAAIM,YAAY,GAAGC,MAAME,cAAc,MAAA;AACvEL,YAAMS,OAAAA;AACN,WAAKxB,OAAO2B,OAAOhB,EAAAA;IACvB,CAAA;AACA,SAAKX,OAAO4B,IAAIjB,IAAIc,WAAAA;AACpB,WAAOA;EACX;EAEAI,YAAYb,UAAoBc,SAAiBX,MAAiB;AAC9D,WAAO,KAAKL,YACR,CAACiB,IAAcd,aAAqBY,YAAYE,IAAkBd,QAAAA,GAClE,CAACN,OAAeqB,cAAcrB,EAAAA,GAC9BK,UACAc,MACA,OAAA,GACGX,IAAAA;EAEX;EAEAc,WAAWjB,UAAoBc,SAAiBX,MAAiB;AAC7D,UAAMR,KAAK,KAAKZ;AAChB,UAAMqB,eAAeJ,SAASK,KAAK,MAAI,GAAMC,MAAMC,QAAQJ,IAAAA,IAAQA,OAAO,CAAA,CAAE;AAE5E,UAAMK,UAAUS,WAAW,MAAA;AACvBb,mBAAAA;AACA,WAAKpB,OAAO2B,OAAOhB,EAAAA;IACvB,GAAGmB,IAAAA;AAEH,UAAML,cAAc,IAAIC,YAAYf,IAAImB,MAAM,MAAMV,cAAc,MAAA;AAC9Dc,mBAAaV,OAAAA;AACb,WAAKxB,OAAO2B,OAAOhB,EAAAA;IACvB,CAAA;AACA,SAAKX,OAAO4B,IAAIjB,IAAIc,WAAAA;AACpB,WAAOA;EACX;EAEAU,UAAUnB,aAAuBG,MAAiB;AAC9C,UAAMR,KAAK,KAAKZ;AAChB,UAAMqB,eAAeJ,SAASK,KAAK,MAAI,GAAMC,MAAMC,QAAQJ,IAAAA,IAAQA,OAAO,CAAA,CAAE;AAE5E,SAAKjB,kBAAkB0B,IAAIjB,IAAI;MAAEK;MAAUoB,OAAOhB;IAAa,CAAA;AAG/D,UAAMiB,eAAe,OAAOC,OAAO,eAAe,OAAQA,GAAWC,aAAa;AAGlF,QAAI,CAAC,KAAKpC,oBAAoB;AAC1B,WAAKA,qBAAqB;AAE1B,UAAIkC,cAAc;AAEd,aAAKjC,uBAAuB,MAAA;AACxB,qBAAW,CAAA,EAAGoC,OAAAA,KAAY,KAAKtC,mBAAmB;AAC9C,gBAAI;AACAsC,sBAAQJ,MAAK;YACjB,SAASK,GAAG;AACRH,iBAAGI,QAAQC,SAAS,+BAA+BF,CAAAA,EAAG;YAC1D;UACJ;QACJ;AACAH,WAAGM,OAAOC,IAAI,UAAU,KAAKzC,oBAAoB;MACrD,OAAO;AAEH,cAAM0C,kBAAkB,6BAAA;AACpB,qBAAW,CAAA,EAAGN,OAAAA,KAAY,KAAKtC,mBAAmB;AAC9C,gBAAI;AACAsC,sBAAQJ,MAAK;YACjB,SAASK,GAAG;AACRH,iBAAGI,QAAQC,SAAS,+BAA+BF,CAAAA,EAAG;YAC1D;UACJ;QACJ,GARwB;AASvB,aAAaM,qBAAqBlB,YAAYiB,iBAAiB,CAAA;MACpE;IACJ;AAEA,UAAMrB,cAAc,IAAIC,YAAYf,IAAI,GAAG,OAAOS,cAAc,MAAA;AAC5D,WAAKlB,kBAAkByB,OAAOhB,EAAAA;AAC9B,WAAKX,OAAO2B,OAAOhB,EAAAA;AAGnB,UAAI,KAAKT,kBAAkB8C,SAAS,GAAG;AACnC,YAAIX,gBAAgB,KAAKjC,sBAAsB;AAC3CkC,aAAGM,OAAOK,OAAO,UAAU,KAAK7C,oBAAoB;AACpD,eAAKA,uBAAuB;QAChC,WAAY,KAAa2C,oBAAoB;AACzCf,wBAAe,KAAae,kBAAkB;AAC7C,eAAaA,qBAAqB;QACvC;AACA,aAAK5C,qBAAqB;MAC9B;IACJ,CAAA;AACA,SAAKH,OAAO4B,IAAIjB,IAAIc,WAAAA;AACpB,WAAOA;EACX;EAEAyB,SAASlC,aAAuBG,MAAiB;AAC7C,UAAMR,KAAK,KAAKZ;AAChB,UAAMqB,eAAeJ,SAASK,KAAK,MAAI,GAAMC,MAAMC,QAAQJ,IAAAA,IAAQA,OAAO,CAAA,CAAE;AAG5E,UAAMkB,eAAe,OAAOC,OAAO,eAAe,OAAQA,GAAWC,aAAa;AAElF,QAAIf;AAEJ,QAAIa,cAAc;AAEd,YAAMG,UAAU,6BAAA;AACZ,YAAI;AACApB,uBAAAA;QACJ,UAAA;AACIkB,aAAGM,OAAOK,OAAO,UAAUT,OAAAA;AAC3B,eAAKxC,OAAO2B,OAAOhB,EAAAA;QACvB;MACJ,GAPgB;AAQhB2B,SAAGM,OAAOC,IAAI,UAAUL,OAAAA;AAExB,YAAMf,cAAc,IAAIC,YAAYf,IAAI,GAAG,MAAMS,cAAc,MAAA;AAC3DkB,WAAGM,OAAOK,OAAO,UAAUT,OAAAA;AAC3B,aAAKxC,OAAO2B,OAAOhB,EAAAA;MACvB,CAAA;AACA,WAAKX,OAAO4B,IAAIjB,IAAIc,WAAAA;AACpB,aAAOA;IACX,OAAO;AAEHD,gBAAUS,WAAW,MAAA;AACjB,YAAI;AACAb,uBAAAA;QACJ,UAAA;AACI,eAAKpB,OAAO2B,OAAOhB,EAAAA;QACvB;MACJ,GAAG,CAAA;AAEH,YAAMc,cAAc,IAAIC,YAAYf,IAAI,GAAG,MAAMS,cAAc,MAAA;AAC3Dc,qBAAaV,OAAAA;AACb,aAAKxB,OAAO2B,OAAOhB,EAAAA;MACvB,CAAA;AACA,WAAKX,OAAO4B,IAAIjB,IAAIc,WAAAA;AACpB,aAAOA;IACX;EACJ;EAEAK,KAAKqB,OAAgB;EAGrB;EAEAC,QAAQD,OAAgB;EAExB;AACJ;;;AClMO,IAAME,2BAAN,MAAMA;EAJb,OAIaA;;;EACAC;EACAC;EAET,cAAc;AACV,SAAKA,SAAS,IAAIC,mBAAAA;AAClB,SAAKF,SAAS,IAAIG,aAAAA;EACtB;EAEAC,qBACOC,MAIL;AACE,UAAMC,SAAUC,SAASF,KAAK,CAAA,CAAE,IAAIA,KAAK,CAAA,IAAKG;AAE9C,WAAO;MACHF;MACAG,MAAMJ;IACV;EACJ;EAEAK,IAAIC,QAAaN,MAAmB;AAChC,UAAMO,UAAU;MAACD;SAAQN;MAAMQ,IAAIC,CAAAA,MAC/B,OAAOA,MAAM,WAAWC,KAAKC,UAAUF,CAAAA,IAAKG,OAAOH,CAAAA,CAAAA,EACrDI,KAAK,GAAA;AACPC,OAAGC,QAAQC,QAAQT,OAAAA;EACvB;EAEAU,SAASX,QAAaN,MAAmB;AACrC,UAAMO,UAAU;MAACD;SAAQN;MAAMQ,IAAIC,CAAAA,MAC/B,OAAOA,MAAM,WAAWC,KAAKC,UAAUF,CAAAA,IAAKG,OAAOH,CAAAA,CAAAA,EACrDI,KAAK,GAAA;AACPC,OAAGC,QAAQE,SAASV,OAAAA;EACxB;EAEAW,WAAWZ,QAAaN,MAAmB;AACvC,UAAMO,UAAU;MAACD;SAAQN;MAAMQ,IAAIC,CAAAA,MAC/B,OAAOA,MAAM,WAAWC,KAAKC,UAAUF,CAAAA,IAAKG,OAAOH,CAAAA,CAAAA,EACrDI,KAAK,GAAA;AACPC,OAAGC,QAAQG,WAAWX,OAAAA;EAC1B;EAEAY,SAASb,QAAaN,MAAmB;AAErC,UAAMO,UAAU;MAACD;SAAQN;MAAMQ,IAAIC,CAAAA,MAC/B,OAAOA,MAAM,WAAWC,KAAKC,UAAUF,CAAAA,IAAKG,OAAOH,CAAAA,CAAAA,EACrDI,KAAK,GAAA;AACPC,OAAGC,QAAQC,QAAQ,WAAWT,OAAAA,EAAS;EAC3C;AACJ;;;ACxCA,SAASa,aAAAA,kBAAiB;;;AChB1B,SAASC,aAAAA,YAAWC,UAAAA,SAAQC,cAAAA,mBAAkB;;;;;;;;;;;;AAavC,IAAMC,MAAN,MAAMA;SAAAA;;;EACmCC;EACKC;EACZC;EACYC;EACfC;EACOC;EACjCC;EACAC,SAAS;EAEjB,MAAaC,MAASC,YAAwB;AAC1C,QAAI,KAAKF,QAAQ;AACb,WAAKF,cAAcK,MAAM,wCAAA;AACzB,YAAM,IAAIC,MAAMC,aAAaC,gBAAgB;IACjD;AACA,SAAKR,cAAcS,IAAI,iBAAA;AACvB,UAAM,KAAKC,iBAAiB,aAAA;AAE5B,SAAKV,cAAcS,IAAI,yBAAA;AACvB,UAAM,KAAKC,iBAAiB,YAAA;AAC5B,SAAKT,aAAa,MAAM,KAAKN,kBAAkBgB,KAAKP,UAAAA;AACpD,UAAM,KAAKM,iBAAiB,WAAA;AAE5B,SAAKV,cAAcS,IAAI,gCAAA;AACvB,UAAM,KAAKC,iBAAiB,YAAA;AAC5B,UAAM,KAAKd,uBAAuBgB,KAAK,KAAKX,UAAU;AACtD,UAAM,KAAKS,iBAAiB,WAAA;AAE5B,SAAKV,cAAcS,IAAI,gBAAA;AACvB,UAAM,KAAKC,iBAAiB,YAAA;AAC5B,UAAM,KAAKb,WAAWgB,KAAK,KAAKZ,UAAU;AAC1C,SAAKC,SAAS;AACd,UAAM,KAAKQ,iBAAiB,WAAA;AAE5B,SAAKV,cAAcS,IAAI,YAAA;AAEvB,UAAM,KAAKC,iBAAiB,YAAA;EAChC;EAEA,MAAaI,OAAO;AAChB,QAAI,CAAC,KAAKZ,QAAQ;AACd,WAAKF,cAAcK,MAAM,wCAAA;AACzB,YAAM,IAAIC,MAAMC,aAAaQ,YAAY;IAC7C;AACA,UAAM,KAAKL,iBAAiB,YAAA;AAC5B,SAAKV,cAAcS,IAAI,iBAAA;AACvB,UAAM,KAAKZ,WAAWmB,SAAS,KAAKf,UAAU;AAC9C,SAAKC,SAAS;AACd,SAAKF,cAAcS,IAAI,aAAA;AACvB,UAAM,KAAKC,iBAAiB,WAAA;EAChC;EAEA,MAAcA,iBAAiBO,QAA2B;AACtD,UAAMC,QAAQC,IACV,KAAKpB,QAAQqB,IAAI,OAAOC,MAAAA;AACpB,YAAMC,SAAS,KAAKxB,qBAAqByB,IAAIF,CAAAA;AAC7C,UAAI,CAACC,OAAOL,MAAAA,EAAS,QAAOC,QAAQM,QAAO;AAC3C,aAAON,QAAQM,QAAQF,OAAOL,MAAAA,EAAO,CAAA;IACzC,CAAA,CAAA;EAER;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ADrCO,IAAMQ,aAAN,MAAMA;EArCb,OAqCaA;;;EACUC;EACAC;EACAC;EACAC;EACXC,yBAAsD,CAAC;EAE/D,YAAYC,QAA0B;AAClC,SAAKL,aAAaK,OAAOL;AACzB,SAAKC,uBAAuBI,OAAOJ;AACnC,SAAKC,qBAAqBG,OAAOH;AACjC,SAAKC,UAAUE,OAAOF;EAC1B;EAEOG,mBAAmBC,QAA4B;AAClD,UAAMC,kBAAsC,CAAA;AAC5C,eAAWC,SAASF,QAAQ;AACxB,YAAM,EAAEG,OAAOC,OAAOC,MAAK,IAAKC,cAAcJ,KAAAA;AAC9C,UAAI,CAACC,MAAO,OAAM,IAAII,MAAMF,KAAAA;AAC5BJ,sBAAgBO,KAAKJ,KAAAA;IACzB;AAEA,SAAKV,qBAAqBe,KAAKC,aAAAA,EAAeC,gBAAgBV,eAAAA;AAC9D,WAAO;EACX;EAEOW,yBAAyBC,cAAkC;AAC9D,UAAMC,wBAA4C,CAAA;AAClD,eAAWC,eAAeF,cAAc;AACpC,YAAM,EAAEV,OAAOC,OAAOC,MAAK,IAAKW,oBAAoBD,WAAAA;AACpD,UAAI,CAACZ,MAAO,OAAM,IAAII,MAAMF,KAAAA;AAC5BS,4BAAsBN,KAAKJ,KAAAA;IAC/B;AAEA,SAAKV,qBAAqBe,KAAKQ,mBAAAA,EAAqBN,gBAAgBG,qBAAAA;AACpE,WAAO;EACX;EAEOI,kBAAkBC,OAAiC;AACtD,UAAMC,iBAA2C,CAAA;AACjD,eAAWC,QAAQF,OAAO;AACtB,YAAM,EAAEhB,OAAOC,OAAOC,MAAK,IAAKiB,aAAaD,IAAAA;AAC7C,UAAI,CAAClB,MAAO,OAAM,IAAII,MAAMF,KAAAA;AAC5Be,qBAAeZ,KAAKJ,KAAAA;IACxB;AAEA,SAAKV,qBAAqBe,KAAKc,YAAAA,EAAcZ,gBAAgBS,cAAAA;AAC7D,WAAO;EACX;EAEOI,oBAAoBC,SAA+B;AACtD,UAAMC,mBAAyC,CAAA;AAC/C,eAAWC,UAAUF,SAAS;AAC1B,YAAM,EAAEtB,OAAOC,OAAOC,MAAK,IAAKuB,oBAAoBD,MAAAA;AACpD,UAAI,CAACxB,MAAO,OAAM,IAAII,MAAMF,KAAAA;AAC5BqB,uBAAiBlB,KAAKJ,KAAAA;IAC1B;AAEA,SAAKV,qBAAqBe,KAAKoB,oBAAAA,EAAsBlB,gBAAgBe,gBAAAA;AACrE,WAAO;EACX;EAEOI,cAAclC,SAAiC;AAClDA,YAAQmC,QAAQ,CAACC,MAAM,KAAKtC,qBAAqBe,KAAKuB,CAAAA,EAAGC,OAAM,EAAGC,iBAAgB,CAAA;AAClF,UAAMC,kBAAkB,KAAKzC,qBAAqB0C,IAA4BC,OAAAA;AAC9E,SAAK3C,qBAAqB4C,OAAOD,OAAAA,EAAS1B,gBAAgB;SAAIwB;SAAoBvC;KAAQ;AAC1F,WAAO;EACX;EAEO2C,sBAAsB;AACzB,SAAK7C,qBAAqBe,KAAK+B,qBAAAA,EAAuB7B,gBAAgB,IAAA;AACtE,WAAO;EACX;EAEO8B,oBAAoBC,SAAsCC,aAAa,OAAO;AACjF,SAAK9C,yBAAyB6C;AAC9B,QAAIC,WAAY,QAAO;AACvB,SAAKjD,qBAAqBe,KAAKmC,iBAAAA,EAAmBjC,gBAAgB+B,OAAAA;AAClE,WAAO;EACX;EAEA,MAAaG,QAAQ;AACjB,UAAMC,qBAAqB,IAAIC,WAAU,KAAKlD,sBAAsB;AAEpEiD,uBAAmBrC,KAAKuC,iBAAAA,EAAmBrC,gBAAgBsC,gBAAAA;AAC3DH,uBAAmBrC,KAAKwC,gBAAAA,EAAkBC,UAAUF,iBAAAA;AAGpDF,uBAAmBrC,KAAK0C,mBAAAA,EAAqBxC,gBAAgB,KAAKhB,kBAAkB;AAGpF,SAAKD,qBAAqBe,KAAK2C,GAAAA,EAAKnB,OAAM,EAAGC,iBAAgB;AAC7D,SAAKxC,qBAAqBe,KAAK4C,oBAAAA,EAAsB1C,gBAAgBmC,kBAAAA;AAGrE,SAAKpD,qBAAqBe,KAAK6C,iBAAAA,EAAmBrB,OAAM,EAAGC,iBAAgB;AAC3E,SAAKxC,qBAAqBe,KAAK8C,sBAAAA,EAAwBtB,OAAM,EAAGC,iBAAgB;AAChF,SAAKxC,qBAAqBe,KAAK+C,UAAAA,EAAYvB,OAAM,EAAGC,iBAAgB;AAGpE,SAAKxC,qBAAqBe,KAAKgD,eAAAA,EAAiBxB,OAAM,EAAGC,iBAAgB;AAGzE,SAAKxC,qBAAqBe,KAAKiD,MAAAA,EAAQzB,OAAM,EAAG0B,iBAAgB;AAChE,SAAKjE,qBAAqBe,KAAKmD,oBAAAA,EAAsB3B,OAAM,EAAGC,iBAAgB;AAG9E,SAAKxC,qBAAqBe,KAAKoD,UAAAA,EAAY5B,OAAM,EAAG0B,iBAAgB;AACpE,SAAKjE,qBAAqBe,KAAKqD,wBAAAA,EAA0B7B,OAAM,EAAGC,iBAAgB;AAClF,SAAKxC,qBAAqBe,KAAKsD,qBAAAA,EAAuB9B,OAAM,EAAGC,iBAAgB;AAC/E,SAAKxC,qBAAqBe,KAAKuD,sBAAAA,EAAwB/B,OAAM,EAAGC,iBAAgB;AAChF,SAAKxC,qBAAqBe,KAAKwD,oBAAAA,EAAsBhC,OAAM,EAAGC,iBAAgB;AAG9E,SAAKxC,qBAAqBe,KAAKyD,gBAAAA,EAAkBjC,OAAM,EAAG0B,iBAAgB;AAC1E,SAAKjE,qBAAqBe,KAAK0D,qBAAAA,EAAuBC,UAAU,CAACC,YAAAA;AAC7D,aAAO,CAACC,MAAeC,WAAAA;AACnB,cAAMC,UAAUH,QAAQI,UAAUrC,IAAI8B,gBAAAA;AACtCM,gBAAQE,QAAQJ;AAChBE,gBAAQG,UAAUJ;AAClB,eAAOC;MACX;IACJ,CAAA;AACA,SAAK9E,qBAAqBe,KAAKmE,iBAAAA,EAAmB3C,OAAM,EAAG0B,iBAAgB;AAC3E,SAAKjE,qBAAqBe,KAAKoE,sBAAAA,EAAwBT,UAAU,CAACC,YAAAA;AAC9D,aAAO,MAAA;AACH,eAAOA,QAAQI,UAAUrC,IAAIwC,iBAAAA;MACjC;IACJ,CAAA;AACA,SAAKlF,qBAAqBe,KAAKqE,oBAAAA,EAAsB7C,OAAM,EAAG0B,iBAAgB;AAC9E,SAAKjE,qBAAqBe,KAAKsE,yBAAAA,EAA2BX,UAAU,CAACC,YAAAA;AACjE,aAAO,CACHW,MACAC,UACAC,SACAV,SACAW,UACAC,SAAAA;AAEA,cAAMC,mBAAmBhB,QAAQI,UAAUrC,IAAI0C,oBAAAA;AAC/CO,yBAAiBC,QAAQN;AACzBK,yBAAiBE,WAAWf;AAC5Ba,yBAAiBG,YAAYL;AAC7BE,yBAAiBI,WAAWP;AAC5BG,yBAAiBK,YAAYT;AAC7BI,yBAAiBM,QAAQP;AACzB,eAAOC;MACX;IACJ,CAAA;AAGA,eAAWO,UAAU,KAAKhG,SAAS;AAC/B,WAAKF,qBAAqBe,KAAKmF,MAAAA,EAAQ3D,OAAM,EAAGC,iBAAgB;AAChE,YAAM2D,iBAAiB,KAAKnG,qBAAqB0C,IAAIwD,MAAAA;AACrD,UAAI,CAACC,eAAeC,QAAS;AAC7B,YAAMD,eAAeC,QAAO;IAChC;AAEA,QAAI,CAAC,KAAKpG,qBAAqBqG,QAAQrF,aAAAA,EAAgB,MAAKhB,qBAAqBe,KAAKC,aAAAA,EAAeC,gBAAgB,CAAA,CAAE;AACvH,QAAI,CAAC,KAAKjB,qBAAqBqG,QAAQ9E,mBAAAA,EACnC,MAAKvB,qBAAqBe,KAAKQ,mBAAAA,EAAqBN,gBAAgB,CAAA,CAAE;AAC1E,QAAI,CAAC,KAAKjB,qBAAqBqG,QAAQxE,YAAAA,EAAe,MAAK7B,qBAAqBe,KAAKc,YAAAA,EAAcZ,gBAAgB,CAAA,CAAE;AACrH,QAAI,CAAC,KAAKjB,qBAAqBqG,QAAQlE,oBAAAA,EACnC,MAAKnC,qBAAqBe,KAAKoB,oBAAAA,EAAsBlB,gBAAgB,CAAA,CAAE;AAE3E,WAAO,KAAKjB,qBAAqB0C,IAAIgB,GAAAA;EACzC;AACJ;;;AE5MA,SAAS4C,aAAAA,kBAAiB;AAQ1B,eAAsBC,iBAAuC,EACzDC,YACAC,SACAC,mBACAC,mBAAkB,GAMrB;AACG,QAAMC,uBAAuB,IAAIC,WAAAA;AAEjC,MAAIF,mBAAoBC,sBAAqBE,KAAKC,mBAAAA,EAAqBC,gBAAgBL,kBAAAA;AACvFC,uBAAqBE,KAAKG,OAAAA,EAASD,gBAAgBP,OAAAA;AAEnD,SAAO,IAAIC,kBAAkB;IACzBF;IACAI;IACAD;IACAF;EACJ,CAAA;AACJ;AAtBsBF;;;ACJf,SAASW,qBAAqBC,MAA6BC,MAAeC,WAA2B;AACxG,SAAyB,CAACC,QAAgBC,WAAAA;AACtC,QAAI,CAACC,MAAMJ,IAAAA,KAAS,CAACK,SAASL,IAAAA,GAAO;AACjC,YAAM,IAAIM,MAAMC,aAAaC,qBAAqB;IACtD;AAEAR,WAAOA,QAAQG;AAEf,UAAMM,SACFC,QAAQC,YAAsEC,gBAAgBC,kBAAkBX,MAAAA,KAAW,CAAA;AAE/H,QAAIO,OAAOK,KAAK,CAACC,UAAUA,MAAMZ,WAAWA,UAAUY,MAAMf,SAASA,QAAQe,MAAMhB,SAASA,IAAAA,GAAO;AAC/F,YAAM,IAAIO,MAAMC,aAAaS,qBAAqB;IACtD;AAEAN,YAAQO,eACJL,gBAAgBC,kBAChB;SAAIJ;MAAQ;QAAEN;QAAQH;QAAMD;QAAME;MAAU;OAC5CC,MAAAA;EAER;AACJ;AArBgBJ;;;ACFT,SAASoB,WAAWC,WAAiB;AACxC,SAAOC,qBAAqB,cAAcD,SAAAA;AAC9C;AAFgBD;;;ACAT,SAASG,UAAUC,IAAqBC,WAAkB;AAC7D,SAAOC,qBAAqB,aAAaD,WAAWD,EAAAA;AACxD;AAFgBD;;;ACAT,SAASI,GAAGC,WAAkB;AACjC,SAAOC,qBAAqB,MAAMD,SAAAA;AACtC;AAFgBD;;;ACAT,SAASG,aAAaC,WAAiB;AAC1C,SAAOC,qBAAqB,gBAAgBD,SAAAA;AAChD;AAFgBD;;;ACAT,SAASG,KAAKC,WAAkB;AACnC,SAAOC,qBAAqB,QAAQD,SAAAA;AACxC;AAFgBD;;;ACAT,SAASG,YAAYC,IAAqBC,WAAkB;AAC/D,SAAOC,qBAAqB,eAAeD,WAAWD,EAAAA;AAC1D;AAFgBD;;;ACMT,SAASI,QAAQC,OAA+B;AACnD,SAA4B,CAACC,QAAgBC,QAAgBC,UAAAA;AACzD,UAAMC,iBAA2C,CAAA;AACjD,eAAWC,QAAQL,OAAO;AACtB,YAAM,EAAEM,OAAOC,OAAOC,MAAK,IAAKC,aAAaJ,IAAAA;AAC7C,UAAI,CAACC,MAAO,OAAM,IAAII,MAAMF,KAAAA;AAC5BJ,qBAAeO,KAAKJ,KAAAA;IACxB;AAEA,UAAMK,SAASC,QAAQC,YAA+BC,gBAAgBC,kBAAkBf,QAAQC,MAAAA,KAAW,CAAA;AAE3G,QAAIU,OAAOK,KAAK,CAACC,UAAUA,MAAMf,UAAUA,KAAAA,GAAQ;AAC/C,YAAM,IAAIO,MAAMS,aAAaC,6CAA6C;IAC9E;AAEA,UAAMC,aAAaR,QAAQC,YAAuB,qBAAqBb,QAAQC,MAAAA;AAC/E,UAAMoB,WAAWC,MAAMC,QAAQH,UAAAA,IAAcA,WAAWlB,KAAAA,IAASsB;AAEjEZ,YAAQa,eACJX,gBAAgBC,kBAChB;SAAIJ;MAAQ;QAAET;QAAOD;QAAQF,OAAOI;QAAgBuB,MAAMC,gBAAgB7B;QAAM8B,MAAMJ;QAAWH;MAAS;OAC1GrB,QACAC,MAAAA;EAER;AACJ;AAzBgBH;;;ACCT,SAAS+B,MAAMC,QAAgBC,OAA+B;AACjE,SAA4B,CAACC,QAAgBC,QAAgBC,UAAAA;AACzD,QAAI,CAACC,SAASL,GAAAA,GAAM;AAChB,YAAM,IAAIM,MAAMC,aAAaC,oBAAoB;IACrD;AACA,UAAMC,iBAA2C,CAAA;AACjD,eAAWC,QAAQT,OAAO;AACtB,YAAM,EAAEU,OAAOC,OAAOC,MAAK,IAAKC,aAAaJ,IAAAA;AAC7C,UAAI,CAACC,MAAO,OAAM,IAAIL,MAAMO,KAAAA;AAC5BJ,qBAAeM,KAAKH,KAAAA;IACxB;AAEA,UAAMI,SAASC,QAAQC,YAA+BC,gBAAgBC,kBAAkBlB,QAAQC,MAAAA,KAAW,CAAA;AAE3G,QAAIa,OAAOK,KAAK,CAACC,UAAUA,MAAMlB,UAAUA,KAAAA,GAAQ;AAC/C,YAAM,IAAIE,MAAMC,aAAagB,6CAA6C;IAC9E;AAEA,UAAMC,aAAaP,QAAQC,YAAuB,qBAAqBhB,QAAQC,MAAAA;AAC/E,UAAMsB,WAAWC,MAAMC,QAAQH,UAAAA,IAAcA,WAAWpB,KAAAA,IAASwB;AAEjEX,YAAQY,eACJV,gBAAgBC,kBAChB;SAAIJ;MAAQ;QAAEZ;QAAOD;QAAQF,OAAOQ;QAAgBqB,MAAMC,gBAAgBhC;QAAOiC,MAAMhC;QAAKyB;MAAS;OACrGvB,QACAC,MAAAA;EAER;AACJ;AA5BgBJ;;;ACHT,SAASkC,UAAAA;AACZ,SAA4B,CAACC,QAAgBC,QAAgBC,UAAAA;AACzD,UAAMC,SAASC,QAAQC,YAA+BC,gBAAgBC,kBAAkBP,QAAQC,MAAAA,KAAW,CAAA;AAE3G,QAAIE,OAAOK,KAAK,CAACC,UAAUA,MAAMP,UAAUA,KAAAA,GAAQ;AAC/C,YAAM,IAAIQ,MAAMC,aAAaC,6CAA6C;IAC9E;AAEA,UAAMC,aAAaT,QAAQC,YAAuB,qBAAqBL,QAAQC,MAAAA;AAC/E,UAAMa,WAAWC,MAAMC,QAAQH,UAAAA,IAAcA,WAAWX,KAAAA,IAASe;AAEjEb,YAAQc,eACJZ,gBAAgBC,kBAChB;SAAIJ;MAAQ;QAAED;QAAOD;QAAQkB,MAAMC,gBAAgBrB;QAASsB,MAAMJ;QAAWH;MAAS;OACtFd,QACAC,MAAAA;EAER;AACJ;AAlBgBF;AAoBT,SAASuB,MAAAA;AACZ,SAAOvB,QAAAA;AACX;AAFgBuB;;;ACjBT,SAASC,MAAMC,QAAgBC,OAA+B;AACjE,SAA4B,CAACC,QAAgBC,QAAgBC,UAAAA;AACzD,QAAI,CAACC,SAASL,GAAAA,GAAM;AAChB,YAAM,IAAIM,MAAMC,aAAaC,oBAAoB;IACrD;AACA,UAAMC,iBAA2C,CAAA;AACjD,eAAWC,QAAQT,OAAO;AACtB,YAAM,EAAEU,OAAOC,OAAOC,MAAK,IAAKC,aAAaJ,IAAAA;AAC7C,UAAI,CAACC,MAAO,OAAM,IAAIL,MAAMO,KAAAA;AAC5BJ,qBAAeM,KAAKH,KAAAA;IACxB;AAEA,UAAMI,SAASC,QAAQC,YAA+BC,gBAAgBC,kBAAkBlB,QAAQC,MAAAA,KAAW,CAAA;AAE3G,QAAIa,OAAOK,KAAK,CAACC,UAAUA,MAAMlB,UAAUA,KAAAA,GAAQ;AAC/C,YAAM,IAAIE,MAAMC,aAAagB,6CAA6C;IAC9E;AAEA,UAAMC,aAAaP,QAAQC,YAAuB,qBAAqBhB,QAAQC,MAAAA;AAC/E,UAAMsB,WAAWC,MAAMC,QAAQH,UAAAA,IAAcA,WAAWpB,KAAAA,IAASwB;AAEjEX,YAAQY,eACJV,gBAAgBC,kBAChB;SAAIJ;MAAQ;QAAEZ;QAAOD;QAAQ2B,MAAM9B;QAAKC,OAAOQ;QAAgBsB,MAAMC,gBAAgBjC;QAAO0B;MAAS;OACrGvB,QACAC,MAAAA;EAER;AACJ;AA5BgBJ;;;ACHT,SAASkC,WAAAA;AACZ,SAA4B,CAACC,QAAgBC,QAAgBC,UAAAA;AACzD,UAAMC,SAASC,QAAQC,YAA+BC,gBAAgBC,kBAAkBP,QAAQC,MAAAA,KAAW,CAAA;AAE3G,QAAIE,OAAOK,KAAK,CAACC,UAAUA,MAAMP,UAAUA,KAAAA,GAAQ;AAC/C,YAAM,IAAIQ,MAAMC,aAAaC,6CAA6C;IAC9E;AAEA,UAAMC,aAAaT,QAAQC,YAAuB,qBAAqBL,QAAQC,MAAAA;AAC/E,UAAMa,WAAWC,MAAMC,QAAQH,UAAAA,IAAcA,WAAWX,KAAAA,IAASe;AAEjEb,YAAQc,eACJZ,gBAAgBC,kBAChB;SAAIJ;MAAQ;QAAED;QAAOD;QAAQkB,MAAMC,gBAAgBrB;QAAUsB,MAAMJ;QAAWH;MAAS;OACvFd,QACAC,MAAAA;EAER;AACJ;AAlBgBF;AAoBT,SAASuB,MAAAA;AACZ,SAAOvB,SAAAA;AACX;AAFgBuB;;;ACnBT,SAASC,aAAaC,QAAkC;AAC3D,SAA0C,CAACC,QAAgBC,QAAiBC,eAAAA;AACxE,UAAMC,kBAA8C,CAAA;AACpD,eAAWC,SAASL,QAAQ;AACxB,YAAM,EAAEM,OAAOC,OAAOC,MAAK,IAAKC,cAAcJ,KAAAA;AAC9C,UAAI,CAACC,MAAO,OAAM,IAAII,MAAMF,KAAAA;AAC5BJ,sBAAgBO,KAAKJ,KAAAA;IACzB;AAEA,QAAI,CAACK,MAAMT,UAAAA,KAAe,CAACS,MAAMT,WAAWI,KAAK,GAAG;AAChD,UAAIP,OAAOa,WAAW,GAAG;AACrB,cAAM,IAAIH,MAAMI,aAAaC,uBAAuB;MACxD;AAEA,YAAMC,eAAeC,QAAQC,YAA8BC,gBAAgBC,QAAQnB,OAAO,aAAaC,MAAAA,KAAW,CAAA;AAClHe,cAAQI,eAAeF,gBAAgBC,QAAQ;WAAIhB;WAAoBY;SAAef,OAAO,aAAaC,MAAAA;AAC1G,aAAOC;IACX;AAEA,QAAIH,OAAOa,WAAW,GAAG;AACrB,YAAM,IAAIH,MAAMI,aAAaC,uBAAuB;IACxD;AAEA,UAAMO,cAAcL,QAAQC,YAA8BC,gBAAgBC,QAAQnB,MAAAA,KAAW,CAAA;AAC7FgB,YAAQI,eAAeF,gBAAgBC,QAAQ;SAAIhB;SAAoBkB;OAAcrB,MAAAA;AACrF,WAAOA;EACX;AACJ;AA3BgBF;;;ACAT,SAASwB,mBAAmBC,cAAoD;AACnF,SAA0C,CAACC,QAAgBC,QAAiBC,eAAAA;AACxE,UAAMC,wBAAgE,CAAA;AACtE,eAAWC,eAAeL,cAAc;AACpC,YAAM,EAAEM,OAAOC,OAAOC,MAAK,IAAKC,oBAAoBJ,WAAAA;AACpD,UAAI,CAACC,MAAO,OAAM,IAAII,MAAMF,KAAAA;AAC5BJ,4BAAsBO,KAAKJ,KAAAA;IAC/B;AAEA,QAAI,CAACK,MAAMT,UAAAA,KAAe,CAACS,MAAMT,WAAWI,KAAK,GAAG;AAChD,UAAIP,aAAaa,WAAW,GAAG;AAC3B,cAAM,IAAIH,MAAMI,aAAaC,6BAA6B;MAC9D;AAEA,YAAMC,qBACFC,QAAQC,YAAoCC,gBAAgBC,cAAcnB,OAAO,aAAaC,MAAAA,KAAW,CAAA;AAC7Ge,cAAQI,eACJF,gBAAgBC,cAChB;WAAIhB;WAA0BY;SAC9Bf,OAAO,aACPC,MAAAA;AAEJ,aAAOC;IACX;AAEA,QAAIH,aAAaa,WAAW,GAAG;AAC3B,YAAM,IAAIH,MAAMI,aAAaC,6BAA6B;IAC9D;AAEA,UAAMO,oBAAoBL,QAAQC,YAAoCC,gBAAgBC,cAAcnB,MAAAA,KAAW,CAAA;AAC/GgB,YAAQI,eAAeF,gBAAgBC,cAAc;SAAIhB;SAA0BkB;OAAoBrB,MAAAA;AACvG,WAAOA;EACX;AACJ;AAjCgBF;;;ACAT,SAASwB,YAAYC,OAA+B;AACvD,SAA0C,CAACC,QAAgBC,QAAiBC,eAAAA;AACxE,UAAMC,iBAA2C,CAAA;AACjD,eAAWC,QAAQL,OAAO;AACtB,YAAM,EAAEM,OAAOC,OAAOC,MAAK,IAAKC,aAAaJ,IAAAA;AAC7C,UAAI,CAACC,MAAO,OAAM,IAAII,MAAMF,KAAAA;AAC5BJ,qBAAeO,KAAKJ,KAAAA;IACxB;AAEA,QAAI,CAACK,MAAMT,UAAAA,KAAe,CAACS,MAAMT,WAAWI,KAAK,GAAG;AAChD,UAAIP,MAAMa,WAAW,GAAG;AACpB,cAAM,IAAIH,MAAMI,aAAaC,sBAAsB;MACvD;AAEA,YAAMC,cAAcC,QAAQC,YAA6BC,gBAAgBC,OAAOnB,OAAO,aAAaC,MAAAA,KAAW,CAAA;AAC/Ge,cAAQI,eAAeF,gBAAgBC,OAAO;WAAIhB;WAAmBY;SAAcf,OAAO,aAAaC,MAAAA;AACvG,aAAOC;IACX;AAEA,QAAIH,MAAMa,WAAW,GAAG;AACpB,YAAM,IAAIH,MAAMI,aAAaC,sBAAsB;IACvD;AAEA,UAAMO,aAAaL,QAAQC,YAA6BC,gBAAgBC,OAAOnB,MAAAA,KAAW,CAAA;AAC1FgB,YAAQI,eAAeF,gBAAgBC,OAAO;SAAIhB;SAAmBkB;OAAarB,MAAAA;AAClF,WAAOA;EACX;AACJ;AA3BgBF;;;ACHT,SAASwB,mBAAmBC,MAA2BC,MAAeC,WAA2B;AACpG,SAAyB,CAACC,QAAgBC,WAAAA;AACtC,QAAI,CAACC,MAAMH,SAAAA,KAAc,CAACI,SAASJ,SAAAA,KAAc,CAACK,SAASL,SAAAA,GAAY;AACnE,YAAM,IAAIM,MAAMC,aAAaC,6BAA6B;IAC9D;AAEA,QAAI,CAACL,MAAMJ,IAAAA,KAAS,CAACK,SAASL,IAAAA,GAAO;AACjC,YAAM,IAAIO,MAAMC,aAAaE,mBAAmB;IACpD;AAEAV,WAAOA,QAAQG;AAEf,UAAMQ,OACFC,QAAQC,YAAoEC,gBAAgBC,gBAAgBb,MAAAA,KAAW,CAAA;AAE3H,QAAIS,KAAKK,KAAK,CAACC,QAAQA,IAAId,WAAWA,UAAUc,IAAIjB,SAASA,QAAQiB,IAAIlB,SAASA,IAAAA,GAAO;AACrF,YAAM,IAAIQ,MAAMC,aAAaU,mBAAmB;IACpD;AAEAN,YAAQO,eACJL,gBAAgBC,gBAChB;SAAIJ;MAAM;QAAER;QAAQH;QAAMD;QAAME;MAAU;OAC1CC,MAAAA;EAER;AACJ;AAzBgBJ;;;ACFT,SAASsB,UAAUC,SAAgB;AACtC,SAAOC,mBAAmB,aAAaD,OAAAA;AAC3C;AAFgBD;;;ACAT,SAASG,iBAAiBC,IAAqBC,SAAgB;AAClE,SAAOC,mBAAmB,oBAAoBD,SAASD,EAAAA;AAC3D;AAFgBD;;;ACET,SAASI,qBAAqBC,MAA6BC,MAAeC,SAAkC;AAC/G,SAAyB,CAACC,QAAgBC,WAAAA;AACtC,QAAI,CAACC,MAAMJ,IAAAA,KAAS,CAACK,SAASL,IAAAA,GAAO;AACjC,YAAM,IAAIM,MAAMC,aAAaC,qBAAqB;IACtD;AAEAR,WAAOA,QAAQG;AAEf,UAAMM,SAASC,QAAQC,YAA6BC,gBAAgBC,QAAQX,MAAAA,KAAW,CAAA;AAEvF,QAAIO,OAAOK,KAAK,CAACC,UAAUA,MAAMZ,WAAWA,UAAUY,MAAMf,SAASA,QAAQe,MAAMhB,SAASA,IAAAA,GAAO;AAC/F,YAAM,IAAIO,MAAMC,aAAaS,qBAAqB;IACtD;AAEAN,YAAQO,eACJL,gBAAgBC,QAChB;SAAIJ;MAAuB;QAAEN;QAAQH;QAAMD;QAAME;MAAQ;OACzDC,MAAAA;EAER;AACJ;AApBgBJ;;;ACDT,SAASoB,KAAKC,SAAwBC,UAAuB,CAAC,GAAC;AAClE,SAAOC,qBAAqB,QAAQD,QAAQE,MAAM;IAAEH;IAAS,GAAGC;EAAQ,CAAA;AAC5E;AAFgBF;;;ACDT,SAASK,UAAUC,MAAa;AACnC,SAAOC,qBAAqB,aAAaD,IAAAA;AAC7C;AAFgBD;;;ACGT,SAASG,SAASC,eAAgCC,SAAgB;AACrE,QAAM,CAACC,MAAMC,eAAAA,IAAmBC,SAASJ,aAAAA,IAAiB;IAACA;IAAeC;MAAW;IAACI;IAAWL;;AACjG,SAAOM,qBAAqB,YAAYJ,MAAM;IAAED,SAASE;EAAiB,CAAA;AAC9E;AAHgBJ;;;ACAT,SAASQ,QAAQC,eAAgCC,SAAgB;AACpE,QAAM,CAACC,MAAMC,eAAAA,IAAmBC,SAASJ,aAAAA,IAAiB;IAACA;IAAeC;MAAW;IAACI;IAAWL;;AACjG,SAAOM,qBAAqB,WAAWJ,MAAM;IAAED,SAASE;EAAiB,CAAA;AAC7E;AAHgBJ;;;ACLT,SAASQ,mBAAmBC,YAAoE;AACnG,SAAO,CACHC,QACAC,aACAC,eAAAA;AAEA,eAAWC,aAAaJ,YAAY;AAChC,UAAIC,kBAAkBI,YAAY,CAACF,YAAY;AAC1BC,kBAAWH,MAAAA;AAC5B;MACJ;AACsCG,gBAAWH,QAAQC,aAAaC,UAAAA;IAC1E;EACJ;AACJ;AAdgBJ;;;ACQT,SAASO,qBAA0DC,SAAyD;AAC/H,SAAO,CAAmBC,SAAkBC,UAAAA;AACxC,WAA4B,CAACC,QAAgBC,QAAgBC,UAAAA;AACzD,YAAMC,iBAA2C,CAAA;AACjD,iBAAWC,QAAQL,OAAO;AACtB,cAAM,EAAEM,OAAOC,OAAOC,MAAK,IAAKC,aAAaJ,IAAAA;AAC7C,YAAI,CAACC,MAAO,OAAM,IAAII,MAAMF,KAAAA;AAC5BJ,uBAAeO,KAAKJ,KAAAA;MACxB;AAEA,YAAMK,SAASC,QAAQC,YAA+BC,gBAAgBC,kBAAkBf,QAAQC,MAAAA,KAAW,CAAA;AAE3G,UAAIU,OAAOK,KAAK,CAACC,UAAUA,MAAMf,UAAUA,KAAAA,GAAQ;AAC/C,cAAM,IAAIO,MAAMS,aAAaC,6CAA6C;MAC9E;AAEA,YAAMC,aAAaR,QAAQC,YAAuB,qBAAqBb,QAAQC,MAAAA;AAC/E,YAAMoB,WAAWC,MAAMC,QAAQH,UAAAA,IAAcA,WAAWlB,KAAAA,IAASsB;AAEjEZ,cAAQa,eACJX,gBAAgBC,kBAChB;WACOJ;QACH;UACIT;UACAD;UACAF,OAAOI;UACPuB,MAAMC,gBAAgBC;UACtB/B;UACAC;UACAuB;QACJ;SAEJrB,QACAC,MAAAA;IAER;EACJ;AACJ;AAtCgBL;;;ACRhB,SAASiC,6BAA8C;AAEhD,SAASC,WAAwBC,IAAyC;AAC7E,SAAO,IAAIC,sBAAyBD,EAAAA;AACxC;AAFgBD;;;;;;;;;;A9CKT,IAAMG,mBAAN,MAAMA;SAAAA;;;EACFC,IAA8DC,aAAmBC,QAA4B;AAChH,WAAOC,QAAQC,YAAqBH,aAAaC,MAAAA;EACrD;EAEOG,OACHJ,aACAK,SACF;AACE,YAAiBA,WAAW,CAAA,GAAIC,IAAI,CAACL,WAAW,KAAKF,IAAIC,aAAaC,MAAAA,CAAAA;EAC1E;EAEOM,eACHP,aACAK,SACF;AACE,UAAMG,qBAAqB,KAAKJ,OAAsBJ,aAAaK,OAAAA,EAASI,OAAO,CAACC,SAASA,SAASC,MAAAA;AAEtG,QAAIC,QAAQJ,kBAAAA,EAAqB,QAAgBA;AAEjD,WAAgBA,mBAAmBK,OAAO,CAACC,GAAGC,MAAAA;AAC1C,UAAIC,MAAMC,QAAQH,CAAAA,GAAI;AAClB,eAAOA,EAAEI,OAAOH,CAAAA;MACpB;AACA,UAAII,SAASL,CAAAA,KAAMK,SAASJ,CAAAA,GAAI;AAC5B,eAAO;UACH,GAAGD;UACH,GAAGC;QACP;MACJ;AACA,aAAO;QAACD;QAAGC;;IACf,CAAA;EACJ;EAEOK,kBAA4EpB,aAAmBK,SAAiC;AACnI,eAAWJ,UAAUI,SAAS;AAC1B,YAAMgB,SAAS,KAAKtB,IAAIC,aAAaC,MAAAA;AACrC,UAAIoB,WAAWV,OAAW,QAAgBU;IAC9C;AACA,WAAOV;EACX;EAMA,OAAcW,gBACVC,UAAwD,CAAC,GACf;AAC1C,UAAMvB,cAAcuB,QAAQC,OAAOC,iBAAAA;AACnC,UAAMC,cAAc,wBAACC,kBAA0B,CAAC1B,QAA2BuB,KAAuBI,eAAAA;AAC9F,YAAMC,QAAQN,QAAQO,YAAYP,QAAQO,UAAUH,aAAAA,IAAiBA;AACrEI,kBAAY/B,aAAa6B,SAAS,CAAC,CAAA,EAAG5B,QAAQuB,KAAMI,UAAAA;IACxD,GAHoB;AAKpBF,gBAAYM,MAAMhC;AAClB,WAAO0B;EACX;AACJ;;;;;;A+CjEA,SAASO,UAAAA,SAAQC,cAAAA,mBAAkB;AAEnC,SAASC,QAAAA,aAA8B;;;;;;;;;;;;AAIhC,IAAMC,eAAN,MAAMA;SAAAA;;;EACqCC;EAC7BC,cAAc,oBAAIC,IAAAA;EAClBC,aAAa,oBAAID,IAAAA;EACjBE,YAAY,oBAAIF,IAAAA;EAChBG,SAAS,oBAAIH,IAAAA;EAE9B,IAAWI,MAAM;AACb,WAAO,KAAKN,mBAAmBO,OAAOD;EAC1C;EAEA,IAAWE,aAAa;AACpB,WAAO;SAAI,KAAKP,YAAYQ,OAAM;;EACtC;EAEA,IAAWC,YAAY;AACnB,WAAO;SAAI,KAAKP,WAAWM,OAAM;;EACrC;EAEA,IAAWE,WAAW;AAClB,WAAO;SAAI,KAAKP,UAAUK,OAAM;;EACpC;EAEA,IAAWG,QAAQ;AACf,WAAO;SAAI,KAAKP,OAAOI,OAAM;;EACjC;EAEA,IAAWI,iBAAiBC,OAAe;AACvC,SAAKd,mBAAmBO,OAAOM,mBAAmBC;EACtD;EAEA,IAAWD,mBAAmB;AAC1B,WAAO,KAAKb,mBAAmBO,OAAOM;EAC1C;EAEA,IAAWE,6BAA6BD,OAAe;AACnD,SAAKd,mBAAmBO,OAAOQ,+BAA+BD;EAClE;EAEA,IAAWC,+BAA+B;AACtC,WAAO,KAAKf,mBAAmBO,OAAOQ;EAC1C;EAEOC,cAAcC,UAAoBC,SAAmD;AACxF,UAAM,EAAEC,SAAS,GAAGC,YAAAA,IAAgBF;AAEpC,UAAMG,OAAOC,MAAKH,SAASC,aAAaH,QAAAA;AACxC,QAAIM,SAASL,QAAQM,IAAI,EAAG,MAAKnB,OAAOoB,IAAIP,QAAQM,MAAMH,IAAAA;AAE1D,WAAOA;EACX;EAEOK,eAAeT,UAAoBU,UAAkBH,MAAe;AACvE,UAAMI,QAAQ,KAAK5B,mBAAmBO,OAAOsB,YAAYZ,UAAUU,QAAAA;AACnE,QAAIJ,SAASC,IAAAA,EAAO,MAAKrB,WAAWsB,IAAID,MAAMI,KAAAA;AAC9C,WAAOA;EACX;EAEOE,cAAcb,UAAoBc,SAAiBP,MAAe;AACrE,UAAMI,QAAQ,KAAK5B,mBAAmBO,OAAOyB,WAAWf,UAAUc,OAAAA;AAClE,QAAIR,SAASC,IAAAA,EAAO,MAAKpB,UAAUqB,IAAID,MAAMI,KAAAA;AAC7C,WAAOA;EACX;EAEOK,gBAAgBhB,UAAoBO,MAAe;AACtD,UAAMI,QAAQ,KAAK5B,mBAAmBO,OAAO2B,UAAUjB,QAAAA;AACvD,QAAIM,SAASC,IAAAA,EAAO,MAAKvB,YAAYwB,IAAID,MAAMI,KAAAA;AAC/C,WAAOA;EACX;EAEOO,OAAOC,MAAqDZ,MAAc;AAC7E,YAAQY,MAAAA;MACJ,KAAK;AACD,cAAMC,UAAU,KAAKhC,OAAOiC,IAAId,IAAAA;AAChC,YAAIa,SAAS;AACTA,kBAAQE,KAAI;AACZ,eAAKlC,OAAO8B,OAAOX,IAAAA;QACvB;AACA;MACJ,KAAK;AACD,cAAMgB,YAAY,KAAKvC,YAAYqC,IAAId,IAAAA;AACvC,YAAIgB,WAAW;AACXA,oBAAUC,QAAO;AACjB,eAAKxC,YAAYkC,OAAOX,IAAAA;QAC5B;AACA;MACJ,KAAK;AACD,cAAMG,WAAW,KAAKxB,WAAWmC,IAAId,IAAAA;AACrC,YAAIG,UAAU;AACVA,mBAASc,QAAO;AAChB,eAAKtC,WAAWgC,OAAOX,IAAAA;QAC3B;AACA;MACJ,KAAK;AACD,cAAMO,UAAU,KAAK3B,UAAUkC,IAAId,IAAAA;AACnC,YAAIO,SAAS;AACTA,kBAAQU,QAAO;AACf,eAAKrC,UAAU+B,OAAOX,IAAAA;QAC1B;AACA;IACR;EACJ;EAEOkB,UAAUN,MAAqDZ,MAAc;AAChF,YAAQY,MAAAA;MACJ,KAAK;AACD,eAAO,KAAK/B,OAAOiC,IAAId,IAAAA;MAC3B,KAAK;AACD,eAAO,KAAKvB,YAAYqC,IAAId,IAAAA;MAChC,KAAK;AACD,eAAO,KAAKrB,WAAWmC,IAAId,IAAAA;MAC/B,KAAK;AACD,eAAO,KAAKpB,UAAUkC,IAAId,IAAAA;IAClC;EACJ;EAEOmB,QAAQC,IAAY;AACvB,WAAO,KAAK5C,mBAAmBO,OAAOsC,QAAQD,EAAAA;EAClD;EAEOE,KAAKtB,MAAe;AACvB,WAAO,KAAKxB,mBAAmBO,OAAOuC,KAAKtB,IAAAA;EAC/C;EAEOuB,QAAQvB,MAAe;AAC1B,WAAO,KAAKxB,mBAAmBO,OAAOwC,QAAQvB,IAAAA;EAClD;AACJ;;;;;;;;",
  "names": ["injectable", "injectable", "Controller", "options", "target", "Reflect", "hasMetadata", "CoreMetadataKey", "Error", "ErrorMessage", "DuplicateDecoratorUsage", "valid", "value", "error", "validateControllerOptions", "defineMetadata", "injectable", "Global", "target", "Reflect", "defineMetadata", "CoreMetadataKey", "GlobalModule", "inject", "Inject", "key", "target", "propertyKey", "paramIndex", "isNil", "validateInjectionToken", "valid", "Error", "ErrorMessage", "InvalidInjectionTokenSpecified", "token", "Reflect", "getMetadata", "InjectionTokenNotFound", "inject", "injectable", "Injectable", "options", "target", "Reflect", "hasMetadata", "CoreMetadataKey", "Error", "ErrorMessage", "DuplicateDecoratorUsage", "valid", "value", "error", "validateInjectableMetadata", "defineMetadata", "injectable", "injectable", "Module", "options", "target", "Reflect", "hasMetadata", "CoreMetadataKey", "Error", "ErrorMessage", "DuplicateDecoratorUsage", "valid", "value", "error", "validateModuleOptions", "defineMetadata", "injectable", "optional", "Optional", "target", "propertyKey", "paramIndex", "optional", "SetMetadata", "key", "value", "decoratorFactory", "target", "_method", "descriptor", "Reflect", "defineMetadata", "KEY", "Catch", "exceptions", "target", "Reflect", "hasMetadata", "CoreMetadataKey", "Error", "ErrorMessage", "DuplicateDecoratorUsage", "duplicates", "filter", "exception", "index", "indexOf", "length", "ExceptionHandlingConflict", "defineMetadata", "UseFilters", "filters", "target", "method", "descriptor", "validatedFilters", "filter", "valid", "value", "error", "validateErrorFilter", "Error", "push", "isNil", "length", "ErrorMessage", "AtLeastOneFilterRequired", "methodFilters", "Reflect", "getMetadata", "CoreMetadataKey", "ErrorFilters", "find", "includes", "DuplicateErrorFilterDetected", "defineMetadata", "classFilters", "inject", "injectable", "optional", "AppRuntime", "eventHandler", "rpcHandler", "globalGuards", "globalInterceptors", "globalPipes", "globalErrorFilters", "loggerService", "enableShutdownHooks", "boot", "resolvedTree", "asyncTraverse", "node", "startTime", "Date", "now", "module", "value", "instance", "container", "get", "metadata", "classRef", "controllers", "forEach", "controller", "internalProviders", "externalProviders", "token", "log", "name", "runLifecycleMethod", "runLifecycleMethods", "traverse", "time", "registerTimers", "registerListeners", "shutdown", "timerService", "owner", "TIMER_SERVICE", "everyticks", "timer", "destroy", "intervals", "timeouts", "crons", "cron", "stop", "eventHandlers", "handler", "rpcHandlers", "events", "event", "guards", "interceptors", "pipes", "mappedErrorFilters", "mapErrorFilters", "errorFilters", "registerEvent", "push", "rpcs", "rpc", "registerRPC", "timers", "type", "createCronJob", "method", "bind", "options", "createEveryTick", "createInterval", "timeout", "createTimeout", "filterMap", "filter", "errors", "Reflect", "getMetadata", "CoreMetadataKey", "Catch", "length", "error", "isNil", "find", "filterError", "Error", "ErrorMessage", "ErrorAlreadyHandledByFilter", "Promise", "all", "map", "isObject", "providerInstance", "Container", "inject", "injectable", "optional", "ModuleDependencyBinder", "globalAppContainer", "loggerService", "containerOptions", "bind", "resolvedTree", "asyncTraverse", "node", "startTime", "Date", "now", "module", "value", "container", "ModuleContainer", "metadata", "parent", "classRef", "toSelf", "inSingletonScope", "global", "_", "provider", "externalProviders", "bindProvider", "token", "toDynamicValue", "get", "importModule", "repetitiveImports", "internalProviders", "MODULE_CONTAINER", "toConstantValue", "controllers", "TIMER_SERVICE", "to", "TimerService", "log", "name", "provide", "useValue", "binding", "ctx", "deps", "inject", "map", "dep", "isObject", "err", "optional", "undefined", "error", "useFactory", "scope", "inTransientScope", "inRequestScope", "useClass", "toService", "useExisting", "inject", "injectable", "ModuleTreeScanner", "moduleMetadataReader", "controllerMetadataReader", "loggerService", "scan", "classRef", "startTime", "Date", "now", "moduleMetadata", "read", "module", "Module", "metadata", "log", "name", "scanControllers", "moduleTree", "Tree", "scannedModules", "Map", "set", "importedModule", "imports", "scanModules", "root", "parentNode", "scannedModule", "get", "isNil", "value", "repetitiveImports", "add", "checkCircularDependency", "parent", "treeNode", "TreeNode", "addChild", "importModule", "controllers", "controllerMetadata", "controller", "Controller", "owner", "push", "parentMetadata", "includes", "Error", "ErrorMessage", "CircularDependencyDetected", "RageMPScriptEvent", "eventName", "listener", "destroy", "mp", "events", "remove", "RageMPEventEmmiter", "emit", "eventName", "args", "mp", "events", "call", "on", "listener", "add", "RageMPScriptEvent", "once", "onceWrapper", "remove", "off", "RageMPTimer", "lastTick", "Date", "now", "id", "interval", "once", "callback", "clearTimer", "destroy", "RageMPTimers", "timerIncrementer", "timers", "Map", "everyTickHandlers", "isEveryTickRunning", "everyTickMainHandler", "all", "values", "warningThreshold", "_value", "sourceLocationFrameSkipCount", "getByID", "id", "timer", "get", "createTimer", "clear", "callback", "interval", "once", "args", "callbackBind", "bind", "Array", "isArray", "timerId", "rageMPTimer", "RageMPTimer", "delete", "set", "setInterval", "time", "cb", "clearInterval", "setTimeout", "clearTimeout", "everyTick", "bound", "isClientSide", "mp", "browsers", "handler", "e", "console", "logError", "events", "add", "intervalHandler", "_everyTickInterval", "size", "remove", "nextTick", "_name", "timeEnd", "RageMPMultiplayerService", "Timers", "Events", "RageMPEventEmmiter", "RageMPTimers", "parseInternalArgs", "args", "player", "isObject", "undefined", "body", "log", "arg", "message", "map", "a", "JSON", "stringify", "String", "join", "mp", "console", "logInfo", "logError", "logWarning", "logDebug", "Container", "Container", "inject", "injectable", "App", "moduleTreeScanner", "moduleDependencyBinder", "appRuntime", "internalAppContainer", "plugins", "loggerService", "moduleTree", "loaded", "start", "rootModule", "error", "Error", "ErrorMessage", "AppAlreadyLoaded", "log", "runPluginMethods", "scan", "bind", "boot", "stop", "AppNotLoaded", "shutdown", "method", "Promise", "all", "map", "p", "plugin", "get", "resolve", "AppBuilder", "enviroment", "internalAppContainer", "multiplayerService", "plugins", "globalContainerOptions", "config", "useGlobalGuards", "guards", "validatedGuards", "guard", "valid", "value", "error", "validateGuard", "Error", "push", "bind", "GLOBAL_GUARDS", "toConstantValue", "useGlobalInterceptors", "interceptors", "validatedInterceptors", "interceptor", "validateInterceptor", "GLOBAL_INTERCEPTORS", "useGlobalPipes", "pipes", "validatedPipes", "pipe", "validatePipe", "GLOBAL_PIPES", "useGlobalFilters", "filters", "validatedFIlters", "filter", "validateErrorFilter", "GLOBAL_ERROR_FILTERS", "usePlugins", "forEach", "p", "toSelf", "inSingletonScope", "internalPlugins", "get", "PLUGINS", "rebind", "enableShutdownHooks", "ENABLE_SHUTDOWN_HOOKS", "setContainerOptions", "options", "onlyGlobal", "CONTAINER_OPTIONS", "build", "globalAppContainer", "Container", "REFLECTOR_SERVICE", "ReflectorService", "toService", "MULTIPLAYER_SERVICE", "App", "GLOBAL_APP_CONTAINER", "ModuleTreeScanner", "ModuleDependencyBinder", "AppRuntime", "PipelineHandler", "Module", "inTransientScope", "ModuleMetadataReader", "Controller", "ControllerMetadataReader", "ControllerFlowHandler", "ControllerEventHandler", "ControllerRPCHandler", "MangoRequestBase", "MANGO_REQUEST_FACTORY", "toFactory", "context", "body", "player", "request", "container", "$body", "$player", "MangoResponseBase", "MANGO_RESPONSE_FACTORY", "ExecutionContextBase", "EXECUTION_CONTEXT_FACTORY", "type", "classRef", "handler", "response", "name", "executionContext", "$type", "$request", "$response", "$handler", "$classRef", "$name", "plugin", "pluginInstance", "onBuild", "isBound", "Container", "createAppBuilder", "enviroment", "plugins", "appBuilderInherit", "multiplayerService", "internalAppContainer", "Container", "bind", "MULTIPLAYER_SERVICE", "toConstantValue", "PLUGINS", "createEventDecorator", "type", "name", "webViewId", "target", "method", "isNil", "isString", "Error", "ErrorMessage", "EventNameMustBeString", "events", "Reflect", "getMetadata", "CoreMetadataKey", "ControllerEvents", "some", "event", "EventNameMustBeUnique", "defineMetadata", "OnInternal", "eventName", "createEventDecorator", "OnWebView", "id", "eventName", "createEventDecorator", "On", "eventName", "createEventDecorator", "OnceInternal", "eventName", "createEventDecorator", "Once", "eventName", "createEventDecorator", "OnceWebView", "id", "eventName", "createEventDecorator", "Body", "pipes", "target", "method", "index", "validatedPipes", "pipe", "valid", "value", "error", "validatePipe", "Error", "push", "params", "Reflect", "getMetadata", "CoreMetadataKey", "ControllerParams", "some", "param", "ErrorMessage", "MultipleDecoratorsOnSingleParameterNotAllowed", "paramTypes", "metatype", "Array", "isArray", "undefined", "defineMetadata", "type", "MethodParamType", "data", "Index", "key", "pipes", "target", "method", "index", "isNumber", "Error", "ErrorMessage", "IndexKeyMustBeNumber", "validatedPipes", "pipe", "valid", "value", "error", "validatePipe", "push", "params", "Reflect", "getMetadata", "CoreMetadataKey", "ControllerParams", "some", "param", "MultipleDecoratorsOnSingleParameterNotAllowed", "paramTypes", "metatype", "Array", "isArray", "undefined", "defineMetadata", "type", "MethodParamType", "data", "Request", "target", "method", "index", "params", "Reflect", "getMetadata", "CoreMetadataKey", "ControllerParams", "some", "param", "Error", "ErrorMessage", "MultipleDecoratorsOnSingleParameterNotAllowed", "paramTypes", "metatype", "Array", "isArray", "undefined", "defineMetadata", "type", "MethodParamType", "data", "Req", "Param", "key", "pipes", "target", "method", "index", "isString", "Error", "ErrorMessage", "ParamKeyMustBeString", "validatedPipes", "pipe", "valid", "value", "error", "validatePipe", "push", "params", "Reflect", "getMetadata", "CoreMetadataKey", "ControllerParams", "some", "param", "MultipleDecoratorsOnSingleParameterNotAllowed", "paramTypes", "metatype", "Array", "isArray", "undefined", "defineMetadata", "data", "type", "MethodParamType", "Response", "target", "method", "index", "params", "Reflect", "getMetadata", "CoreMetadataKey", "ControllerParams", "some", "param", "Error", "ErrorMessage", "MultipleDecoratorsOnSingleParameterNotAllowed", "paramTypes", "metatype", "Array", "isArray", "undefined", "defineMetadata", "type", "MethodParamType", "data", "Res", "UseGuards", "guards", "target", "method", "descriptor", "validatedGuards", "guard", "valid", "value", "error", "validateGuard", "Error", "push", "isNil", "length", "ErrorMessage", "AtLeastOneGuardRequired", "methodGuards", "Reflect", "getMetadata", "CoreMetadataKey", "Guards", "defineMetadata", "classGuards", "UseInterceptors", "interceptors", "target", "method", "descriptor", "validatedInterceptors", "interceptor", "valid", "value", "error", "validateInterceptor", "Error", "push", "isNil", "length", "ErrorMessage", "AtLeastOneInterceptorRequired", "methodInterceptors", "Reflect", "getMetadata", "CoreMetadataKey", "Interceptors", "defineMetadata", "classInterceptors", "UsePipes", "pipes", "target", "method", "descriptor", "validatedPipes", "pipe", "valid", "value", "error", "validatePipe", "Error", "push", "isNil", "length", "ErrorMessage", "AtLeastOnePipeRequired", "methodPipes", "Reflect", "getMetadata", "CoreMetadataKey", "Pipes", "defineMetadata", "classPipes", "createRPCDecorator", "type", "name", "webViewId", "target", "method", "isNil", "isString", "isNumber", "Error", "ErrorMessage", "WebViewIdMustBeStringOrNumber", "RPCNameMustBeString", "rpcs", "Reflect", "getMetadata", "CoreMetadataKey", "ControllerRPCs", "some", "rpc", "RPCNameMustBeUnique", "defineMetadata", "OnRequest", "rpcName", "createRPCDecorator", "OnWebViewRequest", "id", "rpcName", "createRPCDecorator", "createTimerDecorator", "type", "name", "options", "target", "method", "isNil", "isString", "Error", "ErrorMessage", "TimerNameMustBeString", "timers", "Reflect", "getMetadata", "CoreMetadataKey", "Timers", "some", "timer", "EventNameMustBeUnique", "defineMetadata", "Cron", "pattern", "options", "createTimerDecorator", "name", "EveryTick", "name", "createTimerDecorator", "Interval", "nameOrTimeout", "timeout", "name", "intervalTimeout", "isString", "undefined", "createTimerDecorator", "Timeout", "nameOrTimeout", "timeout", "name", "intervalTimeout", "isString", "undefined", "createTimerDecorator", "applyDecorators", "decorators", "target", "propertyKey", "descriptor", "decorator", "Function", "createParamDecorator", "factory", "data", "pipes", "target", "method", "index", "validatedPipes", "pipe", "valid", "value", "error", "validatePipe", "Error", "push", "params", "Reflect", "getMetadata", "CoreMetadataKey", "ControllerParams", "some", "param", "ErrorMessage", "MultipleDecoratorsOnSingleParameterNotAllowed", "paramTypes", "metatype", "Array", "isArray", "undefined", "defineMetadata", "type", "MethodParamType", "Custom", "LazyServiceIdentifier", "forwardRef", "fn", "LazyServiceIdentifier", "ReflectorService", "get", "metadataKey", "target", "Reflect", "getMetadata", "getAll", "targets", "map", "getAllAndMerge", "metadataCollection", "filter", "item", "undefined", "isEmpty", "reduce", "a", "b", "Array", "isArray", "concat", "isObject", "getAllAndOverride", "result", "createDecorator", "options", "key", "generateRandomId", "decoratorFn", "metadataValue", "descriptor", "value", "transform", "SetMetadata", "KEY", "inject", "injectable", "Cron", "TimerService", "multiplayerService", "$everyticks", "Map", "$intervals", "$timeouts", "$crons", "all", "Timers", "everyticks", "values", "intervals", "timeouts", "crons", "warningThreshold", "value", "sourceLocationFrameSkipCount", "createCronJob", "callback", "options", "pattern", "cronOptions", "cron", "Cron", "isString", "name", "set", "createInterval", "interval", "timer", "setInterval", "createTimeout", "timeout", "setTimeout", "createEveryTick", "everyTick", "delete", "type", "cronJob", "get", "stop", "everytick", "destroy", "getByName", "getById", "id", "getByID", "time", "timeEnd"]
}
