@ragemp-mango/client 5.1.0 → 5.1.2

package/dist/index.js

@@ -7809,7 +7809,18 @@ var ClientRageMPEventEmmiter = class {
     mp.events.remove(eventName, listener);
   }
   emitServer(eventName, ...args) {
-    mp.events.callRemote(eventName, ...args);
+    const serializedArgs = args.map((arg) => {
+      if (typeof arg === "string") {
+        try {
+          JSON.parse(arg);
+          return arg;
+        } catch {
+          return JSON.stringify(arg);
+        }
+      }
+      return JSON.stringify(arg);
+    });
+    mp.events.callRemote(eventName, ...serializedArgs);
   }
   onServer(eventName, listener) {
     const mappedEventName = this.getEventName(eventName);
@@ -7859,7 +7870,18 @@ var RageMPWebView = class {
     this.$raw.active = value;
   }
   emit(eventName, ...args) {
-    this.$raw.call(eventName, ...args);
+    const serializedArgs = args.map((arg) => {
+      if (typeof arg === "string") {
+        try {
+          JSON.parse(arg);
+          return arg;
+        } catch {
+          return JSON.stringify(arg);
+        }
+      }
+      return JSON.stringify(arg);
+    });
+    this.$raw.call(eventName, ...serializedArgs);
   }
   emitRaw(eventName, ...args) {
     this.$raw.call(eventName, ...args);
@@ -8832,4 +8854,4 @@ export {
   isSymbol,
   isUndefined
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../core/src/app/enums/app-enviroment.enum.ts", "../../core/src/app/enums/core-metadata-key.enum.ts", "../../core/src/app/enums/event-destination.enum.ts", "../../core/src/app/enums/execution-context-type.enum.ts", "../../core/src/app/enums/method-param-type.enum.ts", "../../core/src/constants/index.ts", "../../core/src/enums/error-message.enum.ts", "../../core/src/enums/injectable-scope.enum.ts", "../../core/src/enums/rpc-result-status.enum.ts", "../../core/dist/chunk-7QVYU63E.js", "../../core/src/utils/generate-random-id.util.ts", "../../core/src/utils/type-check.util.ts", "../../core/src/app/module/module-metadata.reader.ts", "../../core/src/app/module/module-container.ts", "../../core/src/app/module/module.ts", "../../core/src/app/pipeline/execution-context-base.ts", "../../core/src/app/pipeline/mango-request-base.ts", "../../core/src/app/pipeline/mango-response-base.ts", "../../core/src/app/utils/tree.util.ts", "../../core/src/schemas/controller/controller-options.validate.ts", "../../core/src/schemas/events/error-filter.validate.ts", "../../core/src/schemas/events/pipe.validate.ts", "../../core/src/schemas/events/event-parameter.validate.ts", "../../core/src/schemas/events/event-metadata.validate.ts", "../../core/src/schemas/events/guard.validate.ts", "../../core/src/schemas/events/interceptor.validate.ts", "../../core/src/schemas/injection-token.validate.ts", "../../core/src/schemas/module/provider.validate.ts", "../../core/src/schemas/module/module-options.validate.ts", "../../core/src/schemas/injectable-metadata.validate.ts", "../../core/src/app/constants/index.ts", "../../core/src/errors/mango.error.ts", "../../core/src/errors/guard-cancel.error.ts", "../../core/src/errors/guard-invalid-return.error.ts", "../../core/src/errors/too-many-requests.error.ts", "../../core/src/errors/unknown.error.ts", "../../core/src/app/controller/controller-event.handler.ts", "../../core/src/app/controller/pipeline.handler.ts", "../../core/src/app/controller/controller-flow.handler.ts", "../../core/src/app/controller/controller-metadata.reader.ts", "../../core/src/app/controller/controller-rpc.handler.ts", "../../core/src/app/controller/controller.ts", "../../../node_modules/.pnpm/@abraham+reflection@0.12.0/node_modules/@abraham/reflection/src/index.ts", "../../core/src/services/index.ts", "../../core/src/services/reflector.service.ts", "../../core/src/decorators/index.ts", "../../core/src/decorators/core/controller.decorator.ts", "../../core/src/decorators/core/global.decorator.ts", "../../core/src/decorators/core/inject.decorator.ts", "../../core/src/decorators/core/injectable.decorator.ts", "../../core/src/decorators/core/module.decorator.ts", "../../core/src/decorators/core/optional.decorator.ts", "../../core/src/decorators/core/set-metadata.decorator.ts", "../../core/src/decorators/errors/catch.decorator.ts", "../../core/src/decorators/errors/use-filters.decorator.ts", "../../core/src/app/index.ts", "../../core/src/app/module-tree/app-runtime.ts", "../../core/src/app/module-tree/dependency-binder.ts", "../../core/src/app/module-tree/module-tree-scanner.ts", "../../core/src/app/multiplayer/ragemp/ragemp-script-event-handler.ts", "../../core/src/app/multiplayer/ragemp/ragemp-event-emmiter.ts", "../../core/src/app/multiplayer/ragemp/ragemp-timer.ts", "../../core/src/app/multiplayer/ragemp/ragemp-timers.ts", "../../core/src/app/multiplayer/ragemp/ragemp-multiplayer.service.ts", "../../core/src/app/app-builder.ts", "../../core/src/app/app.ts", "../../core/src/app/create-app.ts", "../../core/src/decorators/create-event-decorator.ts", "../../core/src/decorators/events/on-internal.decorator.ts", "../../core/src/decorators/events/on-webview.decorator.ts", "../../core/src/decorators/events/on.decorator.ts", "../../core/src/decorators/events/once-internal.decorator.ts", "../../core/src/decorators/events/once.decorator.ts", "../../core/src/decorators/events/once-webview.decorator.ts", "../../core/src/decorators/params/body.decorator.ts", "../../core/src/decorators/params/index.decorator.ts", "../../core/src/decorators/params/request.decorator.ts", "../../core/src/decorators/params/param.decorator.ts", "../../core/src/decorators/params/response.deorator.ts", "../../core/src/decorators/pipeline/use-guards.decorator.ts", "../../core/src/decorators/pipeline/use-interceptors.decorator.ts", "../../core/src/decorators/pipeline/use-pipes.decorator.ts", "../../core/src/decorators/create-rpc-decorator.ts", "../../core/src/decorators/rpc/on-request.decorator.ts", "../../core/src/decorators/rpc/on-webview-request.decorator.ts", "../../core/src/decorators/create-timer.decorator.ts", "../../core/src/decorators/timers/cron.decorator.ts", "../../core/src/decorators/timers/every-tick.decorator.ts", "../../core/src/decorators/timers/interval.decorator.ts", "../../core/src/decorators/timers/timeout.decorator.ts", "../../core/src/decorators/apply-decorator.util.ts", "../../core/src/decorators/create-param.util.ts", "../../core/src/decorators/forward-ref.util.ts", "../../core/src/services/timer.service.ts", "../../../node_modules/.pnpm/croner@8.1.2/node_modules/croner/dist/croner.min.js", "../../core/src/app/services/base-event.service.ts", "../../core/src/app/services/base-rpc.service.ts", "../src/constants/inject.consts.ts", "../src/constants/internal-events.consts.ts", "../src/plugins/event-mediator.plugin.ts", "../../core/src/pipes/default-value.pipe.ts", "../src/plugins/rpc.plugin.ts", "../src/plugins/service-binder.plugin.ts", "../src/services/client-event.service.ts", "../src/services/client-logger.service.ts", "../../core/src/enums/error-message.enum.ts", "../../core/src/enums/injectable-scope.enum.ts", "../../core/src/enums/rpc-result-status.enum.ts", "../../core/src/app/constants/index.ts", "../../core/src/app/controller/controller-event.handler.ts", "../../core/src/utils/generate-random-id.util.ts", "../../core/src/utils/type-check.util.ts", "../../core/src/app/controller/pipeline.handler.ts", "../../core/src/errors/mango.error.ts", "../../core/src/errors/guard-cancel.error.ts", "../../core/src/errors/guard-invalid-return.error.ts", "../../core/src/constants/index.ts", "../../core/src/app/enums/app-enviroment.enum.ts", "../../core/src/app/enums/core-metadata-key.enum.ts", "../../core/src/app/enums/execution-context-type.enum.ts", "../../core/src/app/controller/controller-flow.handler.ts", "../../core/src/app/controller/controller-metadata.reader.ts", "../../core/src/app/controller/controller-rpc.handler.ts", "../../core/src/app/controller/controller.ts", "../../core/src/app/module/module-metadata.reader.ts", "../../core/src/app/module/module-container.ts", "../../core/src/app/module/module.ts", "../../core/src/app/module-tree/app-runtime.ts", "../../core/src/app/module-tree/dependency-binder.ts", "../../core/src/services/reflector.service.ts", "../../core/src/schemas/events/error-filter.validate.ts", "../../core/src/schemas/events/pipe.validate.ts", "../../core/src/schemas/events/guard.validate.ts", "../../core/src/schemas/events/interceptor.validate.ts", "../../core/src/schemas/injectable-metadata.validate.ts", "../../core/src/decorators/core/controller.decorator.ts", "../../core/src/decorators/core/inject.decorator.ts", "../../core/src/decorators/core/injectable.decorator.ts", "../../core/src/decorators/core/module.decorator.ts", "../../core/src/decorators/core/optional.decorator.ts", "../../core/src/decorators/core/set-metadata.decorator.ts", "../../core/src/decorators/forward-ref.util.ts", "../../core/src/services/timer.service.ts", "../../core/src/app/module-tree/module-tree-scanner.ts", "../../core/src/app/utils/tree.util.ts", "../../core/src/app/pipeline/execution-context-base.ts", "../../core/src/app/pipeline/mango-request-base.ts", "../../core/src/app/pipeline/mango-response-base.ts", "../../core/src/app/services/base-event.service.ts", "../../core/src/app/services/base-rpc.service.ts", "../../core/src/app/app-builder.ts", "../../core/src/app/app.ts", "../../core/src/app/create-app.ts", "../src/services/client-rpc.service.ts", "../src/services/webview-list.service.ts", "../src/services/client-webview.service.ts", "../src/plugins/webview.plugin.ts", "../src/multiplayer/ragemp/ragemp-script-event-handler.ts", "../src/multiplayer/ragemp/ragemp-event-emmiter.ts", "../src/multiplayer/ragemp/ragemp-webview.ts", "../src/multiplayer/ragemp/ragemp-webview-manager.ts", "../src/multiplayer/ragemp/ragemp-multiplayer.service.ts", "../src/decorators/errors/use-filters.decorator.ts", "../src/decorators/events/internal/index.ts", "../src/decorators/events/on-server.decorator.ts", "../src/decorators/events/on-webview.decorator.ts", "../src/decorators/events/on.decorator.ts", "../src/decorators/events/once-server.decorator.ts", "../src/decorators/events/once-webview.decorator.ts", "../src/decorators/events/once.decorator.ts", "../src/decorators/pipeline/use-guards.decorator.ts", "../src/decorators/pipeline/use-interceptors.decorator.ts", "../src/decorators/rpc/on-request.decorator.ts", "../src/decorators/rpc/on-server-request.decorator.ts", "../src/decorators/rpc/on-webview-request.decorator.ts", "../src/index.ts"],
  "sourcesContent": ["export enum AppEnviroment {\n    Client,\n    Server,\n}\n", "export enum CoreMetadataKey {\n    // General\n    Injectable = 'mango:injectable',\n    Inject = 'mango:inject',\n    Module = 'mango:module',\n    GlobalModule = 'mango:global-module',\n    Controller = 'mango:controller-options',\n    // Events & RPC\n    ControllerEvents = 'mango:controller-events',\n    ControllerRPCs = 'mango:controller-rpcs',\n    ControllerParams = 'mango:controller-rpc-params',\n    // Pipeline\n    Guards = 'mango:guards',\n    Interceptors = 'mango:interceptors',\n    Pipes = 'mango:pipes',\n    // Error\n    Catch = 'mango:catch',\n    ErrorFilters = 'mango:error-filters',\n    //\n    Timers = 'mango:timers',\n}\n", "export enum EventDestination {\n    Server = 'server',\n    Client = 'client',\n    WebView = 'webview',\n}\n", "export enum ExecutionContextType {\n    Event = 'event',\n    RPC = 'rpc',\n}\n", "export enum MethodParamType {\n    Body = 'body',\n    Custom = 'custom',\n    Param = 'param',\n    Player = 'player',\n    Request = 'request',\n    Response = 'response',\n    Index = 'index',\n}\n", "export const LOGGER_SERVICE = 'LOGGER_SERVICE';\nexport const EVENT_SERVICE = 'EVENT_SERVICE';\nexport const RPC_SERVICE = 'RPC_SERVICE';\nexport const MODULE_CONTAINER = 'MODULE_CONTAINER';\nexport const REFLECTOR_SERVICE = 'REFLECTOR_SERVICE';\nexport const TIMER_SERVICE = 'TIMER_SERVICE';\n", "export enum ErrorMessage {\n    TooManyRequests = 'Too many requests.',\n\n    // Events\n    EventNameMustBeString = 'The event name must be a string.',\n    EventNameMustBeUnique = 'The event name must be unique.',\n    EventNotAllowedInClient = 'The event is not allowed in the client environment.',\n    EventNotAllowedInServer = 'The event is not allowed in the server environment.',\n    InvalidEventType = 'Invalid event type.',\n    InvalidInternalEventName = 'The name of the internal event is invalid.',\n    InvalidReturnInEvent = 'Cannot return a value from an event.',\n\n    // RPC\n    RPCNameMustBeString = 'The RPC name must be a string.',\n    RPCNameMustBeUnique = 'The RPC name must be unique.',\n    RPCNotAllowedInClient = 'The RPC is not allowed in the client environment.',\n    RPCNotAllowedInServer = 'The RPC is not allowed in the server environment.',\n    InvalidRPCType = 'Invalid RPC type.',\n    RPCHandlerAlreadyExists = 'The RPC handler already exists. Please provide a unique name for the RPC.',\n    RPCResponseAlreadySent = 'The RPC response has already been sent.',\n\n    // Error filters\n    InvalidErrorFilterDefinition = 'Invalid error filter. Error filters must be a class reference or an object with a catch method.',\n    ErrorAlreadyHandledByFilter = 'The error already points to a filter.',\n    ExceptionHandlingConflict = 'The same exception can only be caught once.',\n    AtLeastOneFilterRequired = 'At least one error filter must be provided.',\n    DuplicateErrorFilterDetected = 'Duplicate error filter found. Ensure that the same filter is not applied more than once.',\n\n    // WebView\n    WebViewNotFound = 'The WebView with the specified id does not exist.',\n    WebViewIdMustBeStringOrNumber = 'The WebView id must be a string or number.',\n\n    // Guard\n    InvalidGuardDefinition = 'Invalid guard. Guards must be a class reference or an object with a canActivate method.',\n    AtLeastOneGuardRequired = 'At least one guard must be provided.',\n\n    // Interceptor\n    InvalidInterceptorDefinition = 'Invalid interceptor. Interceptors must be a class reference or an object with an intercept method.',\n    AtLeastOneInterceptorRequired = 'At least one interceptor must be provided.',\n    InvalidInterceptorReturnValue = 'The interceptor must return a function.',\n\n    // Pipe\n    InvalidPipeDefinition = 'Invalid pipe. Pipes must be a class reference or an object with a transform method.',\n    AtLeastOnePipeRequired = 'At least one pipe must be provided.',\n\n    // App loading\n    AppAlreadyLoaded = 'App is already loaded. Please call the stop method before calling the start method.',\n    AppNotLoaded = 'App is not loaded. Please call the start method before calling the stop method.',\n\n    // Decorators\n    InvalidInjectionTokenSpecified = 'The specified injection token is invalid.',\n    InjectionTokenNotFound = 'The injection token could not be found.',\n    ParamKeyMustBeString = 'The param key must be a string.',\n    IndexKeyMustBeNumber = 'The index key must be a number.',\n    DuplicateDecoratorUsage = 'The same decorator can only be used once in the same class.',\n    InvalidControllerOptions = 'Invalid controller options found.',\n    InvalidInjectableOptions = 'Invalid injectable options found.',\n    InvalidModuleOptions = 'Invalid module options found.',\n    MultipleDecoratorsOnSingleParameterNotAllowed = 'Cannot apply multiple decorators to the same parameter.',\n\n    // Internal App\n    CircularDependencyDetected = 'Circular dependency detected.',\n    InvalidModuleDefinition = 'The module is invalid.',\n    InvalidExportDefinition = 'The export is invalid.',\n    InvalidProviderDefinition = 'The provider is invalid.',\n    InvalidParameterDecoratorUsage = 'Each parameter must have their its own decorator.',\n    ResponseDecoratorNotAllowedOnEvents = 'The @Response() decorator is not allowed on events.',\n    PlayerDecoratorNotAllowedOnClientEvents = 'The @Player() decorator is not allowed on client events.',\n\n    // Timers\n    TimerNameMustBeString = 'The timer name must be a string.',\n}\n", "export enum InjectableScope {\n    Request = 'request',\n    Transient = 'transient',\n    Singleton = 'singleton',\n}\n", "export enum RPCResultStatus {\n    Success = 1,\n    Timeout = 2,\n    HandlerNotFound = 3,\n    Unknown = 4,\n    CancelledByGuard = 5,\n    InvalidGuardReturn = 6,\n    TooManyRequests = 7,\n    PlayerDisconnected = 8,\n    PlayerNotFound = 9,\n}\n", "var __defProp = Object.defineProperty;\nvar __name = (target, value)=>__defProp(target, \"name\", {\n        value,\n        configurable: true\n    });\nexport { __name }; //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9", "export function generateRandomId() {\n    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);\n}\n", "export const isUndefined = (obj: any): obj is undefined => typeof obj === 'undefined';\nexport const isObject = (fn: any): fn is object => !isNil(fn) && typeof fn === 'object';\nexport const isFunction = (val: any): val is Function => typeof val === 'function';\nexport const isString = (val: any): val is string => typeof val === 'string';\nexport const isNumber = (val: any): val is number => typeof val === 'number';\nexport const isConstructor = (val: any): boolean => val === 'constructor';\nexport const isNil = (val: any): val is null | undefined => isUndefined(val) || val === null;\nexport const isEmpty = (array: any): boolean => !(array && array.length > 0);\nexport const isSymbol = (val: any): val is symbol => typeof val === 'symbol';\nexport const isAsyncFunction = (val: any): boolean => isFunction(val) && val.constructor.name === 'AsyncFunction';\nexport const isBoolean = (val: any): val is boolean => typeof val === 'boolean';\nexport const isPromise = <T = any>(val: any): val is Promise<T> => val instanceof Promise;\n", "import { inject, injectable } from 'inversify';\nimport type { InjectionToken, Newable } from '../../types';\nimport { CoreMetadataKey } from '../enums';\nimport type { InjectableMetadata, ErrorFilter, Guard, Interceptor } from '../interfaces';\nimport type { ModuleMetadata } from '../interfaces';\nimport type { ClassProvider, DynamicModule, LoggerService, ModuleOptions, Pipe, Provider } from '../../interfaces';\nimport { isFunction, isNil, isString, isSymbol } from '../../utils';\nimport { ErrorMessage } from '../../enums';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class ModuleMetadataReader {\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async read(module: Newable | DynamicModule | Promise<DynamicModule>) {\n        // Class reference\n        if (isFunction(module)) {\n            const options = Reflect.getMetadata<Required<ModuleOptions>>(CoreMetadataKey.Module, module) ?? <Required<ModuleOptions>>{};\n            const exportTokens = this.getExportTokens(options.exports);\n            const separatedProviders = this.separateProviders(options.providers, exportTokens);\n\n            return <ModuleMetadata>{\n                controllers: options.controllers,\n                imports: options.imports,\n                ...this.getPipeline(module),\n                ...separatedProviders,\n                classRef: module,\n                global: Reflect.getMetadata<boolean>(CoreMetadataKey.GlobalModule, module) ?? false,\n                container: options.container,\n            };\n        }\n        // Dynamic module\n        if (module instanceof Promise) module = await module;\n        if (!('module' in module)) {\n            this.loggerService.error('An error occurred while reading module metadata.');\n            throw new Error(ErrorMessage.InvalidModuleDefinition);\n        }\n\n        const { module: classRef, global, ...options } = <Required<DynamicModule>>module;\n        const exportTokens = this.getExportTokens(options.exports);\n        const separatedProviders = this.separateProviders(options.providers, exportTokens);\n\n        return <ModuleMetadata>{\n            controllers: options.controllers,\n            imports: options.imports,\n            ...this.getPipeline(classRef),\n            ...separatedProviders,\n            classRef,\n            global: global ?? false,\n            container: options.container,\n        };\n    }\n\n    private getPipeline(classRef: Newable) {\n        const guards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, classRef) ?? [];\n        const interceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, classRef) ?? [];\n        const pipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, classRef) ?? [];\n        const errorFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, classRef) ?? [];\n\n        return { guards, interceptors, pipes, errorFilters };\n    }\n\n    private getExportTokens(exports: Required<ModuleOptions>['exports']) {\n        return exports.map<InjectionToken>((providerExport) => {\n            if (isFunction(providerExport)) {\n                if (!Reflect.hasOwnMetadata(CoreMetadataKey.Injectable, providerExport)) {\n                    this.loggerService.error('An error occurred while reading module metadata.');\n                    throw new Error(ErrorMessage.InvalidExportDefinition);\n                }\n                return providerExport;\n            } else if (isString(providerExport) || isSymbol(providerExport)) {\n                return providerExport;\n            } else if ('provide' in providerExport) {\n                return providerExport.provide;\n            }\n\n            this.loggerService.error('An error occurred while reading module metadata.');\n            throw new Error(ErrorMessage.InvalidExportDefinition);\n        });\n    }\n\n    private separateProviders(providers: Required<ModuleOptions>['providers'], exportTokens: InjectionToken[]) {\n        return providers\n            .map((provider) => {\n                if (isFunction(provider)) {\n                    const injectableMetadata = Reflect.getMetadata<InjectableMetadata>(CoreMetadataKey.Injectable, provider);\n                    if (isNil(injectableMetadata)) {\n                        this.loggerService.error('An error occurred while reading module metadata.');\n                        throw new Error(ErrorMessage.InvalidProviderDefinition);\n                    }\n                    return <ClassProvider>{ provide: provider, useClass: provider, scope: injectableMetadata.scope };\n                } else if ('useClass' in provider || 'useValue' in provider || 'useFactory' in provider || 'useExisting' in provider) {\n                    return provider;\n                }\n\n                this.loggerService.error('An error occurred while reading module metadata.');\n                throw new Error(ErrorMessage.InvalidProviderDefinition);\n            })\n            .reduce(\n                (acc, provider) => {\n                    if (exportTokens.includes(provider.provide)) {\n                        acc.externalProviders.set(provider.provide, provider);\n                    } else {\n                        acc.internalProviders.set(provider.provide, provider);\n                    }\n                    return acc;\n                },\n                {\n                    internalProviders: new Map<InjectionToken, Exclude<Provider, Newable>>(),\n                    externalProviders: new Map<InjectionToken, Exclude<Provider, Newable>>(),\n                },\n            );\n    }\n}\n", "import { Container } from 'inversify';\n\nexport class ModuleContainer extends Container {}\n", "import { injectable } from 'inversify';\nimport { Controller } from '../controller';\nimport type { ModuleMetadata } from '../interfaces';\nimport { ModuleContainer } from './module-container';\n\n@injectable()\nexport class Module {\n    public readonly controllers: Controller[] = [];\n    public container: ModuleContainer;\n    public parent: Module | undefined;\n    public metadata: ModuleMetadata;\n    public instance: { [key: string]: Function };\n    public repetitiveImports: Set<Module> = new Set();\n}\n", "import { injectable } from 'inversify';\nimport type { Newable } from '../../types';\nimport type { ExecutionContextType } from '../enums';\nimport type { ExecutionContext } from '../interfaces';\nimport type { MangoRequestBase } from './mango-request-base';\nimport type { MangoResponseBase } from './mango-response-base';\n\n@injectable()\nexport class ExecutionContextBase<\n    TRequest extends MangoRequestBase = MangoRequestBase,\n    TResponse extends MangoResponseBase = MangoResponseBase,\n> implements ExecutionContext<TRequest, TResponse>\n{\n    public $type: ExecutionContextType;\n    public $classRef: Newable;\n    public $handler: Function;\n    public $request: TRequest;\n    public $response?: TResponse;\n    public $name: string;\n\n    public get type() {\n        return this.$type;\n    }\n\n    public get classRef() {\n        return this.$classRef;\n    }\n\n    public get handler() {\n        return this.$handler;\n    }\n\n    public get request() {\n        return this.$request;\n    }\n\n    public get response() {\n        return this.$response!;\n    }\n\n    public get name() {\n        return this.$name;\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { MangoRequest } from '../interfaces';\n\n@injectable()\nexport class MangoRequestBase<TData = unknown> implements MangoRequest {\n    public $body: TData;\n    public $player?: PlayerMp;\n\n    public get body() {\n        return this.$body;\n    }\n\n    public get player() {\n        return this.$player;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { LoggerService, RPCError } from '../../interfaces';\nimport type { MangoResponse } from '../interfaces';\nimport { ErrorMessage } from '../../enums';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class MangoResponseBase implements MangoResponse {\n    @inject(LOGGER_SERVICE) private readonly $loggerService: LoggerService;\n    public $sendListeners: Set<(data: unknown) => void> = new Set();\n    public $errorListeners: Set<(error: RPCError) => void> = new Set();\n    public $isSent: boolean = false;\n\n    public send<TData = unknown>(data?: TData) {\n        if (this.$isSent) {\n            this.$loggerService.error('An error occurred while sending the RPC response.');\n            throw new Error(ErrorMessage.RPCResponseAlreadySent);\n        }\n\n        this.$sendListeners.forEach((listener) => listener(data));\n        this.$isSent = true;\n    }\n\n    public error<TDetails = unknown>(message: string, details?: TDetails) {\n        if (this.$isSent) {\n            this.$loggerService.error('An error occurred while sending the RPC response.');\n            throw new Error(ErrorMessage.RPCResponseAlreadySent);\n        }\n        this.$errorListeners.forEach((listener) => listener({ message, details }));\n        this.$isSent = true;\n    }\n\n    public $onSend(listener: (data: unknown) => void) {\n        this.$sendListeners.add(listener);\n    }\n\n    public $onError(listener: (error: RPCError) => void) {\n        this.$errorListeners.add(listener);\n    }\n}\n", "export class TreeNode<T> {\n    public value: T;\n    public children: TreeNode<T>[];\n\n    public constructor(value: T) {\n        this.value = value;\n        this.children = [];\n    }\n\n    public addChild(child: TreeNode<T>) {\n        this.children.push(child);\n    }\n\n    public removeChild(child: TreeNode<T>) {\n        const index = this.children.indexOf(child);\n        if (index !== -1) {\n            this.children.splice(index, 1);\n        }\n    }\n}\n\nexport class Tree<T> {\n    public root: TreeNode<T>;\n\n    public constructor(value: T) {\n        this.root = new TreeNode<T>(value);\n    }\n\n    public traverse(callback: (node: TreeNode<T>) => void) {\n        function traverseNode(node: TreeNode<T>) {\n            callback(node);\n            node.children.forEach(traverseNode);\n        }\n\n        traverseNode(this.root);\n    }\n\n    public async asyncTraverse(callback: (node: TreeNode<T>) => Promise<void>) {\n        async function traverseNode(node: TreeNode<T>) {\n            await callback(node);\n            await Promise.all(node.children.map(traverseNode));\n        }\n\n        await traverseNode(this.root);\n    }\n\n    public toString(): string {\n        let result = '';\n        const lines: string[] = [];\n\n        function traverseNode(node: TreeNode<T>, depth: number) {\n            lines.push(`${'-'.repeat(depth * 2)}${node.value}`);\n            node.children.forEach((child) => traverseNode(child, depth + 1));\n        }\n\n        traverseNode(this.root, 0);\n        result = lines.join('\\n');\n\n        return result;\n    }\n}\n", "import type { ControllerOptions } from '../../interfaces';\nimport { isNil, isObject, isString } from '../../utils';\n\nconst defaultControllerOptions: ControllerOptions = { prefix: '' };\n\nexport function validateControllerOptions(options?: ControllerOptions) {\n    if (isNil(options)) {\n        return { valid: true, value: defaultControllerOptions };\n    }\n\n    if (!isObject(options)) {\n        return { valid: false, value: defaultControllerOptions, error: 'Controller options must be an object' };\n    }\n\n    if (!('prefix' in options)) {\n        return { valid: true, value: { ...defaultControllerOptions, ...options } };\n    }\n    if ('prefix' in options && !isString(options.prefix)) {\n        return { valid: true, value: defaultControllerOptions, error: 'Controller prefix must be a string' };\n    }\n\n    return { valid: true, value: { ...defaultControllerOptions, ...options } };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { ErrorFilter } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateErrorFilter<EF extends ErrorFilter = ErrorFilter>(value: EF | Newable<EF>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Error filter must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Error filter must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.catch)) {\n        return { valid: true, value, error: 'Error filter must have a catch method' };\n    }\n\n    if (isObject(value) && !isFunction((<ErrorFilter>value).catch)) {\n        return { valid: true, value, error: 'Error filter must have a catch method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Pipe } from '../../interfaces';\nimport type { Newable } from '../../types';\n\nexport function validatePipe(value: Pipe | Newable<Pipe>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Pipe must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Pipe must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.transform)) {\n        return { valid: false, value, error: 'Pipe must have a transform method' };\n    }\n\n    if (isObject(value) && !isFunction((<Pipe>value).transform)) {\n        return { valid: false, value, error: 'Pipe must have a transform method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isNumber, isObject, isString } from '../../utils';\nimport { validatePipe } from './pipe.validate';\nimport type { MethodParameter } from '../../app/interfaces';\nimport { MethodParamType } from '../../app/enums';\n\nexport function validateEventParameter(value: MethodParameter) {\n    if (isNil(value) || !isObject(value)) {\n        return { valid: false, value, error: 'Event parameter must be an object' };\n    }\n    if ('key' in value && !isNil(value.key) && !isString(value.key)) {\n        return { valid: false, value, error: 'Event parameter key must be a string' };\n    }\n    if (!('index' in value) || !isNumber(value.index)) {\n        return { valid: false, value, error: 'Event parameter index is required' };\n    }\n    // BodyParameter | PlayerParameter\n    if (\n        (value.type === MethodParamType.Body || value.type === MethodParamType.Player) &&\n        'data' in value &&\n        !isNil(value.data) &&\n        !isString(value.data)\n    ) {\n        return { valid: false, value, error: 'Event parameter data must be a string' };\n    }\n    // CustomParameter\n    if (value.type === MethodParamType.Custom && !('factory' in value)) {\n        return { valid: false, value, error: 'Event parameter factory is required' };\n    }\n    if (value.type === MethodParamType.Custom && 'factory' in value && !isFunction(value.factory)) {\n        return { valid: false, value, error: 'Event parameter factory must be a function' };\n    }\n    //  ParamParameter\n    if ((value.type === MethodParamType.Param || value.type === MethodParamType.Index) && !('data' in value)) {\n        return { valid: false, value, error: 'Event parameter data is required' };\n    }\n    if (value.type === MethodParamType.Param && 'data' in value && !isString(value.data)) {\n        return { valid: false, value, error: 'Event parameter data must be a string' };\n    }\n    // IndexParameter\n    if (value.type === MethodParamType.Index && 'data' in value && !isNumber(value.data)) {\n        return { valid: false, value, error: 'Event parameter data must be a number' };\n    }\n    // BodyParameter | CustomParameter | ParamParameter | PlayerParameter | IndexParameter;\n    if (\n        value.type !== MethodParamType.Request &&\n        value.type !== MethodParamType.Response &&\n        'pipes' in value &&\n        !Array.isArray(value.pipes)\n    ) {\n        return { valid: false, value, error: 'Event parameter pipes must be an array' };\n    }\n    if (value.type !== MethodParamType.Request && value.type !== MethodParamType.Response && !('pipes' in value)) {\n        value.pipes = [];\n    }\n    if (value.type !== MethodParamType.Request && value.type !== MethodParamType.Response) {\n        for (const pipe of value.pipes!) {\n            const { valid, error } = validatePipe(pipe);\n            if (!valid) {\n                return { valid: false, value, error };\n            }\n        }\n    }\n\n    return { valid: true, value };\n}\n", "import type { EventMetadata } from '../../app';\nimport { isNil, isObject, isString } from '../../utils';\nimport { validateEventParameter } from './event-parameter.validate';\n\nexport function validateEventMetadata(value: EventMetadata) {\n    if (isNil(value) || !isObject(value)) {\n        return { valid: false, value, error: 'Event metadata must be an object' };\n    }\n\n    // Type\n    if (!('type' in value)) {\n        return { valid: false, value, error: 'Event metadata type is required' };\n    }\n    if (!isString(value.type)) {\n        return { valid: false, value, error: 'Event metadata type must be a string' };\n    }\n    // Name\n    if (!('name' in value)) {\n        return { valid: false, value, error: 'Event metadata name is required' };\n    }\n    if (!isString(value.name)) {\n        return { valid: false, value, error: 'Event metadata name must be a string' };\n    }\n    // Method\n    if (!('method' in value)) {\n        return { valid: false, value, error: 'Event metadata method is required' };\n    }\n    if (!isString(value.method)) {\n        return { valid: false, value, error: 'Event metadata method must be a string' };\n    }\n    // Params\n    if (!('params' in value)) {\n        (<EventMetadata>value).params = [];\n    }\n    if ('params' in value && !Array.isArray(value.params)) {\n        return { valid: false, value, error: 'Event metadata params must be an array' };\n    }\n    for (const param of value.params) {\n        const { valid, error } = validateEventParameter(param);\n        if (!valid) {\n            return { valid, value, error };\n        }\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Guard } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateGuard<G extends Guard = Guard>(value: G | Newable<G>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Guard must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Guard must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.canActivate)) {\n        return { valid: false, value, error: 'Guard must have a canActivate method' };\n    }\n\n    if (isObject(value) && !isFunction((<Guard>value).canActivate)) {\n        return { valid: false, value, error: 'Guard must have a canActivate method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Interceptor } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateInterceptor<I extends Interceptor = Interceptor>(value: I | Newable<I>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Interceptor must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Interceptor must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.intercept)) {\n        return { valid: false, value, error: 'Interceptor must have an intercept method' };\n    }\n\n    if (isObject(value) && !isFunction((<Interceptor>value).intercept)) {\n        return { valid: false, value, error: 'Interceptor must have an intercept method' };\n    }\n\n    return { valid: true, value };\n}\n", "import type { InjectionToken } from '../types';\nimport { isFunction, isObject, isString, isSymbol } from '../utils';\n\nexport function validateInjectionToken(value: InjectionToken) {\n    const valid = isString(value) || isSymbol(value) || isFunction(value) || isObject(value);\n    return valid ? { valid, value } : { valid, value, error: 'Injection token must be a string, symbol, class, or object' };\n}\n", "import { isFunction, isObject } from '../../utils';\nimport type {\n    ClassProvider,\n    ExistingProvider,\n    FactoryProvider,\n    OptionalFactoryDependency,\n    Provider,\n    ValueProvider,\n} from '../../interfaces';\nimport { validateInjectionToken } from '../injection-token.validate';\nimport { InjectableScope } from '../../enums';\n\nexport function validateProvider(value: Provider) {\n    if (!isObject(value) && !isFunction(value)) {\n        return { valid: false, value, error: 'Provider must be an object or function' };\n    }\n\n    if (isObject(value)) {\n        if (!('provide' in value)) {\n            return { valid: false, value, error: 'Provider must have a provide property' };\n        }\n\n        const { valid, error } = validateInjectionToken(value.provide);\n        if (!valid) {\n            return { valid: false, value, error };\n        }\n\n        if ('useClass' in value) {\n            return validateClassProvider(value);\n        } else if ('useValue' in value) {\n            return validateValueProvider(value);\n        } else if ('useFactory' in value) {\n            return validateFactoryProvider(value);\n        } else if ('useExisting' in value) {\n            return validateExistingProvider(value);\n        }\n    } else if (isFunction(value)) {\n        return { valid: true, value };\n    }\n\n    return { valid: false, value, error: 'Provider must have a useClass, useValue, useFactory, or useExisting property' };\n}\n\nexport function validateClassProvider(value: ClassProvider) {\n    if (!('useClass' in value)) {\n        return { valid: false, value, error: 'Provider must have a useClass property' };\n    }\n\n    if (!('scope' in value)) {\n        value.scope = InjectableScope.Singleton;\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value, error: 'Provider scope must be a valid injectable scope' };\n    }\n\n    return { valid: true, value };\n}\n\nexport function validateValueProvider(value: ValueProvider) {\n    if (!('useValue' in value)) {\n        return { valid: false, value, error: 'Provider must have a useValue property' };\n    }\n\n    return { valid: true, value };\n}\n\nfunction validateOptionalFactoryDependency(value: OptionalFactoryDependency) {\n    if (!('optional' in value)) {\n        return { valid: false, value, error: 'Provider must have an optional property' };\n    }\n\n    if (!('token' in value)) {\n        return { valid: false, value, error: 'Provider must have a token property' };\n    }\n\n    const { valid, error } = validateInjectionToken(value.token);\n    if (!valid) {\n        return { valid: false, value, error };\n    }\n\n    return { valid: true, value };\n}\n\nexport function validateFactoryProvider(value: FactoryProvider) {\n    if (!('useFactory' in value)) {\n        return { valid: false, value, error: 'Provider must have a useFactory property' };\n    }\n    if (!isFunction(value.useFactory)) {\n        return { valid: false, value, error: 'Provider useFactory must be a function' };\n    }\n\n    if (!('inject' in value)) {\n        value.inject = [];\n    }\n    if ('inject' in value && !Array.isArray(value.inject)) {\n        return { valid: false, value, error: 'Provider inject must be an array' };\n    }\n    if ('inject' in value) {\n        for (const token of value.inject) {\n            if (isObject(token) && 'optional' in token && 'token' in token) {\n                const { valid, error } = validateOptionalFactoryDependency(token);\n                if (!valid) {\n                    return { valid, value, error };\n                }\n            } else {\n                const { valid, error } = validateInjectionToken(token);\n                if (!valid) {\n                    return { valid, value, error };\n                }\n            }\n        }\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value, error: 'Provider scope must be a valid injectable scope' };\n    }\n\n    return { valid: true, value };\n}\n\nexport function validateExistingProvider(value: ExistingProvider) {\n    if (!('useExisting' in value)) {\n        return { valid: false, value, error: 'Provider must have a useExisting property' };\n    }\n\n    return { valid: true, value };\n}\n", "import type { DynamicModule, ModuleOptions } from '../../interfaces';\nimport { validateProvider } from './provider.validate';\nimport { isBoolean, isFunction, isNil, isObject, isPromise } from '../../utils';\nimport type { InjectionToken, Nullable } from '../../types';\nimport { validateInjectionToken } from '../injection-token.validate';\n\nexport function validateModuleOptions(\n    value?: ModuleOptions | DynamicModule,\n    isDynamic = false,\n): { valid: boolean; value: ModuleOptions | DynamicModule; error?: Nullable<string> } {\n    if (isNil(value)) {\n        value = {\n            controllers: [],\n            imports: [],\n            providers: [],\n            exports: [],\n        };\n    }\n\n    if (!isNil(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Module options must be an object' };\n    }\n\n    if (isDynamic) {\n        if (!('module' in value) || !isFunction(value.module)) {\n            return { valid: false, value, error: 'Dynamic module must have a module function' };\n        }\n\n        if (!('global' in value)) {\n            value.global = false;\n        } else if (!('global' in value) && !isBoolean(value.global)) {\n            return { valid: false, value, error: 'Dynamic module must have a global property' };\n        }\n    }\n\n    if ('imports' in value && !Array.isArray(value.imports)) {\n        return { valid: false, value, error: 'Imports property must be an array' };\n    } else if (!('imports' in value)) {\n        value.imports = [];\n    }\n\n    if ('controllers' in value && !Array.isArray(value.controllers)) {\n        return { valid: false, value, error: 'Controllers property must be an array' };\n    } else if (!('controllers' in value)) {\n        value.controllers = [];\n    }\n\n    if ('providers' in value && !Array.isArray(value.providers)) {\n        return { valid: false, value, error: 'Providers property must be an array' };\n    } else if (!('providers' in value)) {\n        value.providers = [];\n    }\n\n    if ('exports' in value && !Array.isArray(value.exports)) {\n        return { valid: false, value, error: 'Exports property must be an array' };\n    } else if (!('exports' in value)) {\n        value.exports = [];\n    }\n\n    for (const imported of value.imports) {\n        if (!isFunction(imported) && !isObject(imported) && !isPromise(imported)) {\n            return { valid: false, value, error: 'Import must be a function, object, or promise' };\n        }\n\n        if (isObject(imported) && !isPromise(imported)) {\n            const { valid, error } = validateModuleOptions(<DynamicModule>imported, true);\n            if (!valid) {\n                return { valid, value, error };\n            }\n        }\n    }\n\n    for (const controller of value.controllers) {\n        if (!isFunction(controller)) {\n            return { valid: false, value, error: 'Controller must be a function' };\n        }\n    }\n\n    for (const provider of value.providers) {\n        const { valid, error } = validateProvider(provider);\n        if (!valid) {\n            return { valid: false, value, error };\n        }\n    }\n\n    for (const exportItem of value.exports) {\n        const { valid, error } = validateInjectionToken(<InjectionToken>exportItem);\n        if (!valid) {\n            return { valid, value, error };\n        }\n\n        if (\n            isObject(exportItem) &&\n            ('useClass' in exportItem || 'useFactory' in exportItem || 'useValue' in exportItem || 'useExisting' in exportItem)\n        ) {\n            const { valid } = validateProvider(exportItem);\n            if (!valid) {\n                return { valid: false, value, error: 'Export must be a provider object' };\n            }\n        }\n    }\n\n    return { valid: true, value };\n}\n", "import { isNil, isObject, isString } from '../utils';\nimport { InjectableScope } from '../enums';\nimport type { InjectableOptions } from '../interfaces';\n\nconst defaultInjectableOptions: InjectableOptions = { scope: InjectableScope.Singleton };\n\nexport function validateInjectableMetadata(value?: InjectableOptions) {\n    if (isNil(value)) {\n        return { valid: true, value: defaultInjectableOptions };\n    }\n\n    if (!isObject(value)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Injectable options must be an object' };\n    }\n\n    if (!('scope' in value)) {\n        return { valid: true, value: { ...defaultInjectableOptions, ...value } };\n    }\n    if ('scope' in value && !isString(value.scope)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Injectable scope must be a string' };\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Invalid injectable scope' };\n    }\n\n    return { valid: true, value };\n}\n", "import { RPCResultStatus } from '../../enums';\nimport type { RPCResult } from '../../interfaces';\n\nexport const INTERNAL_APP_CONTAINER = 'INTERNAL_APP_CONTAINER';\nexport const GLOBAL_APP_CONTAINER = 'GLOBAL_APP_CONTAINER';\nexport const APP_ENVIROMENT = 'APP_ENVIROMENT';\n\nexport const GLOBAL_GUARDS = 'GLOBAL_GUARDS';\nexport const GLOBAL_INTERCEPTORS = 'GLOBAL_INTERCEPTORS';\nexport const GLOBAL_PIPES = 'GLOBAL_PIPES';\nexport const GLOBAL_ERROR_FILTERS = 'GLOBAL_ERROR_FILTERS';\n\nexport const PLUGINS = 'PLUGINS';\n\nexport const ENABLE_SHUTDOWN_HOOKS = 'ENABLE_SHUTDOWN_HOOKS';\nexport const CONTAINER_OPTIONS = 'CONTAINER_OPTIONS';\nexport const LOG_ERROR_STACKTRACE = 'LOG_ERROR_STACKTRACE';\n\nexport const MANGO_LOG_PREFIX = '🥭';\n\nexport const MANGO_REQUEST_FACTORY = 'MANGO_REQUEST_FACTORY';\nexport const MANGO_RESPONSE_FACTORY = 'MANGO_RESPONSE_FACTORY';\nexport const EXECUTION_CONTEXT_FACTORY = 'EXECUTION_CONTEXT_FACTORY';\n\nexport const MULTIPLAYER_SERVICE = 'MULTIPLAYER_SERVICE';\n\nexport const RPC_RESULT_TIMEOUT: RPCResult = {\n    success: false,\n    error: { message: 'RPC call timed out.' },\n    status: RPCResultStatus.Timeout,\n};\n\nexport const RPC_RESULT_HANDLER_NOT_FOUND: RPCResult = {\n    success: false,\n    error: { message: 'RPC handler not found.' },\n    status: RPCResultStatus.HandlerNotFound,\n};\n\nexport const RPC_RESULT_UNKNOWN: RPCResult = {\n    success: false,\n    error: { message: 'Unknown error.' },\n    status: RPCResultStatus.Unknown,\n};\n\nexport const RPC_RESULT_PLAYER_DISCONNECTED: RPCResult = {\n    success: false,\n    error: { message: 'Player disconnected.' },\n    status: RPCResultStatus.PlayerDisconnected,\n};\n\nexport const RPC_RESULT_PLAYER_NOT_FOUND: RPCResult = {\n    success: false,\n    error: { message: 'Player not found.' },\n    status: RPCResultStatus.PlayerNotFound,\n};\n", "import { RPCResultStatus } from '../enums';\n\nexport class MangoError<TDetails = unknown> extends Error {\n    public status: number = RPCResultStatus.Unknown;\n    public details: TDetails | undefined;\n\n    public constructor(message: string, status?: number, details?: TDetails) {\n        super(message);\n        this.status = status ?? RPCResultStatus.Unknown;\n        this.details = details;\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class GuardCancelError extends MangoError {\n    public constructor() {\n        super('Process cancelled by the guard.', RPCResultStatus.CancelledByGuard);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class GuardInvalidReturnError extends MangoError {\n    public constructor() {\n        super('Guard returned an invalid value. Expected boolean.', RPCResultStatus.InvalidGuardReturn);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class TooManyRequests extends MangoError {\n    public constructor(message = 'Too many requests.') {\n        super(message, RPCResultStatus.TooManyRequests);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class UnknownError extends MangoError {\n    public constructor() {\n        super('Unknown error.', RPCResultStatus.Unknown);\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { ErrorFilter, Guard, Interceptor, InternalEventService, MultiplayerService } from '../interfaces';\nimport type { Newable } from '../../types';\nimport { APP_ENVIROMENT, EXECUTION_CONTEXT_FACTORY, MANGO_REQUEST_FACTORY, MULTIPLAYER_SERVICE } from '../constants';\nimport { isFunction, isNil, isObject } from '../../utils';\nimport { PipelineHandler } from './pipeline.handler';\nimport type { EventMetadata } from '../interfaces';\nimport { EVENT_SERVICE, LOGGER_SERVICE } from '../../constants';\nimport type { Controller } from './controller';\nimport { AppEnviroment, ExecutionContextType } from '../enums';\nimport { ExecutionContextBase, MangoResponseBase, type MangoRequestBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport { isAsyncFunction } from '../../utils';\nimport { ControllerFlowHandler } from './controller-flow.handler';\n\n@injectable()\nexport class ControllerEventHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayerService: MultiplayerService;\n    @inject(EVENT_SERVICE) private readonly eventService: InternalEventService;\n    @inject(ControllerFlowHandler) private readonly controllerFlowHandler: ControllerFlowHandler;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MANGO_REQUEST_FACTORY) private readonly createMangoRequest: (body: unknown, player?: PlayerMp) => MangoRequestBase;\n    @inject(EXECUTION_CONTEXT_FACTORY) private readonly createExecutionContext: (\n        type: ExecutionContextType,\n        classRef: Newable,\n        handler: Function,\n        request: MangoRequestBase,\n        response?: MangoResponseBase,\n        name?: string,\n    ) => ExecutionContextBase;\n\n    public registerEvent(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        event: EventMetadata,\n    ) {\n        if (event.type === 'on' || event.type === 'once') {\n            return this.eventService[event.type](event.name, async (body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);\n            });\n        } else if (event.type === 'onInternal' || event.type === 'onceInternal') {\n            return this.eventService[`$${event.type}`](event.name, async (...args) => {\n                const { player, body } = this.multiplayerService.parseInternalArgs<PlayerMp>(...args);\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        } else if (event.type === 'onPlayer' || event.type === 'oncePlayer') {\n            return this.eventService[event.type](event.name, async (player, body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        } else if (event.type === 'onServer' || event.type === 'onceServer') {\n            return this.eventService[event.type](event.name, async (body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);\n            });\n        } else if (event.type === 'onWebView' || event.type === 'onceWebView') {\n            return this.eventService[event.type](event.webViewId!, event.name, async (...args: unknown[]) => {\n                const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];\n                const player = this.appEnv === AppEnviroment.Server ? <PlayerMp>args[0] : undefined;\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        }\n\n        this.loggerService.error('An error occurred while trying to register event.');\n        throw new Error(ErrorMessage.InvalidEventType);\n    }\n\n    private async handleEvent(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        event: EventMetadata,\n        body: unknown,\n        player?: PlayerMp,\n    ) {\n        const request = this.createMangoRequest(body, player);\n        const executionContext = this.createExecutionContext(\n            ExecutionContextType.Event,\n            controller.metadata.classRef,\n            controller.metadata.classRef.prototype[event.method],\n            request,\n            undefined,\n            event.name,\n        );\n\n        try {\n            await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);\n            const args = await this.controllerFlowHandler.createArgs(controller, executionContext, event, pipes, player);\n            const controllerMethod = controller.instance[event.method]!;\n            const handle = isAsyncFunction(controllerMethod)\n                ? (): unknown => controller.instance[event.method]!.apply(controller.instance, args)\n                : (): Promise<unknown> => controller.instance[event.method]!.apply(controller.instance, args);\n            const callHandler: CallHandler = {\n                handle,\n                return: () => {\n                    this.loggerService.error('An error occurred while trying to return a value from an event.');\n                    throw new Error(ErrorMessage.InvalidReturnInEvent);\n                },\n            };\n\n            if (interceptors.length > 0) {\n                await this.pipelineHandler.goThroughInterceptors(executionContext, interceptors, controller.owner.container, callHandler);\n            } else {\n                await callHandler.handle();\n            }\n        } catch (error) {\n            const errorGroup = mappedErrorFilters.find(\n                ([errorType]) =>\n                    (isFunction(errorType) && error instanceof errorType) || errorType === 'MANGO_ANY_ERROR' || error === errorType,\n            );\n            if (isNil(errorGroup)) return;\n            const instance = isFunction(errorGroup[1])\n                ? controller.owner.container.get(errorGroup[1])\n                : isObject(errorGroup[1]) && isFunction(errorGroup[1]['catch'])\n                  ? errorGroup[1]\n                  : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through error filters.');\n                throw new Error(ErrorMessage.InvalidErrorFilterDefinition);\n            }\n            await Promise.resolve(instance.catch.call(instance, error, executionContext));\n        }\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Guard, Interceptor } from '../interfaces';\nimport type { Newable } from '../../types';\nimport { GuardCancelError, GuardInvalidReturnError } from '../../errors';\nimport { isFunction, isNil, isObject } from '../../utils';\nimport type { ExecutionContextBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { ArgumentMetadata, CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport { LOGGER_SERVICE } from '../../constants';\nimport type { ModuleContainer } from '../module';\n\n@injectable()\nexport class PipelineHandler {\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    // @inject(GLOBAL_APP_CONTAINER) private readonly globalContainer: Container;\n\n    public async goTroughGuards(executionContext: ExecutionContextBase, guards: (Newable<Guard> | Guard)[], container: ModuleContainer) {\n        for (const guard of guards) {\n            const instance = isFunction(guard) ? container.get(guard) : isObject(guard) && isFunction(guard['canActivate']) ? guard : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through guards.');\n                throw new Error(ErrorMessage.InvalidGuardDefinition);\n            }\n            const canActivate = await instance.canActivate.call(instance, executionContext);\n            if (typeof canActivate !== 'boolean') {\n                this.loggerService.error('An error occurred while trying to go through guards.');\n                throw new GuardInvalidReturnError();\n            }\n            if (!canActivate) {\n                throw new GuardCancelError();\n            }\n        }\n    }\n\n    public async goThroughInterceptors(\n        executionContext: ExecutionContextBase,\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        container: ModuleContainer,\n        callHandler: CallHandler,\n    ) {\n        for (const interceptor of interceptors) {\n            const instance = isFunction(interceptor)\n                ? container.get(interceptor)\n                : isObject(interceptor) && isFunction(interceptor['intercept'])\n                  ? interceptor\n                  : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through interceptors.');\n                throw new Error(ErrorMessage.InvalidInterceptorDefinition);\n            }\n            await instance.intercept.call(instance, executionContext, callHandler);\n        }\n    }\n\n    public async goTroughPipes(\n        value: unknown,\n        pipes: (Newable<Pipe> | Pipe)[],\n        argumentMetadata: ArgumentMetadata,\n        container: ModuleContainer,\n    ) {\n        for (const pipe of pipes) {\n            const instance = isFunction(pipe) ? container.get(pipe) : isObject(pipe) ? pipe : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through pipes.');\n                throw new Error(ErrorMessage.InvalidPipeDefinition);\n            }\n            value = await Promise.resolve(instance.transform.call(instance, value, argumentMetadata));\n        }\n\n        return value;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Controller } from './controller';\nimport type { ExecutionContextBase } from '../pipeline';\nimport type { EventMetadata, RPCMetadata } from '../interfaces';\nimport type { Newable } from '../../types';\nimport type { Pipe } from '../../interfaces';\nimport { PipelineHandler } from './pipeline.handler';\nimport { isObject } from '../../utils';\nimport { AppEnviroment } from '../enums';\nimport { APP_ENVIROMENT } from '../constants';\n\n@injectable()\nexport class ControllerFlowHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n\n    public async createArgs(\n        controller: Controller,\n        executionContext: ExecutionContextBase,\n        metadata: RPCMetadata | EventMetadata,\n        pipes: (Newable<Pipe> | Pipe)[],\n        player?: PlayerMp,\n    ) {\n        return Promise.all(\n            metadata.params.map(async (param) => {\n                const argumentMetadata = {\n                    type: param.type,\n                    data: param.data,\n                    metatype: param.metatype,\n                };\n\n                if (param.type === 'body') {\n                    // Body\n                    return this.pipelineHandler.goTroughPipes(\n                        executionContext.request.body,\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'param') {\n                    // Param\n                    if (!isObject(executionContext.request.body)) return undefined;\n                    return this.pipelineHandler.goTroughPipes(\n                        (<Record<string, unknown>>executionContext.request.body)[param.data],\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'index') {\n                    if (!Array.isArray(executionContext.request.body)) return undefined;\n                    return this.pipelineHandler.goTroughPipes(\n                        executionContext.request.body[param.data],\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'request') {\n                    return executionContext.request;\n                } else if (param.type === 'custom') {\n                    // Custom\n                    return this.pipelineHandler.goTroughPipes(\n                        param.factory(param.data, executionContext),\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'player' && this.appEnv === AppEnviroment.Server) {\n                    // Player (Server)\n                    return this.pipelineHandler.goTroughPipes(\n                        param.data ? player![<keyof PlayerMp>param.data] : player,\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                }\n                return undefined;\n            }),\n        );\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Guard, Interceptor, ErrorFilter, TimerMetadata } from '../interfaces';\nimport type { Newable } from '../../types';\nimport type { ControllerMetadata, EventMetadata, MethodParameter, RPCMetadata } from '../interfaces';\nimport { AppEnviroment, CoreMetadataKey } from '../enums';\nimport { APP_ENVIROMENT } from '../constants';\nimport { ErrorMessage } from '../../enums';\nimport type { LoggerService, Pipe } from '../../interfaces';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class ControllerMetadataReader {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async read(classRef: Newable) {\n        const options =\n            Reflect.getMetadata<Pick<ControllerMetadata, 'prefix'>>(CoreMetadataKey.Controller, classRef) ??\n            <Pick<ControllerMetadata, 'prefix'>>{};\n        const events = this.getEvents(classRef);\n        const rpcs = this.getRPCs(classRef);\n        const timers = this.getTimers(classRef);\n\n        return <ControllerMetadata>{\n            ...options,\n            classRef,\n            events,\n            rpcs,\n            ...this.getPipeline(classRef),\n            timers,\n        };\n    }\n\n    private getEvents(classRef: Newable) {\n        const events = Reflect.getMetadata<EventMetadata[]>(CoreMetadataKey.ControllerEvents, classRef.prototype) ?? [];\n\n        return events.map((event) => {\n            return <EventMetadata>{\n                ...event,\n                params: this.getMethodParams(classRef, event),\n                ...this.getPipeline(classRef, event.method),\n            };\n        });\n    }\n\n    private getRPCs(classRef: Newable) {\n        const rpcs = Reflect.getMetadata<RPCMetadata[]>(CoreMetadataKey.ControllerRPCs, classRef.prototype) ?? [];\n\n        return rpcs.map((rpc) => {\n            return <RPCMetadata>{\n                ...rpc,\n                params: this.getMethodParams(classRef, rpc),\n                ...this.getPipeline(classRef, rpc.method),\n            };\n        });\n    }\n\n    private getMethodParams(classRef: Newable, metadata: EventMetadata | RPCMetadata) {\n        const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, classRef.prototype, metadata.method) ?? [];\n\n        params.sort((a, b) => a.index - b.index);\n        params.forEach((param, index) => {\n            if (param.index !== index) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.InvalidParameterDecoratorUsage);\n            } else if (\n                (metadata.type === 'on' ||\n                    metadata.type === 'onPlayer' ||\n                    metadata.type === 'onInternal' ||\n                    metadata.type === 'onServer' ||\n                    metadata.type === 'onWebView' ||\n                    metadata.type === 'once' ||\n                    metadata.type === 'oncePlayer' ||\n                    metadata.type === 'onceInternal' ||\n                    metadata.type === 'onceServer' ||\n                    metadata.type === 'onceWebView') &&\n                param.type === 'response'\n            ) {\n                // Response\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.ResponseDecoratorNotAllowedOnEvents);\n            } else if (param.type === 'player' && this.appEnv === AppEnviroment.Client) {\n                // Player (Client) - Not allowed\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.PlayerDecoratorNotAllowedOnClientEvents);\n            } else if (metadata.type === 'onPlayerRequest' && this.appEnv === AppEnviroment.Client) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.RPCNotAllowedInClient);\n            } else if (metadata.type === 'onServerRequest' && this.appEnv === AppEnviroment.Server) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.RPCNotAllowedInServer);\n            } else if ((metadata.type === 'onPlayer' || metadata.type === 'oncePlayer') && this.appEnv === AppEnviroment.Client) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.EventNotAllowedInClient);\n            } else if ((metadata.type === 'onServer' || metadata.type === 'onceServer') && this.appEnv === AppEnviroment.Server) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.EventNotAllowedInServer);\n            }\n        });\n\n        return params;\n    }\n\n    private getPipeline(target: Newable | object, method?: string) {\n        const guards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, target, method) ?? [];\n        const interceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, target, method) ?? [];\n        const pipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, target, method) ?? [];\n        const errorFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, target, method) ?? [];\n\n        return { guards, interceptors, pipes, errorFilters };\n    }\n\n    private getTimers(classRef: Newable) {\n        return Reflect.getMetadata<TimerMetadata[]>(CoreMetadataKey.Timers, classRef.prototype) ?? [];\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { ErrorFilter, Guard, Interceptor, InternalRPCService } from '../interfaces';\nimport { LOGGER_SERVICE, RPC_SERVICE } from '../../constants';\nimport { APP_ENVIROMENT, EXECUTION_CONTEXT_FACTORY, MANGO_REQUEST_FACTORY, MANGO_RESPONSE_FACTORY } from '../constants';\nimport type { Newable } from '../../types';\nimport { isAsyncFunction, isFunction, isNil, isObject } from '../../utils';\nimport { PipelineHandler } from './pipeline.handler';\nimport type { RPCMetadata } from '../interfaces';\nimport { AppEnviroment, ExecutionContextType } from '../enums';\nimport { ExecutionContextBase, type MangoRequestBase, type MangoResponseBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport type { Controller } from './controller';\nimport { ControllerFlowHandler } from './controller-flow.handler';\n\n@injectable()\nexport class ControllerRPCHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(RPC_SERVICE) private readonly rpcService: InternalRPCService;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n    @inject(ControllerFlowHandler) private readonly controllerFlowHandler: ControllerFlowHandler;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MANGO_REQUEST_FACTORY) private readonly createMangoRequest: (data: unknown, player?: PlayerMp) => MangoRequestBase;\n    @inject(MANGO_RESPONSE_FACTORY) private readonly createMangoResponse: () => MangoResponseBase;\n    @inject(EXECUTION_CONTEXT_FACTORY) private readonly createExecutionContext: (\n        type: ExecutionContextType,\n        classRef: Newable,\n        handler: Function,\n        request: MangoRequestBase,\n        response: MangoResponseBase,\n        name: string,\n    ) => ExecutionContextBase;\n\n    public async registerRPC(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        rpc: RPCMetadata,\n    ) {\n        if (rpc.type === 'onRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);\n            });\n        } else if (rpc.type === 'onPlayerRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (player, body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);\n            });\n        } else if (rpc.type === 'onServerRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);\n            });\n        } else if (rpc.type === 'onWebViewRequest') {\n            return this.rpcService[rpc.type](rpc.webViewId!, rpc.name, async (...args: unknown[]) => {\n                const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];\n                const player = this.appEnv === AppEnviroment.Server ? <PlayerMp>args[0] : undefined;\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);\n            });\n        }\n\n        this.loggerService.error('An error occurred while trying to register RPC.');\n        throw new Error(ErrorMessage.InvalidRPCType);\n    }\n\n    private async handleRPC(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        rpc: RPCMetadata,\n        body: unknown,\n        player?: PlayerMp,\n    ) {\n        return new Promise(async (resolve) => {\n            const request = this.createMangoRequest(\n                body,\n                this.appEnv === AppEnviroment.Server && (rpc.type === 'onPlayerRequest' || rpc.type === 'onWebViewRequest')\n                    ? player\n                    : undefined,\n            );\n            const response = this.createMangoResponse();\n            response.$onSend((data) => resolve(data));\n            response.$onError((error) => resolve(error));\n            const executionContext = this.createExecutionContext(\n                ExecutionContextType.RPC,\n                controller.metadata.classRef,\n                controller.metadata.classRef.prototype[rpc.method],\n                request,\n                response,\n                rpc.name,\n            );\n\n            try {\n                await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);\n                const args = await this.controllerFlowHandler.createArgs(controller, executionContext, rpc, pipes, player);\n                const controllerMethod = controller.instance[rpc.method]!;\n                const handle = isAsyncFunction(controllerMethod)\n                    ? (options: { send: boolean } = { send: true }) => {\n                          const result = controller.instance[rpc.method]!.apply(controller.instance, args);\n                          if (options.send) {\n                              response.send(result);\n                          }\n                          return result;\n                      }\n                    : async (options: { send: boolean } = { send: true }) => {\n                          const result = await controller.instance[rpc.method]!.apply(controller.instance, args);\n                          if (options.send) {\n                              response.send(result);\n                          }\n                          return result;\n                      };\n                const callHandler: CallHandler = {\n                    handle,\n                    return: (value: unknown) => response.send(value),\n                };\n\n                if (interceptors.length > 0) {\n                    await this.pipelineHandler.goThroughInterceptors(\n                        executionContext,\n                        interceptors,\n                        controller.owner.container,\n                        callHandler,\n                    );\n                } else {\n                    await callHandler.handle();\n                }\n            } catch (error) {\n                const errorGroup = mappedErrorFilters.find(\n                    ([errorType]) =>\n                        (isFunction(errorType) && error instanceof errorType) || errorType === 'MANGO_ANY_ERROR' || error === errorType,\n                );\n                if (isNil(errorGroup)) return;\n                const instance = isFunction(errorGroup[1])\n                    ? controller.owner.container.get(errorGroup[1])\n                    : isObject(errorGroup[1]) && isFunction(errorGroup[1]['catch'])\n                      ? errorGroup[1]\n                      : null;\n                if (isNil(instance)) {\n                    return this.loggerService.error(ErrorMessage.InvalidErrorFilterDefinition);\n                }\n                await Promise.resolve(instance.catch.call(instance, error, executionContext));\n            }\n        });\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { ControllerMetadata, ScriptEventHandler } from '../interfaces';\nimport type { Module } from '../module';\nimport type { ScriptRPCHandler } from '../../interfaces';\n\n@injectable()\nexport class Controller {\n    public metadata: ControllerMetadata;\n    public instance: { [key: string]: Function };\n    public owner: Module;\n    public eventHandlers: ScriptEventHandler[] = [];\n    public rpcHandlers: ScriptRPCHandler[] = [];\n}\n", "export type Decorator = ClassDecorator | MemberDecorator;\nexport type MemberDecorator = <T>(\n  target: Target,\n  propertyKey: PropertyKey,\n  descriptor?: TypedPropertyDescriptor<T>,\n) => TypedPropertyDescriptor<T> | void;\nexport type MetadataKey = string | symbol;\nexport type PropertyKey = string | symbol;\nexport type Target = object | Function;\n\nconst Metadata = new WeakMap();\n\nfunction decorateProperty(\n  decorators: MemberDecorator[],\n  target: Target,\n  propertyKey: PropertyKey,\n  descriptor?: PropertyDescriptor,\n): PropertyDescriptor | undefined {\n  decorators.reverse().forEach((decorator: MemberDecorator) => {\n    descriptor = decorator(target, propertyKey, descriptor) || descriptor;\n  });\n  return descriptor;\n}\n\nfunction decorateConstructor(\n  decorators: ClassDecorator[],\n  target: Function,\n): Function {\n  decorators.reverse().forEach((decorator: ClassDecorator) => {\n    const decorated = decorator(target);\n    if (decorated) {\n      target = decorated;\n    }\n  });\n  return target;\n}\n\nexport function decorate(\n  decorators: ClassDecorator[],\n  target: Function,\n): Function;\nexport function decorate(\n  decorators: MemberDecorator[],\n  target: object,\n  propertyKey?: PropertyKey,\n  attributes?: PropertyDescriptor,\n): PropertyDescriptor | undefined;\nexport function decorate(\n  decorators: Decorator[],\n  target: Target,\n  propertyKey?: PropertyKey,\n  attributes?: PropertyDescriptor,\n): Function | PropertyDescriptor | undefined {\n  if (!Array.isArray(decorators) || decorators.length === 0) {\n    throw new TypeError();\n  }\n\n  if (propertyKey !== undefined) {\n    return decorateProperty(\n      decorators as MemberDecorator[],\n      target,\n      propertyKey,\n      attributes,\n    );\n  }\n\n  if (typeof target === 'function') {\n    return decorateConstructor(decorators as ClassDecorator[], target);\n  }\n\n  return;\n}\n\nfunction getMetadataMap<MetadataValue>(\n  target: Target,\n  propertyKey?: PropertyKey,\n): Map<MetadataKey, MetadataValue> | undefined {\n  return Metadata.get(target) && Metadata.get(target).get(propertyKey);\n}\n\nfunction ordinaryGetOwnMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): MetadataValue | undefined {\n  if (target === undefined) {\n    throw new TypeError();\n  }\n  const metadataMap = getMetadataMap<MetadataValue>(target, propertyKey);\n  return metadataMap && metadataMap.get(metadataKey);\n}\n\nfunction createMetadataMap<MetadataValue>(\n  target: Target,\n  propertyKey?: PropertyKey,\n): Map<MetadataKey, MetadataValue> {\n  const targetMetadata =\n    Metadata.get(target) ||\n    new Map<PropertyKey | undefined, Map<MetadataKey, MetadataValue>>();\n  Metadata.set(target, targetMetadata);\n  const metadataMap =\n    targetMetadata.get(propertyKey) || new Map<MetadataKey, MetadataValue>();\n  targetMetadata.set(propertyKey, metadataMap);\n  return metadataMap;\n}\n\nfunction ordinaryDefineOwnMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  metadataValue: MetadataValue,\n  target: Target,\n  propertyKey?: PropertyKey,\n): void {\n  if (propertyKey && !['string', 'symbol'].includes(typeof propertyKey)) {\n    throw new TypeError();\n  }\n\n  (\n    getMetadataMap<MetadataValue>(target, propertyKey) ||\n    createMetadataMap<MetadataValue>(target, propertyKey)\n  ).set(metadataKey, metadataValue);\n}\n\nfunction ordinaryGetMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): MetadataValue | undefined {\n  return ordinaryGetOwnMetadata<MetadataValue>(metadataKey, target, propertyKey)\n    ? ordinaryGetOwnMetadata<MetadataValue>(metadataKey, target, propertyKey)\n    : Object.getPrototypeOf(target)\n    ? ordinaryGetMetadata(\n        metadataKey,\n        Object.getPrototypeOf(target),\n        propertyKey,\n      )\n    : undefined;\n}\n\nexport function metadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  metadataValue: MetadataValue,\n) {\n  return function decorator(target: Target, propertyKey?: PropertyKey): void {\n    ordinaryDefineOwnMetadata<MetadataValue>(\n      metadataKey,\n      metadataValue,\n      target,\n      propertyKey,\n    );\n  };\n}\n\nexport function getMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): MetadataValue | undefined {\n  return ordinaryGetMetadata<MetadataValue>(metadataKey, target, propertyKey);\n}\n\nexport function getOwnMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): MetadataValue | undefined {\n  return ordinaryGetOwnMetadata<MetadataValue>(\n    metadataKey,\n    target,\n    propertyKey,\n  );\n}\n\nexport function hasOwnMetadata(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): boolean {\n  return !!ordinaryGetOwnMetadata(metadataKey, target, propertyKey);\n}\n\nexport function hasMetadata(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): boolean {\n  return !!ordinaryGetMetadata(metadataKey, target, propertyKey);\n}\n\nexport function defineMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  metadataValue: MetadataValue,\n  target: Target,\n  propertyKey?: PropertyKey,\n): void {\n  ordinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n}\n\nexport const Reflection = {\n  decorate,\n  defineMetadata,\n  getMetadata,\n  getOwnMetadata,\n  hasMetadata,\n  hasOwnMetadata,\n  metadata,\n};\n\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/no-namespace\n  namespace Reflect {\n    let decorate: typeof Reflection.decorate;\n    let defineMetadata: typeof Reflection.defineMetadata;\n    let getMetadata: typeof Reflection.getMetadata;\n    let getOwnMetadata: typeof Reflection.getOwnMetadata;\n    let hasOwnMetadata: typeof Reflection.hasOwnMetadata;\n    let hasMetadata: typeof Reflection.hasMetadata;\n    let metadata: typeof Reflection.metadata;\n  }\n}\n\nObject.assign(Reflect, Reflection);\n", "import '@abraham/reflection';\n\nexport * from './reflector.service';\nexport * from './timer.service';\n", "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 '@abraham/reflection';\n\nexport * from './core';\nexport * from './errors';\nexport * from './events';\nexport * from './params';\nexport * from './pipeline';\nexport * from './rpc';\nexport * from './timers';\n\nexport * from './apply-decorator.util';\nexport * from './create-event-decorator';\nexport * from './create-param.util';\nexport * from './create-rpc-decorator';\nexport * from './forward-ref.util';\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 '@abraham/reflection';\n\nexport * from './constants';\nexport * from './controller';\nexport * from './enums';\nexport * from './interfaces';\nexport * from './module';\nexport * from './module-tree';\nexport * from './pipeline';\nexport * from './services';\nexport * from './utils';\nexport * from './multiplayer';\n// App\nexport * from './app-builder';\nexport * from './app';\nexport * from './constants';\nexport * from './create-app';\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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~loaded ~lk~(${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                    `~lw~Controller ~lc~${controller.metadata.classRef.name} ~lw~timers and listeners registered ~lk~(${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                `~lw~Module ~lb~${module.metadata.classRef.name} ~lw~dependencies binded ~lk~(${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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~scanned ~lk~(${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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~scanned ~lk~(${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(`~lw~Controller ~lc~${classRef.name} ~lw~scanned ~lk~(${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    INTERNAL_APP_CONTAINER,\n    GLOBAL_ERROR_FILTERS,\n    GLOBAL_GUARDS,\n    GLOBAL_INTERCEPTORS,\n    GLOBAL_PIPES,\n    ENABLE_SHUTDOWN_HOOKS,\n    PLUGINS,\n    GLOBAL_APP_CONTAINER,\n    APP_ENVIROMENT,\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 { inject, Container, injectable, 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 { ExecutionContextType } from './enums';\nimport { REFLECTOR_SERVICE } from '../constants';\nimport { ReflectorService } from '../services';\n\n@injectable()\nexport class AppBuilder<G extends Guard = Guard, I extends Interceptor = Interceptor, EF extends ErrorFilter = ErrorFilter> {\n    @inject(APP_ENVIROMENT) protected readonly enviroment: string;\n    @inject(INTERNAL_APP_CONTAINER) protected readonly internalAppContainer: Container;\n    @inject(MULTIPLAYER_SERVICE) protected readonly multiplayerService: MultiplayerService;\n    @inject(PLUGINS) protected readonly plugins: Newable<MangoPlugin>[];\n\n    private globalContainerOptions: interfaces.ContainerOptions = {};\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('~lw~Starting app...');\n        await this.runPluginMethods('beforeStart');\n\n        this.loggerService.log('~lw~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('~lw~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('~lw~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('~lw~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('~lw~Stopping app...');\n        await this.appRuntime.shutdown(this.moduleTree);\n        this.loaded = false;\n        this.loggerService.log('~lw~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 { APP_ENVIROMENT, INTERNAL_APP_CONTAINER, 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';\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: Newable<T>;\n    multiplayerService?: MultiplayerService;\n}) {\n    const internalAppContainer = new Container();\n\n    if (multiplayerService) internalAppContainer.bind(MULTIPLAYER_SERVICE).toConstantValue(multiplayerService);\n    internalAppContainer.bind(INTERNAL_APP_CONTAINER).toConstantValue(internalAppContainer);\n    internalAppContainer.bind(APP_ENVIROMENT).toConstantValue(enviroment);\n    internalAppContainer.bind(PLUGINS).toConstantValue(plugins);\n    internalAppContainer.bind(appBuilderInherit).toSelf().inSingletonScope();\n\n    return internalAppContainer.get(appBuilderInherit);\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", "function minitz(y,m,d,h,i,s,tz,throwOnInvalid){return minitz.fromTZ(minitz.tp(y,m,d,h,i,s,tz),throwOnInvalid)}minitz.fromTZISO=(localTimeStr,tz,throwOnInvalid)=>{return minitz.fromTZ(parseISOLocal(localTimeStr,tz),throwOnInvalid)};minitz.fromTZ=function(tp,throwOnInvalid){const inDate=new Date(Date.UTC(tp.y,tp.m-1,tp.d,tp.h,tp.i,tp.s)),offset=getTimezoneOffset(tp.tz,inDate),dateGuess=new Date(inDate.getTime()-offset),dateOffsGuess=getTimezoneOffset(tp.tz,dateGuess);if(dateOffsGuess-offset===0){return dateGuess}else{const dateGuess2=new Date(inDate.getTime()-dateOffsGuess),dateOffsGuess2=getTimezoneOffset(tp.tz,dateGuess2);if(dateOffsGuess2-dateOffsGuess===0){return dateGuess2}else if(!throwOnInvalid&&dateOffsGuess2-dateOffsGuess>0){return dateGuess2}else if(!throwOnInvalid){return dateGuess}else{throw new Error(\"Invalid date passed to fromTZ()\")}}};minitz.toTZ=function(d,tzStr){const localDateString=d.toLocaleString(\"en-US\",{timeZone:tzStr}).replace(/[\\u202f]/,\" \");const td=new Date(localDateString);return{y:td.getFullYear(),m:td.getMonth()+1,d:td.getDate(),h:td.getHours(),i:td.getMinutes(),s:td.getSeconds(),tz:tzStr}};minitz.tp=(y,m,d,h,i,s,tz)=>{return{y:y,m:m,d:d,h:h,i:i,s:s,tz:tz}};function getTimezoneOffset(timeZone,date=new Date){const tz=date.toLocaleString(\"en-US\",{timeZone:timeZone,timeZoneName:\"shortOffset\"}).split(\" \").slice(-1)[0];const dateString=date.toLocaleString(\"en-US\").replace(/[\\u202f]/,\" \");return Date.parse(`${dateString} GMT`)-Date.parse(`${dateString} ${tz}`)}function parseISOLocal(dtStr,tz){const pd=new Date(Date.parse(dtStr));if(isNaN(pd)){throw new Error(\"minitz: Invalid ISO8601 passed to parser.\")}const stringEnd=dtStr.substring(9);if(dtStr.includes(\"Z\")||stringEnd.includes(\"-\")||stringEnd.includes(\"+\")){return minitz.tp(pd.getUTCFullYear(),pd.getUTCMonth()+1,pd.getUTCDate(),pd.getUTCHours(),pd.getUTCMinutes(),pd.getUTCSeconds(),\"Etc/UTC\")}else{return minitz.tp(pd.getFullYear(),pd.getMonth()+1,pd.getDate(),pd.getHours(),pd.getMinutes(),pd.getSeconds(),tz)}}minitz.minitz=minitz;function CronOptions(options){if(options===void 0){options={}}delete options.name;options.legacyMode=options.legacyMode===void 0?true:options.legacyMode;options.paused=options.paused===void 0?false:options.paused;options.maxRuns=options.maxRuns===void 0?Infinity:options.maxRuns;options.catch=options.catch===void 0?false:options.catch;options.interval=options.interval===void 0?0:parseInt(options.interval,10);options.utcOffset=options.utcOffset===void 0?void 0:parseInt(options.utcOffset,10);options.unref=options.unref===void 0?false:options.unref;if(options.startAt){options.startAt=new CronDate(options.startAt,options.timezone)}if(options.stopAt){options.stopAt=new CronDate(options.stopAt,options.timezone)}if(options.interval!==null){if(isNaN(options.interval)){throw new Error(\"CronOptions: Supplied value for interval is not a number\")}else if(options.interval<0){throw new Error(\"CronOptions: Supplied value for interval can not be negative\")}}if(options.utcOffset!==void 0){if(isNaN(options.utcOffset)){throw new Error(\"CronOptions: Invalid value passed for utcOffset, should be number representing minutes offset from UTC.\")}else if(options.utcOffset<-870||options.utcOffset>870){throw new Error(\"CronOptions: utcOffset out of bounds.\")}if(options.utcOffset!==void 0&&options.timezone){throw new Error(\"CronOptions: Combining 'utcOffset' with 'timezone' is not allowed.\")}}if(options.unref!==true&&options.unref!==false){throw new Error(\"CronOptions: Unref should be either true, false or undefined(false).\")}return options}const LAST_OCCURRENCE=32;const ANY_OCCURRENCE=1|2|4|8|16|LAST_OCCURRENCE;const OCCURRENCE_BITMASKS=[1,2,4,8,16];function CronPattern(pattern,timezone){this.pattern=pattern;this.timezone=timezone;this.second=Array(60).fill(0);this.minute=Array(60).fill(0);this.hour=Array(24).fill(0);this.day=Array(31).fill(0);this.month=Array(12).fill(0);this.dayOfWeek=Array(7).fill(0);this.lastDayOfMonth=false;this.starDOM=false;this.starDOW=false;this.parse()}CronPattern.prototype.parse=function(){if(!(typeof this.pattern===\"string\"||this.pattern.constructor===String)){throw new TypeError(\"CronPattern: Pattern has to be of type string.\")}if(this.pattern.indexOf(\"@\")>=0)this.pattern=this.handleNicknames(this.pattern).trim();const parts=this.pattern.replace(/\\s+/g,\" \").split(\" \");if(parts.length<5||parts.length>6){throw new TypeError(\"CronPattern: invalid configuration format ('\"+this.pattern+\"'), exactly five or six space separated parts are required.\")}if(parts.length===5){parts.unshift(\"0\")}if(parts[3].indexOf(\"L\")>=0){parts[3]=parts[3].replace(\"L\",\"\");this.lastDayOfMonth=true}if(parts[3]==\"*\"){this.starDOM=true}if(parts[4].length>=3)parts[4]=this.replaceAlphaMonths(parts[4]);if(parts[5].length>=3)parts[5]=this.replaceAlphaDays(parts[5]);if(parts[5]==\"*\"){this.starDOW=true}if(this.pattern.indexOf(\"?\")>=0){const initDate=new CronDate(new Date,this.timezone).getDate(true);parts[0]=parts[0].replace(\"?\",initDate.getSeconds());parts[1]=parts[1].replace(\"?\",initDate.getMinutes());parts[2]=parts[2].replace(\"?\",initDate.getHours());if(!this.starDOM)parts[3]=parts[3].replace(\"?\",initDate.getDate());parts[4]=parts[4].replace(\"?\",initDate.getMonth()+1);if(!this.starDOW)parts[5]=parts[5].replace(\"?\",initDate.getDay())}this.throwAtIllegalCharacters(parts);this.partToArray(\"second\",parts[0],0,1);this.partToArray(\"minute\",parts[1],0,1);this.partToArray(\"hour\",parts[2],0,1);this.partToArray(\"day\",parts[3],-1,1);this.partToArray(\"month\",parts[4],-1,1);this.partToArray(\"dayOfWeek\",parts[5],0,ANY_OCCURRENCE);if(this.dayOfWeek[7]){this.dayOfWeek[0]=this.dayOfWeek[7]}};CronPattern.prototype.partToArray=function(type,conf,valueIndexOffset,defaultValue){const arr=this[type];const lastDayOfMonth=type===\"day\"&&this.lastDayOfMonth;if(conf===\"\"&&!lastDayOfMonth)throw new TypeError(\"CronPattern: configuration entry \"+type+\" (\"+conf+\") is empty, check for trailing spaces.\");if(conf===\"*\")return arr.fill(defaultValue);const split=conf.split(\",\");if(split.length>1){for(let i=0;i<split.length;i++){this.partToArray(type,split[i],valueIndexOffset,defaultValue)}}else if(conf.indexOf(\"-\")!==-1&&conf.indexOf(\"/\")!==-1){this.handleRangeWithStepping(conf,type,valueIndexOffset,defaultValue)}else if(conf.indexOf(\"-\")!==-1){this.handleRange(conf,type,valueIndexOffset,defaultValue)}else if(conf.indexOf(\"/\")!==-1){this.handleStepping(conf,type,valueIndexOffset,defaultValue)}else if(conf!==\"\"){this.handleNumber(conf,type,valueIndexOffset,defaultValue)}};CronPattern.prototype.throwAtIllegalCharacters=function(parts){for(let i=0;i<parts.length;i++){const reValidCron=i===5?/[^/*0-9,\\-#L]+/:/[^/*0-9,-]+/;if(reValidCron.test(parts[i])){throw new TypeError(\"CronPattern: configuration entry \"+i+\" (\"+parts[i]+\") contains illegal characters.\")}}};CronPattern.prototype.handleNumber=function(conf,type,valueIndexOffset,defaultValue){const result=this.extractNth(conf,type);const i=parseInt(result[0],10)+valueIndexOffset;if(isNaN(i)){throw new TypeError(\"CronPattern: \"+type+\" is not a number: '\"+conf+\"'\")}this.setPart(type,i,result[1]||defaultValue)};CronPattern.prototype.setPart=function(part,index,value){if(!Object.prototype.hasOwnProperty.call(this,part)){throw new TypeError(\"CronPattern: Invalid part specified: \"+part)}if(part===\"dayOfWeek\"){if(index===7)index=0;if((index<0||index>6)&&index!==\"L\"){throw new RangeError(\"CronPattern: Invalid value for dayOfWeek: \"+index)}this.setNthWeekdayOfMonth(index,value);return}if(part===\"second\"||part===\"minute\"){if(index<0||index>=60){throw new RangeError(\"CronPattern: Invalid value for \"+part+\": \"+index)}}else if(part===\"hour\"){if(index<0||index>=24){throw new RangeError(\"CronPattern: Invalid value for \"+part+\": \"+index)}}else if(part===\"day\"){if(index<0||index>=31){throw new RangeError(\"CronPattern: Invalid value for \"+part+\": \"+index)}}else if(part===\"month\"){if(index<0||index>=12){throw new RangeError(\"CronPattern: Invalid value for \"+part+\": \"+index)}}this[part][index]=value};CronPattern.prototype.handleRangeWithStepping=function(conf,type,valueIndexOffset,defaultValue){const result=this.extractNth(conf,type);const matches=result[0].match(/^(\\d+)-(\\d+)\\/(\\d+)$/);if(matches===null)throw new TypeError(\"CronPattern: Syntax error, illegal range with stepping: '\"+conf+\"'\");let[,lower,upper,steps]=matches;lower=parseInt(lower,10)+valueIndexOffset;upper=parseInt(upper,10)+valueIndexOffset;steps=parseInt(steps,10);if(isNaN(lower))throw new TypeError(\"CronPattern: Syntax error, illegal lower range (NaN)\");if(isNaN(upper))throw new TypeError(\"CronPattern: Syntax error, illegal upper range (NaN)\");if(isNaN(steps))throw new TypeError(\"CronPattern: Syntax error, illegal stepping: (NaN)\");if(steps===0)throw new TypeError(\"CronPattern: Syntax error, illegal stepping: 0\");if(steps>this[type].length)throw new TypeError(\"CronPattern: Syntax error, steps cannot be greater than maximum value of part (\"+this[type].length+\")\");if(lower>upper)throw new TypeError(\"CronPattern: From value is larger than to value: '\"+conf+\"'\");for(let i=lower;i<=upper;i+=steps){this.setPart(type,i,result[1]||defaultValue)}};CronPattern.prototype.extractNth=function(conf,type){let rest=conf;let nth;if(rest.includes(\"#\")){if(type!==\"dayOfWeek\"){throw new Error(\"CronPattern: nth (#) only allowed in day-of-week field\")}nth=rest.split(\"#\")[1];rest=rest.split(\"#\")[0]}return[rest,nth]};CronPattern.prototype.handleRange=function(conf,type,valueIndexOffset,defaultValue){const result=this.extractNth(conf,type);const split=result[0].split(\"-\");if(split.length!==2){throw new TypeError(\"CronPattern: Syntax error, illegal range: '\"+conf+\"'\")}const lower=parseInt(split[0],10)+valueIndexOffset,upper=parseInt(split[1],10)+valueIndexOffset;if(isNaN(lower)){throw new TypeError(\"CronPattern: Syntax error, illegal lower range (NaN)\")}else if(isNaN(upper)){throw new TypeError(\"CronPattern: Syntax error, illegal upper range (NaN)\")}if(lower>upper){throw new TypeError(\"CronPattern: From value is larger than to value: '\"+conf+\"'\")}for(let i=lower;i<=upper;i++){this.setPart(type,i,result[1]||defaultValue)}};CronPattern.prototype.handleStepping=function(conf,type,valueIndexOffset,defaultValue){const result=this.extractNth(conf,type);const split=result[0].split(\"/\");if(split.length!==2){throw new TypeError(\"CronPattern: Syntax error, illegal stepping: '\"+conf+\"'\")}let start=0;if(split[0]!==\"*\"){start=parseInt(split[0],10)+valueIndexOffset}const steps=parseInt(split[1],10);if(isNaN(steps))throw new TypeError(\"CronPattern: Syntax error, illegal stepping: (NaN)\");if(steps===0)throw new TypeError(\"CronPattern: Syntax error, illegal stepping: 0\");if(steps>this[type].length)throw new TypeError(\"CronPattern: Syntax error, max steps for part is (\"+this[type].length+\")\");for(let i=start;i<this[type].length;i+=steps){this.setPart(type,i,result[1]||defaultValue)}};CronPattern.prototype.replaceAlphaDays=function(conf){return conf.replace(/-sun/gi,\"-7\").replace(/sun/gi,\"0\").replace(/mon/gi,\"1\").replace(/tue/gi,\"2\").replace(/wed/gi,\"3\").replace(/thu/gi,\"4\").replace(/fri/gi,\"5\").replace(/sat/gi,\"6\")};CronPattern.prototype.replaceAlphaMonths=function(conf){return conf.replace(/jan/gi,\"1\").replace(/feb/gi,\"2\").replace(/mar/gi,\"3\").replace(/apr/gi,\"4\").replace(/may/gi,\"5\").replace(/jun/gi,\"6\").replace(/jul/gi,\"7\").replace(/aug/gi,\"8\").replace(/sep/gi,\"9\").replace(/oct/gi,\"10\").replace(/nov/gi,\"11\").replace(/dec/gi,\"12\")};CronPattern.prototype.handleNicknames=function(pattern){const cleanPattern=pattern.trim().toLowerCase();if(cleanPattern===\"@yearly\"||cleanPattern===\"@annually\"){return\"0 0 1 1 *\"}else if(cleanPattern===\"@monthly\"){return\"0 0 1 * *\"}else if(cleanPattern===\"@weekly\"){return\"0 0 * * 0\"}else if(cleanPattern===\"@daily\"){return\"0 0 * * *\"}else if(cleanPattern===\"@hourly\"){return\"0 * * * *\"}else{return pattern}};CronPattern.prototype.setNthWeekdayOfMonth=function(index,nthWeekday){if(nthWeekday===\"L\"){this[\"dayOfWeek\"][index]=this[\"dayOfWeek\"][index]|LAST_OCCURRENCE}else if(nthWeekday<6&&nthWeekday>0){this[\"dayOfWeek\"][index]=this[\"dayOfWeek\"][index]|OCCURRENCE_BITMASKS[nthWeekday-1]}else if(nthWeekday===ANY_OCCURRENCE){this[\"dayOfWeek\"][index]=ANY_OCCURRENCE}else{throw new TypeError(`CronPattern: nth weekday of of range, should be 1-5 or L. Value: ${nthWeekday}`)}};const DaysOfMonth=[31,28,31,30,31,30,31,31,30,31,30,31];const RecursionSteps=[[\"month\",\"year\",0],[\"day\",\"month\",-1],[\"hour\",\"day\",0],[\"minute\",\"hour\",0],[\"second\",\"minute\",0]];function CronDate(d,tz){this.tz=tz;if(d&&d instanceof Date){if(!isNaN(d)){this.fromDate(d)}else{throw new TypeError(\"CronDate: Invalid date passed to CronDate constructor\")}}else if(d===void 0){this.fromDate(new Date)}else if(d&&typeof d===\"string\"){this.fromString(d)}else if(d instanceof CronDate){this.fromCronDate(d)}else{throw new TypeError(\"CronDate: Invalid type (\"+typeof d+\") passed to CronDate constructor\")}}CronDate.prototype.isNthWeekdayOfMonth=function(year,month,day,nth){const date=new Date(Date.UTC(year,month,day));const weekday=date.getUTCDay();let count=0;for(let d=1;d<=day;d++){if(new Date(Date.UTC(year,month,d)).getUTCDay()===weekday){count++}}if(nth&ANY_OCCURRENCE&&OCCURRENCE_BITMASKS[count-1]&nth){return true}if(nth&LAST_OCCURRENCE){const daysInMonth=new Date(Date.UTC(year,month+1,0)).getUTCDate();for(let d=day+1;d<=daysInMonth;d++){if(new Date(Date.UTC(year,month,d)).getUTCDay()===weekday){return false}}return true}return false};CronDate.prototype.fromDate=function(inDate){if(this.tz!==void 0){if(typeof this.tz===\"number\"){this.ms=inDate.getUTCMilliseconds();this.second=inDate.getUTCSeconds();this.minute=inDate.getUTCMinutes()+this.tz;this.hour=inDate.getUTCHours();this.day=inDate.getUTCDate();this.month=inDate.getUTCMonth();this.year=inDate.getUTCFullYear();this.apply()}else{const d=minitz.toTZ(inDate,this.tz);this.ms=inDate.getMilliseconds();this.second=d.s;this.minute=d.i;this.hour=d.h;this.day=d.d;this.month=d.m-1;this.year=d.y}}else{this.ms=inDate.getMilliseconds();this.second=inDate.getSeconds();this.minute=inDate.getMinutes();this.hour=inDate.getHours();this.day=inDate.getDate();this.month=inDate.getMonth();this.year=inDate.getFullYear()}};CronDate.prototype.fromCronDate=function(d){this.tz=d.tz;this.year=d.year;this.month=d.month;this.day=d.day;this.hour=d.hour;this.minute=d.minute;this.second=d.second;this.ms=d.ms};CronDate.prototype.apply=function(){if(this.month>11||this.day>DaysOfMonth[this.month]||this.hour>59||this.minute>59||this.second>59||this.hour<0||this.minute<0||this.second<0){const d=new Date(Date.UTC(this.year,this.month,this.day,this.hour,this.minute,this.second,this.ms));this.ms=d.getUTCMilliseconds();this.second=d.getUTCSeconds();this.minute=d.getUTCMinutes();this.hour=d.getUTCHours();this.day=d.getUTCDate();this.month=d.getUTCMonth();this.year=d.getUTCFullYear();return true}else{return false}};CronDate.prototype.fromString=function(str){if(typeof this.tz===\"number\"){const inDate=minitz.fromTZISO(str);this.ms=inDate.getUTCMilliseconds();this.second=inDate.getUTCSeconds();this.minute=inDate.getUTCMinutes();this.hour=inDate.getUTCHours();this.day=inDate.getUTCDate();this.month=inDate.getUTCMonth();this.year=inDate.getUTCFullYear();this.apply()}else{return this.fromDate(minitz.fromTZISO(str,this.tz))}};CronDate.prototype.findNext=function(options,target,pattern,offset){const originalTarget=this[target];let lastDayOfMonth;if(pattern.lastDayOfMonth){if(this.month!==1){lastDayOfMonth=DaysOfMonth[this.month]}else{lastDayOfMonth=new Date(Date.UTC(this.year,this.month+1,0,0,0,0,0)).getUTCDate()}}const fDomWeekDay=!pattern.starDOW&&target==\"day\"?new Date(Date.UTC(this.year,this.month,1,0,0,0,0)).getUTCDay():undefined;for(let i=this[target]+offset;i<pattern[target].length;i++){let match=pattern[target][i];if(target===\"day\"&&pattern.lastDayOfMonth&&i-offset==lastDayOfMonth){match=true}if(target===\"day\"&&!pattern.starDOW){let dowMatch=pattern.dayOfWeek[(fDomWeekDay+(i-offset-1))%7];if(dowMatch&&dowMatch&ANY_OCCURRENCE){dowMatch=this.isNthWeekdayOfMonth(this.year,this.month,i-offset,dowMatch)}else if(dowMatch){throw new Error(`CronDate: Invalid value for dayOfWeek encountered. ${dowMatch}`)}if(options.legacyMode&&!pattern.starDOM){match=match||dowMatch}else{match=match&&dowMatch}}if(match){this[target]=i-offset;return originalTarget!==this[target]?2:1}}return 3};CronDate.prototype.recurse=function(pattern,options,doing){const res=this.findNext(options,RecursionSteps[doing][0],pattern,RecursionSteps[doing][2]);if(res>1){let resetLevel=doing+1;while(resetLevel<RecursionSteps.length){this[RecursionSteps[resetLevel][0]]=-RecursionSteps[resetLevel][2];resetLevel++}if(res===3){this[RecursionSteps[doing][1]]++;this[RecursionSteps[doing][0]]=-RecursionSteps[doing][2];this.apply();return this.recurse(pattern,options,0)}else if(this.apply()){return this.recurse(pattern,options,doing-1)}}doing+=1;if(doing>=RecursionSteps.length){return this}else if(this.year>=3e3){return null}else{return this.recurse(pattern,options,doing)}};CronDate.prototype.increment=function(pattern,options,hasPreviousRun){this.second+=options.interval>1&&hasPreviousRun?options.interval:1;this.ms=0;this.apply();return this.recurse(pattern,options,0)};CronDate.prototype.getDate=function(internal){if(internal||this.tz===void 0){return new Date(this.year,this.month,this.day,this.hour,this.minute,this.second,this.ms)}else{if(typeof this.tz===\"number\"){return new Date(Date.UTC(this.year,this.month,this.day,this.hour,this.minute-this.tz,this.second,this.ms))}else{return minitz(this.year,this.month+1,this.day,this.hour,this.minute,this.second,this.tz)}}};CronDate.prototype.getTime=function(){return this.getDate().getTime()};function isFunction(v){return Object.prototype.toString.call(v)===\"[object Function]\"||\"function\"===typeof v||v instanceof Function}function unrefTimer(timer){if(typeof Deno!==\"undefined\"&&typeof Deno.unrefTimer!==\"undefined\"){Deno.unrefTimer(timer)}else if(timer&&typeof timer.unref!==\"undefined\"){timer.unref()}}const maxDelay=30*1e3;const scheduledJobs=[];function Cron(pattern,fnOrOptions1,fnOrOptions2){if(!(this instanceof Cron)){return new Cron(pattern,fnOrOptions1,fnOrOptions2)}let options,func;if(isFunction(fnOrOptions1)){func=fnOrOptions1}else if(typeof fnOrOptions1===\"object\"){options=fnOrOptions1}else if(fnOrOptions1!==void 0){throw new Error(\"Cron: Invalid argument passed for optionsIn. Should be one of function, or object (options).\")}if(isFunction(fnOrOptions2)){func=fnOrOptions2}else if(typeof fnOrOptions2===\"object\"){options=fnOrOptions2}else if(fnOrOptions2!==void 0){throw new Error(\"Cron: Invalid argument passed for funcIn. Should be one of function, or object (options).\")}this.name=options?options.name:void 0;this.options=CronOptions(options);this._states={kill:false,blocking:false,previousRun:void 0,currentRun:void 0,once:void 0,currentTimeout:void 0,maxRuns:options?options.maxRuns:void 0,paused:options?options.paused:false,pattern:void 0};if(pattern&&(pattern instanceof Date||typeof pattern===\"string\"&&pattern.indexOf(\":\")>0)){this._states.once=new CronDate(pattern,this.options.timezone||this.options.utcOffset)}else{this._states.pattern=new CronPattern(pattern,this.options.timezone)}if(this.name){const existing=scheduledJobs.find(j=>j.name===this.name);if(existing){throw new Error(\"Cron: Tried to initialize new named job '\"+this.name+\"', but name already taken.\")}else{scheduledJobs.push(this)}}if(func!==void 0){this.fn=func;this.schedule()}return this}Cron.prototype.nextRun=function(prev){const next=this._next(prev);return next?next.getDate():null};Cron.prototype.nextRuns=function(n,previous){if(n>this._states.maxRuns){n=this._states.maxRuns}const enumeration=[];let prev=previous||this._states.currentRun;while(n--&&(prev=this.nextRun(prev))){enumeration.push(prev)}return enumeration};Cron.prototype.getPattern=function(){return this._states.pattern?this._states.pattern.pattern:void 0};Cron.prototype.isRunning=function(){const nextRunTime=this.nextRun(this._states.currentRun);const isRunning=!this._states.paused;const isScheduled=this.fn!==void 0;const notIsKilled=!this._states.kill;return isRunning&&isScheduled&&notIsKilled&&nextRunTime!==null};Cron.prototype.isStopped=function(){return this._states.kill};Cron.prototype.isBusy=function(){return this._states.blocking};Cron.prototype.currentRun=function(){return this._states.currentRun?this._states.currentRun.getDate():null};Cron.prototype.previousRun=function(){return this._states.previousRun?this._states.previousRun.getDate():null};Cron.prototype.msToNext=function(prev){prev=prev||new Date;const next=this._next(prev);if(next){return next.getTime()-prev.getTime()}else{return null}};Cron.prototype.stop=function(){this._states.kill=true;if(this._states.currentTimeout){clearTimeout(this._states.currentTimeout)}const jobIndex=scheduledJobs.indexOf(this);if(jobIndex>=0){scheduledJobs.splice(jobIndex,1)}};Cron.prototype.pause=function(){this._states.paused=true;return!this._states.kill};Cron.prototype.resume=function(){this._states.paused=false;return!this._states.kill};Cron.prototype.schedule=function(func){if(func&&this.fn){throw new Error(\"Cron: It is not allowed to schedule two functions using the same Croner instance.\")}else if(func){this.fn=func}let waitMs=this.msToNext();const target=this.nextRun(this._states.currentRun);if(waitMs===null||waitMs===undefined||isNaN(waitMs)||target===null)return this;if(waitMs>maxDelay){waitMs=maxDelay}this._states.currentTimeout=setTimeout(()=>this._checkTrigger(target),waitMs);if(this._states.currentTimeout&&this.options.unref){unrefTimer(this._states.currentTimeout)}return this};Cron.prototype._trigger=async function(initiationDate){this._states.blocking=true;this._states.currentRun=new CronDate(void 0,this.options.timezone||this.options.utcOffset);if(this.options.catch){try{await this.fn(this,this.options.context)}catch(_e){if(isFunction(this.options.catch)){this.options.catch(_e,this)}}}else{await this.fn(this,this.options.context)}this._states.previousRun=new CronDate(initiationDate,this.options.timezone||this.options.utcOffset);this._states.blocking=false};Cron.prototype.trigger=async function(){await this._trigger()};Cron.prototype._checkTrigger=function(target){const now=new Date,shouldRun=!this._states.paused&&now.getTime()>=target,isBlocked=this._states.blocking&&this.options.protect;if(shouldRun&&!isBlocked){this._states.maxRuns--;this._trigger()}else{if(shouldRun&&isBlocked&&isFunction(this.options.protect)){setTimeout(()=>this.options.protect(this),0)}}this.schedule()};Cron.prototype._next=function(prev){let hasPreviousRun=prev||this._states.currentRun?true:false;let startAtInFutureWithInterval=false;if(!prev&&this.options.startAt&&this.options.interval){[prev,hasPreviousRun]=this._calculatePreviousRun(prev,hasPreviousRun);startAtInFutureWithInterval=!prev?true:false}prev=new CronDate(prev,this.options.timezone||this.options.utcOffset);if(this.options.startAt&&prev&&prev.getTime()<this.options.startAt.getTime()){prev=this.options.startAt}let nextRun=this._states.once||new CronDate(prev,this.options.timezone||this.options.utcOffset);if(!startAtInFutureWithInterval&&nextRun!==this._states.once){nextRun=nextRun.increment(this._states.pattern,this.options,hasPreviousRun)}if(this._states.once&&this._states.once.getTime()<=prev.getTime()){return null}else if(nextRun===null||this._states.maxRuns<=0||this._states.kill||this.options.stopAt&&nextRun.getTime()>=this.options.stopAt.getTime()){return null}else{return nextRun}};Cron.prototype._calculatePreviousRun=function(prev,hasPreviousRun){const now=new CronDate(undefined,this.options.timezone||this.options.utcOffset);if(this.options.startAt.getTime()<=now.getTime()){prev=this.options.startAt;let prevTimePlusInterval=prev.getTime()+this.options.interval*1e3;while(prevTimePlusInterval<=now.getTime()){prev=new CronDate(prev,this.options.timezone||this.options.utcOffset).increment(this._states.pattern,this.options,true);prevTimePlusInterval=prev.getTime()+this.options.interval*1e3}hasPreviousRun=true}return[prev,hasPreviousRun]};Cron.Cron=Cron;Cron.scheduledJobs=scheduledJobs;export{Cron,Cron as default,scheduledJobs};", "import { injectable } from 'inversify';\nimport { ErrorMessage } from '../../enums';\nimport type { EventEmmiter, ScriptEventHandler } from '../interfaces';\nimport type { EventHandler } from '../../interfaces';\n\n@injectable()\nexport abstract class BaseEventService<T extends Record<string, any>> {\n    protected readonly $localHandlers: Set<ScriptEventHandler> = new Set();\n    protected readonly $internalHandlers: Set<ScriptEventHandler> = new Set();\n    protected readonly $remoteHandlers: Set<ScriptEventHandler> = new Set();\n    protected $internalEventNames = new Set<string>();\n    constructor(protected $eventEmmiter: EventEmmiter) {}\n\n    public on<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;\n    public on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;\n    public on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.on(eventName, wrapper);\n        this.$localHandlers.add(eventHandler);\n        return eventHandler;\n    }\n    public once<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;\n    public once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;\n    public once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.once(eventName, wrapper);\n        this.$localHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public emit<E extends keyof T>(eventName: E, body?: T[E]): void;\n    public emit<E extends string>(eventName: E, body?: unknown): void;\n    public emit<E extends string>(eventName: E, body?: unknown) {\n        this.$eventEmmiter.emit(eventName, body);\n    }\n\n    protected $onInternal(eventName: string, handler: (body: unknown) => void | Promise<void>) {\n        if (!this.$internalEventNames.has(eventName)) {\n            throw new Error(ErrorMessage.InvalidInternalEventName);\n        }\n        const eventHandler = <EventHandler>this.$eventEmmiter.on(eventName, handler);\n        this.$internalHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    protected $onceInternal(eventName: string, handler: (body: unknown) => void | Promise<void>) {\n        if (!this.$internalEventNames.has(eventName)) {\n            throw new Error(ErrorMessage.InvalidInternalEventName);\n        }\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.once(eventName, handler);\n        this.$internalHandlers.add(eventHandler);\n        return eventHandler;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { RPCResult, RPCCallOptions, ScriptRPCHandler, LoggerService } from '../../interfaces';\nimport { RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_TIMEOUT, RPC_RESULT_UNKNOWN } from '../../app/constants';\nimport { ErrorMessage, RPCResultStatus } from '../../enums';\nimport { MangoError } from '../../errors';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class BaseRPCService<T extends Record<string, any>> {\n    @inject(LOGGER_SERVICE) protected readonly $loggerService: LoggerService;\n    protected readonly $TIMEOUT = 2000;\n    private readonly $localHandlers = new Map<string, ScriptRPCHandler>();\n\n    public async call<E extends keyof T>(\n        rpcName: E,\n        body?: Parameters<T[E]>[0],\n        options?: RPCCallOptions,\n    ): Promise<RPCResult<ReturnType<T[E]>>>;\n    public async call<E extends string>(rpcName: E, body?: unknown, options?: RPCCallOptions): Promise<RPCResult<unknown>>;\n    public async call<E extends string>(rpcName: E, body?: unknown, options: RPCCallOptions = { timeout: this.$TIMEOUT }) {\n        return new Promise(async (resolve) => {\n            const handler = this.$localHandlers.get(<string>rpcName)?.handler;\n            if (!handler) {\n                return resolve(RPC_RESULT_HANDLER_NOT_FOUND);\n            }\n\n            const timeoutId = setTimeout(() => {\n                resolve(RPC_RESULT_TIMEOUT);\n            }, options.timeout ?? this.$TIMEOUT);\n\n            try {\n                const result = await handler(body);\n                clearTimeout(timeoutId);\n                resolve({ success: true, status: RPCResultStatus.Success, body: result });\n            } catch (error) {\n                clearTimeout(timeoutId);\n\n                if (error instanceof MangoError) {\n                    return resolve({\n                        success: false,\n                        status: error.status,\n                        error: { message: error.message, details: error.details },\n                    });\n                }\n\n                resolve(RPC_RESULT_UNKNOWN);\n            }\n        });\n    }\n    public onRequest<E extends keyof T>(rpcName: E, handler: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptRPCHandler;\n    public onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;\n    public onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>) {\n        if (this.$localHandlers.has(rpcName)) {\n            this.$loggerService.error('An error occurred while trying to register RPC.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n\n        const rpcHandler: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\n                rpcHandler.valid = false;\n                this.$localHandlers.delete(rpcName);\n            },\n            rpcName: rpcName,\n            handler,\n            valid: true,\n        };\n\n        this.$localHandlers.set(rpcName, rpcHandler);\n\n        return rpcHandler;\n    }\n}\n", "export const WEBVIEW_SERVICE = 'WEBVIEW_SERVICE';\nexport const WEBVIEW_LIST_SERVICE = 'WEBVIEW_LIST_SERVICE';\nexport const ADD_WEBVIEW = 'ADD_WEBVIEW';\n", "export const INTERNAL_EVENTS = {\n    SCRIPT_RPC: 'scriptRPC',\n    SCRIPT_RPC_ANSWER: 'scriptRPCAnswer',\n    KEYBOARD_EVENT: 'keyboardEvent',\n    KEY_UP: 'keyUp',\n    KEY_DOWN: 'keyDown',\n    WEB_VIEW_EVENT: 'webViewEvent',\n    WEB_SOCKET_EVENT: 'webSocketEvent',\n    AUDIO_EVENT: 'audioEvent',\n    RMLUI_EVENT: 'rmluiEvent',\n    WINDOW_FOCUS_CHANGE: 'windowFocusChange',\n    WINDOW_RESOLUTION_CHANGE: 'windowResolutionChange',\n    CONNECTION_COMPLETE: 'connectionComplete',\n    DISCONNECT: 'disconnect',\n    SPAWNED: 'spawned',\n    GAME_ENTITY_CREATE: 'gameEntityCreate',\n    GAME_ENTITY_DESTROY: 'gameEntityDestroy',\n    ENTITY_HIT_ENTITY: 'entityHitEntity',\n    TASK_CHANGE: 'taskChange',\n    PLAYER_WEAPON_SHOOT: 'playerWeaponShoot',\n    PLAYER_BULLET_HIT: 'playerBulletHit',\n    PLAYER_WEAPON_CHANGE: 'playerWeaponChange',\n    PLAYER_START_VEHICLE_ENTER: 'playerStartVehicleEnter',\n    PLAYER_START_VEHICLE_LEAVE: 'playerStartVehicleLeave',\n    PLAYER_VEHICLE_ENTERED: 'playerVehicleEntered',\n    PLAYER_VEHICLE_LEFT: 'playerVehicleLeft',\n    PLAYER_VEHICLE_SEAT_CHANGE: 'playerVehicleSeatChange',\n    VOICE_CONNECTION: 'voiceConnection',\n    PLAYER_START_TALKING: 'playerStartTalking',\n    PLAYER_STOP_TALKING: 'playerStopTalking',\n    WORLD_OBJECT_POSITION_CHANGE: 'worldObjectPositionChange',\n    WORLD_OBJECT_STREAM_IN: 'worldObjectStreamIn',\n    WORLD_OBJECT_STREAM_OUT: 'worldObjectStreamOut',\n    EVENT: 'event',\n    BASE_OBJECT_CREATE: 'baseObjectCreate',\n    BASE_OBJECT_REMOVE: 'baseObjectRemove',\n    NET_OWNER_CHANGE: 'netOwnerChange',\n    WEAPON_DAMAGE: 'weaponDamage',\n    META_CHANGE: 'metaChange',\n    LOCAL_META_CHANGE: 'localMetaChange',\n    SYNCED_META_CHANGE: 'syncedMetaChange',\n    STREAM_SYNCED_META_CHANGE: 'streamSyncedMetaChange',\n    GLOBAL_META_CHANGE: 'globalMetaChange',\n    GLOBAL_SYNCED_META_CHANGE: 'globalSyncedMetaChange',\n    ENTITY_COL_SHAPE_ENTER: 'entityColShapeEnter',\n    ENTITY_COL_SHAPE_LEAVE: 'entityColShapeLeave',\n    ENTITY_CHECKPOINT_ENTER: 'entityCheckpointEnter',\n    ENTITY_CHECKPOINT_LEAVE: 'entityCheckpointLeave',\n    COL_SHAPE_EVENT: 'colShapeEvent',\n    CONSOLE_COMMAND: 'consoleCommand',\n    ERROR: 'error',\n    LOCAL_SCRIPT_EVENT: 'localScriptEvent',\n    REMOTE_SCRIPT_EVENT: 'remoteScriptEvent',\n    RESOURCE_START: 'resourceStart',\n    RESOURCE_STOP: 'resourceStop',\n    RESOURCE_ERROR: 'resourceError',\n} as const;\n", "import { inject, injectable } from 'inversify';\nimport type { MangoPlugin } from '@ragemp-mango/core/app';\nimport { EVENT_SERVICE, LOGGER_SERVICE, type LoggerService } from '@ragemp-mango/core';\nimport { WEBVIEW_SERVICE } from '../constants';\nimport type { EventService } from '../interfaces';\nimport type { ClientWebViewService } from '../services';\n\n@injectable()\nexport class EventMediatorPlugin implements MangoPlugin {\n    @inject(EVENT_SERVICE) private readonly eventService: EventService;\n    @inject(WEBVIEW_SERVICE) private readonly webViewService: ClientWebViewService;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public beforeLoad() {\n        const time = Date.now();\n\n        this.eventService.onServer('SERVER::EMIT_WEBVIEW', (body) => {\n            this.webViewService.get(body.id)?.emit(`WEBVIEW::ON_SERVER_${body.eventName}`, body.payload);\n        });\n\n        this.webViewService.$onCreate((id, webView) => {\n            webView.on('WEBVIEW::EMIT_SERVER', (data: string) => {\n                // Data is JSON stringified from webview because RAGE:MP doesn't properly serialize objects\n                const body = JSON.parse(data) as { eventName: string; payload: unknown };\n                this.eventService.emitServer(`SERVER::ON_WEBVIEW_${body.eventName}_${id}`, body.payload);\n            });\n        });\n\n        this.loggerService.log(`~lw~Event mediator methods defined ~lk~(${Date.now() - time}ms)`);\n    }\n}\n", "import type { Pipe } from '../interfaces';\nimport { isNil, isNumber } from '../utils';\n\nexport class DefaultValuePipe<T = unknown, R = unknown> implements Pipe<T, T | R> {\n    constructor(private readonly defaultValue: T) {}\n\n    public transform(value: T) {\n        if (isNil(value) || (isNumber(value) && isNaN(<number>value))) {\n            return this.defaultValue;\n        }\n        return value;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport { type MangoPlugin, type RPCPayload, RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_UNKNOWN } from '@ragemp-mango/core/app';\nimport {\n    EVENT_SERVICE,\n    RPC_SERVICE,\n    RPCResultStatus,\n    type RPCResult,\n    MangoError,\n    LOGGER_SERVICE,\n    isNil,\n    type LoggerService,\n} from '@ragemp-mango/core';\nimport { WEBVIEW_SERVICE } from '../constants';\nimport type { ClientWebViewService } from '../services';\nimport type { EventService, RPCService } from '../interfaces';\n\n@injectable()\nexport class RPCPlugin implements MangoPlugin {\n    @inject(EVENT_SERVICE) private readonly eventService: EventService;\n    @inject(WEBVIEW_SERVICE) private readonly webViewService: ClientWebViewService;\n    @inject(RPC_SERVICE) private readonly rpcService: RPCService;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public beforeLoad() {\n        const time = Date.now();\n\n        this.eventService.onServer('RPC::CALL_CLIENT', async (payload) => {\n            const rpcHandler = this.rpcService.$serverHandlers.get(payload.rpcName);\n            if (isNil(rpcHandler)) {\n                this.eventService.emitServer(`RPC::RETURN_FROM_CLIENT_${payload.id}`, RPC_RESULT_HANDLER_NOT_FOUND);\n                return;\n            }\n\n            try {\n                const result = await rpcHandler.handler(payload.body);\n                const rpcResult: RPCResult = {\n                    success: true,\n                    status: RPCResultStatus.Success,\n                    body: result,\n                };\n                this.eventService.emitServer(`RPC::RETURN_FROM_CLIENT_${payload.id}`, rpcResult);\n            } catch (error) {\n                if (error instanceof MangoError) {\n                    const rpcResult: RPCResult = {\n                        success: false,\n                        status: error.status,\n                        error: { message: error.message, details: error.details },\n                    };\n                    this.eventService.emitServer(`RPC::RETURN_FROM_CLIENT_${payload.id}`, rpcResult);\n                    return;\n                }\n\n                this.eventService.emitServer(`RPC::RETURN_FROM_CLIENT_${payload.id}`, RPC_RESULT_UNKNOWN);\n            }\n        });\n        this.webViewService.$onCreate((webViewId, webView) => {\n            webView.on('RPC::CALL_CLIENT', async (payload) => {\n                if (!webView.valid) return;\n\n                const rpcHandler = this.rpcService.$webViewHandlers.get(`${webViewId}::${payload.rpcName}`);\n                if (isNil(rpcHandler)) {\n                    webView.emit(`RPC::RETURN_FROM_CLIENT_${payload.id}`, RPC_RESULT_HANDLER_NOT_FOUND);\n                    return;\n                }\n\n                try {\n                    const result = await rpcHandler.handler(payload.body);\n                    webView.emit(`RPC::RETURN_FROM_CLIENT_${payload.id}`, <RPCResult>{\n                        success: true,\n                        status: RPCResultStatus.Success,\n                        body: result,\n                    });\n                } catch (error) {\n                    if (error instanceof MangoError) {\n                        webView.emit(`RPC::RETURN_FROM_CLIENT_${payload.id}`, {\n                            success: false,\n                            status: error.status,\n                            error: { message: error.message, details: error.details },\n                        });\n                        return;\n                    }\n\n                    webView.emit(`RPC::RETURN_FROM_CLIENT_${payload.id}`, RPC_RESULT_UNKNOWN);\n                }\n            });\n\n            webView.on('RPC::CALL_SERVER', (payload) => {\n                this.eventService.emitServer('RPC::CALL_SERVER', <RPCPayload>{ ...payload, webViewId });\n            });\n        });\n\n        this.loggerService.log(`~lw~RPC handlers registered ~lk~(${Date.now() - time}ms)`);\n    }\n}\n", "import { Container, inject, injectable } from 'inversify';\nimport { GLOBAL_APP_CONTAINER, INTERNAL_APP_CONTAINER, type MangoPlugin } from '@ragemp-mango/core/app';\nimport { EVENT_SERVICE, LOGGER_SERVICE, RPC_SERVICE } from '@ragemp-mango/core';\nimport { ClientEventService, ClientLoggerService, ClientRPCService, ClientWebViewService, WebViewListService } from '../services';\nimport { WEBVIEW_LIST_SERVICE, WEBVIEW_SERVICE } from '../constants';\n\n@injectable()\nexport class ServiceBinderPlugin implements MangoPlugin {\n    @inject(INTERNAL_APP_CONTAINER) private readonly internalAppContainer: Container;\n    @inject(GLOBAL_APP_CONTAINER) private readonly globalAppContainer: Container;\n\n    public async onBuild() {\n        const time = Date.now();\n\n        this.globalAppContainer.bind(LOGGER_SERVICE).to(ClientLoggerService).inSingletonScope();\n        this.globalAppContainer.bind(EVENT_SERVICE).to(ClientEventService).inSingletonScope();\n        this.globalAppContainer.bind(RPC_SERVICE).to(ClientRPCService).inSingletonScope();\n        this.globalAppContainer.bind(WEBVIEW_SERVICE).to(ClientWebViewService).inSingletonScope();\n        this.globalAppContainer.bind(WEBVIEW_LIST_SERVICE).to(WebViewListService).inSingletonScope();\n\n        this.internalAppContainer.bind(LOGGER_SERVICE).toConstantValue(this.globalAppContainer.get(LOGGER_SERVICE));\n        this.internalAppContainer.bind(EVENT_SERVICE).toConstantValue(this.globalAppContainer.get(EVENT_SERVICE));\n        this.internalAppContainer.bind(RPC_SERVICE).toConstantValue(this.globalAppContainer.get(RPC_SERVICE));\n        this.internalAppContainer.bind(WEBVIEW_SERVICE).toConstantValue(this.globalAppContainer.get(WEBVIEW_SERVICE));\n        this.internalAppContainer.bind(WEBVIEW_LIST_SERVICE).toConstantValue(this.globalAppContainer.get(WEBVIEW_LIST_SERVICE));\n\n        const loggerService = this.globalAppContainer.get<ClientLoggerService>(LOGGER_SERVICE);\n        loggerService.log(`~lw~Internal services binded ~lk~(${Date.now() - time}ms)`);\n    }\n}\n", "import { BaseEventService, MULTIPLAYER_SERVICE, type ScriptEventHandler } from '@ragemp-mango/core/app';\nimport { inject, injectable } from 'inversify';\nimport { INTERNAL_EVENTS, WEBVIEW_LIST_SERVICE } from '../constants';\nimport type { WebViewListService } from './webview-list.service';\nimport type { ClientEventEmmiter, EventService } from '../interfaces';\nimport type { ClientMultiplayerService } from '../interfaces/multiplayer';\n\n@injectable()\nexport class ClientEventService extends BaseEventService<MangoEvents.CustomClientEvent> implements EventService {\n    @inject(WEBVIEW_LIST_SERVICE) private readonly $webViewListService: WebViewListService;\n    private $rageEvents: ClientEventEmmiter;\n\n    public constructor(@inject(MULTIPLAYER_SERVICE) multiplayerService: ClientMultiplayerService) {\n        super(multiplayerService.Events);\n        this.$rageEvents = multiplayerService.Events;\n        this.$internalEventNames = new Set(Object.values(INTERNAL_EVENTS));\n    }\n\n    public onServer<E extends string>(\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const wrapper = (...args: unknown[]) => callback(args[0]);\n        const eventHandler = this.$rageEvents.onServer(eventName, wrapper);\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public onceServer<E extends string>(\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const wrapper = (...args: unknown[]) => callback(args[0]);\n        const eventHandler = this.$rageEvents.onceServer(eventName, wrapper);\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public emitServer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>, body?: unknown) {\n        this.$rageEvents.emitServer(eventName, body);\n    }\n\n    public onWebView<E extends string>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const webView = this.$webViewListService.tryGet(id);\n        const wrapper = (...args: unknown[]) => callback(args[0]);\n\n        const eventHandler: ScriptEventHandler = {\n            destroy() {\n                webView.off(eventName, wrapper);\n            },\n        };\n\n        webView.on(eventName, wrapper);\n\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public onceWebView<E extends string>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const webView = this.$webViewListService.tryGet(id);\n        const wrapper = (...args: any[]) => callback(args[0]);\n\n        const eventHandler: ScriptEventHandler = {\n            destroy() {\n                webView.off(eventName, wrapper);\n            },\n        };\n\n        webView.once(eventName, wrapper);\n\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public emitWebView<E extends string>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomClientToWebViewEvent>,\n        body?: unknown,\n    ) {\n        const webView = this.$webViewListService.tryGet(id);\n        webView.emit(eventName, body);\n    }\n\n    // RageMP client-specific events\n    public onRender(callback: () => void): ScriptEventHandler {\n        return this.$rageEvents.on('render', callback);\n    }\n\n    public onBrowserDomReady(callback: (browser: BrowserMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('browserDomReady', callback);\n    }\n\n    public onBrowserLoadingFailed(callback: (browser: BrowserMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('browserLoadingFailed', callback);\n    }\n\n    public onPlayerChat(callback: (text: string) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerChat', callback);\n    }\n\n    public onPlayerCommand(callback: (command: string) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerCommand', callback);\n    }\n\n    public onPlayerDeath(callback: (killer?: PlayerMp, reason?: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerDeath', callback);\n    }\n\n    public onPlayerSpawn(callback: () => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerSpawn', callback);\n    }\n\n    public onPlayerEnterVehicle(callback: (vehicle: VehicleMp, seat: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterVehicle', callback);\n    }\n\n    public onPlayerExitVehicle(callback: (vehicle: VehicleMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitVehicle', callback);\n    }\n\n    public onPlayerEnterColshape(callback: (colshape: ColshapeMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterColshape', callback);\n    }\n\n    public onPlayerExitColshape(callback: (colshape: ColshapeMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitColshape', callback);\n    }\n\n    public onPlayerEnterCheckpoint(callback: (checkpoint: CheckpointMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterCheckpoint', callback);\n    }\n\n    public onPlayerExitCheckpoint(callback: (checkpoint: CheckpointMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitCheckpoint', callback);\n    }\n}\n", "import { injectable, inject } from 'inversify';\nimport { MANGO_LOG_PREFIX } from '@ragemp-mango/core/app';\nimport type { LoggerService } from '@ragemp-mango/core';\nimport { MULTIPLAYER_SERVICE, type MultiplayerService } from '../../../core/src/app';\n\n@injectable()\nexport class ClientLoggerService implements LoggerService {\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayerService: MultiplayerService;\n    public log(...args: unknown[]): void {\n        this.multiplayerService.log(`~w~[~y~${MANGO_LOG_PREFIX}Client~w~][~lb~Log~w~]`, ...args);\n    }\n\n    public warn(...args: unknown[]): void {\n        this.multiplayerService.logWarning(`[${MANGO_LOG_PREFIX}Client][Warn]`, ...args);\n    }\n\n    public error(...args: unknown[]): void {\n        this.multiplayerService.logError(`[${MANGO_LOG_PREFIX}Client][Error]`, ...args);\n    }\n\n    public debug(...args: unknown[]): void {\n        this.multiplayerService.logDebug(`~w~[~y~${MANGO_LOG_PREFIX}Client~w~][~lc~Debug~w~]`, ...args);\n    }\n}\n", "export enum ErrorMessage {\n    TooManyRequests = 'Too many requests.',\n\n    // Events\n    EventNameMustBeString = 'The event name must be a string.',\n    EventNameMustBeUnique = 'The event name must be unique.',\n    EventNotAllowedInClient = 'The event is not allowed in the client environment.',\n    EventNotAllowedInServer = 'The event is not allowed in the server environment.',\n    InvalidEventType = 'Invalid event type.',\n    InvalidInternalEventName = 'The name of the internal event is invalid.',\n    InvalidReturnInEvent = 'Cannot return a value from an event.',\n\n    // RPC\n    RPCNameMustBeString = 'The RPC name must be a string.',\n    RPCNameMustBeUnique = 'The RPC name must be unique.',\n    RPCNotAllowedInClient = 'The RPC is not allowed in the client environment.',\n    RPCNotAllowedInServer = 'The RPC is not allowed in the server environment.',\n    InvalidRPCType = 'Invalid RPC type.',\n    RPCHandlerAlreadyExists = 'The RPC handler already exists. Please provide a unique name for the RPC.',\n    RPCResponseAlreadySent = 'The RPC response has already been sent.',\n\n    // Error filters\n    InvalidErrorFilterDefinition = 'Invalid error filter. Error filters must be a class reference or an object with a catch method.',\n    ErrorAlreadyHandledByFilter = 'The error already points to a filter.',\n    ExceptionHandlingConflict = 'The same exception can only be caught once.',\n    AtLeastOneFilterRequired = 'At least one error filter must be provided.',\n    DuplicateErrorFilterDetected = 'Duplicate error filter found. Ensure that the same filter is not applied more than once.',\n\n    // WebView\n    WebViewNotFound = 'The WebView with the specified id does not exist.',\n    WebViewIdMustBeStringOrNumber = 'The WebView id must be a string or number.',\n\n    // Guard\n    InvalidGuardDefinition = 'Invalid guard. Guards must be a class reference or an object with a canActivate method.',\n    AtLeastOneGuardRequired = 'At least one guard must be provided.',\n\n    // Interceptor\n    InvalidInterceptorDefinition = 'Invalid interceptor. Interceptors must be a class reference or an object with an intercept method.',\n    AtLeastOneInterceptorRequired = 'At least one interceptor must be provided.',\n    InvalidInterceptorReturnValue = 'The interceptor must return a function.',\n\n    // Pipe\n    InvalidPipeDefinition = 'Invalid pipe. Pipes must be a class reference or an object with a transform method.',\n    AtLeastOnePipeRequired = 'At least one pipe must be provided.',\n\n    // App loading\n    AppAlreadyLoaded = 'App is already loaded. Please call the stop method before calling the start method.',\n    AppNotLoaded = 'App is not loaded. Please call the start method before calling the stop method.',\n\n    // Decorators\n    InvalidInjectionTokenSpecified = 'The specified injection token is invalid.',\n    InjectionTokenNotFound = 'The injection token could not be found.',\n    ParamKeyMustBeString = 'The param key must be a string.',\n    IndexKeyMustBeNumber = 'The index key must be a number.',\n    DuplicateDecoratorUsage = 'The same decorator can only be used once in the same class.',\n    InvalidControllerOptions = 'Invalid controller options found.',\n    InvalidInjectableOptions = 'Invalid injectable options found.',\n    InvalidModuleOptions = 'Invalid module options found.',\n    MultipleDecoratorsOnSingleParameterNotAllowed = 'Cannot apply multiple decorators to the same parameter.',\n\n    // Internal App\n    CircularDependencyDetected = 'Circular dependency detected.',\n    InvalidModuleDefinition = 'The module is invalid.',\n    InvalidExportDefinition = 'The export is invalid.',\n    InvalidProviderDefinition = 'The provider is invalid.',\n    InvalidParameterDecoratorUsage = 'Each parameter must have their its own decorator.',\n    ResponseDecoratorNotAllowedOnEvents = 'The @Response() decorator is not allowed on events.',\n    PlayerDecoratorNotAllowedOnClientEvents = 'The @Player() decorator is not allowed on client events.',\n\n    // Timers\n    TimerNameMustBeString = 'The timer name must be a string.',\n}\n", "export enum InjectableScope {\n    Request = 'request',\n    Transient = 'transient',\n    Singleton = 'singleton',\n}\n", "export enum RPCResultStatus {\n    Success = 1,\n    Timeout = 2,\n    HandlerNotFound = 3,\n    Unknown = 4,\n    CancelledByGuard = 5,\n    InvalidGuardReturn = 6,\n    TooManyRequests = 7,\n    PlayerDisconnected = 8,\n    PlayerNotFound = 9,\n}\n", "import { RPCResultStatus } from '../../enums';\nimport type { RPCResult } from '../../interfaces';\n\nexport const INTERNAL_APP_CONTAINER = 'INTERNAL_APP_CONTAINER';\nexport const GLOBAL_APP_CONTAINER = 'GLOBAL_APP_CONTAINER';\nexport const APP_ENVIROMENT = 'APP_ENVIROMENT';\n\nexport const GLOBAL_GUARDS = 'GLOBAL_GUARDS';\nexport const GLOBAL_INTERCEPTORS = 'GLOBAL_INTERCEPTORS';\nexport const GLOBAL_PIPES = 'GLOBAL_PIPES';\nexport const GLOBAL_ERROR_FILTERS = 'GLOBAL_ERROR_FILTERS';\n\nexport const PLUGINS = 'PLUGINS';\n\nexport const ENABLE_SHUTDOWN_HOOKS = 'ENABLE_SHUTDOWN_HOOKS';\nexport const CONTAINER_OPTIONS = 'CONTAINER_OPTIONS';\nexport const LOG_ERROR_STACKTRACE = 'LOG_ERROR_STACKTRACE';\n\nexport const MANGO_LOG_PREFIX = '🥭';\n\nexport const MANGO_REQUEST_FACTORY = 'MANGO_REQUEST_FACTORY';\nexport const MANGO_RESPONSE_FACTORY = 'MANGO_RESPONSE_FACTORY';\nexport const EXECUTION_CONTEXT_FACTORY = 'EXECUTION_CONTEXT_FACTORY';\n\nexport const MULTIPLAYER_SERVICE = 'MULTIPLAYER_SERVICE';\n\nexport const RPC_RESULT_TIMEOUT: RPCResult = {\n    success: false,\n    error: { message: 'RPC call timed out.' },\n    status: RPCResultStatus.Timeout,\n};\n\nexport const RPC_RESULT_HANDLER_NOT_FOUND: RPCResult = {\n    success: false,\n    error: { message: 'RPC handler not found.' },\n    status: RPCResultStatus.HandlerNotFound,\n};\n\nexport const RPC_RESULT_UNKNOWN: RPCResult = {\n    success: false,\n    error: { message: 'Unknown error.' },\n    status: RPCResultStatus.Unknown,\n};\n\nexport const RPC_RESULT_PLAYER_DISCONNECTED: RPCResult = {\n    success: false,\n    error: { message: 'Player disconnected.' },\n    status: RPCResultStatus.PlayerDisconnected,\n};\n\nexport const RPC_RESULT_PLAYER_NOT_FOUND: RPCResult = {\n    success: false,\n    error: { message: 'Player not found.' },\n    status: RPCResultStatus.PlayerNotFound,\n};\n", "import { inject, injectable } from 'inversify';\nimport type { ErrorFilter, Guard, Interceptor, InternalEventService, MultiplayerService } from '../interfaces';\nimport type { Newable } from '../../types';\nimport { APP_ENVIROMENT, EXECUTION_CONTEXT_FACTORY, MANGO_REQUEST_FACTORY, MULTIPLAYER_SERVICE } from '../constants';\nimport { isFunction, isNil, isObject } from '../../utils';\nimport { PipelineHandler } from './pipeline.handler';\nimport type { EventMetadata } from '../interfaces';\nimport { EVENT_SERVICE, LOGGER_SERVICE } from '../../constants';\nimport type { Controller } from './controller';\nimport { AppEnviroment, ExecutionContextType } from '../enums';\nimport { ExecutionContextBase, MangoResponseBase, type MangoRequestBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport { isAsyncFunction } from '../../utils';\nimport { ControllerFlowHandler } from './controller-flow.handler';\n\n@injectable()\nexport class ControllerEventHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayerService: MultiplayerService;\n    @inject(EVENT_SERVICE) private readonly eventService: InternalEventService;\n    @inject(ControllerFlowHandler) private readonly controllerFlowHandler: ControllerFlowHandler;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MANGO_REQUEST_FACTORY) private readonly createMangoRequest: (body: unknown, player?: PlayerMp) => MangoRequestBase;\n    @inject(EXECUTION_CONTEXT_FACTORY) private readonly createExecutionContext: (\n        type: ExecutionContextType,\n        classRef: Newable,\n        handler: Function,\n        request: MangoRequestBase,\n        response?: MangoResponseBase,\n        name?: string,\n    ) => ExecutionContextBase;\n\n    public registerEvent(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        event: EventMetadata,\n    ) {\n        if (event.type === 'on' || event.type === 'once') {\n            return this.eventService[event.type](event.name, async (body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);\n            });\n        } else if (event.type === 'onInternal' || event.type === 'onceInternal') {\n            return this.eventService[`$${event.type}`](event.name, async (...args) => {\n                const { player, body } = this.multiplayerService.parseInternalArgs<PlayerMp>(...args);\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        } else if (event.type === 'onPlayer' || event.type === 'oncePlayer') {\n            return this.eventService[event.type](event.name, async (player, body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        } else if (event.type === 'onServer' || event.type === 'onceServer') {\n            return this.eventService[event.type](event.name, async (body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);\n            });\n        } else if (event.type === 'onWebView' || event.type === 'onceWebView') {\n            return this.eventService[event.type](event.webViewId!, event.name, async (...args: unknown[]) => {\n                const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];\n                const player = this.appEnv === AppEnviroment.Server ? <PlayerMp>args[0] : undefined;\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        }\n\n        this.loggerService.error('An error occurred while trying to register event.');\n        throw new Error(ErrorMessage.InvalidEventType);\n    }\n\n    private async handleEvent(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        event: EventMetadata,\n        body: unknown,\n        player?: PlayerMp,\n    ) {\n        const request = this.createMangoRequest(body, player);\n        const executionContext = this.createExecutionContext(\n            ExecutionContextType.Event,\n            controller.metadata.classRef,\n            controller.metadata.classRef.prototype[event.method],\n            request,\n            undefined,\n            event.name,\n        );\n\n        try {\n            await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);\n            const args = await this.controllerFlowHandler.createArgs(controller, executionContext, event, pipes, player);\n            const controllerMethod = controller.instance[event.method]!;\n            const handle = isAsyncFunction(controllerMethod)\n                ? (): unknown => controller.instance[event.method]!.apply(controller.instance, args)\n                : (): Promise<unknown> => controller.instance[event.method]!.apply(controller.instance, args);\n            const callHandler: CallHandler = {\n                handle,\n                return: () => {\n                    this.loggerService.error('An error occurred while trying to return a value from an event.');\n                    throw new Error(ErrorMessage.InvalidReturnInEvent);\n                },\n            };\n\n            if (interceptors.length > 0) {\n                await this.pipelineHandler.goThroughInterceptors(executionContext, interceptors, controller.owner.container, callHandler);\n            } else {\n                await callHandler.handle();\n            }\n        } catch (error) {\n            const errorGroup = mappedErrorFilters.find(\n                ([errorType]) =>\n                    (isFunction(errorType) && error instanceof errorType) || errorType === 'MANGO_ANY_ERROR' || error === errorType,\n            );\n            if (isNil(errorGroup)) return;\n            const instance = isFunction(errorGroup[1])\n                ? controller.owner.container.get(errorGroup[1])\n                : isObject(errorGroup[1]) && isFunction(errorGroup[1]['catch'])\n                  ? errorGroup[1]\n                  : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through error filters.');\n                throw new Error(ErrorMessage.InvalidErrorFilterDefinition);\n            }\n            await Promise.resolve(instance.catch.call(instance, error, executionContext));\n        }\n    }\n}\n", "export function generateRandomId() {\n    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);\n}\n", "export const isUndefined = (obj: any): obj is undefined => typeof obj === 'undefined';\nexport const isObject = (fn: any): fn is object => !isNil(fn) && typeof fn === 'object';\nexport const isFunction = (val: any): val is Function => typeof val === 'function';\nexport const isString = (val: any): val is string => typeof val === 'string';\nexport const isNumber = (val: any): val is number => typeof val === 'number';\nexport const isConstructor = (val: any): boolean => val === 'constructor';\nexport const isNil = (val: any): val is null | undefined => isUndefined(val) || val === null;\nexport const isEmpty = (array: any): boolean => !(array && array.length > 0);\nexport const isSymbol = (val: any): val is symbol => typeof val === 'symbol';\nexport const isAsyncFunction = (val: any): boolean => isFunction(val) && val.constructor.name === 'AsyncFunction';\nexport const isBoolean = (val: any): val is boolean => typeof val === 'boolean';\nexport const isPromise = <T = any>(val: any): val is Promise<T> => val instanceof Promise;\n", "import { inject, injectable } from 'inversify';\nimport type { Guard, Interceptor } from '../interfaces';\nimport type { Newable } from '../../types';\nimport { GuardCancelError, GuardInvalidReturnError } from '../../errors';\nimport { isFunction, isNil, isObject } from '../../utils';\nimport type { ExecutionContextBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { ArgumentMetadata, CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport { LOGGER_SERVICE } from '../../constants';\nimport type { ModuleContainer } from '../module';\n\n@injectable()\nexport class PipelineHandler {\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    // @inject(GLOBAL_APP_CONTAINER) private readonly globalContainer: Container;\n\n    public async goTroughGuards(executionContext: ExecutionContextBase, guards: (Newable<Guard> | Guard)[], container: ModuleContainer) {\n        for (const guard of guards) {\n            const instance = isFunction(guard) ? container.get(guard) : isObject(guard) && isFunction(guard['canActivate']) ? guard : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through guards.');\n                throw new Error(ErrorMessage.InvalidGuardDefinition);\n            }\n            const canActivate = await instance.canActivate.call(instance, executionContext);\n            if (typeof canActivate !== 'boolean') {\n                this.loggerService.error('An error occurred while trying to go through guards.');\n                throw new GuardInvalidReturnError();\n            }\n            if (!canActivate) {\n                throw new GuardCancelError();\n            }\n        }\n    }\n\n    public async goThroughInterceptors(\n        executionContext: ExecutionContextBase,\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        container: ModuleContainer,\n        callHandler: CallHandler,\n    ) {\n        for (const interceptor of interceptors) {\n            const instance = isFunction(interceptor)\n                ? container.get(interceptor)\n                : isObject(interceptor) && isFunction(interceptor['intercept'])\n                  ? interceptor\n                  : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through interceptors.');\n                throw new Error(ErrorMessage.InvalidInterceptorDefinition);\n            }\n            await instance.intercept.call(instance, executionContext, callHandler);\n        }\n    }\n\n    public async goTroughPipes(\n        value: unknown,\n        pipes: (Newable<Pipe> | Pipe)[],\n        argumentMetadata: ArgumentMetadata,\n        container: ModuleContainer,\n    ) {\n        for (const pipe of pipes) {\n            const instance = isFunction(pipe) ? container.get(pipe) : isObject(pipe) ? pipe : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through pipes.');\n                throw new Error(ErrorMessage.InvalidPipeDefinition);\n            }\n            value = await Promise.resolve(instance.transform.call(instance, value, argumentMetadata));\n        }\n\n        return value;\n    }\n}\n", "import { RPCResultStatus } from '../enums';\n\nexport class MangoError<TDetails = unknown> extends Error {\n    public status: number = RPCResultStatus.Unknown;\n    public details: TDetails | undefined;\n\n    public constructor(message: string, status?: number, details?: TDetails) {\n        super(message);\n        this.status = status ?? RPCResultStatus.Unknown;\n        this.details = details;\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class GuardCancelError extends MangoError {\n    public constructor() {\n        super('Process cancelled by the guard.', RPCResultStatus.CancelledByGuard);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class GuardInvalidReturnError extends MangoError {\n    public constructor() {\n        super('Guard returned an invalid value. Expected boolean.', RPCResultStatus.InvalidGuardReturn);\n    }\n}\n", "export const LOGGER_SERVICE = 'LOGGER_SERVICE';\nexport const EVENT_SERVICE = 'EVENT_SERVICE';\nexport const RPC_SERVICE = 'RPC_SERVICE';\nexport const MODULE_CONTAINER = 'MODULE_CONTAINER';\nexport const REFLECTOR_SERVICE = 'REFLECTOR_SERVICE';\nexport const TIMER_SERVICE = 'TIMER_SERVICE';\n", "export enum AppEnviroment {\n    Client,\n    Server,\n}\n", "export enum CoreMetadataKey {\n    // General\n    Injectable = 'mango:injectable',\n    Inject = 'mango:inject',\n    Module = 'mango:module',\n    GlobalModule = 'mango:global-module',\n    Controller = 'mango:controller-options',\n    // Events & RPC\n    ControllerEvents = 'mango:controller-events',\n    ControllerRPCs = 'mango:controller-rpcs',\n    ControllerParams = 'mango:controller-rpc-params',\n    // Pipeline\n    Guards = 'mango:guards',\n    Interceptors = 'mango:interceptors',\n    Pipes = 'mango:pipes',\n    // Error\n    Catch = 'mango:catch',\n    ErrorFilters = 'mango:error-filters',\n    //\n    Timers = 'mango:timers',\n}\n", "export enum ExecutionContextType {\n    Event = 'event',\n    RPC = 'rpc',\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Controller } from './controller';\nimport type { ExecutionContextBase } from '../pipeline';\nimport type { EventMetadata, RPCMetadata } from '../interfaces';\nimport type { Newable } from '../../types';\nimport type { Pipe } from '../../interfaces';\nimport { PipelineHandler } from './pipeline.handler';\nimport { isObject } from '../../utils';\nimport { AppEnviroment } from '../enums';\nimport { APP_ENVIROMENT } from '../constants';\n\n@injectable()\nexport class ControllerFlowHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n\n    public async createArgs(\n        controller: Controller,\n        executionContext: ExecutionContextBase,\n        metadata: RPCMetadata | EventMetadata,\n        pipes: (Newable<Pipe> | Pipe)[],\n        player?: PlayerMp,\n    ) {\n        return Promise.all(\n            metadata.params.map(async (param) => {\n                const argumentMetadata = {\n                    type: param.type,\n                    data: param.data,\n                    metatype: param.metatype,\n                };\n\n                if (param.type === 'body') {\n                    // Body\n                    return this.pipelineHandler.goTroughPipes(\n                        executionContext.request.body,\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'param') {\n                    // Param\n                    if (!isObject(executionContext.request.body)) return undefined;\n                    return this.pipelineHandler.goTroughPipes(\n                        (<Record<string, unknown>>executionContext.request.body)[param.data],\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'index') {\n                    if (!Array.isArray(executionContext.request.body)) return undefined;\n                    return this.pipelineHandler.goTroughPipes(\n                        executionContext.request.body[param.data],\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'request') {\n                    return executionContext.request;\n                } else if (param.type === 'custom') {\n                    // Custom\n                    return this.pipelineHandler.goTroughPipes(\n                        param.factory(param.data, executionContext),\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'player' && this.appEnv === AppEnviroment.Server) {\n                    // Player (Server)\n                    return this.pipelineHandler.goTroughPipes(\n                        param.data ? player![<keyof PlayerMp>param.data] : player,\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                }\n                return undefined;\n            }),\n        );\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Guard, Interceptor, ErrorFilter, TimerMetadata } from '../interfaces';\nimport type { Newable } from '../../types';\nimport type { ControllerMetadata, EventMetadata, MethodParameter, RPCMetadata } from '../interfaces';\nimport { AppEnviroment, CoreMetadataKey } from '../enums';\nimport { APP_ENVIROMENT } from '../constants';\nimport { ErrorMessage } from '../../enums';\nimport type { LoggerService, Pipe } from '../../interfaces';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class ControllerMetadataReader {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async read(classRef: Newable) {\n        const options =\n            Reflect.getMetadata<Pick<ControllerMetadata, 'prefix'>>(CoreMetadataKey.Controller, classRef) ??\n            <Pick<ControllerMetadata, 'prefix'>>{};\n        const events = this.getEvents(classRef);\n        const rpcs = this.getRPCs(classRef);\n        const timers = this.getTimers(classRef);\n\n        return <ControllerMetadata>{\n            ...options,\n            classRef,\n            events,\n            rpcs,\n            ...this.getPipeline(classRef),\n            timers,\n        };\n    }\n\n    private getEvents(classRef: Newable) {\n        const events = Reflect.getMetadata<EventMetadata[]>(CoreMetadataKey.ControllerEvents, classRef.prototype) ?? [];\n\n        return events.map((event) => {\n            return <EventMetadata>{\n                ...event,\n                params: this.getMethodParams(classRef, event),\n                ...this.getPipeline(classRef, event.method),\n            };\n        });\n    }\n\n    private getRPCs(classRef: Newable) {\n        const rpcs = Reflect.getMetadata<RPCMetadata[]>(CoreMetadataKey.ControllerRPCs, classRef.prototype) ?? [];\n\n        return rpcs.map((rpc) => {\n            return <RPCMetadata>{\n                ...rpc,\n                params: this.getMethodParams(classRef, rpc),\n                ...this.getPipeline(classRef, rpc.method),\n            };\n        });\n    }\n\n    private getMethodParams(classRef: Newable, metadata: EventMetadata | RPCMetadata) {\n        const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, classRef.prototype, metadata.method) ?? [];\n\n        params.sort((a, b) => a.index - b.index);\n        params.forEach((param, index) => {\n            if (param.index !== index) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.InvalidParameterDecoratorUsage);\n            } else if (\n                (metadata.type === 'on' ||\n                    metadata.type === 'onPlayer' ||\n                    metadata.type === 'onInternal' ||\n                    metadata.type === 'onServer' ||\n                    metadata.type === 'onWebView' ||\n                    metadata.type === 'once' ||\n                    metadata.type === 'oncePlayer' ||\n                    metadata.type === 'onceInternal' ||\n                    metadata.type === 'onceServer' ||\n                    metadata.type === 'onceWebView') &&\n                param.type === 'response'\n            ) {\n                // Response\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.ResponseDecoratorNotAllowedOnEvents);\n            } else if (param.type === 'player' && this.appEnv === AppEnviroment.Client) {\n                // Player (Client) - Not allowed\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.PlayerDecoratorNotAllowedOnClientEvents);\n            } else if (metadata.type === 'onPlayerRequest' && this.appEnv === AppEnviroment.Client) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.RPCNotAllowedInClient);\n            } else if (metadata.type === 'onServerRequest' && this.appEnv === AppEnviroment.Server) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.RPCNotAllowedInServer);\n            } else if ((metadata.type === 'onPlayer' || metadata.type === 'oncePlayer') && this.appEnv === AppEnviroment.Client) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.EventNotAllowedInClient);\n            } else if ((metadata.type === 'onServer' || metadata.type === 'onceServer') && this.appEnv === AppEnviroment.Server) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.EventNotAllowedInServer);\n            }\n        });\n\n        return params;\n    }\n\n    private getPipeline(target: Newable | object, method?: string) {\n        const guards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, target, method) ?? [];\n        const interceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, target, method) ?? [];\n        const pipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, target, method) ?? [];\n        const errorFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, target, method) ?? [];\n\n        return { guards, interceptors, pipes, errorFilters };\n    }\n\n    private getTimers(classRef: Newable) {\n        return Reflect.getMetadata<TimerMetadata[]>(CoreMetadataKey.Timers, classRef.prototype) ?? [];\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { ErrorFilter, Guard, Interceptor, InternalRPCService } from '../interfaces';\nimport { LOGGER_SERVICE, RPC_SERVICE } from '../../constants';\nimport { APP_ENVIROMENT, EXECUTION_CONTEXT_FACTORY, MANGO_REQUEST_FACTORY, MANGO_RESPONSE_FACTORY } from '../constants';\nimport type { Newable } from '../../types';\nimport { isAsyncFunction, isFunction, isNil, isObject } from '../../utils';\nimport { PipelineHandler } from './pipeline.handler';\nimport type { RPCMetadata } from '../interfaces';\nimport { AppEnviroment, ExecutionContextType } from '../enums';\nimport { ExecutionContextBase, type MangoRequestBase, type MangoResponseBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport type { Controller } from './controller';\nimport { ControllerFlowHandler } from './controller-flow.handler';\n\n@injectable()\nexport class ControllerRPCHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(RPC_SERVICE) private readonly rpcService: InternalRPCService;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n    @inject(ControllerFlowHandler) private readonly controllerFlowHandler: ControllerFlowHandler;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MANGO_REQUEST_FACTORY) private readonly createMangoRequest: (data: unknown, player?: PlayerMp) => MangoRequestBase;\n    @inject(MANGO_RESPONSE_FACTORY) private readonly createMangoResponse: () => MangoResponseBase;\n    @inject(EXECUTION_CONTEXT_FACTORY) private readonly createExecutionContext: (\n        type: ExecutionContextType,\n        classRef: Newable,\n        handler: Function,\n        request: MangoRequestBase,\n        response: MangoResponseBase,\n        name: string,\n    ) => ExecutionContextBase;\n\n    public async registerRPC(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        rpc: RPCMetadata,\n    ) {\n        if (rpc.type === 'onRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);\n            });\n        } else if (rpc.type === 'onPlayerRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (player, body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);\n            });\n        } else if (rpc.type === 'onServerRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);\n            });\n        } else if (rpc.type === 'onWebViewRequest') {\n            return this.rpcService[rpc.type](rpc.webViewId!, rpc.name, async (...args: unknown[]) => {\n                const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];\n                const player = this.appEnv === AppEnviroment.Server ? <PlayerMp>args[0] : undefined;\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);\n            });\n        }\n\n        this.loggerService.error('An error occurred while trying to register RPC.');\n        throw new Error(ErrorMessage.InvalidRPCType);\n    }\n\n    private async handleRPC(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        rpc: RPCMetadata,\n        body: unknown,\n        player?: PlayerMp,\n    ) {\n        return new Promise(async (resolve) => {\n            const request = this.createMangoRequest(\n                body,\n                this.appEnv === AppEnviroment.Server && (rpc.type === 'onPlayerRequest' || rpc.type === 'onWebViewRequest')\n                    ? player\n                    : undefined,\n            );\n            const response = this.createMangoResponse();\n            response.$onSend((data) => resolve(data));\n            response.$onError((error) => resolve(error));\n            const executionContext = this.createExecutionContext(\n                ExecutionContextType.RPC,\n                controller.metadata.classRef,\n                controller.metadata.classRef.prototype[rpc.method],\n                request,\n                response,\n                rpc.name,\n            );\n\n            try {\n                await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);\n                const args = await this.controllerFlowHandler.createArgs(controller, executionContext, rpc, pipes, player);\n                const controllerMethod = controller.instance[rpc.method]!;\n                const handle = isAsyncFunction(controllerMethod)\n                    ? (options: { send: boolean } = { send: true }) => {\n                          const result = controller.instance[rpc.method]!.apply(controller.instance, args);\n                          if (options.send) {\n                              response.send(result);\n                          }\n                          return result;\n                      }\n                    : async (options: { send: boolean } = { send: true }) => {\n                          const result = await controller.instance[rpc.method]!.apply(controller.instance, args);\n                          if (options.send) {\n                              response.send(result);\n                          }\n                          return result;\n                      };\n                const callHandler: CallHandler = {\n                    handle,\n                    return: (value: unknown) => response.send(value),\n                };\n\n                if (interceptors.length > 0) {\n                    await this.pipelineHandler.goThroughInterceptors(\n                        executionContext,\n                        interceptors,\n                        controller.owner.container,\n                        callHandler,\n                    );\n                } else {\n                    await callHandler.handle();\n                }\n            } catch (error) {\n                const errorGroup = mappedErrorFilters.find(\n                    ([errorType]) =>\n                        (isFunction(errorType) && error instanceof errorType) || errorType === 'MANGO_ANY_ERROR' || error === errorType,\n                );\n                if (isNil(errorGroup)) return;\n                const instance = isFunction(errorGroup[1])\n                    ? controller.owner.container.get(errorGroup[1])\n                    : isObject(errorGroup[1]) && isFunction(errorGroup[1]['catch'])\n                      ? errorGroup[1]\n                      : null;\n                if (isNil(instance)) {\n                    return this.loggerService.error(ErrorMessage.InvalidErrorFilterDefinition);\n                }\n                await Promise.resolve(instance.catch.call(instance, error, executionContext));\n            }\n        });\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { ControllerMetadata, ScriptEventHandler } from '../interfaces';\nimport type { Module } from '../module';\nimport type { ScriptRPCHandler } from '../../interfaces';\n\n@injectable()\nexport class Controller {\n    public metadata: ControllerMetadata;\n    public instance: { [key: string]: Function };\n    public owner: Module;\n    public eventHandlers: ScriptEventHandler[] = [];\n    public rpcHandlers: ScriptRPCHandler[] = [];\n}\n", "import { inject, injectable } from 'inversify';\nimport type { InjectionToken, Newable } from '../../types';\nimport { CoreMetadataKey } from '../enums';\nimport type { InjectableMetadata, ErrorFilter, Guard, Interceptor } from '../interfaces';\nimport type { ModuleMetadata } from '../interfaces';\nimport type { ClassProvider, DynamicModule, LoggerService, ModuleOptions, Pipe, Provider } from '../../interfaces';\nimport { isFunction, isNil, isString, isSymbol } from '../../utils';\nimport { ErrorMessage } from '../../enums';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class ModuleMetadataReader {\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async read(module: Newable | DynamicModule | Promise<DynamicModule>) {\n        // Class reference\n        if (isFunction(module)) {\n            const options = Reflect.getMetadata<Required<ModuleOptions>>(CoreMetadataKey.Module, module) ?? <Required<ModuleOptions>>{};\n            const exportTokens = this.getExportTokens(options.exports);\n            const separatedProviders = this.separateProviders(options.providers, exportTokens);\n\n            return <ModuleMetadata>{\n                controllers: options.controllers,\n                imports: options.imports,\n                ...this.getPipeline(module),\n                ...separatedProviders,\n                classRef: module,\n                global: Reflect.getMetadata<boolean>(CoreMetadataKey.GlobalModule, module) ?? false,\n                container: options.container,\n            };\n        }\n        // Dynamic module\n        if (module instanceof Promise) module = await module;\n        if (!('module' in module)) {\n            this.loggerService.error('An error occurred while reading module metadata.');\n            throw new Error(ErrorMessage.InvalidModuleDefinition);\n        }\n\n        const { module: classRef, global, ...options } = <Required<DynamicModule>>module;\n        const exportTokens = this.getExportTokens(options.exports);\n        const separatedProviders = this.separateProviders(options.providers, exportTokens);\n\n        return <ModuleMetadata>{\n            controllers: options.controllers,\n            imports: options.imports,\n            ...this.getPipeline(classRef),\n            ...separatedProviders,\n            classRef,\n            global: global ?? false,\n            container: options.container,\n        };\n    }\n\n    private getPipeline(classRef: Newable) {\n        const guards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, classRef) ?? [];\n        const interceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, classRef) ?? [];\n        const pipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, classRef) ?? [];\n        const errorFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, classRef) ?? [];\n\n        return { guards, interceptors, pipes, errorFilters };\n    }\n\n    private getExportTokens(exports: Required<ModuleOptions>['exports']) {\n        return exports.map<InjectionToken>((providerExport) => {\n            if (isFunction(providerExport)) {\n                if (!Reflect.hasOwnMetadata(CoreMetadataKey.Injectable, providerExport)) {\n                    this.loggerService.error('An error occurred while reading module metadata.');\n                    throw new Error(ErrorMessage.InvalidExportDefinition);\n                }\n                return providerExport;\n            } else if (isString(providerExport) || isSymbol(providerExport)) {\n                return providerExport;\n            } else if ('provide' in providerExport) {\n                return providerExport.provide;\n            }\n\n            this.loggerService.error('An error occurred while reading module metadata.');\n            throw new Error(ErrorMessage.InvalidExportDefinition);\n        });\n    }\n\n    private separateProviders(providers: Required<ModuleOptions>['providers'], exportTokens: InjectionToken[]) {\n        return providers\n            .map((provider) => {\n                if (isFunction(provider)) {\n                    const injectableMetadata = Reflect.getMetadata<InjectableMetadata>(CoreMetadataKey.Injectable, provider);\n                    if (isNil(injectableMetadata)) {\n                        this.loggerService.error('An error occurred while reading module metadata.');\n                        throw new Error(ErrorMessage.InvalidProviderDefinition);\n                    }\n                    return <ClassProvider>{ provide: provider, useClass: provider, scope: injectableMetadata.scope };\n                } else if ('useClass' in provider || 'useValue' in provider || 'useFactory' in provider || 'useExisting' in provider) {\n                    return provider;\n                }\n\n                this.loggerService.error('An error occurred while reading module metadata.');\n                throw new Error(ErrorMessage.InvalidProviderDefinition);\n            })\n            .reduce(\n                (acc, provider) => {\n                    if (exportTokens.includes(provider.provide)) {\n                        acc.externalProviders.set(provider.provide, provider);\n                    } else {\n                        acc.internalProviders.set(provider.provide, provider);\n                    }\n                    return acc;\n                },\n                {\n                    internalProviders: new Map<InjectionToken, Exclude<Provider, Newable>>(),\n                    externalProviders: new Map<InjectionToken, Exclude<Provider, Newable>>(),\n                },\n            );\n    }\n}\n", "import { Container } from 'inversify';\n\nexport class ModuleContainer extends Container {}\n", "import { injectable } from 'inversify';\nimport { Controller } from '../controller';\nimport type { ModuleMetadata } from '../interfaces';\nimport { ModuleContainer } from './module-container';\n\n@injectable()\nexport class Module {\n    public readonly controllers: Controller[] = [];\n    public container: ModuleContainer;\n    public parent: Module | undefined;\n    public metadata: ModuleMetadata;\n    public instance: { [key: string]: Function };\n    public repetitiveImports: Set<Module> = new Set();\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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~loaded ~lk~(${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                    `~lw~Controller ~lc~${controller.metadata.classRef.name} ~lw~timers and listeners registered ~lk~(${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                `~lw~Module ~lb~${module.metadata.classRef.name} ~lw~dependencies binded ~lk~(${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 { 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 { isFunction, isNil, isObject } from '../../utils';\nimport type { ErrorFilter } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateErrorFilter<EF extends ErrorFilter = ErrorFilter>(value: EF | Newable<EF>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Error filter must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Error filter must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.catch)) {\n        return { valid: true, value, error: 'Error filter must have a catch method' };\n    }\n\n    if (isObject(value) && !isFunction((<ErrorFilter>value).catch)) {\n        return { valid: true, value, error: 'Error filter must have a catch method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Pipe } from '../../interfaces';\nimport type { Newable } from '../../types';\n\nexport function validatePipe(value: Pipe | Newable<Pipe>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Pipe must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Pipe must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.transform)) {\n        return { valid: false, value, error: 'Pipe must have a transform method' };\n    }\n\n    if (isObject(value) && !isFunction((<Pipe>value).transform)) {\n        return { valid: false, value, error: 'Pipe must have a transform method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Guard } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateGuard<G extends Guard = Guard>(value: G | Newable<G>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Guard must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Guard must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.canActivate)) {\n        return { valid: false, value, error: 'Guard must have a canActivate method' };\n    }\n\n    if (isObject(value) && !isFunction((<Guard>value).canActivate)) {\n        return { valid: false, value, error: 'Guard must have a canActivate method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Interceptor } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateInterceptor<I extends Interceptor = Interceptor>(value: I | Newable<I>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Interceptor must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Interceptor must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.intercept)) {\n        return { valid: false, value, error: 'Interceptor must have an intercept method' };\n    }\n\n    if (isObject(value) && !isFunction((<Interceptor>value).intercept)) {\n        return { valid: false, value, error: 'Interceptor must have an intercept method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isNil, isObject, isString } from '../utils';\nimport { InjectableScope } from '../enums';\nimport type { InjectableOptions } from '../interfaces';\n\nconst defaultInjectableOptions: InjectableOptions = { scope: InjectableScope.Singleton };\n\nexport function validateInjectableMetadata(value?: InjectableOptions) {\n    if (isNil(value)) {\n        return { valid: true, value: defaultInjectableOptions };\n    }\n\n    if (!isObject(value)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Injectable options must be an object' };\n    }\n\n    if (!('scope' in value)) {\n        return { valid: true, value: { ...defaultInjectableOptions, ...value } };\n    }\n    if ('scope' in value && !isString(value.scope)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Injectable scope must be a string' };\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Invalid injectable scope' };\n    }\n\n    return { valid: true, value };\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 { 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 { 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", "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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~scanned ~lk~(${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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~scanned ~lk~(${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(`~lw~Controller ~lc~${classRef.name} ~lw~scanned ~lk~(${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", "export class TreeNode<T> {\n    public value: T;\n    public children: TreeNode<T>[];\n\n    public constructor(value: T) {\n        this.value = value;\n        this.children = [];\n    }\n\n    public addChild(child: TreeNode<T>) {\n        this.children.push(child);\n    }\n\n    public removeChild(child: TreeNode<T>) {\n        const index = this.children.indexOf(child);\n        if (index !== -1) {\n            this.children.splice(index, 1);\n        }\n    }\n}\n\nexport class Tree<T> {\n    public root: TreeNode<T>;\n\n    public constructor(value: T) {\n        this.root = new TreeNode<T>(value);\n    }\n\n    public traverse(callback: (node: TreeNode<T>) => void) {\n        function traverseNode(node: TreeNode<T>) {\n            callback(node);\n            node.children.forEach(traverseNode);\n        }\n\n        traverseNode(this.root);\n    }\n\n    public async asyncTraverse(callback: (node: TreeNode<T>) => Promise<void>) {\n        async function traverseNode(node: TreeNode<T>) {\n            await callback(node);\n            await Promise.all(node.children.map(traverseNode));\n        }\n\n        await traverseNode(this.root);\n    }\n\n    public toString(): string {\n        let result = '';\n        const lines: string[] = [];\n\n        function traverseNode(node: TreeNode<T>, depth: number) {\n            lines.push(`${'-'.repeat(depth * 2)}${node.value}`);\n            node.children.forEach((child) => traverseNode(child, depth + 1));\n        }\n\n        traverseNode(this.root, 0);\n        result = lines.join('\\n');\n\n        return result;\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { Newable } from '../../types';\nimport type { ExecutionContextType } from '../enums';\nimport type { ExecutionContext } from '../interfaces';\nimport type { MangoRequestBase } from './mango-request-base';\nimport type { MangoResponseBase } from './mango-response-base';\n\n@injectable()\nexport class ExecutionContextBase<\n    TRequest extends MangoRequestBase = MangoRequestBase,\n    TResponse extends MangoResponseBase = MangoResponseBase,\n> implements ExecutionContext<TRequest, TResponse>\n{\n    public $type: ExecutionContextType;\n    public $classRef: Newable;\n    public $handler: Function;\n    public $request: TRequest;\n    public $response?: TResponse;\n    public $name: string;\n\n    public get type() {\n        return this.$type;\n    }\n\n    public get classRef() {\n        return this.$classRef;\n    }\n\n    public get handler() {\n        return this.$handler;\n    }\n\n    public get request() {\n        return this.$request;\n    }\n\n    public get response() {\n        return this.$response!;\n    }\n\n    public get name() {\n        return this.$name;\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { MangoRequest } from '../interfaces';\n\n@injectable()\nexport class MangoRequestBase<TData = unknown> implements MangoRequest {\n    public $body: TData;\n    public $player?: PlayerMp;\n\n    public get body() {\n        return this.$body;\n    }\n\n    public get player() {\n        return this.$player;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { LoggerService, RPCError } from '../../interfaces';\nimport type { MangoResponse } from '../interfaces';\nimport { ErrorMessage } from '../../enums';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class MangoResponseBase implements MangoResponse {\n    @inject(LOGGER_SERVICE) private readonly $loggerService: LoggerService;\n    public $sendListeners: Set<(data: unknown) => void> = new Set();\n    public $errorListeners: Set<(error: RPCError) => void> = new Set();\n    public $isSent: boolean = false;\n\n    public send<TData = unknown>(data?: TData) {\n        if (this.$isSent) {\n            this.$loggerService.error('An error occurred while sending the RPC response.');\n            throw new Error(ErrorMessage.RPCResponseAlreadySent);\n        }\n\n        this.$sendListeners.forEach((listener) => listener(data));\n        this.$isSent = true;\n    }\n\n    public error<TDetails = unknown>(message: string, details?: TDetails) {\n        if (this.$isSent) {\n            this.$loggerService.error('An error occurred while sending the RPC response.');\n            throw new Error(ErrorMessage.RPCResponseAlreadySent);\n        }\n        this.$errorListeners.forEach((listener) => listener({ message, details }));\n        this.$isSent = true;\n    }\n\n    public $onSend(listener: (data: unknown) => void) {\n        this.$sendListeners.add(listener);\n    }\n\n    public $onError(listener: (error: RPCError) => void) {\n        this.$errorListeners.add(listener);\n    }\n}\n", "import { injectable } from 'inversify';\nimport { ErrorMessage } from '../../enums';\nimport type { EventEmmiter, ScriptEventHandler } from '../interfaces';\nimport type { EventHandler } from '../../interfaces';\n\n@injectable()\nexport abstract class BaseEventService<T extends Record<string, any>> {\n    protected readonly $localHandlers: Set<ScriptEventHandler> = new Set();\n    protected readonly $internalHandlers: Set<ScriptEventHandler> = new Set();\n    protected readonly $remoteHandlers: Set<ScriptEventHandler> = new Set();\n    protected $internalEventNames = new Set<string>();\n    constructor(protected $eventEmmiter: EventEmmiter) {}\n\n    public on<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;\n    public on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;\n    public on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.on(eventName, wrapper);\n        this.$localHandlers.add(eventHandler);\n        return eventHandler;\n    }\n    public once<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;\n    public once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;\n    public once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.once(eventName, wrapper);\n        this.$localHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public emit<E extends keyof T>(eventName: E, body?: T[E]): void;\n    public emit<E extends string>(eventName: E, body?: unknown): void;\n    public emit<E extends string>(eventName: E, body?: unknown) {\n        this.$eventEmmiter.emit(eventName, body);\n    }\n\n    protected $onInternal(eventName: string, handler: (body: unknown) => void | Promise<void>) {\n        if (!this.$internalEventNames.has(eventName)) {\n            throw new Error(ErrorMessage.InvalidInternalEventName);\n        }\n        const eventHandler = <EventHandler>this.$eventEmmiter.on(eventName, handler);\n        this.$internalHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    protected $onceInternal(eventName: string, handler: (body: unknown) => void | Promise<void>) {\n        if (!this.$internalEventNames.has(eventName)) {\n            throw new Error(ErrorMessage.InvalidInternalEventName);\n        }\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.once(eventName, handler);\n        this.$internalHandlers.add(eventHandler);\n        return eventHandler;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { RPCResult, RPCCallOptions, ScriptRPCHandler, LoggerService } from '../../interfaces';\nimport { RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_TIMEOUT, RPC_RESULT_UNKNOWN } from '../../app/constants';\nimport { ErrorMessage, RPCResultStatus } from '../../enums';\nimport { MangoError } from '../../errors';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class BaseRPCService<T extends Record<string, any>> {\n    @inject(LOGGER_SERVICE) protected readonly $loggerService: LoggerService;\n    protected readonly $TIMEOUT = 2000;\n    private readonly $localHandlers = new Map<string, ScriptRPCHandler>();\n\n    public async call<E extends keyof T>(\n        rpcName: E,\n        body?: Parameters<T[E]>[0],\n        options?: RPCCallOptions,\n    ): Promise<RPCResult<ReturnType<T[E]>>>;\n    public async call<E extends string>(rpcName: E, body?: unknown, options?: RPCCallOptions): Promise<RPCResult<unknown>>;\n    public async call<E extends string>(rpcName: E, body?: unknown, options: RPCCallOptions = { timeout: this.$TIMEOUT }) {\n        return new Promise(async (resolve) => {\n            const handler = this.$localHandlers.get(<string>rpcName)?.handler;\n            if (!handler) {\n                return resolve(RPC_RESULT_HANDLER_NOT_FOUND);\n            }\n\n            const timeoutId = setTimeout(() => {\n                resolve(RPC_RESULT_TIMEOUT);\n            }, options.timeout ?? this.$TIMEOUT);\n\n            try {\n                const result = await handler(body);\n                clearTimeout(timeoutId);\n                resolve({ success: true, status: RPCResultStatus.Success, body: result });\n            } catch (error) {\n                clearTimeout(timeoutId);\n\n                if (error instanceof MangoError) {\n                    return resolve({\n                        success: false,\n                        status: error.status,\n                        error: { message: error.message, details: error.details },\n                    });\n                }\n\n                resolve(RPC_RESULT_UNKNOWN);\n            }\n        });\n    }\n    public onRequest<E extends keyof T>(rpcName: E, handler: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptRPCHandler;\n    public onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;\n    public onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>) {\n        if (this.$localHandlers.has(rpcName)) {\n            this.$loggerService.error('An error occurred while trying to register RPC.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n\n        const rpcHandler: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\n                rpcHandler.valid = false;\n                this.$localHandlers.delete(rpcName);\n            },\n            rpcName: rpcName,\n            handler,\n            valid: true,\n        };\n\n        this.$localHandlers.set(rpcName, rpcHandler);\n\n        return rpcHandler;\n    }\n}\n", "import { validateErrorFilter, validateGuard, validateInterceptor, validatePipe } from '../schemas/events';\nimport {\n    INTERNAL_APP_CONTAINER,\n    GLOBAL_ERROR_FILTERS,\n    GLOBAL_GUARDS,\n    GLOBAL_INTERCEPTORS,\n    GLOBAL_PIPES,\n    ENABLE_SHUTDOWN_HOOKS,\n    PLUGINS,\n    GLOBAL_APP_CONTAINER,\n    APP_ENVIROMENT,\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 { inject, Container, injectable, 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 { ExecutionContextType } from './enums';\nimport { REFLECTOR_SERVICE } from '../constants';\nimport { ReflectorService } from '../services';\n\n@injectable()\nexport class AppBuilder<G extends Guard = Guard, I extends Interceptor = Interceptor, EF extends ErrorFilter = ErrorFilter> {\n    @inject(APP_ENVIROMENT) protected readonly enviroment: string;\n    @inject(INTERNAL_APP_CONTAINER) protected readonly internalAppContainer: Container;\n    @inject(MULTIPLAYER_SERVICE) protected readonly multiplayerService: MultiplayerService;\n    @inject(PLUGINS) protected readonly plugins: Newable<MangoPlugin>[];\n\n    private globalContainerOptions: interfaces.ContainerOptions = {};\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('~lw~Starting app...');\n        await this.runPluginMethods('beforeStart');\n\n        this.loggerService.log('~lw~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('~lw~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('~lw~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('~lw~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('~lw~Stopping app...');\n        await this.appRuntime.shutdown(this.moduleTree);\n        this.loaded = false;\n        this.loggerService.log('~lw~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 { APP_ENVIROMENT, INTERNAL_APP_CONTAINER, 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';\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: Newable<T>;\n    multiplayerService?: MultiplayerService;\n}) {\n    const internalAppContainer = new Container();\n\n    if (multiplayerService) internalAppContainer.bind(MULTIPLAYER_SERVICE).toConstantValue(multiplayerService);\n    internalAppContainer.bind(INTERNAL_APP_CONTAINER).toConstantValue(internalAppContainer);\n    internalAppContainer.bind(APP_ENVIROMENT).toConstantValue(enviroment);\n    internalAppContainer.bind(PLUGINS).toConstantValue(plugins);\n    internalAppContainer.bind(appBuilderInherit).toSelf().inSingletonScope();\n\n    return internalAppContainer.get(appBuilderInherit);\n}\n", "import { inject, injectable } from 'inversify';\nimport { BaseRPCService, EventDestination, type RPCPayload, RPC_RESULT_TIMEOUT } from '@ragemp-mango/core/app';\nimport {\n    ErrorMessage,\n    EVENT_SERVICE,\n    generateRandomId,\n    type RPCCallOptions,\n    type RPCResult,\n    type ScriptRPCHandler,\n} from '@ragemp-mango/core';\nimport type { RPCService } from '../interfaces';\nimport type { ClientEventService } from './client-event.service';\n\n@injectable()\nexport class ClientRPCService extends BaseRPCService<MangoRPC.CustomClientRPC> implements RPCService {\n    @inject(EVENT_SERVICE) private readonly $eventService: ClientEventService;\n    public readonly $serverHandlers = new Map<string, ScriptRPCHandler>();\n    public readonly $webViewHandlers = new Map<string, ScriptRPCHandler>();\n\n    public async callServer<E extends string>(\n        rpcName: Exclude<E, keyof MangoRPC.CustomClientToServerRPC>,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ) {\n        return this.$handleCall(rpcName, EventDestination.Server, options, body);\n    }\n\n    public onServerRequest<E extends string>(\n        rpcName: Exclude<E, keyof MangoRPC.CustomServerToClientRPC>,\n        handler: (body: unknown) => unknown | Promise<unknown>,\n    ) {\n        if (this.$serverHandlers.has(rpcName)) {\n            this.$loggerService.error('An error occurred while trying to register RPC.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n        const rpcHandler: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\n                rpcHandler.valid = false;\n                this.$serverHandlers.delete(rpcName);\n            },\n            rpcName,\n            handler,\n            valid: true,\n        };\n        this.$serverHandlers.set(rpcName, rpcHandler);\n        return rpcHandler;\n    }\n\n    public async callWebView<E extends string>(\n        id: string | number,\n        rpcName: Exclude<E, keyof MangoRPC.CustomClientToWebviewRPC>,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ) {\n        return this.$handleCall(rpcName, EventDestination.WebView, options, body, id);\n    }\n\n    public onWebViewRequest<E extends string>(\n        id: string | number,\n        rpcName: Exclude<E, keyof MangoRPC.CustomWebViewToClientRPC>,\n        handler: (body: unknown) => unknown | Promise<unknown>,\n    ) {\n        const key = `${id}::${rpcName}`;\n        if (this.$webViewHandlers.has(key)) {\n            this.$loggerService.error('An error occurred while trying to register RPC.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n\n        const rpcHandler = {\n            destroy: () => {\n                rpcHandler.valid = false;\n                this.$webViewHandlers.delete(key);\n            },\n            rpcName,\n            handler,\n            valid: true,\n        };\n\n        this.$webViewHandlers.set(key, rpcHandler);\n\n        return rpcHandler;\n    }\n\n    private async $handleCall<TResult>(\n        rpcName: string,\n        destination: EventDestination, // 'server' | 'webview',\n        options?: Partial<RPCCallOptions>,\n        body?: unknown,\n        webViewId?: string | number,\n    ) {\n        return new Promise<RPCResult<TResult>>((resolve) => {\n            const callId = generateRandomId();\n            let timeoutId: NodeJS.Timeout;\n\n            const onceHandle = (resultData: unknown) => {\n                clearTimeout(timeoutId);\n                resolve(<RPCResult<TResult>>resultData);\n            };\n            // Example: RPC::RETURN_FROM_SERVER_21ewrEq, RPC::RETURN_FROM_WEBVIEW_teEqd2\n            const eventHandler =\n                destination === EventDestination.WebView\n                    ? this.$eventService.onceWebView(webViewId!, `RPC::RETURN_FROM_WEBVIEW_${callId}`, onceHandle)\n                    : this.$eventService.onceServer(`RPC::RETURN_FROM_SERVER_${callId}`, onceHandle);\n\n            const payload: RPCPayload = {\n                source: EventDestination.Client,\n                destination,\n                id: callId,\n                rpcName,\n                body,\n            };\n            // Example: RPC::CALL_SERVER, RPC::CALL_WEBVIEW\n            destination === EventDestination.WebView\n                ? this.$eventService.emitWebView(webViewId!, <string>'RPC::CALL_WEBVIEW', payload)\n                : this.$eventService.emitServer(<string>'RPC::CALL_SERVER', payload);\n\n            timeoutId = setTimeout(() => {\n                eventHandler.destroy();\n                resolve(<RPCResult<TResult>>RPC_RESULT_TIMEOUT);\n            }, options?.timeout ?? this.$TIMEOUT);\n        });\n    }\n}\n", "\nimport { inject, injectable } from 'inversify';\nimport { ErrorMessage, LOGGER_SERVICE, isNil, type LoggerService } from '@ragemp-mango/core';\nimport type { MultiplayerWebView } from '../interfaces';\n\n@injectable()\nexport class WebViewListService {\n    @inject(LOGGER_SERVICE) private readonly $loggerService: LoggerService;\n\n    private readonly $webViews: Map<string | number, MultiplayerWebView> = new Map();\n\n    public set(id: string | number, webView: MultiplayerWebView) {\n        this.$webViews.set(id, webView);\n    }\n\n    public get(id: string | number) {\n        return this.$webViews.get(id);\n    }\n\n    public tryGet(id: string | number) {\n        const webView = this.$webViews.get(id);\n        if (isNil(webView) || !webView.valid) {\n            this.$loggerService.error('An error occurred while trying to get a WebView.');\n            throw new Error(ErrorMessage.WebViewNotFound);\n        }\n        return webView;\n    }\n\n    public delete(id: string | number) {\n        const webView = this.$webViews.get(id);\n        if (webView) {\n            webView.destroy();\n            this.$webViews.delete(id);\n        }\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport { WEBVIEW_LIST_SERVICE } from '../constants';\nimport type { WebViewListService } from './webview-list.service';\nimport { ErrorMessage, isNumber, isString, LOGGER_SERVICE, type LoggerService } from '@ragemp-mango/core';\nimport type { WebViewService } from '../interfaces';\nimport type {\n    ClientMultiplayerService,\n    MultiplayerWebView,\n    MultiplayerWebViewCreateOptionsDrawable,\n    MultiplayerWebViewCreateOptionsOverlay,\n} from '../interfaces/multiplayer';\nimport { MULTIPLAYER_SERVICE } from '@ragemp-mango/core/app';\n\n@injectable()\nexport class ClientWebViewService implements WebViewService {\n    @inject(LOGGER_SERVICE) private readonly $loggerService: LoggerService;\n    @inject(WEBVIEW_LIST_SERVICE) private readonly $webViewListService: WebViewListService;\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayer: ClientMultiplayerService;\n    private readonly $createListeners: ((id: string | number, webView: MultiplayerWebView) => void)[] = [];\n\n    public create(id: string | number, options: MultiplayerWebViewCreateOptionsOverlay): MultiplayerWebView;\n    public create(id: string | number, options: MultiplayerWebViewCreateOptionsDrawable): MultiplayerWebView;\n    public create(\n        id: string | number,\n        options: MultiplayerWebViewCreateOptionsOverlay | MultiplayerWebViewCreateOptionsDrawable,\n    ): MultiplayerWebView {\n        if (!isString(id) && !isNumber(id)) {\n            this.$loggerService.error('An error occurred while trying to create a WebView.');\n            throw new Error(ErrorMessage.WebViewIdMustBeStringOrNumber);\n        }\n\n        const webView = this.multiplayer.WebView.create(options);\n        this.$webViewListService.set(id, webView);\n        this.$createListeners.forEach((listener) => listener(id, webView));\n        return webView;\n    }\n\n    public get(id: string | number) {\n        return this.$webViewListService.get(id);\n    }\n\n    public tryGet(id: string | number) {\n        return this.$webViewListService.tryGet(id);\n    }\n\n    public destroy(id: string | number) {\n        const webView = this.$webViewListService.get(id);\n        if (webView) {\n            webView.destroy();\n            this.$webViewListService.delete(id);\n        }\n    }\n\n    public $onCreate(listener: (id: string | number, webView: MultiplayerWebView) => void) {\n        this.$createListeners.push(listener);\n    }\n}\n", "import { Container, inject, injectable } from 'inversify';\nimport { INTERNAL_APP_CONTAINER, type MangoPlugin } from '@ragemp-mango/core/app';\nimport { ADD_WEBVIEW, WEBVIEW_SERVICE } from '../constants';\nimport type { ClientLoggerService, ClientWebViewService } from '../services';\nimport { LOGGER_SERVICE } from '@ragemp-mango/core';\nimport type { MultiplayerWebViewCreateOptionsDrawable, MultiplayerWebViewCreateOptionsOverlay } from '../interfaces';\n\n@injectable()\nexport class WebViewPlugin implements MangoPlugin {\n    @inject(INTERNAL_APP_CONTAINER) private readonly internalAppContainer: Container;\n    @inject(WEBVIEW_SERVICE) private readonly webViewService: ClientWebViewService;\n    @inject(LOGGER_SERVICE) private readonly loggerService: ClientLoggerService;\n\n    public async beforeLoad() {\n        const time = Date.now();\n\n        const addWebViews = this.internalAppContainer.isBound(ADD_WEBVIEW)\n            ? this.internalAppContainer.get<\n                  {\n                      id: string | number;\n                      options: MultiplayerWebViewCreateOptionsDrawable | MultiplayerWebViewCreateOptionsOverlay;\n                  }[]\n              >(ADD_WEBVIEW)\n            : [];\n        if (addWebViews.length === 0) return;\n\n        addWebViews.forEach((webView) => {\n            this.webViewService.create(webView.id, webView.options);\n        });\n\n        this.loggerService.log(`~lw~WebViews created ~lk~(${Date.now() - time}ms)`);\n    }\n}\n", "import type { ScriptEventHandler } from '@ragemp-mango/core/app';\n\nexport class RageMPClientScriptEvent 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 { ScriptEventHandler } from '@ragemp-mango/core/app';\nimport type { ClientEventEmmiter } from '../../interfaces/event';\nimport { RageMPClientScriptEvent } from './ragemp-script-event-handler';\n\nexport class ClientRageMPEventEmmiter implements ClientEventEmmiter {\n    private mapEventsShared: Record<string, string> = {\n        // Map alt:V event names to RageMP equivalents\n        'entityColShapeEnter': 'playerEnterColshape',\n        'entityColShapeLeave': 'playerExitColshape',\n        'keyUp': 'keyup',\n        'keyDown': 'keydown',\n        'playerVehicleEntered': 'playerEnterVehicle',\n        'playerVehicleLeft': 'playerLeaveVehicle',\n        'playerStartVehicleEnter': 'playerStartEnterVehicle',\n    };\n\n    constructor(private mapEvents: Record<string, string> = {}) {}\n\n    private getEventName(eventName: string): string {\n        return this.mapEventsShared[eventName] || this.mapEvents[eventName] || eventName;\n    }\n\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        const mappedEventName = this.getEventName(eventName);\n        mp.events.add(mappedEventName, listener);\n        return new RageMPClientScriptEvent(mappedEventName, listener);\n    }\n\n    once(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        const mappedEventName = this.getEventName(eventName);\n        const onceWrapper = (...args: any[]) => {\n            mp.events.remove(mappedEventName, onceWrapper);\n            listener(...args);\n        };\n        mp.events.add(mappedEventName, onceWrapper);\n        return new RageMPClientScriptEvent(mappedEventName, onceWrapper);\n    }\n\n    off(eventName: string, listener: (...args: any[]) => void): void {\n        mp.events.remove(eventName, listener);\n    }\n\n    emitServer(eventName: string, ...args: any[]): void {\n        // In RageMP, use mp.events.callRemote to send events to server\n        mp.events.callRemote(eventName, ...args);\n    }\n\n    onServer(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        // In RageMP, server events come through mp.events.add\n        // Events from server are received the same way as local events\n        const mappedEventName = this.getEventName(eventName);\n        mp.events.add(mappedEventName, listener);\n        return new RageMPClientScriptEvent(mappedEventName, listener);\n    }\n\n    onceServer(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        const mappedEventName = this.getEventName(eventName);\n        const onceWrapper = (...args: any[]) => {\n            mp.events.remove(mappedEventName, onceWrapper);\n            listener(...args);\n        };\n        mp.events.add(mappedEventName, onceWrapper);\n        return new RageMPClientScriptEvent(mappedEventName, onceWrapper);\n    }\n\n    offServer(eventName: string, listener: (...args: any[]) => void): void {\n        mp.events.remove(eventName, listener);\n    }\n}\n", "import type { MultiplayerWebView } from '../../interfaces/multiplayer';\n\nexport class RageMPWebView implements MultiplayerWebView {\n    private eventListeners: Map<string, Set<(...args: unknown[]) => void>> = new Map();\n\n    constructor(private $raw: BrowserMp) {}\n\n    public get valid(): boolean {\n        // RageMP browsers don't have a 'valid' property, check if it exists\n        return this.$raw !== null && this.$raw !== undefined;\n    }\n\n    public destroy(): void {\n        this.$raw.destroy();\n    }\n\n    public get url(): string {\n        return this.$raw.url;\n    }\n\n    public set url(value: string) {\n        this.$raw.url = value;\n    }\n\n    public get visible(): boolean {\n        return this.$raw.active;\n    }\n\n    public set visible(value: boolean) {\n        this.$raw.active = value;\n    }\n\n    emit(eventName: string, ...args: unknown[]): void {\n        // In RageMP, use browser.call() to send events to CEF\n        this.$raw.call(eventName, ...args);\n    }\n\n    emitRaw(eventName: string, ...args: unknown[]): void {\n        this.$raw.call(eventName, ...args);\n    }\n\n    reload(ignoreCache: boolean): void {\n        this.$raw.reload(ignoreCache);\n    }\n\n    on(eventName: string, listener: (...args: unknown[]) => void): void {\n        // In RageMP, we need to listen through mp.events for browser events\n        // We'll create a wrapper that filters by browser instance\n        if (!this.eventListeners.has(eventName)) {\n            this.eventListeners.set(eventName, new Set());\n        }\n        this.eventListeners.get(eventName)!.add(listener);\n\n        // Add a global event listener if this is the first for this event\n        const listeners = this.eventListeners.get(eventName)!;\n        if (listeners.size === 1) {\n            mp.events.add(eventName, (...args: unknown[]) => {\n                for (const l of listeners) {\n                    l(...args);\n                }\n            });\n        }\n    }\n\n    once(eventName: string, listener: (...args: unknown[]) => void): void {\n        const onceWrapper = (...args: unknown[]) => {\n            this.off(eventName, onceWrapper);\n            listener(...args);\n        };\n        this.on(eventName, onceWrapper);\n    }\n\n    off(eventName: string, listener: (...args: unknown[]) => void): void {\n        const listeners = this.eventListeners.get(eventName);\n        if (listeners) {\n            listeners.delete(listener);\n        }\n    }\n\n    execute(code: string): void {\n        this.$raw.execute(code);\n    }\n\n    markAsChat(): void {\n        this.$raw.markAsChat();\n    }\n\n    public get raw(): BrowserMp {\n        return this.$raw;\n    }\n}\n", "import type {\n    MultiplayerWebView,\n    MultiplayerWebViewCreateOptionsDrawable,\n    MultiplayerWebViewCreateOptionsOverlay,\n    MultiplayerWebViewManager,\n} from '../../interfaces/multiplayer';\nimport { RageMPWebView } from './ragemp-webview';\n\nexport class RageMPWebViewManager implements MultiplayerWebViewManager {\n    private webViews: Map<number, RageMPWebView> = new Map();\n    private idCounter: number = 0;\n\n    public create(options: MultiplayerWebViewCreateOptionsDrawable): MultiplayerWebView;\n    public create(options: MultiplayerWebViewCreateOptionsOverlay): MultiplayerWebView;\n    public create(options: MultiplayerWebViewCreateOptionsOverlay | MultiplayerWebViewCreateOptionsDrawable): MultiplayerWebView {\n        let raw: BrowserMp;\n\n        if ('drawable' in options) {\n            // RageMP doesn't support drawable/texture targets directly like alt:V\n            // We'll create a regular browser and log a warning\n            mp.console.logWarning('RageMP does not support drawable WebViews. Creating overlay browser instead.');\n            raw = mp.browsers.new(options.url);\n        } else {\n            raw = mp.browsers.new(options.url);\n            if (options.visible !== undefined) {\n                raw.active = options.visible;\n            }\n        }\n\n        const webView = new RageMPWebView(raw);\n        const id = this.idCounter++;\n        this.webViews.set(id, webView);\n\n        return webView;\n    }\n\n    public getByID(id: number): MultiplayerWebView | null {\n        // RageMP browsers are stored in mp.browsers pool\n        // We need to find by ID or return from our cache\n        const cached = this.webViews.get(id);\n        if (cached) {\n            return cached;\n        }\n\n        // Try to get from RageMP's browser pool\n        const browser = mp.browsers.at(id);\n        if (browser) {\n            const webView = new RageMPWebView(browser);\n            this.webViews.set(id, webView);\n            return webView;\n        }\n\n        return null;\n    }\n}\n", "import type { ClientEventEmmiter } from '../../interfaces';\nimport type { ClientMultiplayerService, MultiplayerWebViewManager } from '../../interfaces/multiplayer';\nimport { RageMPMultiplayerService } from '@ragemp-mango/core/app';\nimport { ClientRageMPEventEmmiter } from './ragemp-event-emmiter';\nimport { RageMPWebViewManager } from './ragemp-webview-manager';\n\nexport class ClientRageMPMultiplayerService extends RageMPMultiplayerService implements ClientMultiplayerService {\n    public override Events: ClientEventEmmiter;\n    public WebView: MultiplayerWebViewManager;\n\n    constructor() {\n        super();\n        this.Events = new ClientRageMPEventEmmiter();\n        this.WebView = new RageMPWebViewManager();\n    }\n\n    public setAudioFactory(_factory: any): void {\n        // RageMP doesn't have audio factory like alt:V\n    }\n\n    public setAudioFilterFactory(_factory: any): void {\n        // RageMP doesn't have audio filter factory\n    }\n\n    public setAudioOutputAttachedFactory(_factory: any): void {\n        // RageMP doesn't have audio output attached factory\n    }\n\n    public setAudioOutputFrontendFactory(_factory: any): void {\n        // RageMP doesn't have audio output frontend factory\n    }\n\n    public setAudioOutputWorldFactory(_factory: any): void {\n        // RageMP doesn't have audio output world factory\n    }\n\n    public setBlipFactory(factory: any): void {\n        if (factory && (mp as any).Blip) {\n            Object.assign((mp as any).Blip.prototype, factory);\n        }\n    }\n\n    public setMarkerFactory(factory: any): void {\n        if (factory && (mp as any).Marker) {\n            Object.assign((mp as any).Marker.prototype, factory);\n        }\n    }\n\n    public setColshapeFactory(factory: any): void {\n        if (factory && (mp as any).Colshape) {\n            Object.assign((mp as any).Colshape.prototype, factory);\n        }\n    }\n\n    public setCheckpointFactory(factory: any): void {\n        if (factory && (mp as any).Checkpoint) {\n            Object.assign((mp as any).Checkpoint.prototype, factory);\n        }\n    }\n\n    public setObjectFactory(factory: any): void {\n        if (factory && (mp as any).Object) {\n            Object.assign((mp as any).Object.prototype, factory);\n        }\n    }\n\n    public setLocalObjectFactory(_factory: any): void {\n        // RageMP doesn't have LocalObject like alt:V\n    }\n\n    public setPedFactory(factory: any): void {\n        if (factory && (mp as any).Ped) {\n            Object.assign((mp as any).Ped.prototype, factory);\n        }\n    }\n\n    public setLocalPedFactory(_factory: any): void {\n        // RageMP doesn't have LocalPed like alt:V\n    }\n\n    public setLocalPlayerFactory(_factory: any): void {\n        // RageMP doesn't have LocalPlayer factory - use mp.players.local\n    }\n\n    public setLocalVehicleFactory(_factory: any): void {\n        // RageMP doesn't have LocalVehicle like alt:V\n    }\n\n    public setPlayerFactory(factory: any): void {\n        if (factory && (mp as any).Player) {\n            Object.assign((mp as any).Player.prototype, factory);\n        }\n    }\n\n    public setRmlDocumentFactory(_factory: any): void {\n        // RageMP doesn't have RmlDocument like alt:V\n    }\n\n    public setTextLabelFactory(factory: any): void {\n        if (factory && (mp as any).TextLabel) {\n            Object.assign((mp as any).TextLabel.prototype, factory);\n        }\n    }\n\n    public setVehicleFactory(factory: any): void {\n        if (factory && (mp as any).Vehicle) {\n            Object.assign((mp as any).Vehicle.prototype, factory);\n        }\n    }\n\n    public setVirtualEntityGroupFactory(_factory: any): void {\n        // RageMP doesn't have VirtualEntityGroup\n    }\n\n    public setVirtualEntityFactory(_factory: any): void {\n        // RageMP doesn't have VirtualEntity\n    }\n\n    public setWebSocketClientFactory(_factory: any): void {\n        // RageMP doesn't have WebSocketClient factory\n    }\n\n    public setWebViewFactory(factory: any): void {\n        if (factory && (mp as any).Browser) {\n            Object.assign((mp as any).Browser.prototype, factory);\n        }\n    }\n}\n", "import { UseFilters as $UseFilters, type Newable } from '@ragemp-mango/core';\nimport type { ErrorFilter } from '../../interfaces';\n\nexport function UseFilters(...filters: (Newable<ErrorFilter> | ErrorFilter)[]) {\n    return $UseFilters(...filters);\n}\n", "import { OnInternal, OnceInternal } from '@ragemp-mango/core';\nimport { INTERNAL_EVENTS } from '../../../constants';\n\nexport function OnScriptRPC() {\n    return OnInternal(INTERNAL_EVENTS.SCRIPT_RPC);\n}\n\nexport function OnceScriptRPC() {\n    return OnceInternal(INTERNAL_EVENTS.SCRIPT_RPC);\n}\nexport function OnScriptRPCAnswer() {\n    return OnInternal(INTERNAL_EVENTS.SCRIPT_RPC_ANSWER);\n}\n\nexport function OnceScriptRPCAnswer() {\n    return OnceInternal(INTERNAL_EVENTS.SCRIPT_RPC_ANSWER);\n}\nexport function OnKeyBoardEvent() {\n    return OnInternal(INTERNAL_EVENTS.KEYBOARD_EVENT);\n}\n\nexport function OnceKeyBoardEvent() {\n    return OnceInternal(INTERNAL_EVENTS.KEYBOARD_EVENT);\n}\nexport function OnKeyUp() {\n    return OnInternal(INTERNAL_EVENTS.KEY_UP);\n}\n\nexport function OnceKeyUp() {\n    return OnceInternal(INTERNAL_EVENTS.KEY_UP);\n}\nexport function OnKeyDown() {\n    return OnInternal(INTERNAL_EVENTS.KEY_DOWN);\n}\n\nexport function OnceKeyDown() {\n    return OnceInternal(INTERNAL_EVENTS.KEY_DOWN);\n}\nexport function OnWebViewEvent() {\n    return OnInternal(INTERNAL_EVENTS.WEB_VIEW_EVENT);\n}\n\nexport function OnceWebViewEvent() {\n    return OnceInternal(INTERNAL_EVENTS.WEB_VIEW_EVENT);\n}\nexport function OnWebSocketEvent() {\n    return OnInternal(INTERNAL_EVENTS.WEB_SOCKET_EVENT);\n}\n\nexport function OnceWebSocketEvent() {\n    return OnceInternal(INTERNAL_EVENTS.WEB_SOCKET_EVENT);\n}\nexport function OnAudioEvent() {\n    return OnInternal(INTERNAL_EVENTS.AUDIO_EVENT);\n}\n\nexport function OnceAudioEvent() {\n    return OnceInternal(INTERNAL_EVENTS.AUDIO_EVENT);\n}\nexport function OnRmluiEvent() {\n    return OnInternal(INTERNAL_EVENTS.RMLUI_EVENT);\n}\n\nexport function OnceRmluiEvent() {\n    return OnceInternal(INTERNAL_EVENTS.RMLUI_EVENT);\n}\nexport function OnWindowFocusChange() {\n    return OnInternal(INTERNAL_EVENTS.WINDOW_FOCUS_CHANGE);\n}\n\nexport function OnceWindowFocusChange() {\n    return OnceInternal(INTERNAL_EVENTS.WINDOW_FOCUS_CHANGE);\n}\nexport function OnWindowResolutionChange() {\n    return OnInternal(INTERNAL_EVENTS.WINDOW_RESOLUTION_CHANGE);\n}\n\nexport function OnceWindowResolutionChange() {\n    return OnceInternal(INTERNAL_EVENTS.WINDOW_RESOLUTION_CHANGE);\n}\nexport function OnConnectionComplete() {\n    return OnInternal(INTERNAL_EVENTS.CONNECTION_COMPLETE);\n}\n\nexport function OnceConnectionComplete() {\n    return OnceInternal(INTERNAL_EVENTS.CONNECTION_COMPLETE);\n}\nexport function OnDisconnect() {\n    return OnInternal(INTERNAL_EVENTS.DISCONNECT);\n}\n\nexport function OnceDisconnect() {\n    return OnceInternal(INTERNAL_EVENTS.DISCONNECT);\n}\nexport function OnSpawned() {\n    return OnInternal(INTERNAL_EVENTS.SPAWNED);\n}\n\nexport function OnceSpawned() {\n    return OnceInternal(INTERNAL_EVENTS.SPAWNED);\n}\nexport function OnGameEntityCreate() {\n    return OnInternal(INTERNAL_EVENTS.GAME_ENTITY_CREATE);\n}\n\nexport function OnceGameEntityCreate() {\n    return OnceInternal(INTERNAL_EVENTS.GAME_ENTITY_CREATE);\n}\nexport function OnGameEntityDestroy() {\n    return OnInternal(INTERNAL_EVENTS.GAME_ENTITY_DESTROY);\n}\n\nexport function OnceGameEntityDestroy() {\n    return OnceInternal(INTERNAL_EVENTS.GAME_ENTITY_DESTROY);\n}\nexport function OnEntityHitEntity() {\n    return OnInternal(INTERNAL_EVENTS.ENTITY_HIT_ENTITY);\n}\n\nexport function OnceEntityHitEntity() {\n    return OnceInternal(INTERNAL_EVENTS.ENTITY_HIT_ENTITY);\n}\nexport function OnTaskChange() {\n    return OnInternal(INTERNAL_EVENTS.TASK_CHANGE);\n}\n\nexport function OnceTaskChange() {\n    return OnceInternal(INTERNAL_EVENTS.TASK_CHANGE);\n}\nexport function OnPlayerWeaponShoot() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_WEAPON_SHOOT);\n}\n\nexport function OncePlayerWeaponShoot() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_WEAPON_SHOOT);\n}\nexport function OnPlayerBulletHit() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_BULLET_HIT);\n}\n\nexport function OncePlayerBulletHit() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_BULLET_HIT);\n}\nexport function OnPlayerWeaponChange() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_WEAPON_CHANGE);\n}\n\nexport function OncePlayerWeaponChange() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_WEAPON_CHANGE);\n}\nexport function OnPlayerStartVehicleEnter() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_START_VEHICLE_ENTER);\n}\n\nexport function OncePlayerStartVehicleEnter() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_START_VEHICLE_ENTER);\n}\nexport function OnPlayerStartVehicleLeave() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_START_VEHICLE_LEAVE);\n}\n\nexport function OncePlayerStartVehicleLeave() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_START_VEHICLE_LEAVE);\n}\nexport function OnPlayerVehicleEntered() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_ENTERED);\n}\n\nexport function OncePlayerVehicleEntered() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_ENTERED);\n}\nexport function OnPlayerVehicleLeft() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_LEFT);\n}\n\nexport function OncePlayerVehicleLeft() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_LEFT);\n}\nexport function OnPlayerVehicleSeatChange() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_SEAT_CHANGE);\n}\n\nexport function OncePlayerVehicleSeatChange() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_SEAT_CHANGE);\n}\nexport function OnVoiceConnection() {\n    return OnInternal(INTERNAL_EVENTS.VOICE_CONNECTION);\n}\n\nexport function OnceVoiceConnection() {\n    return OnceInternal(INTERNAL_EVENTS.VOICE_CONNECTION);\n}\nexport function OnPlayerStartTalking() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_START_TALKING);\n}\n\nexport function OncePlayerStartTalking() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_START_TALKING);\n}\nexport function OnPlayerStopTalking() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_STOP_TALKING);\n}\n\nexport function OncePlayerStopTalking() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_STOP_TALKING);\n}\n\nexport function OnWorldObjectPositionChange() {\n    return OnInternal(INTERNAL_EVENTS.WORLD_OBJECT_POSITION_CHANGE);\n}\n\nexport function OnceWorldObjectPositionChange() {\n    return OnceInternal(INTERNAL_EVENTS.WORLD_OBJECT_POSITION_CHANGE);\n}\nexport function OnWorldObjectStreamIn() {\n    return OnInternal(INTERNAL_EVENTS.WORLD_OBJECT_STREAM_IN);\n}\n\nexport function OnceWorldObjectStreamIn() {\n    return OnceInternal(INTERNAL_EVENTS.WORLD_OBJECT_STREAM_IN);\n}\nexport function OnWorldObjectStreamOut() {\n    return OnInternal(INTERNAL_EVENTS.WORLD_OBJECT_STREAM_OUT);\n}\n\nexport function OnceWorldObjectStreamOut() {\n    return OnceInternal(INTERNAL_EVENTS.WORLD_OBJECT_STREAM_OUT);\n}\nexport function OnEvent() {\n    return OnInternal(INTERNAL_EVENTS.EVENT);\n}\n\nexport function OnceEvent() {\n    return OnceInternal(INTERNAL_EVENTS.EVENT);\n}\nexport function OnBaseObjectCreate() {\n    return OnInternal(INTERNAL_EVENTS.BASE_OBJECT_CREATE);\n}\n\nexport function OnceBaseObjectCreate() {\n    return OnceInternal(INTERNAL_EVENTS.BASE_OBJECT_CREATE);\n}\nexport function OnBaseObjectRemove() {\n    return OnInternal(INTERNAL_EVENTS.BASE_OBJECT_REMOVE);\n}\n\nexport function OnceBaseObjectRemove() {\n    return OnceInternal(INTERNAL_EVENTS.BASE_OBJECT_REMOVE);\n}\nexport function OnNetOwnerChange() {\n    return OnInternal(INTERNAL_EVENTS.NET_OWNER_CHANGE);\n}\n\nexport function OnceNetOwnerChange() {\n    return OnceInternal(INTERNAL_EVENTS.NET_OWNER_CHANGE);\n}\nexport function OnWeaponDamage() {\n    return OnInternal(INTERNAL_EVENTS.WEAPON_DAMAGE);\n}\n\nexport function OnceWeaponDamage() {\n    return OnceInternal(INTERNAL_EVENTS.WEAPON_DAMAGE);\n}\nexport function OnMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.META_CHANGE);\n}\n\nexport function OnceMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.META_CHANGE);\n}\nexport function OnLocalMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.LOCAL_META_CHANGE);\n}\n\nexport function OnceLocalMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.LOCAL_META_CHANGE);\n}\nexport function OnSyncedMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.SYNCED_META_CHANGE);\n}\n\nexport function OnceSyncedMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.SYNCED_META_CHANGE);\n}\nexport function OnStreamSyncedMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.STREAM_SYNCED_META_CHANGE);\n}\n\nexport function OnceStreamSyncedMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.STREAM_SYNCED_META_CHANGE);\n}\nexport function OnGlobalMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.GLOBAL_META_CHANGE);\n}\n\nexport function OnceGlobalMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.GLOBAL_META_CHANGE);\n}\nexport function OnGlobalSyncedMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.GLOBAL_SYNCED_META_CHANGE);\n}\n\nexport function OnceGlobalSyncedMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.GLOBAL_SYNCED_META_CHANGE);\n}\nexport function OnEntityColShapeEnter() {\n    return OnInternal(INTERNAL_EVENTS.ENTITY_COL_SHAPE_ENTER);\n}\n\nexport function OnceEntityColShapeEnter() {\n    return OnceInternal(INTERNAL_EVENTS.ENTITY_COL_SHAPE_ENTER);\n}\nexport function OnEntityColShapeLeave() {\n    return OnInternal(INTERNAL_EVENTS.ENTITY_COL_SHAPE_LEAVE);\n}\n\nexport function OnceEntityColShapeLeave() {\n    return OnceInternal(INTERNAL_EVENTS.ENTITY_COL_SHAPE_LEAVE);\n}\nexport function OnEntityCheckpointEnter() {\n    return OnInternal(INTERNAL_EVENTS.ENTITY_CHECKPOINT_ENTER);\n}\n\nexport function OnceEntityCheckpointEnter() {\n    return OnceInternal(INTERNAL_EVENTS.ENTITY_CHECKPOINT_ENTER);\n}\nexport function OnEntityCheckpointLeave() {\n    return OnInternal(INTERNAL_EVENTS.ENTITY_CHECKPOINT_LEAVE);\n}\n\nexport function OnceEntityCheckpointLeave() {\n    return OnceInternal(INTERNAL_EVENTS.ENTITY_CHECKPOINT_LEAVE);\n}\nexport function OnColShapeEvent() {\n    return OnInternal(INTERNAL_EVENTS.COL_SHAPE_EVENT);\n}\n\nexport function OnceColShapeEvent() {\n    return OnceInternal(INTERNAL_EVENTS.COL_SHAPE_EVENT);\n}\nexport function OnConsoleCommand() {\n    return OnInternal(INTERNAL_EVENTS.CONSOLE_COMMAND);\n}\n\nexport function OnceConsoleCommand() {\n    return OnceInternal(INTERNAL_EVENTS.CONSOLE_COMMAND);\n}\nexport function OnError() {\n    return OnInternal(INTERNAL_EVENTS.ERROR);\n}\n\nexport function OnceError() {\n    return OnceInternal(INTERNAL_EVENTS.ERROR);\n}\nexport function OnLocalScriptEvent() {\n    return OnInternal(INTERNAL_EVENTS.LOCAL_SCRIPT_EVENT);\n}\n\nexport function OnceLocalScriptEvent() {\n    return OnceInternal(INTERNAL_EVENTS.LOCAL_SCRIPT_EVENT);\n}\nexport function OnRemoteScriptEvent() {\n    return OnInternal(INTERNAL_EVENTS.REMOTE_SCRIPT_EVENT);\n}\n\nexport function OnceRemoteScriptEvent() {\n    return OnceInternal(INTERNAL_EVENTS.REMOTE_SCRIPT_EVENT);\n}\nexport function OnResourceStart() {\n    return OnInternal(INTERNAL_EVENTS.RESOURCE_START);\n}\n\nexport function OnceResourceStart() {\n    return OnceInternal(INTERNAL_EVENTS.RESOURCE_START);\n}\nexport function OnResourceStop() {\n    return OnInternal(INTERNAL_EVENTS.RESOURCE_STOP);\n}\n\nexport function OnceResourceStop() {\n    return OnceInternal(INTERNAL_EVENTS.RESOURCE_STOP);\n}\nexport function OnResourceError() {\n    return OnInternal(INTERNAL_EVENTS.RESOURCE_ERROR);\n}\n\nexport function OnceResourceError() {\n    return OnceInternal(INTERNAL_EVENTS.RESOURCE_ERROR);\n}\n", "import { createEventDecorator } from '@ragemp-mango/core';\n\nexport function OnServer<E extends keyof MangoEvents.CustomServerToPlayerEvent>(eventName?: E): MethodDecorator;\nexport function OnServer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>): MethodDecorator;\nexport function OnServer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>) {\n    return createEventDecorator('onServer', eventName);\n}\n", "import { OnWebView as $OnWebView } from '@ragemp-mango/core';\n\nexport function OnWebView<E extends keyof MangoEvents.CustomWebViewToClientEvent>(id: string | number, eventName?: E): MethodDecorator;\nexport function OnWebView<E extends string>(\n    id: string | number,\n    eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>,\n): MethodDecorator;\nexport function OnWebView<E extends string>(id: string | number, eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>) {\n    return $OnWebView(id, eventName);\n}\n", "import { On as $On } from '@ragemp-mango/core';\n\nexport function On<E extends keyof MangoEvents.CustomClientEvent>(eventName?: E): MethodDecorator;\nexport function On<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomClientEvent>): MethodDecorator;\nexport function On<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomClientEvent>) {\n    return $On(eventName);\n}\n", "import { createEventDecorator } from '@ragemp-mango/core';\n\nexport function OnceServer<E extends keyof MangoEvents.CustomServerToPlayerEvent>(eventName?: E): MethodDecorator;\nexport function OnceServer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>): MethodDecorator;\nexport function OnceServer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>) {\n    return createEventDecorator('onceServer', eventName);\n}\n", "import { OnceWebView as $OnceWebView } from '@ragemp-mango/core';\n\nexport function OnceWebView<E extends keyof MangoEvents.CustomWebViewToClientEvent>(id: string | number, eventName?: E): MethodDecorator;\nexport function OnceWebView<E extends string>(\n    id: string | number,\n    eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>,\n): MethodDecorator;\nexport function OnceWebView<E extends string>(id: string | number, eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>) {\n    return $OnceWebView(id, eventName);\n}\n", "import { Once as $Once } from '@ragemp-mango/core';\n\nexport function Once<E extends keyof MangoEvents.CustomClientEvent>(eventName?: E): MethodDecorator;\nexport function Once<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomClientEvent>): MethodDecorator;\nexport function Once<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomClientEvent>) {\n    return $Once(eventName);\n}\n", "import type { Guard } from '../../interfaces';\nimport { UseGuards as $UseGuards, type Newable } from '@ragemp-mango/core';\n\nexport function UseGuards(...guards: (Newable<Guard> | Guard)[]) {\n    return $UseGuards(...guards);\n}\n", "import type { Interceptor } from '../../interfaces';\nimport { UseInterceptors as $UseInterceptors, type Newable } from '@ragemp-mango/core';\n\nexport function UseInterceptors(...interceptors: (Newable<Interceptor> | Interceptor)[]) {\n    return $UseInterceptors(...interceptors);\n}\n", "import { OnRequest as $OnRequest } from '@ragemp-mango/core';\n\nexport function OnRequest<E extends keyof MangoRPC.CustomClientRPC>(rpcName?: E): MethodDecorator;\nexport function OnRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomClientRPC>): MethodDecorator;\nexport function OnRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomClientRPC>) {\n    return $OnRequest(rpcName);\n}\n", "import { createRPCDecorator } from '@ragemp-mango/core';\n\nexport function OnServerRequest<E extends keyof MangoRPC.CustomServerToClientRPC>(rpcName?: E): MethodDecorator;\nexport function OnServerRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomServerToClientRPC>): MethodDecorator;\nexport function OnServerRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomServerToClientRPC>) {\n    return createRPCDecorator('onServerRequest', rpcName);\n}\n", "import { OnWebViewRequest as $OnWebViewRequest } from '@ragemp-mango/core';\n\nexport function OnWebViewRequest<E extends keyof MangoRPC.CustomWebViewToClientRPC>(id: string | number, rpcName?: E): MethodDecorator;\nexport function OnWebViewRequest<E extends string>(\n    id: string | number,\n    rpcName?: Exclude<E, keyof MangoRPC.CustomWebViewToClientRPC>,\n): MethodDecorator;\nexport function OnWebViewRequest<E extends string>(id: string | number, rpcName?: Exclude<E, keyof MangoRPC.CustomWebViewToClientRPC>) {\n    return $OnWebViewRequest(id, rpcName);\n}\n", "import { AppBuilder, AppEnviroment, createAppBuilder as $createAppBuilder } from '@ragemp-mango/core/app';\nimport { ADD_WEBVIEW } from './constants';\nimport { EventMediatorPlugin, RPCPlugin, ServiceBinderPlugin, WebViewPlugin } from './plugins';\nimport type {\n    ClientMultiplayerService,\n    ErrorFilter,\n    Guard,\n    Interceptor,\n    MultiplayerWebViewCreateOptionsDrawable,\n    MultiplayerWebViewCreateOptionsOverlay,\n} from './interfaces';\nimport { ClientRageMPMultiplayerService } from './multiplayer/ragemp';\n\nconst multiplayerService: ClientMultiplayerService = new ClientRageMPMultiplayerService();\n\nclass ClientAppBuilder extends AppBuilder<Guard, Interceptor, ErrorFilter> {\n    public addWebView(id: string | number, options: MultiplayerWebViewCreateOptionsDrawable): ClientAppBuilder;\n    public addWebView(id: string | number, options: MultiplayerWebViewCreateOptionsOverlay): ClientAppBuilder;\n    public addWebView(id: string | number, options: MultiplayerWebViewCreateOptionsOverlay) {\n        const addWebViews = this.internalAppContainer.isBound(ADD_WEBVIEW)\n            ? this.internalAppContainer.get<\n                  {\n                      id: string | number;\n                      options: MultiplayerWebViewCreateOptionsDrawable | MultiplayerWebViewCreateOptionsOverlay;\n                  }[]\n              >(ADD_WEBVIEW)\n            : [];\n        if (this.internalAppContainer.isBound(ADD_WEBVIEW)) {\n            this.internalAppContainer.rebind(ADD_WEBVIEW).toConstantValue([...addWebViews, { id, options }]);\n        } else {\n            this.internalAppContainer.bind(ADD_WEBVIEW).toConstantValue([{ id, options }]);\n        }\n        return this;\n    }\n\n    public setAudioFactory(factory: unknown) {\n        multiplayerService.setAudioFactory(factory);\n    }\n\n    public setAudioFilterFactory(factory: unknown) {\n        multiplayerService.setAudioFilterFactory(factory);\n    }\n\n    public setAudioOutputAttachedFactory(factory: unknown) {\n        multiplayerService.setAudioOutputAttachedFactory(factory);\n    }\n\n    public setAudioOutputFrontendFactory(factory: unknown) {\n        multiplayerService.setAudioOutputFrontendFactory(factory);\n    }\n\n    public setAudioOutputWorldFactory(factory: unknown) {\n        multiplayerService.setAudioOutputWorldFactory(factory);\n    }\n\n    public setBlipFactory(factory: unknown) {\n        multiplayerService.setBlipFactory(factory);\n    }\n\n    public setMarkerFactory(factory: unknown) {\n        multiplayerService.setMarkerFactory(factory);\n    }\n\n    public setColShapeFactory(factory: unknown) {\n        multiplayerService.setColshapeFactory(factory);\n    }\n\n    public setCheckpointFactory(factory: unknown) {\n        multiplayerService.setCheckpointFactory(factory);\n    }\n\n    public setObjectFactory(factory: unknown) {\n        multiplayerService.setObjectFactory(factory);\n    }\n\n    public setLocalObjectFactory(factory: unknown) {\n        multiplayerService.setLocalObjectFactory(factory);\n    }\n\n    public setPedFactory(factory: unknown) {\n        multiplayerService.setPedFactory(factory);\n    }\n\n    public setLocalPedFactory(factory: unknown) {\n        multiplayerService.setLocalPedFactory(factory);\n    }\n\n    public setLocalPlayerFactory(factory: unknown) {\n        multiplayerService.setLocalPlayerFactory(factory);\n    }\n\n    public setLocalVehicleFactory(factory: unknown) {\n        multiplayerService.setLocalVehicleFactory(factory);\n    }\n\n    public setPlayerFactory(factory: unknown) {\n        multiplayerService.setPlayerFactory(factory);\n    }\n\n    public setRmlDocumentFactory(factory: unknown) {\n        multiplayerService.setRmlDocumentFactory(factory);\n    }\n\n    public setTextLabelFactory(factory: unknown) {\n        multiplayerService.setTextLabelFactory(factory);\n    }\n\n    public setVehicleFactory(factory: unknown) {\n        multiplayerService.setVehicleFactory(factory);\n    }\n\n    public setVirtualEntityGroupFactory(factory: unknown) {\n        multiplayerService.setVirtualEntityGroupFactory(factory);\n    }\n\n    public setVirtualEntityFactory(factory: unknown) {\n        multiplayerService.setVirtualEntityFactory(factory);\n    }\n\n    public setWebSocketClientFactory(factory: unknown) {\n        multiplayerService.setWebSocketClientFactory(factory);\n    }\n\n    public setWebViewFactory(factory: unknown) {\n        multiplayerService.setWebViewFactory(factory);\n    }\n}\n\nexport async function createAppBuilder() {\n    return await $createAppBuilder({\n        enviroment: AppEnviroment.Client,\n        plugins: [ServiceBinderPlugin, EventMediatorPlugin, RPCPlugin, WebViewPlugin],\n        multiplayerService,\n        appBuilderInherit: ClientAppBuilder,\n    });\n}\n\nexport * from './exports';\n\nimport './extension.d.ts';\n\n"],
  "mappings": "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",
  "names": ["AppEnviroment", "CoreMetadataKey", "EventDestination", "ExecutionContextType", "MethodParamType", "LOGGER_SERVICE", "EVENT_SERVICE", "RPC_SERVICE", "MODULE_CONTAINER", "REFLECTOR_SERVICE", "TIMER_SERVICE", "ErrorMessage", "InjectableScope", "RPCResultStatus", "__defProp", "__name", "generateRandomId", "Math", "random", "toString", "substring", "isUndefined", "__name", "obj", "isObject", "fn", "isNil", "isFunction", "val", "isString", "isNumber", "isConstructor", "isEmpty", "array", "length", "isSymbol", "isAsyncFunction", "name", "isBoolean", "isPromise", "Promise", "inject", "injectable", "Container", "ModuleMetadataReader", "loggerService", "read", "module", "isFunction", "options", "Reflect", "getMetadata", "CoreMetadataKey", "Module", "exportTokens", "getExportTokens", "exports", "separatedProviders", "separateProviders", "providers", "controllers", "imports", "getPipeline", "classRef", "global", "GlobalModule", "container", "Promise", "error", "Error", "ErrorMessage", "InvalidModuleDefinition", "guards", "Guards", "interceptors", "Interceptors", "pipes", "Pipes", "errorFilters", "ErrorFilters", "map", "providerExport", "hasOwnMetadata", "Injectable", "InvalidExportDefinition", "isString", "isSymbol", "provide", "provider", "injectableMetadata", "isNil", "InvalidProviderDefinition", "useClass", "scope", "reduce", "acc", "includes", "externalProviders", "set", "internalProviders", "Map", "ModuleContainer", "Container", "parent", "metadata", "instance", "repetitiveImports", "Set", "injectable", "inject", "ExecutionContextBase", "$type", "$classRef", "$handler", "$request", "$response", "$name", "type", "classRef", "handler", "request", "response", "name", "MangoRequestBase", "$body", "$player", "body", "player", "MangoResponseBase", "$loggerService", "$sendListeners", "Set", "$errorListeners", "$isSent", "send", "data", "error", "Error", "ErrorMessage", "RPCResponseAlreadySent", "forEach", "listener", "message", "details", "$onSend", "add", "$onError", "TreeNode", "value", "children", "addChild", "child", "push", "removeChild", "index", "indexOf", "splice", "Tree", "root", "traverse", "callback", "traverseNode", "node", "forEach", "asyncTraverse", "Promise", "all", "map", "toString", "result", "lines", "depth", "repeat", "join", "defaultControllerOptions", "prefix", "validateControllerOptions", "options", "isNil", "valid", "value", "isObject", "error", "isString", "validateErrorFilter", "isFunction", "prototype", "catch", "validatePipe", "transform", "validateEventParameter", "key", "isNumber", "index", "type", "MethodParamType", "Body", "Player", "data", "Custom", "factory", "Param", "Index", "Request", "Response", "Array", "isArray", "pipes", "pipe", "validateEventMetadata", "name", "method", "params", "param", "validateGuard", "canActivate", "validateInterceptor", "intercept", "validateInjectionToken", "isSymbol", "validateProvider", "provide", "validateClassProvider", "validateValueProvider", "validateFactoryProvider", "validateExistingProvider", "scope", "InjectableScope", "Singleton", "Object", "values", "includes", "validateOptionalFactoryDependency", "token", "useFactory", "inject", "validateModuleOptions", "isDynamic", "controllers", "imports", "providers", "exports", "module", "global", "isBoolean", "imported", "isPromise", "controller", "provider", "exportItem", "defaultInjectableOptions", "validateInjectableMetadata", "INTERNAL_APP_CONTAINER", "GLOBAL_APP_CONTAINER", "APP_ENVIROMENT", "GLOBAL_GUARDS", "GLOBAL_INTERCEPTORS", "GLOBAL_PIPES", "GLOBAL_ERROR_FILTERS", "PLUGINS", "ENABLE_SHUTDOWN_HOOKS", "CONTAINER_OPTIONS", "MANGO_LOG_PREFIX", "MANGO_REQUEST_FACTORY", "MANGO_RESPONSE_FACTORY", "EXECUTION_CONTEXT_FACTORY", "MULTIPLAYER_SERVICE", "RPC_RESULT_TIMEOUT", "success", "error", "message", "status", "RPCResultStatus", "Timeout", "RPC_RESULT_HANDLER_NOT_FOUND", "HandlerNotFound", "RPC_RESULT_UNKNOWN", "Unknown", "RPC_RESULT_PLAYER_DISCONNECTED", "PlayerDisconnected", "RPC_RESULT_PLAYER_NOT_FOUND", "PlayerNotFound", "MangoError", "Error", "status", "RPCResultStatus", "Unknown", "details", "message", "GuardCancelError", "CancelledByGuard", "GuardInvalidReturnError", "InvalidGuardReturn", "TooManyRequests", "UnknownError", "inject", "injectable", "PipelineHandler", "loggerService", "goTroughGuards", "executionContext", "guards", "container", "guard", "instance", "isFunction", "get", "isObject", "isNil", "error", "Error", "ErrorMessage", "InvalidGuardDefinition", "canActivate", "call", "GuardInvalidReturnError", "GuardCancelError", "goThroughInterceptors", "interceptors", "callHandler", "interceptor", "InvalidInterceptorDefinition", "intercept", "goTroughPipes", "value", "pipes", "argumentMetadata", "pipe", "InvalidPipeDefinition", "Promise", "resolve", "transform", "ControllerFlowHandler", "appEnv", "pipelineHandler", "createArgs", "controller", "metadata", "player", "all", "params", "map", "param", "type", "data", "metatype", "request", "body", "owner", "undefined", "Array", "isArray", "factory", "AppEnviroment", "Server", "ControllerEventHandler", "multiplayerService", "eventService", "controllerFlowHandler", "createMangoRequest", "createExecutionContext", "registerEvent", "mappedErrorFilters", "event", "name", "handleEvent", "args", "parseInternalArgs", "webViewId", "InvalidEventType", "ExecutionContextType", "Event", "classRef", "prototype", "method", "controllerMethod", "handle", "isAsyncFunction", "apply", "return", "__name", "InvalidReturnInEvent", "length", "errorGroup", "find", "errorType", "InvalidErrorFilterDefinition", "catch", "ControllerMetadataReader", "read", "options", "Reflect", "getMetadata", "CoreMetadataKey", "Controller", "events", "getEvents", "rpcs", "getRPCs", "timers", "getTimers", "getPipeline", "ControllerEvents", "getMethodParams", "ControllerRPCs", "rpc", "ControllerParams", "sort", "a", "b", "index", "forEach", "InvalidParameterDecoratorUsage", "ResponseDecoratorNotAllowedOnEvents", "Client", "PlayerDecoratorNotAllowedOnClientEvents", "RPCNotAllowedInClient", "RPCNotAllowedInServer", "EventNotAllowedInClient", "EventNotAllowedInServer", "target", "Guards", "Interceptors", "Pipes", "errorFilters", "ErrorFilters", "Timers", "ControllerRPCHandler", "rpcService", "createMangoResponse", "registerRPC", "handleRPC", "InvalidRPCType", "response", "$onSend", "$onError", "RPC", "send", "result", "eventHandlers", "rpcHandlers", "injectable", "injectable", "inject", "optional", "inject", "injectable", "optional", "Container", "LazyServiceIdentifier", "minitz", "y", "m", "d", "h", "i", "s", "tz", "throwOnInvalid", "fromTZ", "tp", "fromTZISO", "localTimeStr", "parseISOLocal", "inDate", "Date", "UTC", "offset", "getTimezoneOffset", "dateGuess", "getTime", "dateOffsGuess", "dateGuess2", "dateOffsGuess2", "Error", "toTZ", "tzStr", "localDateString", "toLocaleString", "timeZone", "replace", "td", "getFullYear", "getMonth", "getDate", "getHours", "getMinutes", "getSeconds", "date", "timeZoneName", "split", "slice", "dateString", "parse", "dtStr", "pd", "isNaN", "stringEnd", "substring", "includes", "getUTCFullYear", "getUTCMonth", "getUTCDate", "getUTCHours", "getUTCMinutes", "getUTCSeconds", "CronOptions", "options", "name", "legacyMode", "paused", "maxRuns", "Infinity", "catch", "interval", "parseInt", "utcOffset", "unref", "startAt", "CronDate", "timezone", "stopAt", "LAST_OCCURRENCE", "ANY_OCCURRENCE", "OCCURRENCE_BITMASKS", "CronPattern", "pattern", "second", "Array", "fill", "minute", "hour", "day", "month", "dayOfWeek", "lastDayOfMonth", "starDOM", "starDOW", "prototype", "String", "TypeError", "indexOf", "handleNicknames", "trim", "parts", "length", "unshift", "replaceAlphaMonths", "replaceAlphaDays", "initDate", "getDay", "throwAtIllegalCharacters", "partToArray", "type", "conf", "valueIndexOffset", "defaultValue", "arr", "handleRangeWithStepping", "handleRange", "handleStepping", "handleNumber", "reValidCron", "test", "result", "extractNth", "setPart", "part", "index", "value", "Object", "hasOwnProperty", "call", "RangeError", "setNthWeekdayOfMonth", "matches", "match", "lower", "upper", "steps", "rest", "nth", "start", "cleanPattern", "toLowerCase", "nthWeekday", "DaysOfMonth", "RecursionSteps", "fromDate", "fromString", "fromCronDate", "isNthWeekdayOfMonth", "year", "weekday", "getUTCDay", "count", "daysInMonth", "ms", "getUTCMilliseconds", "apply", "getMilliseconds", "str", "findNext", "target", "originalTarget", "fDomWeekDay", "undefined", "dowMatch", "recurse", "doing", "res", "resetLevel", "increment", "hasPreviousRun", "internal", "isFunction", "v", "toString", "Function", "unrefTimer", "timer", "Deno", "maxDelay", "scheduledJobs", "Cron", "fnOrOptions1", "fnOrOptions2", "func", "_states", "kill", "blocking", "previousRun", "currentRun", "once", "currentTimeout", "existing", "find", "j", "push", "fn", "schedule", "nextRun", "prev", "next", "_next", "nextRuns", "n", "previous", "enumeration", "getPattern", "isRunning", "nextRunTime", "isScheduled", "notIsKilled", "isStopped", "isBusy", "msToNext", "stop", "clearTimeout", "jobIndex", "splice", "pause", "resume", "waitMs", "setTimeout", "_checkTrigger", "_trigger", "initiationDate", "context", "_e", "trigger", "now", "shouldRun", "isBlocked", "protect", "startAtInFutureWithInterval", "_calculatePreviousRun", "prevTimePlusInterval", "Controller", "options", "target", "Reflect", "hasMetadata", "CoreMetadataKey", "Error", "ErrorMessage", "DuplicateDecoratorUsage", "valid", "value", "error", "validateControllerOptions", "defineMetadata", "injectable", "Global", "GlobalModule", "Inject", "key", "propertyKey", "paramIndex", "isNil", "validateInjectionToken", "InvalidInjectionTokenSpecified", "token", "getMetadata", "InjectionTokenNotFound", "inject", "Injectable", "validateInjectableMetadata", "Module", "validateModuleOptions", "Optional", "optional", "SetMetadata", "decoratorFactory", "__name", "_method", "descriptor", "KEY", "Catch", "exceptions", "duplicates", "filter", "exception", "index", "indexOf", "length", "ExceptionHandlingConflict", "UseFilters", "filters", "method", "validatedFilters", "validateErrorFilter", "push", "AtLeastOneFilterRequired", "methodFilters", "ErrorFilters", "find", "includes", "DuplicateErrorFilterDetected", "classFilters", "AppRuntime", "eventHandler", "rpcHandler", "globalGuards", "globalInterceptors", "globalPipes", "globalErrorFilters", "loggerService", "enableShutdownHooks", "boot", "resolvedTree", "asyncTraverse", "node", "startTime", "Date", "now", "module", "instance", "container", "get", "metadata", "classRef", "controllers", "forEach", "controller", "internalProviders", "externalProviders", "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", "rpcs", "rpc", "registerRPC", "timers", "type", "createCronJob", "bind", "createEveryTick", "createInterval", "timeout", "createTimeout", "filterMap", "errors", "filterError", "ErrorAlreadyHandledByFilter", "Promise", "all", "map", "isObject", "providerInstance", "ModuleDependencyBinder", "globalAppContainer", "containerOptions", "ModuleContainer", "parent", "toSelf", "inSingletonScope", "global", "_", "provider", "bindProvider", "toDynamicValue", "importModule", "repetitiveImports", "MODULE_CONTAINER", "toConstantValue", "to", "TimerService", "provide", "useValue", "binding", "ctx", "deps", "dep", "err", "undefined", "useFactory", "scope", "inTransientScope", "inRequestScope", "useClass", "toService", "useExisting", "ModuleTreeScanner", "moduleMetadataReader", "controllerMetadataReader", "scan", "moduleMetadata", "read", "scanControllers", "moduleTree", "Tree", "scannedModules", "Map", "set", "importedModule", "imports", "scanModules", "root", "parentNode", "scannedModule", "add", "checkCircularDependency", "treeNode", "TreeNode", "addChild", "controllerMetadata", "parentMetadata", "CircularDependencyDetected", "RageMPScriptEvent", "eventName", "listener", "mp", "remove", "RageMPEventEmmiter", "emit", "args", "call", "on", "once", "onceWrapper", "off", "RageMPTimer", "lastTick", "id", "interval", "callback", "clearTimer", "RageMPTimers", "timerIncrementer", "everyTickHandlers", "isEveryTickRunning", "everyTickMainHandler", "values", "warningThreshold", "_value", "sourceLocationFrameSkipCount", "getByID", "createTimer", "clear", "callbackBind", "Array", "isArray", "timerId", "rageMPTimer", "delete", "setInterval", "cb", "clearInterval", "setTimeout", "clearTimeout", "everyTick", "bound", "isClientSide", "browsers", "e", "console", "logError", "intervalHandler", "_everyTickInterval", "size", "nextTick", "_name", "timeEnd", "RageMPMultiplayerService", "Timers", "Events", "parseInternalArgs", "player", "body", "arg", "message", "a", "JSON", "stringify", "String", "join", "logInfo", "logWarning", "logDebug", "App", "moduleTreeScanner", "moduleDependencyBinder", "appRuntime", "internalAppContainer", "plugins", "loaded", "start", "rootModule", "AppAlreadyLoaded", "runPluginMethods", "AppNotLoaded", "p", "plugin", "resolve", "AppBuilder", "enviroment", "multiplayerService", "globalContainerOptions", "useGlobalGuards", "validatedGuards", "guard", "validateGuard", "GLOBAL_GUARDS", "useGlobalInterceptors", "validatedInterceptors", "interceptor", "validateInterceptor", "GLOBAL_INTERCEPTORS", "useGlobalPipes", "validatedPipes", "pipe", "validatePipe", "GLOBAL_PIPES", "useGlobalFilters", "validatedFIlters", "GLOBAL_ERROR_FILTERS", "usePlugins", "internalPlugins", "PLUGINS", "rebind", "ENABLE_SHUTDOWN_HOOKS", "setContainerOptions", "onlyGlobal", "CONTAINER_OPTIONS", "build", "Container", "REFLECTOR_SERVICE", "ReflectorService", "MULTIPLAYER_SERVICE", "GLOBAL_APP_CONTAINER", "PipelineHandler", "ModuleMetadataReader", "ControllerMetadataReader", "ControllerFlowHandler", "ControllerEventHandler", "ControllerRPCHandler", "MangoRequestBase", "MANGO_REQUEST_FACTORY", "toFactory", "context", "request", "$body", "$player", "MangoResponseBase", "MANGO_RESPONSE_FACTORY", "ExecutionContextBase", "EXECUTION_CONTEXT_FACTORY", "response", "executionContext", "$type", "$request", "$response", "$handler", "$classRef", "$name", "pluginInstance", "onBuild", "isBound", "createAppBuilder", "appBuilderInherit", "INTERNAL_APP_CONTAINER", "APP_ENVIROMENT", "createEventDecorator", "webViewId", "isString", "EventNameMustBeString", "ControllerEvents", "some", "EventNameMustBeUnique", "OnInternal", "OnWebView", "On", "OnceInternal", "Once", "OnceWebView", "Body", "params", "ControllerParams", "param", "MultipleDecoratorsOnSingleParameterNotAllowed", "paramTypes", "metatype", "MethodParamType", "data", "Index", "isNumber", "IndexKeyMustBeNumber", "Request", "Req", "Param", "ParamKeyMustBeString", "Response", "Res", "UseGuards", "AtLeastOneGuardRequired", "methodGuards", "Guards", "classGuards", "UseInterceptors", "AtLeastOneInterceptorRequired", "methodInterceptors", "Interceptors", "classInterceptors", "UsePipes", "AtLeastOnePipeRequired", "methodPipes", "Pipes", "classPipes", "createRPCDecorator", "WebViewIdMustBeStringOrNumber", "RPCNameMustBeString", "ControllerRPCs", "RPCNameMustBeUnique", "OnRequest", "rpcName", "OnWebViewRequest", "createTimerDecorator", "TimerNameMustBeString", "Cron", "pattern", "EveryTick", "Interval", "nameOrTimeout", "intervalTimeout", "Timeout", "applyDecorators", "decorators", "decorator", "Function", "createParamDecorator", "factory", "Custom", "forwardRef", "fn", "LazyServiceIdentifier", "metadataKey", "getAll", "targets", "getAllAndMerge", "metadataCollection", "item", "isEmpty", "reduce", "b", "concat", "getAllAndOverride", "result", "createDecorator", "generateRandomId", "decoratorFn", "metadataValue", "transform", "$everyticks", "$intervals", "$timeouts", "$crons", "cronOptions", "cronJob", "everytick", "getByName", "getById", "injectable", "inject", "BaseEventService", "$localHandlers", "Set", "$internalHandlers", "$remoteHandlers", "$internalEventNames", "$eventEmmiter", "on", "eventName", "callback", "wrapper", "__name", "args", "eventHandler", "add", "once", "emit", "body", "$onInternal", "handler", "has", "Error", "ErrorMessage", "InvalidInternalEventName", "$onceInternal", "BaseRPCService", "$loggerService", "$TIMEOUT", "Map", "call", "rpcName", "options", "timeout", "Promise", "resolve", "get", "RPC_RESULT_HANDLER_NOT_FOUND", "timeoutId", "setTimeout", "RPC_RESULT_TIMEOUT", "result", "clearTimeout", "success", "status", "RPCResultStatus", "Success", "error", "MangoError", "message", "details", "RPC_RESULT_UNKNOWN", "onRequest", "RPCHandlerAlreadyExists", "rpcHandler", "destroy", "valid", "delete", "set", "WEBVIEW_SERVICE", "WEBVIEW_LIST_SERVICE", "ADD_WEBVIEW", "INTERNAL_EVENTS", "SCRIPT_RPC", "SCRIPT_RPC_ANSWER", "KEYBOARD_EVENT", "KEY_UP", "KEY_DOWN", "WEB_VIEW_EVENT", "WEB_SOCKET_EVENT", "AUDIO_EVENT", "RMLUI_EVENT", "WINDOW_FOCUS_CHANGE", "WINDOW_RESOLUTION_CHANGE", "CONNECTION_COMPLETE", "DISCONNECT", "SPAWNED", "GAME_ENTITY_CREATE", "GAME_ENTITY_DESTROY", "ENTITY_HIT_ENTITY", "TASK_CHANGE", "PLAYER_WEAPON_SHOOT", "PLAYER_BULLET_HIT", "PLAYER_WEAPON_CHANGE", "PLAYER_START_VEHICLE_ENTER", "PLAYER_START_VEHICLE_LEAVE", "PLAYER_VEHICLE_ENTERED", "PLAYER_VEHICLE_LEFT", "PLAYER_VEHICLE_SEAT_CHANGE", "VOICE_CONNECTION", "PLAYER_START_TALKING", "PLAYER_STOP_TALKING", "WORLD_OBJECT_POSITION_CHANGE", "WORLD_OBJECT_STREAM_IN", "WORLD_OBJECT_STREAM_OUT", "EVENT", "BASE_OBJECT_CREATE", "BASE_OBJECT_REMOVE", "NET_OWNER_CHANGE", "WEAPON_DAMAGE", "META_CHANGE", "LOCAL_META_CHANGE", "SYNCED_META_CHANGE", "STREAM_SYNCED_META_CHANGE", "GLOBAL_META_CHANGE", "GLOBAL_SYNCED_META_CHANGE", "ENTITY_COL_SHAPE_ENTER", "ENTITY_COL_SHAPE_LEAVE", "ENTITY_CHECKPOINT_ENTER", "ENTITY_CHECKPOINT_LEAVE", "COL_SHAPE_EVENT", "CONSOLE_COMMAND", "ERROR", "LOCAL_SCRIPT_EVENT", "REMOTE_SCRIPT_EVENT", "RESOURCE_START", "RESOURCE_STOP", "RESOURCE_ERROR", "inject", "injectable", "DefaultValuePipe", "defaultValue", "transform", "value", "isNil", "isNumber", "isNaN", "EventMediatorPlugin", "eventService", "webViewService", "loggerService", "beforeLoad", "time", "Date", "now", "onServer", "body", "get", "id", "emit", "eventName", "payload", "$onCreate", "webView", "on", "data", "JSON", "parse", "emitServer", "log", "inject", "injectable", "RPCPlugin", "eventService", "webViewService", "rpcService", "loggerService", "beforeLoad", "time", "Date", "now", "onServer", "payload", "rpcHandler", "$serverHandlers", "get", "rpcName", "isNil", "emitServer", "id", "RPC_RESULT_HANDLER_NOT_FOUND", "result", "handler", "body", "rpcResult", "success", "status", "RPCResultStatus", "Success", "error", "MangoError", "message", "details", "RPC_RESULT_UNKNOWN", "$onCreate", "webViewId", "webView", "on", "valid", "$webViewHandlers", "emit", "log", "Container", "inject", "injectable", "inject", "injectable", "ClientEventService", "BaseEventService", "$webViewListService", "$rageEvents", "multiplayerService", "Events", "$internalEventNames", "Set", "Object", "values", "INTERNAL_EVENTS", "onServer", "eventName", "callback", "wrapper", "args", "eventHandler", "$remoteHandlers", "add", "onceServer", "emitServer", "body", "onWebView", "id", "webView", "tryGet", "destroy", "off", "on", "onceWebView", "once", "emitWebView", "emit", "onRender", "onBrowserDomReady", "onBrowserLoadingFailed", "onPlayerChat", "onPlayerCommand", "onPlayerDeath", "onPlayerSpawn", "onPlayerEnterVehicle", "onPlayerExitVehicle", "onPlayerEnterColshape", "onPlayerExitColshape", "onPlayerEnterCheckpoint", "onPlayerExitCheckpoint", "injectable", "inject", "ErrorMessage", "InjectableScope", "RPCResultStatus", "INTERNAL_APP_CONTAINER", "GLOBAL_APP_CONTAINER", "APP_ENVIROMENT", "GLOBAL_GUARDS", "GLOBAL_INTERCEPTORS", "GLOBAL_PIPES", "GLOBAL_ERROR_FILTERS", "PLUGINS", "ENABLE_SHUTDOWN_HOOKS", "CONTAINER_OPTIONS", "MANGO_REQUEST_FACTORY", "MANGO_RESPONSE_FACTORY", "EXECUTION_CONTEXT_FACTORY", "MULTIPLAYER_SERVICE", "RPC_RESULT_TIMEOUT", "success", "error", "message", "status", "RPCResultStatus", "Timeout", "RPC_RESULT_HANDLER_NOT_FOUND", "HandlerNotFound", "RPC_RESULT_UNKNOWN", "Unknown", "RPC_RESULT_PLAYER_DISCONNECTED", "PlayerDisconnected", "RPC_RESULT_PLAYER_NOT_FOUND", "PlayerNotFound", "inject", "injectable", "generateRandomId", "Math", "random", "toString", "substring", "isUndefined", "obj", "isObject", "fn", "isNil", "isFunction", "val", "isString", "isNil", "val", "isUndefined", "isEmpty", "array", "length", "isSymbol", "isAsyncFunction", "isFunction", "name", "inject", "injectable", "MangoError", "Error", "status", "RPCResultStatus", "Unknown", "details", "message", "GuardCancelError", "MangoError", "RPCResultStatus", "CancelledByGuard", "GuardInvalidReturnError", "MangoError", "RPCResultStatus", "InvalidGuardReturn", "LOGGER_SERVICE", "EVENT_SERVICE", "RPC_SERVICE", "MODULE_CONTAINER", "REFLECTOR_SERVICE", "TIMER_SERVICE", "PipelineHandler", "loggerService", "goTroughGuards", "executionContext", "guards", "container", "guard", "instance", "isFunction", "get", "isObject", "isNil", "error", "Error", "ErrorMessage", "InvalidGuardDefinition", "canActivate", "call", "GuardInvalidReturnError", "GuardCancelError", "goThroughInterceptors", "interceptors", "callHandler", "interceptor", "InvalidInterceptorDefinition", "intercept", "goTroughPipes", "value", "pipes", "argumentMetadata", "pipe", "InvalidPipeDefinition", "Promise", "resolve", "transform", "AppEnviroment", "CoreMetadataKey", "ExecutionContextType", "inject", "injectable", "ControllerFlowHandler", "appEnv", "pipelineHandler", "createArgs", "controller", "executionContext", "metadata", "pipes", "player", "Promise", "all", "params", "map", "param", "argumentMetadata", "type", "data", "metatype", "goTroughPipes", "request", "body", "owner", "container", "isObject", "undefined", "Array", "isArray", "factory", "AppEnviroment", "Server", "ControllerEventHandler", "appEnv", "multiplayerService", "eventService", "controllerFlowHandler", "pipelineHandler", "loggerService", "createMangoRequest", "createExecutionContext", "registerEvent", "guards", "interceptors", "pipes", "mappedErrorFilters", "controller", "event", "type", "name", "body", "handleEvent", "args", "player", "parseInternalArgs", "webViewId", "AppEnviroment", "Server", "undefined", "error", "Error", "ErrorMessage", "InvalidEventType", "request", "executionContext", "ExecutionContextType", "Event", "metadata", "classRef", "prototype", "method", "goTroughGuards", "owner", "container", "createArgs", "controllerMethod", "instance", "handle", "isAsyncFunction", "apply", "callHandler", "return", "InvalidReturnInEvent", "length", "goThroughInterceptors", "errorGroup", "find", "errorType", "isFunction", "isNil", "get", "isObject", "InvalidErrorFilterDefinition", "Promise", "resolve", "catch", "call", "inject", "injectable", "ControllerMetadataReader", "appEnv", "loggerService", "read", "classRef", "options", "Reflect", "getMetadata", "CoreMetadataKey", "Controller", "events", "getEvents", "rpcs", "getRPCs", "timers", "getTimers", "getPipeline", "ControllerEvents", "prototype", "map", "event", "params", "getMethodParams", "method", "ControllerRPCs", "rpc", "metadata", "ControllerParams", "sort", "a", "b", "index", "forEach", "param", "error", "Error", "ErrorMessage", "InvalidParameterDecoratorUsage", "type", "ResponseDecoratorNotAllowedOnEvents", "AppEnviroment", "Client", "PlayerDecoratorNotAllowedOnClientEvents", "RPCNotAllowedInClient", "Server", "RPCNotAllowedInServer", "EventNotAllowedInClient", "EventNotAllowedInServer", "target", "guards", "Guards", "interceptors", "Interceptors", "pipes", "Pipes", "errorFilters", "ErrorFilters", "Timers", "inject", "injectable", "ControllerRPCHandler", "appEnv", "rpcService", "pipelineHandler", "controllerFlowHandler", "loggerService", "createMangoRequest", "createMangoResponse", "createExecutionContext", "registerRPC", "guards", "interceptors", "pipes", "mappedErrorFilters", "controller", "rpc", "type", "name", "body", "handleRPC", "player", "webViewId", "args", "AppEnviroment", "Server", "undefined", "error", "Error", "ErrorMessage", "InvalidRPCType", "Promise", "resolve", "request", "response", "$onSend", "data", "$onError", "executionContext", "ExecutionContextType", "RPC", "metadata", "classRef", "prototype", "method", "goTroughGuards", "owner", "container", "createArgs", "controllerMethod", "instance", "handle", "isAsyncFunction", "options", "send", "result", "apply", "callHandler", "return", "value", "length", "goThroughInterceptors", "errorGroup", "find", "errorType", "isFunction", "isNil", "get", "isObject", "InvalidErrorFilterDefinition", "catch", "call", "injectable", "Controller", "metadata", "instance", "owner", "eventHandlers", "rpcHandlers", "inject", "injectable", "ModuleMetadataReader", "loggerService", "read", "module", "isFunction", "options", "Reflect", "getMetadata", "CoreMetadataKey", "Module", "exportTokens", "getExportTokens", "exports", "separatedProviders", "separateProviders", "providers", "controllers", "imports", "getPipeline", "classRef", "global", "GlobalModule", "container", "Promise", "error", "Error", "ErrorMessage", "InvalidModuleDefinition", "guards", "Guards", "interceptors", "Interceptors", "pipes", "Pipes", "errorFilters", "ErrorFilters", "map", "providerExport", "hasOwnMetadata", "Injectable", "InvalidExportDefinition", "isString", "isSymbol", "provide", "provider", "injectableMetadata", "isNil", "InvalidProviderDefinition", "useClass", "scope", "reduce", "acc", "includes", "externalProviders", "set", "internalProviders", "Map", "Container", "ModuleContainer", "Container", "injectable", "Module", "controllers", "container", "parent", "metadata", "instance", "repetitiveImports", "Set", "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", "injectable", "validateErrorFilter", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "catch", "validatePipe", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "transform", "validateGuard", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "canActivate", "validateInterceptor", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "intercept", "defaultInjectableOptions", "scope", "InjectableScope", "Singleton", "injectable", "inject", "injectable", "injectable", "optional", "SetMetadata", "key", "value", "decoratorFactory", "target", "_method", "descriptor", "Reflect", "defineMetadata", "KEY", "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", "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", "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", "TreeNode", "value", "children", "addChild", "child", "push", "removeChild", "index", "indexOf", "splice", "Tree", "root", "traverse", "callback", "traverseNode", "node", "forEach", "asyncTraverse", "Promise", "all", "map", "toString", "result", "lines", "depth", "repeat", "join", "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", "injectable", "ExecutionContextBase", "$type", "$classRef", "$handler", "$request", "$response", "$name", "type", "classRef", "handler", "request", "response", "name", "injectable", "MangoRequestBase", "$body", "$player", "body", "player", "inject", "injectable", "MangoResponseBase", "$loggerService", "$sendListeners", "Set", "$errorListeners", "$isSent", "send", "data", "error", "Error", "ErrorMessage", "RPCResponseAlreadySent", "forEach", "listener", "message", "details", "$onSend", "add", "$onError", "injectable", "BaseEventService", "$localHandlers", "Set", "$internalHandlers", "$remoteHandlers", "$internalEventNames", "$eventEmmiter", "on", "eventName", "callback", "wrapper", "args", "eventHandler", "add", "once", "emit", "body", "$onInternal", "handler", "has", "Error", "ErrorMessage", "InvalidInternalEventName", "$onceInternal", "inject", "injectable", "BaseRPCService", "$loggerService", "$TIMEOUT", "$localHandlers", "Map", "call", "rpcName", "body", "options", "timeout", "Promise", "resolve", "handler", "get", "RPC_RESULT_HANDLER_NOT_FOUND", "timeoutId", "setTimeout", "RPC_RESULT_TIMEOUT", "result", "clearTimeout", "success", "status", "RPCResultStatus", "Success", "error", "MangoError", "message", "details", "RPC_RESULT_UNKNOWN", "onRequest", "has", "Error", "ErrorMessage", "RPCHandlerAlreadyExists", "rpcHandler", "destroy", "valid", "delete", "set", "inject", "Container", "injectable", "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", "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", "ClientLoggerService", "multiplayerService", "log", "args", "MANGO_LOG_PREFIX", "warn", "logWarning", "error", "logError", "debug", "logDebug", "inject", "injectable", "ClientRPCService", "BaseRPCService", "$eventService", "$serverHandlers", "Map", "$webViewHandlers", "callServer", "rpcName", "body", "options", "timeout", "$TIMEOUT", "$handleCall", "EventDestination", "Server", "onServerRequest", "handler", "has", "$loggerService", "error", "Error", "ErrorMessage", "RPCHandlerAlreadyExists", "rpcHandler", "destroy", "valid", "delete", "set", "callWebView", "id", "WebView", "onWebViewRequest", "key", "destination", "webViewId", "Promise", "resolve", "callId", "generateRandomId", "timeoutId", "onceHandle", "resultData", "clearTimeout", "eventHandler", "onceWebView", "onceServer", "payload", "source", "Client", "emitWebView", "emitServer", "setTimeout", "RPC_RESULT_TIMEOUT", "inject", "injectable", "WebViewListService", "$loggerService", "$webViews", "Map", "set", "id", "webView", "get", "tryGet", "isNil", "valid", "error", "Error", "ErrorMessage", "WebViewNotFound", "delete", "destroy", "inject", "injectable", "ClientWebViewService", "$loggerService", "$webViewListService", "multiplayer", "$createListeners", "create", "id", "options", "isString", "isNumber", "error", "Error", "ErrorMessage", "WebViewIdMustBeStringOrNumber", "webView", "WebView", "set", "forEach", "listener", "get", "tryGet", "destroy", "delete", "$onCreate", "push", "ServiceBinderPlugin", "internalAppContainer", "globalAppContainer", "onBuild", "time", "Date", "now", "bind", "LOGGER_SERVICE", "to", "ClientLoggerService", "inSingletonScope", "EVENT_SERVICE", "ClientEventService", "RPC_SERVICE", "ClientRPCService", "WEBVIEW_SERVICE", "ClientWebViewService", "WEBVIEW_LIST_SERVICE", "WebViewListService", "toConstantValue", "get", "loggerService", "log", "Container", "inject", "injectable", "WebViewPlugin", "internalAppContainer", "webViewService", "loggerService", "beforeLoad", "time", "Date", "now", "addWebViews", "isBound", "ADD_WEBVIEW", "get", "length", "forEach", "webView", "create", "id", "options", "log", "RageMPClientScriptEvent", "eventName", "listener", "destroy", "mp", "events", "remove", "ClientRageMPEventEmmiter", "mapEventsShared", "mapEvents", "getEventName", "eventName", "emit", "args", "mp", "events", "call", "on", "listener", "mappedEventName", "add", "RageMPClientScriptEvent", "once", "onceWrapper", "remove", "off", "emitServer", "callRemote", "onServer", "onceServer", "offServer", "RageMPWebView", "eventListeners", "Map", "$raw", "valid", "undefined", "destroy", "url", "value", "visible", "active", "emit", "eventName", "args", "call", "emitRaw", "reload", "ignoreCache", "on", "listener", "has", "set", "Set", "get", "add", "listeners", "size", "mp", "events", "l", "once", "onceWrapper", "off", "delete", "execute", "code", "markAsChat", "raw", "RageMPWebViewManager", "webViews", "Map", "idCounter", "create", "options", "raw", "mp", "console", "logWarning", "browsers", "new", "url", "visible", "undefined", "active", "webView", "RageMPWebView", "id", "set", "getByID", "cached", "get", "browser", "at", "ClientRageMPMultiplayerService", "RageMPMultiplayerService", "Events", "WebView", "ClientRageMPEventEmmiter", "RageMPWebViewManager", "setAudioFactory", "_factory", "setAudioFilterFactory", "setAudioOutputAttachedFactory", "setAudioOutputFrontendFactory", "setAudioOutputWorldFactory", "setBlipFactory", "factory", "mp", "Blip", "Object", "assign", "prototype", "setMarkerFactory", "Marker", "setColshapeFactory", "Colshape", "setCheckpointFactory", "Checkpoint", "setObjectFactory", "setLocalObjectFactory", "setPedFactory", "Ped", "setLocalPedFactory", "setLocalPlayerFactory", "setLocalVehicleFactory", "setPlayerFactory", "Player", "setRmlDocumentFactory", "setTextLabelFactory", "TextLabel", "setVehicleFactory", "Vehicle", "setVirtualEntityGroupFactory", "setVirtualEntityFactory", "setWebSocketClientFactory", "setWebViewFactory", "Browser", "UseFilters", "filters", "$UseFilters", "OnScriptRPC", "OnInternal", "INTERNAL_EVENTS", "SCRIPT_RPC", "OnceScriptRPC", "OnceInternal", "OnScriptRPCAnswer", "SCRIPT_RPC_ANSWER", "OnceScriptRPCAnswer", "OnKeyBoardEvent", "KEYBOARD_EVENT", "OnceKeyBoardEvent", "OnKeyUp", "KEY_UP", "OnceKeyUp", "OnKeyDown", "KEY_DOWN", "OnceKeyDown", "OnWebViewEvent", "WEB_VIEW_EVENT", "OnceWebViewEvent", "OnWebSocketEvent", "WEB_SOCKET_EVENT", "OnceWebSocketEvent", "OnAudioEvent", "AUDIO_EVENT", "OnceAudioEvent", "OnRmluiEvent", "RMLUI_EVENT", "OnceRmluiEvent", "OnWindowFocusChange", "WINDOW_FOCUS_CHANGE", "OnceWindowFocusChange", "OnWindowResolutionChange", "WINDOW_RESOLUTION_CHANGE", "OnceWindowResolutionChange", "OnConnectionComplete", "CONNECTION_COMPLETE", "OnceConnectionComplete", "OnDisconnect", "DISCONNECT", "OnceDisconnect", "OnSpawned", "SPAWNED", "OnceSpawned", "OnGameEntityCreate", "GAME_ENTITY_CREATE", "OnceGameEntityCreate", "OnGameEntityDestroy", "GAME_ENTITY_DESTROY", "OnceGameEntityDestroy", "OnEntityHitEntity", "ENTITY_HIT_ENTITY", "OnceEntityHitEntity", "OnTaskChange", "TASK_CHANGE", "OnceTaskChange", "OnPlayerWeaponShoot", "PLAYER_WEAPON_SHOOT", "OncePlayerWeaponShoot", "OnPlayerBulletHit", "PLAYER_BULLET_HIT", "OncePlayerBulletHit", "OnPlayerWeaponChange", "PLAYER_WEAPON_CHANGE", "OncePlayerWeaponChange", "OnPlayerStartVehicleEnter", "PLAYER_START_VEHICLE_ENTER", "OncePlayerStartVehicleEnter", "OnPlayerStartVehicleLeave", "PLAYER_START_VEHICLE_LEAVE", "OncePlayerStartVehicleLeave", "OnPlayerVehicleEntered", "PLAYER_VEHICLE_ENTERED", "OncePlayerVehicleEntered", "OnPlayerVehicleLeft", "PLAYER_VEHICLE_LEFT", "OncePlayerVehicleLeft", "OnPlayerVehicleSeatChange", "PLAYER_VEHICLE_SEAT_CHANGE", "OncePlayerVehicleSeatChange", "OnVoiceConnection", "VOICE_CONNECTION", "OnceVoiceConnection", "OnPlayerStartTalking", "PLAYER_START_TALKING", "OncePlayerStartTalking", "OnPlayerStopTalking", "PLAYER_STOP_TALKING", "OncePlayerStopTalking", "OnWorldObjectPositionChange", "WORLD_OBJECT_POSITION_CHANGE", "OnceWorldObjectPositionChange", "OnWorldObjectStreamIn", "WORLD_OBJECT_STREAM_IN", "OnceWorldObjectStreamIn", "OnWorldObjectStreamOut", "WORLD_OBJECT_STREAM_OUT", "OnceWorldObjectStreamOut", "OnEvent", "EVENT", "OnceEvent", "OnBaseObjectCreate", "BASE_OBJECT_CREATE", "OnceBaseObjectCreate", "OnBaseObjectRemove", "BASE_OBJECT_REMOVE", "OnceBaseObjectRemove", "OnNetOwnerChange", "NET_OWNER_CHANGE", "OnceNetOwnerChange", "OnWeaponDamage", "WEAPON_DAMAGE", "OnceWeaponDamage", "OnMetaChange", "META_CHANGE", "OnceMetaChange", "OnLocalMetaChange", "LOCAL_META_CHANGE", "OnceLocalMetaChange", "OnSyncedMetaChange", "SYNCED_META_CHANGE", "OnceSyncedMetaChange", "OnStreamSyncedMetaChange", "STREAM_SYNCED_META_CHANGE", "OnceStreamSyncedMetaChange", "OnGlobalMetaChange", "GLOBAL_META_CHANGE", "OnceGlobalMetaChange", "OnGlobalSyncedMetaChange", "GLOBAL_SYNCED_META_CHANGE", "OnceGlobalSyncedMetaChange", "OnEntityColShapeEnter", "ENTITY_COL_SHAPE_ENTER", "OnceEntityColShapeEnter", "OnEntityColShapeLeave", "ENTITY_COL_SHAPE_LEAVE", "OnceEntityColShapeLeave", "OnEntityCheckpointEnter", "ENTITY_CHECKPOINT_ENTER", "OnceEntityCheckpointEnter", "OnEntityCheckpointLeave", "ENTITY_CHECKPOINT_LEAVE", "OnceEntityCheckpointLeave", "OnColShapeEvent", "COL_SHAPE_EVENT", "OnceColShapeEvent", "OnConsoleCommand", "CONSOLE_COMMAND", "OnceConsoleCommand", "OnError", "ERROR", "OnceError", "OnLocalScriptEvent", "LOCAL_SCRIPT_EVENT", "OnceLocalScriptEvent", "OnRemoteScriptEvent", "REMOTE_SCRIPT_EVENT", "OnceRemoteScriptEvent", "OnResourceStart", "RESOURCE_START", "OnceResourceStart", "OnResourceStop", "RESOURCE_STOP", "OnceResourceStop", "OnResourceError", "RESOURCE_ERROR", "OnceResourceError", "OnServer", "eventName", "createEventDecorator", "OnWebView", "id", "eventName", "$OnWebView", "On", "eventName", "$On", "OnceServer", "eventName", "createEventDecorator", "OnceWebView", "id", "eventName", "$OnceWebView", "Once", "eventName", "$Once", "UseGuards", "guards", "$UseGuards", "UseInterceptors", "interceptors", "$UseInterceptors", "OnRequest", "rpcName", "$OnRequest", "OnServerRequest", "rpcName", "createRPCDecorator", "OnWebViewRequest", "id", "rpcName", "$OnWebViewRequest", "multiplayerService", "ClientRageMPMultiplayerService", "ClientAppBuilder", "AppBuilder", "addWebView", "id", "options", "addWebViews", "internalAppContainer", "isBound", "ADD_WEBVIEW", "get", "rebind", "toConstantValue", "bind", "setAudioFactory", "factory", "setAudioFilterFactory", "setAudioOutputAttachedFactory", "setAudioOutputFrontendFactory", "setAudioOutputWorldFactory", "setBlipFactory", "setMarkerFactory", "setColShapeFactory", "setColshapeFactory", "setCheckpointFactory", "setObjectFactory", "setLocalObjectFactory", "setPedFactory", "setLocalPedFactory", "setLocalPlayerFactory", "setLocalVehicleFactory", "setPlayerFactory", "setRmlDocumentFactory", "setTextLabelFactory", "setVehicleFactory", "setVirtualEntityGroupFactory", "setVirtualEntityFactory", "setWebSocketClientFactory", "setWebViewFactory", "createAppBuilder", "$createAppBuilder", "enviroment", "AppEnviroment", "Client", "plugins", "ServiceBinderPlugin", "EventMediatorPlugin", "RPCPlugin", "WebViewPlugin", "appBuilderInherit"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../core/src/app/enums/app-enviroment.enum.ts", "../../core/src/app/enums/core-metadata-key.enum.ts", "../../core/src/app/enums/event-destination.enum.ts", "../../core/src/app/enums/execution-context-type.enum.ts", "../../core/src/app/enums/method-param-type.enum.ts", "../../core/src/constants/index.ts", "../../core/src/enums/error-message.enum.ts", "../../core/src/enums/injectable-scope.enum.ts", "../../core/src/enums/rpc-result-status.enum.ts", "../../core/dist/chunk-7QVYU63E.js", "../../core/src/utils/generate-random-id.util.ts", "../../core/src/utils/type-check.util.ts", "../../core/src/app/module/module-metadata.reader.ts", "../../core/src/app/module/module-container.ts", "../../core/src/app/module/module.ts", "../../core/src/app/pipeline/execution-context-base.ts", "../../core/src/app/pipeline/mango-request-base.ts", "../../core/src/app/pipeline/mango-response-base.ts", "../../core/src/app/utils/tree.util.ts", "../../core/src/schemas/controller/controller-options.validate.ts", "../../core/src/schemas/events/error-filter.validate.ts", "../../core/src/schemas/events/pipe.validate.ts", "../../core/src/schemas/events/event-parameter.validate.ts", "../../core/src/schemas/events/event-metadata.validate.ts", "../../core/src/schemas/events/guard.validate.ts", "../../core/src/schemas/events/interceptor.validate.ts", "../../core/src/schemas/injection-token.validate.ts", "../../core/src/schemas/module/provider.validate.ts", "../../core/src/schemas/module/module-options.validate.ts", "../../core/src/schemas/injectable-metadata.validate.ts", "../../core/src/app/constants/index.ts", "../../core/src/errors/mango.error.ts", "../../core/src/errors/guard-cancel.error.ts", "../../core/src/errors/guard-invalid-return.error.ts", "../../core/src/errors/too-many-requests.error.ts", "../../core/src/errors/unknown.error.ts", "../../core/src/app/controller/controller-event.handler.ts", "../../core/src/app/controller/pipeline.handler.ts", "../../core/src/app/controller/controller-flow.handler.ts", "../../core/src/app/controller/controller-metadata.reader.ts", "../../core/src/app/controller/controller-rpc.handler.ts", "../../core/src/app/controller/controller.ts", "../../../node_modules/.pnpm/@abraham+reflection@0.12.0/node_modules/@abraham/reflection/src/index.ts", "../../core/src/services/index.ts", "../../core/src/services/reflector.service.ts", "../../core/src/decorators/index.ts", "../../core/src/decorators/core/controller.decorator.ts", "../../core/src/decorators/core/global.decorator.ts", "../../core/src/decorators/core/inject.decorator.ts", "../../core/src/decorators/core/injectable.decorator.ts", "../../core/src/decorators/core/module.decorator.ts", "../../core/src/decorators/core/optional.decorator.ts", "../../core/src/decorators/core/set-metadata.decorator.ts", "../../core/src/decorators/errors/catch.decorator.ts", "../../core/src/decorators/errors/use-filters.decorator.ts", "../../core/src/app/index.ts", "../../core/src/app/module-tree/app-runtime.ts", "../../core/src/app/module-tree/dependency-binder.ts", "../../core/src/app/module-tree/module-tree-scanner.ts", "../../core/src/app/multiplayer/ragemp/ragemp-script-event-handler.ts", "../../core/src/app/multiplayer/ragemp/ragemp-event-emmiter.ts", "../../core/src/app/multiplayer/ragemp/ragemp-timer.ts", "../../core/src/app/multiplayer/ragemp/ragemp-timers.ts", "../../core/src/app/multiplayer/ragemp/ragemp-multiplayer.service.ts", "../../core/src/app/app-builder.ts", "../../core/src/app/app.ts", "../../core/src/app/create-app.ts", "../../core/src/decorators/create-event-decorator.ts", "../../core/src/decorators/events/on-internal.decorator.ts", "../../core/src/decorators/events/on-webview.decorator.ts", "../../core/src/decorators/events/on.decorator.ts", "../../core/src/decorators/events/once-internal.decorator.ts", "../../core/src/decorators/events/once.decorator.ts", "../../core/src/decorators/events/once-webview.decorator.ts", "../../core/src/decorators/params/body.decorator.ts", "../../core/src/decorators/params/index.decorator.ts", "../../core/src/decorators/params/request.decorator.ts", "../../core/src/decorators/params/param.decorator.ts", "../../core/src/decorators/params/response.deorator.ts", "../../core/src/decorators/pipeline/use-guards.decorator.ts", "../../core/src/decorators/pipeline/use-interceptors.decorator.ts", "../../core/src/decorators/pipeline/use-pipes.decorator.ts", "../../core/src/decorators/create-rpc-decorator.ts", "../../core/src/decorators/rpc/on-request.decorator.ts", "../../core/src/decorators/rpc/on-webview-request.decorator.ts", "../../core/src/decorators/create-timer.decorator.ts", "../../core/src/decorators/timers/cron.decorator.ts", "../../core/src/decorators/timers/every-tick.decorator.ts", "../../core/src/decorators/timers/interval.decorator.ts", "../../core/src/decorators/timers/timeout.decorator.ts", "../../core/src/decorators/apply-decorator.util.ts", "../../core/src/decorators/create-param.util.ts", "../../core/src/decorators/forward-ref.util.ts", "../../core/src/services/timer.service.ts", "../../../node_modules/.pnpm/croner@8.1.2/node_modules/croner/dist/croner.min.js", "../../core/src/app/services/base-event.service.ts", "../../core/src/app/services/base-rpc.service.ts", "../src/constants/inject.consts.ts", "../src/constants/internal-events.consts.ts", "../src/plugins/event-mediator.plugin.ts", "../../core/src/pipes/default-value.pipe.ts", "../src/plugins/rpc.plugin.ts", "../src/plugins/service-binder.plugin.ts", "../src/services/client-event.service.ts", "../src/services/client-logger.service.ts", "../../core/src/enums/error-message.enum.ts", "../../core/src/enums/injectable-scope.enum.ts", "../../core/src/enums/rpc-result-status.enum.ts", "../../core/src/app/constants/index.ts", "../../core/src/app/controller/controller-event.handler.ts", "../../core/src/utils/generate-random-id.util.ts", "../../core/src/utils/type-check.util.ts", "../../core/src/app/controller/pipeline.handler.ts", "../../core/src/errors/mango.error.ts", "../../core/src/errors/guard-cancel.error.ts", "../../core/src/errors/guard-invalid-return.error.ts", "../../core/src/constants/index.ts", "../../core/src/app/enums/app-enviroment.enum.ts", "../../core/src/app/enums/core-metadata-key.enum.ts", "../../core/src/app/enums/execution-context-type.enum.ts", "../../core/src/app/controller/controller-flow.handler.ts", "../../core/src/app/controller/controller-metadata.reader.ts", "../../core/src/app/controller/controller-rpc.handler.ts", "../../core/src/app/controller/controller.ts", "../../core/src/app/module/module-metadata.reader.ts", "../../core/src/app/module/module-container.ts", "../../core/src/app/module/module.ts", "../../core/src/app/module-tree/app-runtime.ts", "../../core/src/app/module-tree/dependency-binder.ts", "../../core/src/services/reflector.service.ts", "../../core/src/schemas/events/error-filter.validate.ts", "../../core/src/schemas/events/pipe.validate.ts", "../../core/src/schemas/events/guard.validate.ts", "../../core/src/schemas/events/interceptor.validate.ts", "../../core/src/schemas/injectable-metadata.validate.ts", "../../core/src/decorators/core/controller.decorator.ts", "../../core/src/decorators/core/inject.decorator.ts", "../../core/src/decorators/core/injectable.decorator.ts", "../../core/src/decorators/core/module.decorator.ts", "../../core/src/decorators/core/optional.decorator.ts", "../../core/src/decorators/core/set-metadata.decorator.ts", "../../core/src/decorators/forward-ref.util.ts", "../../core/src/services/timer.service.ts", "../../core/src/app/module-tree/module-tree-scanner.ts", "../../core/src/app/utils/tree.util.ts", "../../core/src/app/pipeline/execution-context-base.ts", "../../core/src/app/pipeline/mango-request-base.ts", "../../core/src/app/pipeline/mango-response-base.ts", "../../core/src/app/services/base-event.service.ts", "../../core/src/app/services/base-rpc.service.ts", "../../core/src/app/app-builder.ts", "../../core/src/app/app.ts", "../../core/src/app/create-app.ts", "../src/services/client-rpc.service.ts", "../src/services/webview-list.service.ts", "../src/services/client-webview.service.ts", "../src/plugins/webview.plugin.ts", "../src/multiplayer/ragemp/ragemp-script-event-handler.ts", "../src/multiplayer/ragemp/ragemp-event-emmiter.ts", "../src/multiplayer/ragemp/ragemp-webview.ts", "../src/multiplayer/ragemp/ragemp-webview-manager.ts", "../src/multiplayer/ragemp/ragemp-multiplayer.service.ts", "../src/decorators/errors/use-filters.decorator.ts", "../src/decorators/events/internal/index.ts", "../src/decorators/events/on-server.decorator.ts", "../src/decorators/events/on-webview.decorator.ts", "../src/decorators/events/on.decorator.ts", "../src/decorators/events/once-server.decorator.ts", "../src/decorators/events/once-webview.decorator.ts", "../src/decorators/events/once.decorator.ts", "../src/decorators/pipeline/use-guards.decorator.ts", "../src/decorators/pipeline/use-interceptors.decorator.ts", "../src/decorators/rpc/on-request.decorator.ts", "../src/decorators/rpc/on-server-request.decorator.ts", "../src/decorators/rpc/on-webview-request.decorator.ts", "../src/index.ts"],
  "sourcesContent": ["export enum AppEnviroment {\n    Client,\n    Server,\n}\n", "export enum CoreMetadataKey {\n    // General\n    Injectable = 'mango:injectable',\n    Inject = 'mango:inject',\n    Module = 'mango:module',\n    GlobalModule = 'mango:global-module',\n    Controller = 'mango:controller-options',\n    // Events & RPC\n    ControllerEvents = 'mango:controller-events',\n    ControllerRPCs = 'mango:controller-rpcs',\n    ControllerParams = 'mango:controller-rpc-params',\n    // Pipeline\n    Guards = 'mango:guards',\n    Interceptors = 'mango:interceptors',\n    Pipes = 'mango:pipes',\n    // Error\n    Catch = 'mango:catch',\n    ErrorFilters = 'mango:error-filters',\n    //\n    Timers = 'mango:timers',\n}\n", "export enum EventDestination {\n    Server = 'server',\n    Client = 'client',\n    WebView = 'webview',\n}\n", "export enum ExecutionContextType {\n    Event = 'event',\n    RPC = 'rpc',\n}\n", "export enum MethodParamType {\n    Body = 'body',\n    Custom = 'custom',\n    Param = 'param',\n    Player = 'player',\n    Request = 'request',\n    Response = 'response',\n    Index = 'index',\n}\n", "export const LOGGER_SERVICE = 'LOGGER_SERVICE';\nexport const EVENT_SERVICE = 'EVENT_SERVICE';\nexport const RPC_SERVICE = 'RPC_SERVICE';\nexport const MODULE_CONTAINER = 'MODULE_CONTAINER';\nexport const REFLECTOR_SERVICE = 'REFLECTOR_SERVICE';\nexport const TIMER_SERVICE = 'TIMER_SERVICE';\n", "export enum ErrorMessage {\n    TooManyRequests = 'Too many requests.',\n\n    // Events\n    EventNameMustBeString = 'The event name must be a string.',\n    EventNameMustBeUnique = 'The event name must be unique.',\n    EventNotAllowedInClient = 'The event is not allowed in the client environment.',\n    EventNotAllowedInServer = 'The event is not allowed in the server environment.',\n    InvalidEventType = 'Invalid event type.',\n    InvalidInternalEventName = 'The name of the internal event is invalid.',\n    InvalidReturnInEvent = 'Cannot return a value from an event.',\n\n    // RPC\n    RPCNameMustBeString = 'The RPC name must be a string.',\n    RPCNameMustBeUnique = 'The RPC name must be unique.',\n    RPCNotAllowedInClient = 'The RPC is not allowed in the client environment.',\n    RPCNotAllowedInServer = 'The RPC is not allowed in the server environment.',\n    InvalidRPCType = 'Invalid RPC type.',\n    RPCHandlerAlreadyExists = 'The RPC handler already exists. Please provide a unique name for the RPC.',\n    RPCResponseAlreadySent = 'The RPC response has already been sent.',\n\n    // Error filters\n    InvalidErrorFilterDefinition = 'Invalid error filter. Error filters must be a class reference or an object with a catch method.',\n    ErrorAlreadyHandledByFilter = 'The error already points to a filter.',\n    ExceptionHandlingConflict = 'The same exception can only be caught once.',\n    AtLeastOneFilterRequired = 'At least one error filter must be provided.',\n    DuplicateErrorFilterDetected = 'Duplicate error filter found. Ensure that the same filter is not applied more than once.',\n\n    // WebView\n    WebViewNotFound = 'The WebView with the specified id does not exist.',\n    WebViewIdMustBeStringOrNumber = 'The WebView id must be a string or number.',\n\n    // Guard\n    InvalidGuardDefinition = 'Invalid guard. Guards must be a class reference or an object with a canActivate method.',\n    AtLeastOneGuardRequired = 'At least one guard must be provided.',\n\n    // Interceptor\n    InvalidInterceptorDefinition = 'Invalid interceptor. Interceptors must be a class reference or an object with an intercept method.',\n    AtLeastOneInterceptorRequired = 'At least one interceptor must be provided.',\n    InvalidInterceptorReturnValue = 'The interceptor must return a function.',\n\n    // Pipe\n    InvalidPipeDefinition = 'Invalid pipe. Pipes must be a class reference or an object with a transform method.',\n    AtLeastOnePipeRequired = 'At least one pipe must be provided.',\n\n    // App loading\n    AppAlreadyLoaded = 'App is already loaded. Please call the stop method before calling the start method.',\n    AppNotLoaded = 'App is not loaded. Please call the start method before calling the stop method.',\n\n    // Decorators\n    InvalidInjectionTokenSpecified = 'The specified injection token is invalid.',\n    InjectionTokenNotFound = 'The injection token could not be found.',\n    ParamKeyMustBeString = 'The param key must be a string.',\n    IndexKeyMustBeNumber = 'The index key must be a number.',\n    DuplicateDecoratorUsage = 'The same decorator can only be used once in the same class.',\n    InvalidControllerOptions = 'Invalid controller options found.',\n    InvalidInjectableOptions = 'Invalid injectable options found.',\n    InvalidModuleOptions = 'Invalid module options found.',\n    MultipleDecoratorsOnSingleParameterNotAllowed = 'Cannot apply multiple decorators to the same parameter.',\n\n    // Internal App\n    CircularDependencyDetected = 'Circular dependency detected.',\n    InvalidModuleDefinition = 'The module is invalid.',\n    InvalidExportDefinition = 'The export is invalid.',\n    InvalidProviderDefinition = 'The provider is invalid.',\n    InvalidParameterDecoratorUsage = 'Each parameter must have their its own decorator.',\n    ResponseDecoratorNotAllowedOnEvents = 'The @Response() decorator is not allowed on events.',\n    PlayerDecoratorNotAllowedOnClientEvents = 'The @Player() decorator is not allowed on client events.',\n\n    // Timers\n    TimerNameMustBeString = 'The timer name must be a string.',\n}\n", "export enum InjectableScope {\n    Request = 'request',\n    Transient = 'transient',\n    Singleton = 'singleton',\n}\n", "export enum RPCResultStatus {\n    Success = 1,\n    Timeout = 2,\n    HandlerNotFound = 3,\n    Unknown = 4,\n    CancelledByGuard = 5,\n    InvalidGuardReturn = 6,\n    TooManyRequests = 7,\n    PlayerDisconnected = 8,\n    PlayerNotFound = 9,\n}\n", "var __defProp = Object.defineProperty;\nvar __name = (target, value)=>__defProp(target, \"name\", {\n        value,\n        configurable: true\n    });\nexport { __name }; //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9", "export function generateRandomId() {\n    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);\n}\n", "export const isUndefined = (obj: any): obj is undefined => typeof obj === 'undefined';\nexport const isObject = (fn: any): fn is object => !isNil(fn) && typeof fn === 'object';\nexport const isFunction = (val: any): val is Function => typeof val === 'function';\nexport const isString = (val: any): val is string => typeof val === 'string';\nexport const isNumber = (val: any): val is number => typeof val === 'number';\nexport const isConstructor = (val: any): boolean => val === 'constructor';\nexport const isNil = (val: any): val is null | undefined => isUndefined(val) || val === null;\nexport const isEmpty = (array: any): boolean => !(array && array.length > 0);\nexport const isSymbol = (val: any): val is symbol => typeof val === 'symbol';\nexport const isAsyncFunction = (val: any): boolean => isFunction(val) && val.constructor.name === 'AsyncFunction';\nexport const isBoolean = (val: any): val is boolean => typeof val === 'boolean';\nexport const isPromise = <T = any>(val: any): val is Promise<T> => val instanceof Promise;\n", "import { inject, injectable } from 'inversify';\nimport type { InjectionToken, Newable } from '../../types';\nimport { CoreMetadataKey } from '../enums';\nimport type { InjectableMetadata, ErrorFilter, Guard, Interceptor } from '../interfaces';\nimport type { ModuleMetadata } from '../interfaces';\nimport type { ClassProvider, DynamicModule, LoggerService, ModuleOptions, Pipe, Provider } from '../../interfaces';\nimport { isFunction, isNil, isString, isSymbol } from '../../utils';\nimport { ErrorMessage } from '../../enums';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class ModuleMetadataReader {\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async read(module: Newable | DynamicModule | Promise<DynamicModule>) {\n        // Class reference\n        if (isFunction(module)) {\n            const options = Reflect.getMetadata<Required<ModuleOptions>>(CoreMetadataKey.Module, module) ?? <Required<ModuleOptions>>{};\n            const exportTokens = this.getExportTokens(options.exports);\n            const separatedProviders = this.separateProviders(options.providers, exportTokens);\n\n            return <ModuleMetadata>{\n                controllers: options.controllers,\n                imports: options.imports,\n                ...this.getPipeline(module),\n                ...separatedProviders,\n                classRef: module,\n                global: Reflect.getMetadata<boolean>(CoreMetadataKey.GlobalModule, module) ?? false,\n                container: options.container,\n            };\n        }\n        // Dynamic module\n        if (module instanceof Promise) module = await module;\n        if (!('module' in module)) {\n            this.loggerService.error('An error occurred while reading module metadata.');\n            throw new Error(ErrorMessage.InvalidModuleDefinition);\n        }\n\n        const { module: classRef, global, ...options } = <Required<DynamicModule>>module;\n        const exportTokens = this.getExportTokens(options.exports);\n        const separatedProviders = this.separateProviders(options.providers, exportTokens);\n\n        return <ModuleMetadata>{\n            controllers: options.controllers,\n            imports: options.imports,\n            ...this.getPipeline(classRef),\n            ...separatedProviders,\n            classRef,\n            global: global ?? false,\n            container: options.container,\n        };\n    }\n\n    private getPipeline(classRef: Newable) {\n        const guards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, classRef) ?? [];\n        const interceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, classRef) ?? [];\n        const pipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, classRef) ?? [];\n        const errorFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, classRef) ?? [];\n\n        return { guards, interceptors, pipes, errorFilters };\n    }\n\n    private getExportTokens(exports: Required<ModuleOptions>['exports']) {\n        return exports.map<InjectionToken>((providerExport) => {\n            if (isFunction(providerExport)) {\n                if (!Reflect.hasOwnMetadata(CoreMetadataKey.Injectable, providerExport)) {\n                    this.loggerService.error('An error occurred while reading module metadata.');\n                    throw new Error(ErrorMessage.InvalidExportDefinition);\n                }\n                return providerExport;\n            } else if (isString(providerExport) || isSymbol(providerExport)) {\n                return providerExport;\n            } else if ('provide' in providerExport) {\n                return providerExport.provide;\n            }\n\n            this.loggerService.error('An error occurred while reading module metadata.');\n            throw new Error(ErrorMessage.InvalidExportDefinition);\n        });\n    }\n\n    private separateProviders(providers: Required<ModuleOptions>['providers'], exportTokens: InjectionToken[]) {\n        return providers\n            .map((provider) => {\n                if (isFunction(provider)) {\n                    const injectableMetadata = Reflect.getMetadata<InjectableMetadata>(CoreMetadataKey.Injectable, provider);\n                    if (isNil(injectableMetadata)) {\n                        this.loggerService.error('An error occurred while reading module metadata.');\n                        throw new Error(ErrorMessage.InvalidProviderDefinition);\n                    }\n                    return <ClassProvider>{ provide: provider, useClass: provider, scope: injectableMetadata.scope };\n                } else if ('useClass' in provider || 'useValue' in provider || 'useFactory' in provider || 'useExisting' in provider) {\n                    return provider;\n                }\n\n                this.loggerService.error('An error occurred while reading module metadata.');\n                throw new Error(ErrorMessage.InvalidProviderDefinition);\n            })\n            .reduce(\n                (acc, provider) => {\n                    if (exportTokens.includes(provider.provide)) {\n                        acc.externalProviders.set(provider.provide, provider);\n                    } else {\n                        acc.internalProviders.set(provider.provide, provider);\n                    }\n                    return acc;\n                },\n                {\n                    internalProviders: new Map<InjectionToken, Exclude<Provider, Newable>>(),\n                    externalProviders: new Map<InjectionToken, Exclude<Provider, Newable>>(),\n                },\n            );\n    }\n}\n", "import { Container } from 'inversify';\n\nexport class ModuleContainer extends Container {}\n", "import { injectable } from 'inversify';\nimport { Controller } from '../controller';\nimport type { ModuleMetadata } from '../interfaces';\nimport { ModuleContainer } from './module-container';\n\n@injectable()\nexport class Module {\n    public readonly controllers: Controller[] = [];\n    public container: ModuleContainer;\n    public parent: Module | undefined;\n    public metadata: ModuleMetadata;\n    public instance: { [key: string]: Function };\n    public repetitiveImports: Set<Module> = new Set();\n}\n", "import { injectable } from 'inversify';\nimport type { Newable } from '../../types';\nimport type { ExecutionContextType } from '../enums';\nimport type { ExecutionContext } from '../interfaces';\nimport type { MangoRequestBase } from './mango-request-base';\nimport type { MangoResponseBase } from './mango-response-base';\n\n@injectable()\nexport class ExecutionContextBase<\n    TRequest extends MangoRequestBase = MangoRequestBase,\n    TResponse extends MangoResponseBase = MangoResponseBase,\n> implements ExecutionContext<TRequest, TResponse>\n{\n    public $type: ExecutionContextType;\n    public $classRef: Newable;\n    public $handler: Function;\n    public $request: TRequest;\n    public $response?: TResponse;\n    public $name: string;\n\n    public get type() {\n        return this.$type;\n    }\n\n    public get classRef() {\n        return this.$classRef;\n    }\n\n    public get handler() {\n        return this.$handler;\n    }\n\n    public get request() {\n        return this.$request;\n    }\n\n    public get response() {\n        return this.$response!;\n    }\n\n    public get name() {\n        return this.$name;\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { MangoRequest } from '../interfaces';\n\n@injectable()\nexport class MangoRequestBase<TData = unknown> implements MangoRequest {\n    public $body: TData;\n    public $player?: PlayerMp;\n\n    public get body() {\n        return this.$body;\n    }\n\n    public get player() {\n        return this.$player;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { LoggerService, RPCError } from '../../interfaces';\nimport type { MangoResponse } from '../interfaces';\nimport { ErrorMessage } from '../../enums';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class MangoResponseBase implements MangoResponse {\n    @inject(LOGGER_SERVICE) private readonly $loggerService: LoggerService;\n    public $sendListeners: Set<(data: unknown) => void> = new Set();\n    public $errorListeners: Set<(error: RPCError) => void> = new Set();\n    public $isSent: boolean = false;\n\n    public send<TData = unknown>(data?: TData) {\n        if (this.$isSent) {\n            this.$loggerService.error('An error occurred while sending the RPC response.');\n            throw new Error(ErrorMessage.RPCResponseAlreadySent);\n        }\n\n        this.$sendListeners.forEach((listener) => listener(data));\n        this.$isSent = true;\n    }\n\n    public error<TDetails = unknown>(message: string, details?: TDetails) {\n        if (this.$isSent) {\n            this.$loggerService.error('An error occurred while sending the RPC response.');\n            throw new Error(ErrorMessage.RPCResponseAlreadySent);\n        }\n        this.$errorListeners.forEach((listener) => listener({ message, details }));\n        this.$isSent = true;\n    }\n\n    public $onSend(listener: (data: unknown) => void) {\n        this.$sendListeners.add(listener);\n    }\n\n    public $onError(listener: (error: RPCError) => void) {\n        this.$errorListeners.add(listener);\n    }\n}\n", "export class TreeNode<T> {\n    public value: T;\n    public children: TreeNode<T>[];\n\n    public constructor(value: T) {\n        this.value = value;\n        this.children = [];\n    }\n\n    public addChild(child: TreeNode<T>) {\n        this.children.push(child);\n    }\n\n    public removeChild(child: TreeNode<T>) {\n        const index = this.children.indexOf(child);\n        if (index !== -1) {\n            this.children.splice(index, 1);\n        }\n    }\n}\n\nexport class Tree<T> {\n    public root: TreeNode<T>;\n\n    public constructor(value: T) {\n        this.root = new TreeNode<T>(value);\n    }\n\n    public traverse(callback: (node: TreeNode<T>) => void) {\n        function traverseNode(node: TreeNode<T>) {\n            callback(node);\n            node.children.forEach(traverseNode);\n        }\n\n        traverseNode(this.root);\n    }\n\n    public async asyncTraverse(callback: (node: TreeNode<T>) => Promise<void>) {\n        async function traverseNode(node: TreeNode<T>) {\n            await callback(node);\n            await Promise.all(node.children.map(traverseNode));\n        }\n\n        await traverseNode(this.root);\n    }\n\n    public toString(): string {\n        let result = '';\n        const lines: string[] = [];\n\n        function traverseNode(node: TreeNode<T>, depth: number) {\n            lines.push(`${'-'.repeat(depth * 2)}${node.value}`);\n            node.children.forEach((child) => traverseNode(child, depth + 1));\n        }\n\n        traverseNode(this.root, 0);\n        result = lines.join('\\n');\n\n        return result;\n    }\n}\n", "import type { ControllerOptions } from '../../interfaces';\nimport { isNil, isObject, isString } from '../../utils';\n\nconst defaultControllerOptions: ControllerOptions = { prefix: '' };\n\nexport function validateControllerOptions(options?: ControllerOptions) {\n    if (isNil(options)) {\n        return { valid: true, value: defaultControllerOptions };\n    }\n\n    if (!isObject(options)) {\n        return { valid: false, value: defaultControllerOptions, error: 'Controller options must be an object' };\n    }\n\n    if (!('prefix' in options)) {\n        return { valid: true, value: { ...defaultControllerOptions, ...options } };\n    }\n    if ('prefix' in options && !isString(options.prefix)) {\n        return { valid: true, value: defaultControllerOptions, error: 'Controller prefix must be a string' };\n    }\n\n    return { valid: true, value: { ...defaultControllerOptions, ...options } };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { ErrorFilter } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateErrorFilter<EF extends ErrorFilter = ErrorFilter>(value: EF | Newable<EF>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Error filter must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Error filter must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.catch)) {\n        return { valid: true, value, error: 'Error filter must have a catch method' };\n    }\n\n    if (isObject(value) && !isFunction((<ErrorFilter>value).catch)) {\n        return { valid: true, value, error: 'Error filter must have a catch method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Pipe } from '../../interfaces';\nimport type { Newable } from '../../types';\n\nexport function validatePipe(value: Pipe | Newable<Pipe>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Pipe must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Pipe must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.transform)) {\n        return { valid: false, value, error: 'Pipe must have a transform method' };\n    }\n\n    if (isObject(value) && !isFunction((<Pipe>value).transform)) {\n        return { valid: false, value, error: 'Pipe must have a transform method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isNumber, isObject, isString } from '../../utils';\nimport { validatePipe } from './pipe.validate';\nimport type { MethodParameter } from '../../app/interfaces';\nimport { MethodParamType } from '../../app/enums';\n\nexport function validateEventParameter(value: MethodParameter) {\n    if (isNil(value) || !isObject(value)) {\n        return { valid: false, value, error: 'Event parameter must be an object' };\n    }\n    if ('key' in value && !isNil(value.key) && !isString(value.key)) {\n        return { valid: false, value, error: 'Event parameter key must be a string' };\n    }\n    if (!('index' in value) || !isNumber(value.index)) {\n        return { valid: false, value, error: 'Event parameter index is required' };\n    }\n    // BodyParameter | PlayerParameter\n    if (\n        (value.type === MethodParamType.Body || value.type === MethodParamType.Player) &&\n        'data' in value &&\n        !isNil(value.data) &&\n        !isString(value.data)\n    ) {\n        return { valid: false, value, error: 'Event parameter data must be a string' };\n    }\n    // CustomParameter\n    if (value.type === MethodParamType.Custom && !('factory' in value)) {\n        return { valid: false, value, error: 'Event parameter factory is required' };\n    }\n    if (value.type === MethodParamType.Custom && 'factory' in value && !isFunction(value.factory)) {\n        return { valid: false, value, error: 'Event parameter factory must be a function' };\n    }\n    //  ParamParameter\n    if ((value.type === MethodParamType.Param || value.type === MethodParamType.Index) && !('data' in value)) {\n        return { valid: false, value, error: 'Event parameter data is required' };\n    }\n    if (value.type === MethodParamType.Param && 'data' in value && !isString(value.data)) {\n        return { valid: false, value, error: 'Event parameter data must be a string' };\n    }\n    // IndexParameter\n    if (value.type === MethodParamType.Index && 'data' in value && !isNumber(value.data)) {\n        return { valid: false, value, error: 'Event parameter data must be a number' };\n    }\n    // BodyParameter | CustomParameter | ParamParameter | PlayerParameter | IndexParameter;\n    if (\n        value.type !== MethodParamType.Request &&\n        value.type !== MethodParamType.Response &&\n        'pipes' in value &&\n        !Array.isArray(value.pipes)\n    ) {\n        return { valid: false, value, error: 'Event parameter pipes must be an array' };\n    }\n    if (value.type !== MethodParamType.Request && value.type !== MethodParamType.Response && !('pipes' in value)) {\n        value.pipes = [];\n    }\n    if (value.type !== MethodParamType.Request && value.type !== MethodParamType.Response) {\n        for (const pipe of value.pipes!) {\n            const { valid, error } = validatePipe(pipe);\n            if (!valid) {\n                return { valid: false, value, error };\n            }\n        }\n    }\n\n    return { valid: true, value };\n}\n", "import type { EventMetadata } from '../../app';\nimport { isNil, isObject, isString } from '../../utils';\nimport { validateEventParameter } from './event-parameter.validate';\n\nexport function validateEventMetadata(value: EventMetadata) {\n    if (isNil(value) || !isObject(value)) {\n        return { valid: false, value, error: 'Event metadata must be an object' };\n    }\n\n    // Type\n    if (!('type' in value)) {\n        return { valid: false, value, error: 'Event metadata type is required' };\n    }\n    if (!isString(value.type)) {\n        return { valid: false, value, error: 'Event metadata type must be a string' };\n    }\n    // Name\n    if (!('name' in value)) {\n        return { valid: false, value, error: 'Event metadata name is required' };\n    }\n    if (!isString(value.name)) {\n        return { valid: false, value, error: 'Event metadata name must be a string' };\n    }\n    // Method\n    if (!('method' in value)) {\n        return { valid: false, value, error: 'Event metadata method is required' };\n    }\n    if (!isString(value.method)) {\n        return { valid: false, value, error: 'Event metadata method must be a string' };\n    }\n    // Params\n    if (!('params' in value)) {\n        (<EventMetadata>value).params = [];\n    }\n    if ('params' in value && !Array.isArray(value.params)) {\n        return { valid: false, value, error: 'Event metadata params must be an array' };\n    }\n    for (const param of value.params) {\n        const { valid, error } = validateEventParameter(param);\n        if (!valid) {\n            return { valid, value, error };\n        }\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Guard } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateGuard<G extends Guard = Guard>(value: G | Newable<G>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Guard must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Guard must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.canActivate)) {\n        return { valid: false, value, error: 'Guard must have a canActivate method' };\n    }\n\n    if (isObject(value) && !isFunction((<Guard>value).canActivate)) {\n        return { valid: false, value, error: 'Guard must have a canActivate method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Interceptor } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateInterceptor<I extends Interceptor = Interceptor>(value: I | Newable<I>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Interceptor must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Interceptor must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.intercept)) {\n        return { valid: false, value, error: 'Interceptor must have an intercept method' };\n    }\n\n    if (isObject(value) && !isFunction((<Interceptor>value).intercept)) {\n        return { valid: false, value, error: 'Interceptor must have an intercept method' };\n    }\n\n    return { valid: true, value };\n}\n", "import type { InjectionToken } from '../types';\nimport { isFunction, isObject, isString, isSymbol } from '../utils';\n\nexport function validateInjectionToken(value: InjectionToken) {\n    const valid = isString(value) || isSymbol(value) || isFunction(value) || isObject(value);\n    return valid ? { valid, value } : { valid, value, error: 'Injection token must be a string, symbol, class, or object' };\n}\n", "import { isFunction, isObject } from '../../utils';\nimport type {\n    ClassProvider,\n    ExistingProvider,\n    FactoryProvider,\n    OptionalFactoryDependency,\n    Provider,\n    ValueProvider,\n} from '../../interfaces';\nimport { validateInjectionToken } from '../injection-token.validate';\nimport { InjectableScope } from '../../enums';\n\nexport function validateProvider(value: Provider) {\n    if (!isObject(value) && !isFunction(value)) {\n        return { valid: false, value, error: 'Provider must be an object or function' };\n    }\n\n    if (isObject(value)) {\n        if (!('provide' in value)) {\n            return { valid: false, value, error: 'Provider must have a provide property' };\n        }\n\n        const { valid, error } = validateInjectionToken(value.provide);\n        if (!valid) {\n            return { valid: false, value, error };\n        }\n\n        if ('useClass' in value) {\n            return validateClassProvider(value);\n        } else if ('useValue' in value) {\n            return validateValueProvider(value);\n        } else if ('useFactory' in value) {\n            return validateFactoryProvider(value);\n        } else if ('useExisting' in value) {\n            return validateExistingProvider(value);\n        }\n    } else if (isFunction(value)) {\n        return { valid: true, value };\n    }\n\n    return { valid: false, value, error: 'Provider must have a useClass, useValue, useFactory, or useExisting property' };\n}\n\nexport function validateClassProvider(value: ClassProvider) {\n    if (!('useClass' in value)) {\n        return { valid: false, value, error: 'Provider must have a useClass property' };\n    }\n\n    if (!('scope' in value)) {\n        value.scope = InjectableScope.Singleton;\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value, error: 'Provider scope must be a valid injectable scope' };\n    }\n\n    return { valid: true, value };\n}\n\nexport function validateValueProvider(value: ValueProvider) {\n    if (!('useValue' in value)) {\n        return { valid: false, value, error: 'Provider must have a useValue property' };\n    }\n\n    return { valid: true, value };\n}\n\nfunction validateOptionalFactoryDependency(value: OptionalFactoryDependency) {\n    if (!('optional' in value)) {\n        return { valid: false, value, error: 'Provider must have an optional property' };\n    }\n\n    if (!('token' in value)) {\n        return { valid: false, value, error: 'Provider must have a token property' };\n    }\n\n    const { valid, error } = validateInjectionToken(value.token);\n    if (!valid) {\n        return { valid: false, value, error };\n    }\n\n    return { valid: true, value };\n}\n\nexport function validateFactoryProvider(value: FactoryProvider) {\n    if (!('useFactory' in value)) {\n        return { valid: false, value, error: 'Provider must have a useFactory property' };\n    }\n    if (!isFunction(value.useFactory)) {\n        return { valid: false, value, error: 'Provider useFactory must be a function' };\n    }\n\n    if (!('inject' in value)) {\n        value.inject = [];\n    }\n    if ('inject' in value && !Array.isArray(value.inject)) {\n        return { valid: false, value, error: 'Provider inject must be an array' };\n    }\n    if ('inject' in value) {\n        for (const token of value.inject) {\n            if (isObject(token) && 'optional' in token && 'token' in token) {\n                const { valid, error } = validateOptionalFactoryDependency(token);\n                if (!valid) {\n                    return { valid, value, error };\n                }\n            } else {\n                const { valid, error } = validateInjectionToken(token);\n                if (!valid) {\n                    return { valid, value, error };\n                }\n            }\n        }\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value, error: 'Provider scope must be a valid injectable scope' };\n    }\n\n    return { valid: true, value };\n}\n\nexport function validateExistingProvider(value: ExistingProvider) {\n    if (!('useExisting' in value)) {\n        return { valid: false, value, error: 'Provider must have a useExisting property' };\n    }\n\n    return { valid: true, value };\n}\n", "import type { DynamicModule, ModuleOptions } from '../../interfaces';\nimport { validateProvider } from './provider.validate';\nimport { isBoolean, isFunction, isNil, isObject, isPromise } from '../../utils';\nimport type { InjectionToken, Nullable } from '../../types';\nimport { validateInjectionToken } from '../injection-token.validate';\n\nexport function validateModuleOptions(\n    value?: ModuleOptions | DynamicModule,\n    isDynamic = false,\n): { valid: boolean; value: ModuleOptions | DynamicModule; error?: Nullable<string> } {\n    if (isNil(value)) {\n        value = {\n            controllers: [],\n            imports: [],\n            providers: [],\n            exports: [],\n        };\n    }\n\n    if (!isNil(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Module options must be an object' };\n    }\n\n    if (isDynamic) {\n        if (!('module' in value) || !isFunction(value.module)) {\n            return { valid: false, value, error: 'Dynamic module must have a module function' };\n        }\n\n        if (!('global' in value)) {\n            value.global = false;\n        } else if (!('global' in value) && !isBoolean(value.global)) {\n            return { valid: false, value, error: 'Dynamic module must have a global property' };\n        }\n    }\n\n    if ('imports' in value && !Array.isArray(value.imports)) {\n        return { valid: false, value, error: 'Imports property must be an array' };\n    } else if (!('imports' in value)) {\n        value.imports = [];\n    }\n\n    if ('controllers' in value && !Array.isArray(value.controllers)) {\n        return { valid: false, value, error: 'Controllers property must be an array' };\n    } else if (!('controllers' in value)) {\n        value.controllers = [];\n    }\n\n    if ('providers' in value && !Array.isArray(value.providers)) {\n        return { valid: false, value, error: 'Providers property must be an array' };\n    } else if (!('providers' in value)) {\n        value.providers = [];\n    }\n\n    if ('exports' in value && !Array.isArray(value.exports)) {\n        return { valid: false, value, error: 'Exports property must be an array' };\n    } else if (!('exports' in value)) {\n        value.exports = [];\n    }\n\n    for (const imported of value.imports) {\n        if (!isFunction(imported) && !isObject(imported) && !isPromise(imported)) {\n            return { valid: false, value, error: 'Import must be a function, object, or promise' };\n        }\n\n        if (isObject(imported) && !isPromise(imported)) {\n            const { valid, error } = validateModuleOptions(<DynamicModule>imported, true);\n            if (!valid) {\n                return { valid, value, error };\n            }\n        }\n    }\n\n    for (const controller of value.controllers) {\n        if (!isFunction(controller)) {\n            return { valid: false, value, error: 'Controller must be a function' };\n        }\n    }\n\n    for (const provider of value.providers) {\n        const { valid, error } = validateProvider(provider);\n        if (!valid) {\n            return { valid: false, value, error };\n        }\n    }\n\n    for (const exportItem of value.exports) {\n        const { valid, error } = validateInjectionToken(<InjectionToken>exportItem);\n        if (!valid) {\n            return { valid, value, error };\n        }\n\n        if (\n            isObject(exportItem) &&\n            ('useClass' in exportItem || 'useFactory' in exportItem || 'useValue' in exportItem || 'useExisting' in exportItem)\n        ) {\n            const { valid } = validateProvider(exportItem);\n            if (!valid) {\n                return { valid: false, value, error: 'Export must be a provider object' };\n            }\n        }\n    }\n\n    return { valid: true, value };\n}\n", "import { isNil, isObject, isString } from '../utils';\nimport { InjectableScope } from '../enums';\nimport type { InjectableOptions } from '../interfaces';\n\nconst defaultInjectableOptions: InjectableOptions = { scope: InjectableScope.Singleton };\n\nexport function validateInjectableMetadata(value?: InjectableOptions) {\n    if (isNil(value)) {\n        return { valid: true, value: defaultInjectableOptions };\n    }\n\n    if (!isObject(value)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Injectable options must be an object' };\n    }\n\n    if (!('scope' in value)) {\n        return { valid: true, value: { ...defaultInjectableOptions, ...value } };\n    }\n    if ('scope' in value && !isString(value.scope)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Injectable scope must be a string' };\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Invalid injectable scope' };\n    }\n\n    return { valid: true, value };\n}\n", "import { RPCResultStatus } from '../../enums';\nimport type { RPCResult } from '../../interfaces';\n\nexport const INTERNAL_APP_CONTAINER = 'INTERNAL_APP_CONTAINER';\nexport const GLOBAL_APP_CONTAINER = 'GLOBAL_APP_CONTAINER';\nexport const APP_ENVIROMENT = 'APP_ENVIROMENT';\n\nexport const GLOBAL_GUARDS = 'GLOBAL_GUARDS';\nexport const GLOBAL_INTERCEPTORS = 'GLOBAL_INTERCEPTORS';\nexport const GLOBAL_PIPES = 'GLOBAL_PIPES';\nexport const GLOBAL_ERROR_FILTERS = 'GLOBAL_ERROR_FILTERS';\n\nexport const PLUGINS = 'PLUGINS';\n\nexport const ENABLE_SHUTDOWN_HOOKS = 'ENABLE_SHUTDOWN_HOOKS';\nexport const CONTAINER_OPTIONS = 'CONTAINER_OPTIONS';\nexport const LOG_ERROR_STACKTRACE = 'LOG_ERROR_STACKTRACE';\n\nexport const MANGO_LOG_PREFIX = '🥭';\n\nexport const MANGO_REQUEST_FACTORY = 'MANGO_REQUEST_FACTORY';\nexport const MANGO_RESPONSE_FACTORY = 'MANGO_RESPONSE_FACTORY';\nexport const EXECUTION_CONTEXT_FACTORY = 'EXECUTION_CONTEXT_FACTORY';\n\nexport const MULTIPLAYER_SERVICE = 'MULTIPLAYER_SERVICE';\n\nexport const RPC_RESULT_TIMEOUT: RPCResult = {\n    success: false,\n    error: { message: 'RPC call timed out.' },\n    status: RPCResultStatus.Timeout,\n};\n\nexport const RPC_RESULT_HANDLER_NOT_FOUND: RPCResult = {\n    success: false,\n    error: { message: 'RPC handler not found.' },\n    status: RPCResultStatus.HandlerNotFound,\n};\n\nexport const RPC_RESULT_UNKNOWN: RPCResult = {\n    success: false,\n    error: { message: 'Unknown error.' },\n    status: RPCResultStatus.Unknown,\n};\n\nexport const RPC_RESULT_PLAYER_DISCONNECTED: RPCResult = {\n    success: false,\n    error: { message: 'Player disconnected.' },\n    status: RPCResultStatus.PlayerDisconnected,\n};\n\nexport const RPC_RESULT_PLAYER_NOT_FOUND: RPCResult = {\n    success: false,\n    error: { message: 'Player not found.' },\n    status: RPCResultStatus.PlayerNotFound,\n};\n", "import { RPCResultStatus } from '../enums';\n\nexport class MangoError<TDetails = unknown> extends Error {\n    public status: number = RPCResultStatus.Unknown;\n    public details: TDetails | undefined;\n\n    public constructor(message: string, status?: number, details?: TDetails) {\n        super(message);\n        this.status = status ?? RPCResultStatus.Unknown;\n        this.details = details;\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class GuardCancelError extends MangoError {\n    public constructor() {\n        super('Process cancelled by the guard.', RPCResultStatus.CancelledByGuard);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class GuardInvalidReturnError extends MangoError {\n    public constructor() {\n        super('Guard returned an invalid value. Expected boolean.', RPCResultStatus.InvalidGuardReturn);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class TooManyRequests extends MangoError {\n    public constructor(message = 'Too many requests.') {\n        super(message, RPCResultStatus.TooManyRequests);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class UnknownError extends MangoError {\n    public constructor() {\n        super('Unknown error.', RPCResultStatus.Unknown);\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { ErrorFilter, Guard, Interceptor, InternalEventService, MultiplayerService } from '../interfaces';\nimport type { Newable } from '../../types';\nimport { APP_ENVIROMENT, EXECUTION_CONTEXT_FACTORY, MANGO_REQUEST_FACTORY, MULTIPLAYER_SERVICE } from '../constants';\nimport { isFunction, isNil, isObject } from '../../utils';\nimport { PipelineHandler } from './pipeline.handler';\nimport type { EventMetadata } from '../interfaces';\nimport { EVENT_SERVICE, LOGGER_SERVICE } from '../../constants';\nimport type { Controller } from './controller';\nimport { AppEnviroment, ExecutionContextType } from '../enums';\nimport { ExecutionContextBase, MangoResponseBase, type MangoRequestBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport { isAsyncFunction } from '../../utils';\nimport { ControllerFlowHandler } from './controller-flow.handler';\n\n@injectable()\nexport class ControllerEventHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayerService: MultiplayerService;\n    @inject(EVENT_SERVICE) private readonly eventService: InternalEventService;\n    @inject(ControllerFlowHandler) private readonly controllerFlowHandler: ControllerFlowHandler;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MANGO_REQUEST_FACTORY) private readonly createMangoRequest: (body: unknown, player?: PlayerMp) => MangoRequestBase;\n    @inject(EXECUTION_CONTEXT_FACTORY) private readonly createExecutionContext: (\n        type: ExecutionContextType,\n        classRef: Newable,\n        handler: Function,\n        request: MangoRequestBase,\n        response?: MangoResponseBase,\n        name?: string,\n    ) => ExecutionContextBase;\n\n    public registerEvent(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        event: EventMetadata,\n    ) {\n        if (event.type === 'on' || event.type === 'once') {\n            return this.eventService[event.type](event.name, async (body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);\n            });\n        } else if (event.type === 'onInternal' || event.type === 'onceInternal') {\n            return this.eventService[`$${event.type}`](event.name, async (...args) => {\n                const { player, body } = this.multiplayerService.parseInternalArgs<PlayerMp>(...args);\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        } else if (event.type === 'onPlayer' || event.type === 'oncePlayer') {\n            return this.eventService[event.type](event.name, async (player, body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        } else if (event.type === 'onServer' || event.type === 'onceServer') {\n            return this.eventService[event.type](event.name, async (body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);\n            });\n        } else if (event.type === 'onWebView' || event.type === 'onceWebView') {\n            return this.eventService[event.type](event.webViewId!, event.name, async (...args: unknown[]) => {\n                const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];\n                const player = this.appEnv === AppEnviroment.Server ? <PlayerMp>args[0] : undefined;\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        }\n\n        this.loggerService.error('An error occurred while trying to register event.');\n        throw new Error(ErrorMessage.InvalidEventType);\n    }\n\n    private async handleEvent(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        event: EventMetadata,\n        body: unknown,\n        player?: PlayerMp,\n    ) {\n        const request = this.createMangoRequest(body, player);\n        const executionContext = this.createExecutionContext(\n            ExecutionContextType.Event,\n            controller.metadata.classRef,\n            controller.metadata.classRef.prototype[event.method],\n            request,\n            undefined,\n            event.name,\n        );\n\n        try {\n            await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);\n            const args = await this.controllerFlowHandler.createArgs(controller, executionContext, event, pipes, player);\n            const controllerMethod = controller.instance[event.method]!;\n            const handle = isAsyncFunction(controllerMethod)\n                ? (): unknown => controller.instance[event.method]!.apply(controller.instance, args)\n                : (): Promise<unknown> => controller.instance[event.method]!.apply(controller.instance, args);\n            const callHandler: CallHandler = {\n                handle,\n                return: () => {\n                    this.loggerService.error('An error occurred while trying to return a value from an event.');\n                    throw new Error(ErrorMessage.InvalidReturnInEvent);\n                },\n            };\n\n            if (interceptors.length > 0) {\n                await this.pipelineHandler.goThroughInterceptors(executionContext, interceptors, controller.owner.container, callHandler);\n            } else {\n                await callHandler.handle();\n            }\n        } catch (error) {\n            const errorGroup = mappedErrorFilters.find(\n                ([errorType]) =>\n                    (isFunction(errorType) && error instanceof errorType) || errorType === 'MANGO_ANY_ERROR' || error === errorType,\n            );\n            if (isNil(errorGroup)) return;\n            const instance = isFunction(errorGroup[1])\n                ? controller.owner.container.get(errorGroup[1])\n                : isObject(errorGroup[1]) && isFunction(errorGroup[1]['catch'])\n                  ? errorGroup[1]\n                  : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through error filters.');\n                throw new Error(ErrorMessage.InvalidErrorFilterDefinition);\n            }\n            await Promise.resolve(instance.catch.call(instance, error, executionContext));\n        }\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Guard, Interceptor } from '../interfaces';\nimport type { Newable } from '../../types';\nimport { GuardCancelError, GuardInvalidReturnError } from '../../errors';\nimport { isFunction, isNil, isObject } from '../../utils';\nimport type { ExecutionContextBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { ArgumentMetadata, CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport { LOGGER_SERVICE } from '../../constants';\nimport type { ModuleContainer } from '../module';\n\n@injectable()\nexport class PipelineHandler {\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    // @inject(GLOBAL_APP_CONTAINER) private readonly globalContainer: Container;\n\n    public async goTroughGuards(executionContext: ExecutionContextBase, guards: (Newable<Guard> | Guard)[], container: ModuleContainer) {\n        for (const guard of guards) {\n            const instance = isFunction(guard) ? container.get(guard) : isObject(guard) && isFunction(guard['canActivate']) ? guard : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through guards.');\n                throw new Error(ErrorMessage.InvalidGuardDefinition);\n            }\n            const canActivate = await instance.canActivate.call(instance, executionContext);\n            if (typeof canActivate !== 'boolean') {\n                this.loggerService.error('An error occurred while trying to go through guards.');\n                throw new GuardInvalidReturnError();\n            }\n            if (!canActivate) {\n                throw new GuardCancelError();\n            }\n        }\n    }\n\n    public async goThroughInterceptors(\n        executionContext: ExecutionContextBase,\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        container: ModuleContainer,\n        callHandler: CallHandler,\n    ) {\n        for (const interceptor of interceptors) {\n            const instance = isFunction(interceptor)\n                ? container.get(interceptor)\n                : isObject(interceptor) && isFunction(interceptor['intercept'])\n                  ? interceptor\n                  : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through interceptors.');\n                throw new Error(ErrorMessage.InvalidInterceptorDefinition);\n            }\n            await instance.intercept.call(instance, executionContext, callHandler);\n        }\n    }\n\n    public async goTroughPipes(\n        value: unknown,\n        pipes: (Newable<Pipe> | Pipe)[],\n        argumentMetadata: ArgumentMetadata,\n        container: ModuleContainer,\n    ) {\n        for (const pipe of pipes) {\n            const instance = isFunction(pipe) ? container.get(pipe) : isObject(pipe) ? pipe : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through pipes.');\n                throw new Error(ErrorMessage.InvalidPipeDefinition);\n            }\n            value = await Promise.resolve(instance.transform.call(instance, value, argumentMetadata));\n        }\n\n        return value;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Controller } from './controller';\nimport type { ExecutionContextBase } from '../pipeline';\nimport type { EventMetadata, RPCMetadata } from '../interfaces';\nimport type { Newable } from '../../types';\nimport type { Pipe } from '../../interfaces';\nimport { PipelineHandler } from './pipeline.handler';\nimport { isObject } from '../../utils';\nimport { AppEnviroment } from '../enums';\nimport { APP_ENVIROMENT } from '../constants';\n\n@injectable()\nexport class ControllerFlowHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n\n    public async createArgs(\n        controller: Controller,\n        executionContext: ExecutionContextBase,\n        metadata: RPCMetadata | EventMetadata,\n        pipes: (Newable<Pipe> | Pipe)[],\n        player?: PlayerMp,\n    ) {\n        return Promise.all(\n            metadata.params.map(async (param) => {\n                const argumentMetadata = {\n                    type: param.type,\n                    data: param.data,\n                    metatype: param.metatype,\n                };\n\n                if (param.type === 'body') {\n                    // Body\n                    return this.pipelineHandler.goTroughPipes(\n                        executionContext.request.body,\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'param') {\n                    // Param\n                    if (!isObject(executionContext.request.body)) return undefined;\n                    return this.pipelineHandler.goTroughPipes(\n                        (<Record<string, unknown>>executionContext.request.body)[param.data],\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'index') {\n                    if (!Array.isArray(executionContext.request.body)) return undefined;\n                    return this.pipelineHandler.goTroughPipes(\n                        executionContext.request.body[param.data],\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'request') {\n                    return executionContext.request;\n                } else if (param.type === 'custom') {\n                    // Custom\n                    return this.pipelineHandler.goTroughPipes(\n                        param.factory(param.data, executionContext),\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'player' && this.appEnv === AppEnviroment.Server) {\n                    // Player (Server)\n                    return this.pipelineHandler.goTroughPipes(\n                        param.data ? player![<keyof PlayerMp>param.data] : player,\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                }\n                return undefined;\n            }),\n        );\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Guard, Interceptor, ErrorFilter, TimerMetadata } from '../interfaces';\nimport type { Newable } from '../../types';\nimport type { ControllerMetadata, EventMetadata, MethodParameter, RPCMetadata } from '../interfaces';\nimport { AppEnviroment, CoreMetadataKey } from '../enums';\nimport { APP_ENVIROMENT } from '../constants';\nimport { ErrorMessage } from '../../enums';\nimport type { LoggerService, Pipe } from '../../interfaces';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class ControllerMetadataReader {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async read(classRef: Newable) {\n        const options =\n            Reflect.getMetadata<Pick<ControllerMetadata, 'prefix'>>(CoreMetadataKey.Controller, classRef) ??\n            <Pick<ControllerMetadata, 'prefix'>>{};\n        const events = this.getEvents(classRef);\n        const rpcs = this.getRPCs(classRef);\n        const timers = this.getTimers(classRef);\n\n        return <ControllerMetadata>{\n            ...options,\n            classRef,\n            events,\n            rpcs,\n            ...this.getPipeline(classRef),\n            timers,\n        };\n    }\n\n    private getEvents(classRef: Newable) {\n        const events = Reflect.getMetadata<EventMetadata[]>(CoreMetadataKey.ControllerEvents, classRef.prototype) ?? [];\n\n        return events.map((event) => {\n            return <EventMetadata>{\n                ...event,\n                params: this.getMethodParams(classRef, event),\n                ...this.getPipeline(classRef, event.method),\n            };\n        });\n    }\n\n    private getRPCs(classRef: Newable) {\n        const rpcs = Reflect.getMetadata<RPCMetadata[]>(CoreMetadataKey.ControllerRPCs, classRef.prototype) ?? [];\n\n        return rpcs.map((rpc) => {\n            return <RPCMetadata>{\n                ...rpc,\n                params: this.getMethodParams(classRef, rpc),\n                ...this.getPipeline(classRef, rpc.method),\n            };\n        });\n    }\n\n    private getMethodParams(classRef: Newable, metadata: EventMetadata | RPCMetadata) {\n        const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, classRef.prototype, metadata.method) ?? [];\n\n        params.sort((a, b) => a.index - b.index);\n        params.forEach((param, index) => {\n            if (param.index !== index) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.InvalidParameterDecoratorUsage);\n            } else if (\n                (metadata.type === 'on' ||\n                    metadata.type === 'onPlayer' ||\n                    metadata.type === 'onInternal' ||\n                    metadata.type === 'onServer' ||\n                    metadata.type === 'onWebView' ||\n                    metadata.type === 'once' ||\n                    metadata.type === 'oncePlayer' ||\n                    metadata.type === 'onceInternal' ||\n                    metadata.type === 'onceServer' ||\n                    metadata.type === 'onceWebView') &&\n                param.type === 'response'\n            ) {\n                // Response\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.ResponseDecoratorNotAllowedOnEvents);\n            } else if (param.type === 'player' && this.appEnv === AppEnviroment.Client) {\n                // Player (Client) - Not allowed\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.PlayerDecoratorNotAllowedOnClientEvents);\n            } else if (metadata.type === 'onPlayerRequest' && this.appEnv === AppEnviroment.Client) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.RPCNotAllowedInClient);\n            } else if (metadata.type === 'onServerRequest' && this.appEnv === AppEnviroment.Server) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.RPCNotAllowedInServer);\n            } else if ((metadata.type === 'onPlayer' || metadata.type === 'oncePlayer') && this.appEnv === AppEnviroment.Client) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.EventNotAllowedInClient);\n            } else if ((metadata.type === 'onServer' || metadata.type === 'onceServer') && this.appEnv === AppEnviroment.Server) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.EventNotAllowedInServer);\n            }\n        });\n\n        return params;\n    }\n\n    private getPipeline(target: Newable | object, method?: string) {\n        const guards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, target, method) ?? [];\n        const interceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, target, method) ?? [];\n        const pipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, target, method) ?? [];\n        const errorFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, target, method) ?? [];\n\n        return { guards, interceptors, pipes, errorFilters };\n    }\n\n    private getTimers(classRef: Newable) {\n        return Reflect.getMetadata<TimerMetadata[]>(CoreMetadataKey.Timers, classRef.prototype) ?? [];\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { ErrorFilter, Guard, Interceptor, InternalRPCService } from '../interfaces';\nimport { LOGGER_SERVICE, RPC_SERVICE } from '../../constants';\nimport { APP_ENVIROMENT, EXECUTION_CONTEXT_FACTORY, MANGO_REQUEST_FACTORY, MANGO_RESPONSE_FACTORY } from '../constants';\nimport type { Newable } from '../../types';\nimport { isAsyncFunction, isFunction, isNil, isObject } from '../../utils';\nimport { PipelineHandler } from './pipeline.handler';\nimport type { RPCMetadata } from '../interfaces';\nimport { AppEnviroment, ExecutionContextType } from '../enums';\nimport { ExecutionContextBase, type MangoRequestBase, type MangoResponseBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport type { Controller } from './controller';\nimport { ControllerFlowHandler } from './controller-flow.handler';\n\n@injectable()\nexport class ControllerRPCHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(RPC_SERVICE) private readonly rpcService: InternalRPCService;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n    @inject(ControllerFlowHandler) private readonly controllerFlowHandler: ControllerFlowHandler;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MANGO_REQUEST_FACTORY) private readonly createMangoRequest: (data: unknown, player?: PlayerMp) => MangoRequestBase;\n    @inject(MANGO_RESPONSE_FACTORY) private readonly createMangoResponse: () => MangoResponseBase;\n    @inject(EXECUTION_CONTEXT_FACTORY) private readonly createExecutionContext: (\n        type: ExecutionContextType,\n        classRef: Newable,\n        handler: Function,\n        request: MangoRequestBase,\n        response: MangoResponseBase,\n        name: string,\n    ) => ExecutionContextBase;\n\n    public async registerRPC(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        rpc: RPCMetadata,\n    ) {\n        if (rpc.type === 'onRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);\n            });\n        } else if (rpc.type === 'onPlayerRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (player, body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);\n            });\n        } else if (rpc.type === 'onServerRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);\n            });\n        } else if (rpc.type === 'onWebViewRequest') {\n            return this.rpcService[rpc.type](rpc.webViewId!, rpc.name, async (...args: unknown[]) => {\n                const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];\n                const player = this.appEnv === AppEnviroment.Server ? <PlayerMp>args[0] : undefined;\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);\n            });\n        }\n\n        this.loggerService.error('An error occurred while trying to register RPC.');\n        throw new Error(ErrorMessage.InvalidRPCType);\n    }\n\n    private async handleRPC(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        rpc: RPCMetadata,\n        body: unknown,\n        player?: PlayerMp,\n    ) {\n        return new Promise(async (resolve) => {\n            const request = this.createMangoRequest(\n                body,\n                this.appEnv === AppEnviroment.Server && (rpc.type === 'onPlayerRequest' || rpc.type === 'onWebViewRequest')\n                    ? player\n                    : undefined,\n            );\n            const response = this.createMangoResponse();\n            response.$onSend((data) => resolve(data));\n            response.$onError((error) => resolve(error));\n            const executionContext = this.createExecutionContext(\n                ExecutionContextType.RPC,\n                controller.metadata.classRef,\n                controller.metadata.classRef.prototype[rpc.method],\n                request,\n                response,\n                rpc.name,\n            );\n\n            try {\n                await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);\n                const args = await this.controllerFlowHandler.createArgs(controller, executionContext, rpc, pipes, player);\n                const controllerMethod = controller.instance[rpc.method]!;\n                const handle = isAsyncFunction(controllerMethod)\n                    ? (options: { send: boolean } = { send: true }) => {\n                          const result = controller.instance[rpc.method]!.apply(controller.instance, args);\n                          if (options.send) {\n                              response.send(result);\n                          }\n                          return result;\n                      }\n                    : async (options: { send: boolean } = { send: true }) => {\n                          const result = await controller.instance[rpc.method]!.apply(controller.instance, args);\n                          if (options.send) {\n                              response.send(result);\n                          }\n                          return result;\n                      };\n                const callHandler: CallHandler = {\n                    handle,\n                    return: (value: unknown) => response.send(value),\n                };\n\n                if (interceptors.length > 0) {\n                    await this.pipelineHandler.goThroughInterceptors(\n                        executionContext,\n                        interceptors,\n                        controller.owner.container,\n                        callHandler,\n                    );\n                } else {\n                    await callHandler.handle();\n                }\n            } catch (error) {\n                const errorGroup = mappedErrorFilters.find(\n                    ([errorType]) =>\n                        (isFunction(errorType) && error instanceof errorType) || errorType === 'MANGO_ANY_ERROR' || error === errorType,\n                );\n                if (isNil(errorGroup)) return;\n                const instance = isFunction(errorGroup[1])\n                    ? controller.owner.container.get(errorGroup[1])\n                    : isObject(errorGroup[1]) && isFunction(errorGroup[1]['catch'])\n                      ? errorGroup[1]\n                      : null;\n                if (isNil(instance)) {\n                    return this.loggerService.error(ErrorMessage.InvalidErrorFilterDefinition);\n                }\n                await Promise.resolve(instance.catch.call(instance, error, executionContext));\n            }\n        });\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { ControllerMetadata, ScriptEventHandler } from '../interfaces';\nimport type { Module } from '../module';\nimport type { ScriptRPCHandler } from '../../interfaces';\n\n@injectable()\nexport class Controller {\n    public metadata: ControllerMetadata;\n    public instance: { [key: string]: Function };\n    public owner: Module;\n    public eventHandlers: ScriptEventHandler[] = [];\n    public rpcHandlers: ScriptRPCHandler[] = [];\n}\n", "export type Decorator = ClassDecorator | MemberDecorator;\nexport type MemberDecorator = <T>(\n  target: Target,\n  propertyKey: PropertyKey,\n  descriptor?: TypedPropertyDescriptor<T>,\n) => TypedPropertyDescriptor<T> | void;\nexport type MetadataKey = string | symbol;\nexport type PropertyKey = string | symbol;\nexport type Target = object | Function;\n\nconst Metadata = new WeakMap();\n\nfunction decorateProperty(\n  decorators: MemberDecorator[],\n  target: Target,\n  propertyKey: PropertyKey,\n  descriptor?: PropertyDescriptor,\n): PropertyDescriptor | undefined {\n  decorators.reverse().forEach((decorator: MemberDecorator) => {\n    descriptor = decorator(target, propertyKey, descriptor) || descriptor;\n  });\n  return descriptor;\n}\n\nfunction decorateConstructor(\n  decorators: ClassDecorator[],\n  target: Function,\n): Function {\n  decorators.reverse().forEach((decorator: ClassDecorator) => {\n    const decorated = decorator(target);\n    if (decorated) {\n      target = decorated;\n    }\n  });\n  return target;\n}\n\nexport function decorate(\n  decorators: ClassDecorator[],\n  target: Function,\n): Function;\nexport function decorate(\n  decorators: MemberDecorator[],\n  target: object,\n  propertyKey?: PropertyKey,\n  attributes?: PropertyDescriptor,\n): PropertyDescriptor | undefined;\nexport function decorate(\n  decorators: Decorator[],\n  target: Target,\n  propertyKey?: PropertyKey,\n  attributes?: PropertyDescriptor,\n): Function | PropertyDescriptor | undefined {\n  if (!Array.isArray(decorators) || decorators.length === 0) {\n    throw new TypeError();\n  }\n\n  if (propertyKey !== undefined) {\n    return decorateProperty(\n      decorators as MemberDecorator[],\n      target,\n      propertyKey,\n      attributes,\n    );\n  }\n\n  if (typeof target === 'function') {\n    return decorateConstructor(decorators as ClassDecorator[], target);\n  }\n\n  return;\n}\n\nfunction getMetadataMap<MetadataValue>(\n  target: Target,\n  propertyKey?: PropertyKey,\n): Map<MetadataKey, MetadataValue> | undefined {\n  return Metadata.get(target) && Metadata.get(target).get(propertyKey);\n}\n\nfunction ordinaryGetOwnMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): MetadataValue | undefined {\n  if (target === undefined) {\n    throw new TypeError();\n  }\n  const metadataMap = getMetadataMap<MetadataValue>(target, propertyKey);\n  return metadataMap && metadataMap.get(metadataKey);\n}\n\nfunction createMetadataMap<MetadataValue>(\n  target: Target,\n  propertyKey?: PropertyKey,\n): Map<MetadataKey, MetadataValue> {\n  const targetMetadata =\n    Metadata.get(target) ||\n    new Map<PropertyKey | undefined, Map<MetadataKey, MetadataValue>>();\n  Metadata.set(target, targetMetadata);\n  const metadataMap =\n    targetMetadata.get(propertyKey) || new Map<MetadataKey, MetadataValue>();\n  targetMetadata.set(propertyKey, metadataMap);\n  return metadataMap;\n}\n\nfunction ordinaryDefineOwnMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  metadataValue: MetadataValue,\n  target: Target,\n  propertyKey?: PropertyKey,\n): void {\n  if (propertyKey && !['string', 'symbol'].includes(typeof propertyKey)) {\n    throw new TypeError();\n  }\n\n  (\n    getMetadataMap<MetadataValue>(target, propertyKey) ||\n    createMetadataMap<MetadataValue>(target, propertyKey)\n  ).set(metadataKey, metadataValue);\n}\n\nfunction ordinaryGetMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): MetadataValue | undefined {\n  return ordinaryGetOwnMetadata<MetadataValue>(metadataKey, target, propertyKey)\n    ? ordinaryGetOwnMetadata<MetadataValue>(metadataKey, target, propertyKey)\n    : Object.getPrototypeOf(target)\n    ? ordinaryGetMetadata(\n        metadataKey,\n        Object.getPrototypeOf(target),\n        propertyKey,\n      )\n    : undefined;\n}\n\nexport function metadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  metadataValue: MetadataValue,\n) {\n  return function decorator(target: Target, propertyKey?: PropertyKey): void {\n    ordinaryDefineOwnMetadata<MetadataValue>(\n      metadataKey,\n      metadataValue,\n      target,\n      propertyKey,\n    );\n  };\n}\n\nexport function getMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): MetadataValue | undefined {\n  return ordinaryGetMetadata<MetadataValue>(metadataKey, target, propertyKey);\n}\n\nexport function getOwnMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): MetadataValue | undefined {\n  return ordinaryGetOwnMetadata<MetadataValue>(\n    metadataKey,\n    target,\n    propertyKey,\n  );\n}\n\nexport function hasOwnMetadata(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): boolean {\n  return !!ordinaryGetOwnMetadata(metadataKey, target, propertyKey);\n}\n\nexport function hasMetadata(\n  metadataKey: MetadataKey,\n  target: Target,\n  propertyKey?: PropertyKey,\n): boolean {\n  return !!ordinaryGetMetadata(metadataKey, target, propertyKey);\n}\n\nexport function defineMetadata<MetadataValue>(\n  metadataKey: MetadataKey,\n  metadataValue: MetadataValue,\n  target: Target,\n  propertyKey?: PropertyKey,\n): void {\n  ordinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n}\n\nexport const Reflection = {\n  decorate,\n  defineMetadata,\n  getMetadata,\n  getOwnMetadata,\n  hasMetadata,\n  hasOwnMetadata,\n  metadata,\n};\n\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/no-namespace\n  namespace Reflect {\n    let decorate: typeof Reflection.decorate;\n    let defineMetadata: typeof Reflection.defineMetadata;\n    let getMetadata: typeof Reflection.getMetadata;\n    let getOwnMetadata: typeof Reflection.getOwnMetadata;\n    let hasOwnMetadata: typeof Reflection.hasOwnMetadata;\n    let hasMetadata: typeof Reflection.hasMetadata;\n    let metadata: typeof Reflection.metadata;\n  }\n}\n\nObject.assign(Reflect, Reflection);\n", "import '@abraham/reflection';\n\nexport * from './reflector.service';\nexport * from './timer.service';\n", "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 '@abraham/reflection';\n\nexport * from './core';\nexport * from './errors';\nexport * from './events';\nexport * from './params';\nexport * from './pipeline';\nexport * from './rpc';\nexport * from './timers';\n\nexport * from './apply-decorator.util';\nexport * from './create-event-decorator';\nexport * from './create-param.util';\nexport * from './create-rpc-decorator';\nexport * from './forward-ref.util';\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 '@abraham/reflection';\n\nexport * from './constants';\nexport * from './controller';\nexport * from './enums';\nexport * from './interfaces';\nexport * from './module';\nexport * from './module-tree';\nexport * from './pipeline';\nexport * from './services';\nexport * from './utils';\nexport * from './multiplayer';\n// App\nexport * from './app-builder';\nexport * from './app';\nexport * from './constants';\nexport * from './create-app';\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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~loaded ~lk~(${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                    `~lw~Controller ~lc~${controller.metadata.classRef.name} ~lw~timers and listeners registered ~lk~(${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                `~lw~Module ~lb~${module.metadata.classRef.name} ~lw~dependencies binded ~lk~(${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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~scanned ~lk~(${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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~scanned ~lk~(${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(`~lw~Controller ~lc~${classRef.name} ~lw~scanned ~lk~(${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    INTERNAL_APP_CONTAINER,\n    GLOBAL_ERROR_FILTERS,\n    GLOBAL_GUARDS,\n    GLOBAL_INTERCEPTORS,\n    GLOBAL_PIPES,\n    ENABLE_SHUTDOWN_HOOKS,\n    PLUGINS,\n    GLOBAL_APP_CONTAINER,\n    APP_ENVIROMENT,\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 { inject, Container, injectable, 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 { ExecutionContextType } from './enums';\nimport { REFLECTOR_SERVICE } from '../constants';\nimport { ReflectorService } from '../services';\n\n@injectable()\nexport class AppBuilder<G extends Guard = Guard, I extends Interceptor = Interceptor, EF extends ErrorFilter = ErrorFilter> {\n    @inject(APP_ENVIROMENT) protected readonly enviroment: string;\n    @inject(INTERNAL_APP_CONTAINER) protected readonly internalAppContainer: Container;\n    @inject(MULTIPLAYER_SERVICE) protected readonly multiplayerService: MultiplayerService;\n    @inject(PLUGINS) protected readonly plugins: Newable<MangoPlugin>[];\n\n    private globalContainerOptions: interfaces.ContainerOptions = {};\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('~lw~Starting app...');\n        await this.runPluginMethods('beforeStart');\n\n        this.loggerService.log('~lw~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('~lw~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('~lw~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('~lw~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('~lw~Stopping app...');\n        await this.appRuntime.shutdown(this.moduleTree);\n        this.loaded = false;\n        this.loggerService.log('~lw~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 { APP_ENVIROMENT, INTERNAL_APP_CONTAINER, 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';\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: Newable<T>;\n    multiplayerService?: MultiplayerService;\n}) {\n    const internalAppContainer = new Container();\n\n    if (multiplayerService) internalAppContainer.bind(MULTIPLAYER_SERVICE).toConstantValue(multiplayerService);\n    internalAppContainer.bind(INTERNAL_APP_CONTAINER).toConstantValue(internalAppContainer);\n    internalAppContainer.bind(APP_ENVIROMENT).toConstantValue(enviroment);\n    internalAppContainer.bind(PLUGINS).toConstantValue(plugins);\n    internalAppContainer.bind(appBuilderInherit).toSelf().inSingletonScope();\n\n    return internalAppContainer.get(appBuilderInherit);\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", "function minitz(y,m,d,h,i,s,tz,throwOnInvalid){return minitz.fromTZ(minitz.tp(y,m,d,h,i,s,tz),throwOnInvalid)}minitz.fromTZISO=(localTimeStr,tz,throwOnInvalid)=>{return minitz.fromTZ(parseISOLocal(localTimeStr,tz),throwOnInvalid)};minitz.fromTZ=function(tp,throwOnInvalid){const inDate=new Date(Date.UTC(tp.y,tp.m-1,tp.d,tp.h,tp.i,tp.s)),offset=getTimezoneOffset(tp.tz,inDate),dateGuess=new Date(inDate.getTime()-offset),dateOffsGuess=getTimezoneOffset(tp.tz,dateGuess);if(dateOffsGuess-offset===0){return dateGuess}else{const dateGuess2=new Date(inDate.getTime()-dateOffsGuess),dateOffsGuess2=getTimezoneOffset(tp.tz,dateGuess2);if(dateOffsGuess2-dateOffsGuess===0){return dateGuess2}else if(!throwOnInvalid&&dateOffsGuess2-dateOffsGuess>0){return dateGuess2}else if(!throwOnInvalid){return dateGuess}else{throw new Error(\"Invalid date passed to fromTZ()\")}}};minitz.toTZ=function(d,tzStr){const localDateString=d.toLocaleString(\"en-US\",{timeZone:tzStr}).replace(/[\\u202f]/,\" \");const td=new Date(localDateString);return{y:td.getFullYear(),m:td.getMonth()+1,d:td.getDate(),h:td.getHours(),i:td.getMinutes(),s:td.getSeconds(),tz:tzStr}};minitz.tp=(y,m,d,h,i,s,tz)=>{return{y:y,m:m,d:d,h:h,i:i,s:s,tz:tz}};function getTimezoneOffset(timeZone,date=new Date){const tz=date.toLocaleString(\"en-US\",{timeZone:timeZone,timeZoneName:\"shortOffset\"}).split(\" \").slice(-1)[0];const dateString=date.toLocaleString(\"en-US\").replace(/[\\u202f]/,\" \");return Date.parse(`${dateString} GMT`)-Date.parse(`${dateString} ${tz}`)}function parseISOLocal(dtStr,tz){const pd=new Date(Date.parse(dtStr));if(isNaN(pd)){throw new Error(\"minitz: Invalid ISO8601 passed to parser.\")}const stringEnd=dtStr.substring(9);if(dtStr.includes(\"Z\")||stringEnd.includes(\"-\")||stringEnd.includes(\"+\")){return minitz.tp(pd.getUTCFullYear(),pd.getUTCMonth()+1,pd.getUTCDate(),pd.getUTCHours(),pd.getUTCMinutes(),pd.getUTCSeconds(),\"Etc/UTC\")}else{return minitz.tp(pd.getFullYear(),pd.getMonth()+1,pd.getDate(),pd.getHours(),pd.getMinutes(),pd.getSeconds(),tz)}}minitz.minitz=minitz;function CronOptions(options){if(options===void 0){options={}}delete options.name;options.legacyMode=options.legacyMode===void 0?true:options.legacyMode;options.paused=options.paused===void 0?false:options.paused;options.maxRuns=options.maxRuns===void 0?Infinity:options.maxRuns;options.catch=options.catch===void 0?false:options.catch;options.interval=options.interval===void 0?0:parseInt(options.interval,10);options.utcOffset=options.utcOffset===void 0?void 0:parseInt(options.utcOffset,10);options.unref=options.unref===void 0?false:options.unref;if(options.startAt){options.startAt=new CronDate(options.startAt,options.timezone)}if(options.stopAt){options.stopAt=new CronDate(options.stopAt,options.timezone)}if(options.interval!==null){if(isNaN(options.interval)){throw new Error(\"CronOptions: Supplied value for interval is not a number\")}else if(options.interval<0){throw new Error(\"CronOptions: Supplied value for interval can not be negative\")}}if(options.utcOffset!==void 0){if(isNaN(options.utcOffset)){throw new Error(\"CronOptions: Invalid value passed for utcOffset, should be number representing minutes offset from UTC.\")}else if(options.utcOffset<-870||options.utcOffset>870){throw new Error(\"CronOptions: utcOffset out of bounds.\")}if(options.utcOffset!==void 0&&options.timezone){throw new Error(\"CronOptions: Combining 'utcOffset' with 'timezone' is not allowed.\")}}if(options.unref!==true&&options.unref!==false){throw new Error(\"CronOptions: Unref should be either true, false or undefined(false).\")}return options}const LAST_OCCURRENCE=32;const ANY_OCCURRENCE=1|2|4|8|16|LAST_OCCURRENCE;const OCCURRENCE_BITMASKS=[1,2,4,8,16];function CronPattern(pattern,timezone){this.pattern=pattern;this.timezone=timezone;this.second=Array(60).fill(0);this.minute=Array(60).fill(0);this.hour=Array(24).fill(0);this.day=Array(31).fill(0);this.month=Array(12).fill(0);this.dayOfWeek=Array(7).fill(0);this.lastDayOfMonth=false;this.starDOM=false;this.starDOW=false;this.parse()}CronPattern.prototype.parse=function(){if(!(typeof this.pattern===\"string\"||this.pattern.constructor===String)){throw new TypeError(\"CronPattern: Pattern has to be of type string.\")}if(this.pattern.indexOf(\"@\")>=0)this.pattern=this.handleNicknames(this.pattern).trim();const parts=this.pattern.replace(/\\s+/g,\" \").split(\" \");if(parts.length<5||parts.length>6){throw new TypeError(\"CronPattern: invalid configuration format ('\"+this.pattern+\"'), exactly five or six space separated parts are required.\")}if(parts.length===5){parts.unshift(\"0\")}if(parts[3].indexOf(\"L\")>=0){parts[3]=parts[3].replace(\"L\",\"\");this.lastDayOfMonth=true}if(parts[3]==\"*\"){this.starDOM=true}if(parts[4].length>=3)parts[4]=this.replaceAlphaMonths(parts[4]);if(parts[5].length>=3)parts[5]=this.replaceAlphaDays(parts[5]);if(parts[5]==\"*\"){this.starDOW=true}if(this.pattern.indexOf(\"?\")>=0){const initDate=new CronDate(new Date,this.timezone).getDate(true);parts[0]=parts[0].replace(\"?\",initDate.getSeconds());parts[1]=parts[1].replace(\"?\",initDate.getMinutes());parts[2]=parts[2].replace(\"?\",initDate.getHours());if(!this.starDOM)parts[3]=parts[3].replace(\"?\",initDate.getDate());parts[4]=parts[4].replace(\"?\",initDate.getMonth()+1);if(!this.starDOW)parts[5]=parts[5].replace(\"?\",initDate.getDay())}this.throwAtIllegalCharacters(parts);this.partToArray(\"second\",parts[0],0,1);this.partToArray(\"minute\",parts[1],0,1);this.partToArray(\"hour\",parts[2],0,1);this.partToArray(\"day\",parts[3],-1,1);this.partToArray(\"month\",parts[4],-1,1);this.partToArray(\"dayOfWeek\",parts[5],0,ANY_OCCURRENCE);if(this.dayOfWeek[7]){this.dayOfWeek[0]=this.dayOfWeek[7]}};CronPattern.prototype.partToArray=function(type,conf,valueIndexOffset,defaultValue){const arr=this[type];const lastDayOfMonth=type===\"day\"&&this.lastDayOfMonth;if(conf===\"\"&&!lastDayOfMonth)throw new TypeError(\"CronPattern: configuration entry \"+type+\" (\"+conf+\") is empty, check for trailing spaces.\");if(conf===\"*\")return arr.fill(defaultValue);const split=conf.split(\",\");if(split.length>1){for(let i=0;i<split.length;i++){this.partToArray(type,split[i],valueIndexOffset,defaultValue)}}else if(conf.indexOf(\"-\")!==-1&&conf.indexOf(\"/\")!==-1){this.handleRangeWithStepping(conf,type,valueIndexOffset,defaultValue)}else if(conf.indexOf(\"-\")!==-1){this.handleRange(conf,type,valueIndexOffset,defaultValue)}else if(conf.indexOf(\"/\")!==-1){this.handleStepping(conf,type,valueIndexOffset,defaultValue)}else if(conf!==\"\"){this.handleNumber(conf,type,valueIndexOffset,defaultValue)}};CronPattern.prototype.throwAtIllegalCharacters=function(parts){for(let i=0;i<parts.length;i++){const reValidCron=i===5?/[^/*0-9,\\-#L]+/:/[^/*0-9,-]+/;if(reValidCron.test(parts[i])){throw new TypeError(\"CronPattern: configuration entry \"+i+\" (\"+parts[i]+\") contains illegal characters.\")}}};CronPattern.prototype.handleNumber=function(conf,type,valueIndexOffset,defaultValue){const result=this.extractNth(conf,type);const i=parseInt(result[0],10)+valueIndexOffset;if(isNaN(i)){throw new TypeError(\"CronPattern: \"+type+\" is not a number: '\"+conf+\"'\")}this.setPart(type,i,result[1]||defaultValue)};CronPattern.prototype.setPart=function(part,index,value){if(!Object.prototype.hasOwnProperty.call(this,part)){throw new TypeError(\"CronPattern: Invalid part specified: \"+part)}if(part===\"dayOfWeek\"){if(index===7)index=0;if((index<0||index>6)&&index!==\"L\"){throw new RangeError(\"CronPattern: Invalid value for dayOfWeek: \"+index)}this.setNthWeekdayOfMonth(index,value);return}if(part===\"second\"||part===\"minute\"){if(index<0||index>=60){throw new RangeError(\"CronPattern: Invalid value for \"+part+\": \"+index)}}else if(part===\"hour\"){if(index<0||index>=24){throw new RangeError(\"CronPattern: Invalid value for \"+part+\": \"+index)}}else if(part===\"day\"){if(index<0||index>=31){throw new RangeError(\"CronPattern: Invalid value for \"+part+\": \"+index)}}else if(part===\"month\"){if(index<0||index>=12){throw new RangeError(\"CronPattern: Invalid value for \"+part+\": \"+index)}}this[part][index]=value};CronPattern.prototype.handleRangeWithStepping=function(conf,type,valueIndexOffset,defaultValue){const result=this.extractNth(conf,type);const matches=result[0].match(/^(\\d+)-(\\d+)\\/(\\d+)$/);if(matches===null)throw new TypeError(\"CronPattern: Syntax error, illegal range with stepping: '\"+conf+\"'\");let[,lower,upper,steps]=matches;lower=parseInt(lower,10)+valueIndexOffset;upper=parseInt(upper,10)+valueIndexOffset;steps=parseInt(steps,10);if(isNaN(lower))throw new TypeError(\"CronPattern: Syntax error, illegal lower range (NaN)\");if(isNaN(upper))throw new TypeError(\"CronPattern: Syntax error, illegal upper range (NaN)\");if(isNaN(steps))throw new TypeError(\"CronPattern: Syntax error, illegal stepping: (NaN)\");if(steps===0)throw new TypeError(\"CronPattern: Syntax error, illegal stepping: 0\");if(steps>this[type].length)throw new TypeError(\"CronPattern: Syntax error, steps cannot be greater than maximum value of part (\"+this[type].length+\")\");if(lower>upper)throw new TypeError(\"CronPattern: From value is larger than to value: '\"+conf+\"'\");for(let i=lower;i<=upper;i+=steps){this.setPart(type,i,result[1]||defaultValue)}};CronPattern.prototype.extractNth=function(conf,type){let rest=conf;let nth;if(rest.includes(\"#\")){if(type!==\"dayOfWeek\"){throw new Error(\"CronPattern: nth (#) only allowed in day-of-week field\")}nth=rest.split(\"#\")[1];rest=rest.split(\"#\")[0]}return[rest,nth]};CronPattern.prototype.handleRange=function(conf,type,valueIndexOffset,defaultValue){const result=this.extractNth(conf,type);const split=result[0].split(\"-\");if(split.length!==2){throw new TypeError(\"CronPattern: Syntax error, illegal range: '\"+conf+\"'\")}const lower=parseInt(split[0],10)+valueIndexOffset,upper=parseInt(split[1],10)+valueIndexOffset;if(isNaN(lower)){throw new TypeError(\"CronPattern: Syntax error, illegal lower range (NaN)\")}else if(isNaN(upper)){throw new TypeError(\"CronPattern: Syntax error, illegal upper range (NaN)\")}if(lower>upper){throw new TypeError(\"CronPattern: From value is larger than to value: '\"+conf+\"'\")}for(let i=lower;i<=upper;i++){this.setPart(type,i,result[1]||defaultValue)}};CronPattern.prototype.handleStepping=function(conf,type,valueIndexOffset,defaultValue){const result=this.extractNth(conf,type);const split=result[0].split(\"/\");if(split.length!==2){throw new TypeError(\"CronPattern: Syntax error, illegal stepping: '\"+conf+\"'\")}let start=0;if(split[0]!==\"*\"){start=parseInt(split[0],10)+valueIndexOffset}const steps=parseInt(split[1],10);if(isNaN(steps))throw new TypeError(\"CronPattern: Syntax error, illegal stepping: (NaN)\");if(steps===0)throw new TypeError(\"CronPattern: Syntax error, illegal stepping: 0\");if(steps>this[type].length)throw new TypeError(\"CronPattern: Syntax error, max steps for part is (\"+this[type].length+\")\");for(let i=start;i<this[type].length;i+=steps){this.setPart(type,i,result[1]||defaultValue)}};CronPattern.prototype.replaceAlphaDays=function(conf){return conf.replace(/-sun/gi,\"-7\").replace(/sun/gi,\"0\").replace(/mon/gi,\"1\").replace(/tue/gi,\"2\").replace(/wed/gi,\"3\").replace(/thu/gi,\"4\").replace(/fri/gi,\"5\").replace(/sat/gi,\"6\")};CronPattern.prototype.replaceAlphaMonths=function(conf){return conf.replace(/jan/gi,\"1\").replace(/feb/gi,\"2\").replace(/mar/gi,\"3\").replace(/apr/gi,\"4\").replace(/may/gi,\"5\").replace(/jun/gi,\"6\").replace(/jul/gi,\"7\").replace(/aug/gi,\"8\").replace(/sep/gi,\"9\").replace(/oct/gi,\"10\").replace(/nov/gi,\"11\").replace(/dec/gi,\"12\")};CronPattern.prototype.handleNicknames=function(pattern){const cleanPattern=pattern.trim().toLowerCase();if(cleanPattern===\"@yearly\"||cleanPattern===\"@annually\"){return\"0 0 1 1 *\"}else if(cleanPattern===\"@monthly\"){return\"0 0 1 * *\"}else if(cleanPattern===\"@weekly\"){return\"0 0 * * 0\"}else if(cleanPattern===\"@daily\"){return\"0 0 * * *\"}else if(cleanPattern===\"@hourly\"){return\"0 * * * *\"}else{return pattern}};CronPattern.prototype.setNthWeekdayOfMonth=function(index,nthWeekday){if(nthWeekday===\"L\"){this[\"dayOfWeek\"][index]=this[\"dayOfWeek\"][index]|LAST_OCCURRENCE}else if(nthWeekday<6&&nthWeekday>0){this[\"dayOfWeek\"][index]=this[\"dayOfWeek\"][index]|OCCURRENCE_BITMASKS[nthWeekday-1]}else if(nthWeekday===ANY_OCCURRENCE){this[\"dayOfWeek\"][index]=ANY_OCCURRENCE}else{throw new TypeError(`CronPattern: nth weekday of of range, should be 1-5 or L. Value: ${nthWeekday}`)}};const DaysOfMonth=[31,28,31,30,31,30,31,31,30,31,30,31];const RecursionSteps=[[\"month\",\"year\",0],[\"day\",\"month\",-1],[\"hour\",\"day\",0],[\"minute\",\"hour\",0],[\"second\",\"minute\",0]];function CronDate(d,tz){this.tz=tz;if(d&&d instanceof Date){if(!isNaN(d)){this.fromDate(d)}else{throw new TypeError(\"CronDate: Invalid date passed to CronDate constructor\")}}else if(d===void 0){this.fromDate(new Date)}else if(d&&typeof d===\"string\"){this.fromString(d)}else if(d instanceof CronDate){this.fromCronDate(d)}else{throw new TypeError(\"CronDate: Invalid type (\"+typeof d+\") passed to CronDate constructor\")}}CronDate.prototype.isNthWeekdayOfMonth=function(year,month,day,nth){const date=new Date(Date.UTC(year,month,day));const weekday=date.getUTCDay();let count=0;for(let d=1;d<=day;d++){if(new Date(Date.UTC(year,month,d)).getUTCDay()===weekday){count++}}if(nth&ANY_OCCURRENCE&&OCCURRENCE_BITMASKS[count-1]&nth){return true}if(nth&LAST_OCCURRENCE){const daysInMonth=new Date(Date.UTC(year,month+1,0)).getUTCDate();for(let d=day+1;d<=daysInMonth;d++){if(new Date(Date.UTC(year,month,d)).getUTCDay()===weekday){return false}}return true}return false};CronDate.prototype.fromDate=function(inDate){if(this.tz!==void 0){if(typeof this.tz===\"number\"){this.ms=inDate.getUTCMilliseconds();this.second=inDate.getUTCSeconds();this.minute=inDate.getUTCMinutes()+this.tz;this.hour=inDate.getUTCHours();this.day=inDate.getUTCDate();this.month=inDate.getUTCMonth();this.year=inDate.getUTCFullYear();this.apply()}else{const d=minitz.toTZ(inDate,this.tz);this.ms=inDate.getMilliseconds();this.second=d.s;this.minute=d.i;this.hour=d.h;this.day=d.d;this.month=d.m-1;this.year=d.y}}else{this.ms=inDate.getMilliseconds();this.second=inDate.getSeconds();this.minute=inDate.getMinutes();this.hour=inDate.getHours();this.day=inDate.getDate();this.month=inDate.getMonth();this.year=inDate.getFullYear()}};CronDate.prototype.fromCronDate=function(d){this.tz=d.tz;this.year=d.year;this.month=d.month;this.day=d.day;this.hour=d.hour;this.minute=d.minute;this.second=d.second;this.ms=d.ms};CronDate.prototype.apply=function(){if(this.month>11||this.day>DaysOfMonth[this.month]||this.hour>59||this.minute>59||this.second>59||this.hour<0||this.minute<0||this.second<0){const d=new Date(Date.UTC(this.year,this.month,this.day,this.hour,this.minute,this.second,this.ms));this.ms=d.getUTCMilliseconds();this.second=d.getUTCSeconds();this.minute=d.getUTCMinutes();this.hour=d.getUTCHours();this.day=d.getUTCDate();this.month=d.getUTCMonth();this.year=d.getUTCFullYear();return true}else{return false}};CronDate.prototype.fromString=function(str){if(typeof this.tz===\"number\"){const inDate=minitz.fromTZISO(str);this.ms=inDate.getUTCMilliseconds();this.second=inDate.getUTCSeconds();this.minute=inDate.getUTCMinutes();this.hour=inDate.getUTCHours();this.day=inDate.getUTCDate();this.month=inDate.getUTCMonth();this.year=inDate.getUTCFullYear();this.apply()}else{return this.fromDate(minitz.fromTZISO(str,this.tz))}};CronDate.prototype.findNext=function(options,target,pattern,offset){const originalTarget=this[target];let lastDayOfMonth;if(pattern.lastDayOfMonth){if(this.month!==1){lastDayOfMonth=DaysOfMonth[this.month]}else{lastDayOfMonth=new Date(Date.UTC(this.year,this.month+1,0,0,0,0,0)).getUTCDate()}}const fDomWeekDay=!pattern.starDOW&&target==\"day\"?new Date(Date.UTC(this.year,this.month,1,0,0,0,0)).getUTCDay():undefined;for(let i=this[target]+offset;i<pattern[target].length;i++){let match=pattern[target][i];if(target===\"day\"&&pattern.lastDayOfMonth&&i-offset==lastDayOfMonth){match=true}if(target===\"day\"&&!pattern.starDOW){let dowMatch=pattern.dayOfWeek[(fDomWeekDay+(i-offset-1))%7];if(dowMatch&&dowMatch&ANY_OCCURRENCE){dowMatch=this.isNthWeekdayOfMonth(this.year,this.month,i-offset,dowMatch)}else if(dowMatch){throw new Error(`CronDate: Invalid value for dayOfWeek encountered. ${dowMatch}`)}if(options.legacyMode&&!pattern.starDOM){match=match||dowMatch}else{match=match&&dowMatch}}if(match){this[target]=i-offset;return originalTarget!==this[target]?2:1}}return 3};CronDate.prototype.recurse=function(pattern,options,doing){const res=this.findNext(options,RecursionSteps[doing][0],pattern,RecursionSteps[doing][2]);if(res>1){let resetLevel=doing+1;while(resetLevel<RecursionSteps.length){this[RecursionSteps[resetLevel][0]]=-RecursionSteps[resetLevel][2];resetLevel++}if(res===3){this[RecursionSteps[doing][1]]++;this[RecursionSteps[doing][0]]=-RecursionSteps[doing][2];this.apply();return this.recurse(pattern,options,0)}else if(this.apply()){return this.recurse(pattern,options,doing-1)}}doing+=1;if(doing>=RecursionSteps.length){return this}else if(this.year>=3e3){return null}else{return this.recurse(pattern,options,doing)}};CronDate.prototype.increment=function(pattern,options,hasPreviousRun){this.second+=options.interval>1&&hasPreviousRun?options.interval:1;this.ms=0;this.apply();return this.recurse(pattern,options,0)};CronDate.prototype.getDate=function(internal){if(internal||this.tz===void 0){return new Date(this.year,this.month,this.day,this.hour,this.minute,this.second,this.ms)}else{if(typeof this.tz===\"number\"){return new Date(Date.UTC(this.year,this.month,this.day,this.hour,this.minute-this.tz,this.second,this.ms))}else{return minitz(this.year,this.month+1,this.day,this.hour,this.minute,this.second,this.tz)}}};CronDate.prototype.getTime=function(){return this.getDate().getTime()};function isFunction(v){return Object.prototype.toString.call(v)===\"[object Function]\"||\"function\"===typeof v||v instanceof Function}function unrefTimer(timer){if(typeof Deno!==\"undefined\"&&typeof Deno.unrefTimer!==\"undefined\"){Deno.unrefTimer(timer)}else if(timer&&typeof timer.unref!==\"undefined\"){timer.unref()}}const maxDelay=30*1e3;const scheduledJobs=[];function Cron(pattern,fnOrOptions1,fnOrOptions2){if(!(this instanceof Cron)){return new Cron(pattern,fnOrOptions1,fnOrOptions2)}let options,func;if(isFunction(fnOrOptions1)){func=fnOrOptions1}else if(typeof fnOrOptions1===\"object\"){options=fnOrOptions1}else if(fnOrOptions1!==void 0){throw new Error(\"Cron: Invalid argument passed for optionsIn. Should be one of function, or object (options).\")}if(isFunction(fnOrOptions2)){func=fnOrOptions2}else if(typeof fnOrOptions2===\"object\"){options=fnOrOptions2}else if(fnOrOptions2!==void 0){throw new Error(\"Cron: Invalid argument passed for funcIn. Should be one of function, or object (options).\")}this.name=options?options.name:void 0;this.options=CronOptions(options);this._states={kill:false,blocking:false,previousRun:void 0,currentRun:void 0,once:void 0,currentTimeout:void 0,maxRuns:options?options.maxRuns:void 0,paused:options?options.paused:false,pattern:void 0};if(pattern&&(pattern instanceof Date||typeof pattern===\"string\"&&pattern.indexOf(\":\")>0)){this._states.once=new CronDate(pattern,this.options.timezone||this.options.utcOffset)}else{this._states.pattern=new CronPattern(pattern,this.options.timezone)}if(this.name){const existing=scheduledJobs.find(j=>j.name===this.name);if(existing){throw new Error(\"Cron: Tried to initialize new named job '\"+this.name+\"', but name already taken.\")}else{scheduledJobs.push(this)}}if(func!==void 0){this.fn=func;this.schedule()}return this}Cron.prototype.nextRun=function(prev){const next=this._next(prev);return next?next.getDate():null};Cron.prototype.nextRuns=function(n,previous){if(n>this._states.maxRuns){n=this._states.maxRuns}const enumeration=[];let prev=previous||this._states.currentRun;while(n--&&(prev=this.nextRun(prev))){enumeration.push(prev)}return enumeration};Cron.prototype.getPattern=function(){return this._states.pattern?this._states.pattern.pattern:void 0};Cron.prototype.isRunning=function(){const nextRunTime=this.nextRun(this._states.currentRun);const isRunning=!this._states.paused;const isScheduled=this.fn!==void 0;const notIsKilled=!this._states.kill;return isRunning&&isScheduled&&notIsKilled&&nextRunTime!==null};Cron.prototype.isStopped=function(){return this._states.kill};Cron.prototype.isBusy=function(){return this._states.blocking};Cron.prototype.currentRun=function(){return this._states.currentRun?this._states.currentRun.getDate():null};Cron.prototype.previousRun=function(){return this._states.previousRun?this._states.previousRun.getDate():null};Cron.prototype.msToNext=function(prev){prev=prev||new Date;const next=this._next(prev);if(next){return next.getTime()-prev.getTime()}else{return null}};Cron.prototype.stop=function(){this._states.kill=true;if(this._states.currentTimeout){clearTimeout(this._states.currentTimeout)}const jobIndex=scheduledJobs.indexOf(this);if(jobIndex>=0){scheduledJobs.splice(jobIndex,1)}};Cron.prototype.pause=function(){this._states.paused=true;return!this._states.kill};Cron.prototype.resume=function(){this._states.paused=false;return!this._states.kill};Cron.prototype.schedule=function(func){if(func&&this.fn){throw new Error(\"Cron: It is not allowed to schedule two functions using the same Croner instance.\")}else if(func){this.fn=func}let waitMs=this.msToNext();const target=this.nextRun(this._states.currentRun);if(waitMs===null||waitMs===undefined||isNaN(waitMs)||target===null)return this;if(waitMs>maxDelay){waitMs=maxDelay}this._states.currentTimeout=setTimeout(()=>this._checkTrigger(target),waitMs);if(this._states.currentTimeout&&this.options.unref){unrefTimer(this._states.currentTimeout)}return this};Cron.prototype._trigger=async function(initiationDate){this._states.blocking=true;this._states.currentRun=new CronDate(void 0,this.options.timezone||this.options.utcOffset);if(this.options.catch){try{await this.fn(this,this.options.context)}catch(_e){if(isFunction(this.options.catch)){this.options.catch(_e,this)}}}else{await this.fn(this,this.options.context)}this._states.previousRun=new CronDate(initiationDate,this.options.timezone||this.options.utcOffset);this._states.blocking=false};Cron.prototype.trigger=async function(){await this._trigger()};Cron.prototype._checkTrigger=function(target){const now=new Date,shouldRun=!this._states.paused&&now.getTime()>=target,isBlocked=this._states.blocking&&this.options.protect;if(shouldRun&&!isBlocked){this._states.maxRuns--;this._trigger()}else{if(shouldRun&&isBlocked&&isFunction(this.options.protect)){setTimeout(()=>this.options.protect(this),0)}}this.schedule()};Cron.prototype._next=function(prev){let hasPreviousRun=prev||this._states.currentRun?true:false;let startAtInFutureWithInterval=false;if(!prev&&this.options.startAt&&this.options.interval){[prev,hasPreviousRun]=this._calculatePreviousRun(prev,hasPreviousRun);startAtInFutureWithInterval=!prev?true:false}prev=new CronDate(prev,this.options.timezone||this.options.utcOffset);if(this.options.startAt&&prev&&prev.getTime()<this.options.startAt.getTime()){prev=this.options.startAt}let nextRun=this._states.once||new CronDate(prev,this.options.timezone||this.options.utcOffset);if(!startAtInFutureWithInterval&&nextRun!==this._states.once){nextRun=nextRun.increment(this._states.pattern,this.options,hasPreviousRun)}if(this._states.once&&this._states.once.getTime()<=prev.getTime()){return null}else if(nextRun===null||this._states.maxRuns<=0||this._states.kill||this.options.stopAt&&nextRun.getTime()>=this.options.stopAt.getTime()){return null}else{return nextRun}};Cron.prototype._calculatePreviousRun=function(prev,hasPreviousRun){const now=new CronDate(undefined,this.options.timezone||this.options.utcOffset);if(this.options.startAt.getTime()<=now.getTime()){prev=this.options.startAt;let prevTimePlusInterval=prev.getTime()+this.options.interval*1e3;while(prevTimePlusInterval<=now.getTime()){prev=new CronDate(prev,this.options.timezone||this.options.utcOffset).increment(this._states.pattern,this.options,true);prevTimePlusInterval=prev.getTime()+this.options.interval*1e3}hasPreviousRun=true}return[prev,hasPreviousRun]};Cron.Cron=Cron;Cron.scheduledJobs=scheduledJobs;export{Cron,Cron as default,scheduledJobs};", "import { injectable } from 'inversify';\nimport { ErrorMessage } from '../../enums';\nimport type { EventEmmiter, ScriptEventHandler } from '../interfaces';\nimport type { EventHandler } from '../../interfaces';\n\n@injectable()\nexport abstract class BaseEventService<T extends Record<string, any>> {\n    protected readonly $localHandlers: Set<ScriptEventHandler> = new Set();\n    protected readonly $internalHandlers: Set<ScriptEventHandler> = new Set();\n    protected readonly $remoteHandlers: Set<ScriptEventHandler> = new Set();\n    protected $internalEventNames = new Set<string>();\n    constructor(protected $eventEmmiter: EventEmmiter) {}\n\n    public on<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;\n    public on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;\n    public on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.on(eventName, wrapper);\n        this.$localHandlers.add(eventHandler);\n        return eventHandler;\n    }\n    public once<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;\n    public once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;\n    public once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.once(eventName, wrapper);\n        this.$localHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public emit<E extends keyof T>(eventName: E, body?: T[E]): void;\n    public emit<E extends string>(eventName: E, body?: unknown): void;\n    public emit<E extends string>(eventName: E, body?: unknown) {\n        this.$eventEmmiter.emit(eventName, body);\n    }\n\n    protected $onInternal(eventName: string, handler: (body: unknown) => void | Promise<void>) {\n        if (!this.$internalEventNames.has(eventName)) {\n            throw new Error(ErrorMessage.InvalidInternalEventName);\n        }\n        const eventHandler = <EventHandler>this.$eventEmmiter.on(eventName, handler);\n        this.$internalHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    protected $onceInternal(eventName: string, handler: (body: unknown) => void | Promise<void>) {\n        if (!this.$internalEventNames.has(eventName)) {\n            throw new Error(ErrorMessage.InvalidInternalEventName);\n        }\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.once(eventName, handler);\n        this.$internalHandlers.add(eventHandler);\n        return eventHandler;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { RPCResult, RPCCallOptions, ScriptRPCHandler, LoggerService } from '../../interfaces';\nimport { RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_TIMEOUT, RPC_RESULT_UNKNOWN } from '../../app/constants';\nimport { ErrorMessage, RPCResultStatus } from '../../enums';\nimport { MangoError } from '../../errors';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class BaseRPCService<T extends Record<string, any>> {\n    @inject(LOGGER_SERVICE) protected readonly $loggerService: LoggerService;\n    protected readonly $TIMEOUT = 2000;\n    private readonly $localHandlers = new Map<string, ScriptRPCHandler>();\n\n    public async call<E extends keyof T>(\n        rpcName: E,\n        body?: Parameters<T[E]>[0],\n        options?: RPCCallOptions,\n    ): Promise<RPCResult<ReturnType<T[E]>>>;\n    public async call<E extends string>(rpcName: E, body?: unknown, options?: RPCCallOptions): Promise<RPCResult<unknown>>;\n    public async call<E extends string>(rpcName: E, body?: unknown, options: RPCCallOptions = { timeout: this.$TIMEOUT }) {\n        return new Promise(async (resolve) => {\n            const handler = this.$localHandlers.get(<string>rpcName)?.handler;\n            if (!handler) {\n                return resolve(RPC_RESULT_HANDLER_NOT_FOUND);\n            }\n\n            const timeoutId = setTimeout(() => {\n                resolve(RPC_RESULT_TIMEOUT);\n            }, options.timeout ?? this.$TIMEOUT);\n\n            try {\n                const result = await handler(body);\n                clearTimeout(timeoutId);\n                resolve({ success: true, status: RPCResultStatus.Success, body: result });\n            } catch (error) {\n                clearTimeout(timeoutId);\n\n                if (error instanceof MangoError) {\n                    return resolve({\n                        success: false,\n                        status: error.status,\n                        error: { message: error.message, details: error.details },\n                    });\n                }\n\n                resolve(RPC_RESULT_UNKNOWN);\n            }\n        });\n    }\n    public onRequest<E extends keyof T>(rpcName: E, handler: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptRPCHandler;\n    public onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;\n    public onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>) {\n        if (this.$localHandlers.has(rpcName)) {\n            this.$loggerService.error('An error occurred while trying to register RPC.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n\n        const rpcHandler: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\n                rpcHandler.valid = false;\n                this.$localHandlers.delete(rpcName);\n            },\n            rpcName: rpcName,\n            handler,\n            valid: true,\n        };\n\n        this.$localHandlers.set(rpcName, rpcHandler);\n\n        return rpcHandler;\n    }\n}\n", "export const WEBVIEW_SERVICE = 'WEBVIEW_SERVICE';\nexport const WEBVIEW_LIST_SERVICE = 'WEBVIEW_LIST_SERVICE';\nexport const ADD_WEBVIEW = 'ADD_WEBVIEW';\n", "export const INTERNAL_EVENTS = {\n    SCRIPT_RPC: 'scriptRPC',\n    SCRIPT_RPC_ANSWER: 'scriptRPCAnswer',\n    KEYBOARD_EVENT: 'keyboardEvent',\n    KEY_UP: 'keyUp',\n    KEY_DOWN: 'keyDown',\n    WEB_VIEW_EVENT: 'webViewEvent',\n    WEB_SOCKET_EVENT: 'webSocketEvent',\n    AUDIO_EVENT: 'audioEvent',\n    RMLUI_EVENT: 'rmluiEvent',\n    WINDOW_FOCUS_CHANGE: 'windowFocusChange',\n    WINDOW_RESOLUTION_CHANGE: 'windowResolutionChange',\n    CONNECTION_COMPLETE: 'connectionComplete',\n    DISCONNECT: 'disconnect',\n    SPAWNED: 'spawned',\n    GAME_ENTITY_CREATE: 'gameEntityCreate',\n    GAME_ENTITY_DESTROY: 'gameEntityDestroy',\n    ENTITY_HIT_ENTITY: 'entityHitEntity',\n    TASK_CHANGE: 'taskChange',\n    PLAYER_WEAPON_SHOOT: 'playerWeaponShoot',\n    PLAYER_BULLET_HIT: 'playerBulletHit',\n    PLAYER_WEAPON_CHANGE: 'playerWeaponChange',\n    PLAYER_START_VEHICLE_ENTER: 'playerStartVehicleEnter',\n    PLAYER_START_VEHICLE_LEAVE: 'playerStartVehicleLeave',\n    PLAYER_VEHICLE_ENTERED: 'playerVehicleEntered',\n    PLAYER_VEHICLE_LEFT: 'playerVehicleLeft',\n    PLAYER_VEHICLE_SEAT_CHANGE: 'playerVehicleSeatChange',\n    VOICE_CONNECTION: 'voiceConnection',\n    PLAYER_START_TALKING: 'playerStartTalking',\n    PLAYER_STOP_TALKING: 'playerStopTalking',\n    WORLD_OBJECT_POSITION_CHANGE: 'worldObjectPositionChange',\n    WORLD_OBJECT_STREAM_IN: 'worldObjectStreamIn',\n    WORLD_OBJECT_STREAM_OUT: 'worldObjectStreamOut',\n    EVENT: 'event',\n    BASE_OBJECT_CREATE: 'baseObjectCreate',\n    BASE_OBJECT_REMOVE: 'baseObjectRemove',\n    NET_OWNER_CHANGE: 'netOwnerChange',\n    WEAPON_DAMAGE: 'weaponDamage',\n    META_CHANGE: 'metaChange',\n    LOCAL_META_CHANGE: 'localMetaChange',\n    SYNCED_META_CHANGE: 'syncedMetaChange',\n    STREAM_SYNCED_META_CHANGE: 'streamSyncedMetaChange',\n    GLOBAL_META_CHANGE: 'globalMetaChange',\n    GLOBAL_SYNCED_META_CHANGE: 'globalSyncedMetaChange',\n    ENTITY_COL_SHAPE_ENTER: 'entityColShapeEnter',\n    ENTITY_COL_SHAPE_LEAVE: 'entityColShapeLeave',\n    ENTITY_CHECKPOINT_ENTER: 'entityCheckpointEnter',\n    ENTITY_CHECKPOINT_LEAVE: 'entityCheckpointLeave',\n    COL_SHAPE_EVENT: 'colShapeEvent',\n    CONSOLE_COMMAND: 'consoleCommand',\n    ERROR: 'error',\n    LOCAL_SCRIPT_EVENT: 'localScriptEvent',\n    REMOTE_SCRIPT_EVENT: 'remoteScriptEvent',\n    RESOURCE_START: 'resourceStart',\n    RESOURCE_STOP: 'resourceStop',\n    RESOURCE_ERROR: 'resourceError',\n} as const;\n", "import { inject, injectable } from 'inversify';\nimport type { MangoPlugin } from '@ragemp-mango/core/app';\nimport { EVENT_SERVICE, LOGGER_SERVICE, type LoggerService } from '@ragemp-mango/core';\nimport { WEBVIEW_SERVICE } from '../constants';\nimport type { EventService } from '../interfaces';\nimport type { ClientWebViewService } from '../services';\n\n@injectable()\nexport class EventMediatorPlugin implements MangoPlugin {\n    @inject(EVENT_SERVICE) private readonly eventService: EventService;\n    @inject(WEBVIEW_SERVICE) private readonly webViewService: ClientWebViewService;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public beforeLoad() {\n        const time = Date.now();\n\n        this.eventService.onServer('SERVER::EMIT_WEBVIEW', (body) => {\n            this.webViewService.get(body.id)?.emit(`WEBVIEW::ON_SERVER_${body.eventName}`, body.payload);\n        });\n\n        this.webViewService.$onCreate((id, webView) => {\n            webView.on('WEBVIEW::EMIT_SERVER', (data: string) => {\n                // Data is JSON stringified from webview because RAGE:MP doesn't properly serialize objects\n                const body = JSON.parse(data) as { eventName: string; payload: unknown };\n                this.eventService.emitServer(`SERVER::ON_WEBVIEW_${body.eventName}_${id}`, body.payload);\n            });\n        });\n\n        this.loggerService.log(`~lw~Event mediator methods defined ~lk~(${Date.now() - time}ms)`);\n    }\n}\n", "import type { Pipe } from '../interfaces';\nimport { isNil, isNumber } from '../utils';\n\nexport class DefaultValuePipe<T = unknown, R = unknown> implements Pipe<T, T | R> {\n    constructor(private readonly defaultValue: T) {}\n\n    public transform(value: T) {\n        if (isNil(value) || (isNumber(value) && isNaN(<number>value))) {\n            return this.defaultValue;\n        }\n        return value;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport { type MangoPlugin, type RPCPayload, RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_UNKNOWN } from '@ragemp-mango/core/app';\nimport {\n    EVENT_SERVICE,\n    RPC_SERVICE,\n    RPCResultStatus,\n    type RPCResult,\n    MangoError,\n    LOGGER_SERVICE,\n    isNil,\n    type LoggerService,\n} from '@ragemp-mango/core';\nimport { WEBVIEW_SERVICE } from '../constants';\nimport type { ClientWebViewService } from '../services';\nimport type { EventService, RPCService } from '../interfaces';\n\n@injectable()\nexport class RPCPlugin implements MangoPlugin {\n    @inject(EVENT_SERVICE) private readonly eventService: EventService;\n    @inject(WEBVIEW_SERVICE) private readonly webViewService: ClientWebViewService;\n    @inject(RPC_SERVICE) private readonly rpcService: RPCService;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public beforeLoad() {\n        const time = Date.now();\n\n        this.eventService.onServer('RPC::CALL_CLIENT', async (payload) => {\n            const rpcHandler = this.rpcService.$serverHandlers.get(payload.rpcName);\n            if (isNil(rpcHandler)) {\n                this.eventService.emitServer(`RPC::RETURN_FROM_CLIENT_${payload.id}`, RPC_RESULT_HANDLER_NOT_FOUND);\n                return;\n            }\n\n            try {\n                const result = await rpcHandler.handler(payload.body);\n                const rpcResult: RPCResult = {\n                    success: true,\n                    status: RPCResultStatus.Success,\n                    body: result,\n                };\n                this.eventService.emitServer(`RPC::RETURN_FROM_CLIENT_${payload.id}`, rpcResult);\n            } catch (error) {\n                if (error instanceof MangoError) {\n                    const rpcResult: RPCResult = {\n                        success: false,\n                        status: error.status,\n                        error: { message: error.message, details: error.details },\n                    };\n                    this.eventService.emitServer(`RPC::RETURN_FROM_CLIENT_${payload.id}`, rpcResult);\n                    return;\n                }\n\n                this.eventService.emitServer(`RPC::RETURN_FROM_CLIENT_${payload.id}`, RPC_RESULT_UNKNOWN);\n            }\n        });\n        this.webViewService.$onCreate((webViewId, webView) => {\n            webView.on('RPC::CALL_CLIENT', async (payload) => {\n                if (!webView.valid) return;\n\n                const rpcHandler = this.rpcService.$webViewHandlers.get(`${webViewId}::${payload.rpcName}`);\n                if (isNil(rpcHandler)) {\n                    webView.emit(`RPC::RETURN_FROM_CLIENT_${payload.id}`, RPC_RESULT_HANDLER_NOT_FOUND);\n                    return;\n                }\n\n                try {\n                    const result = await rpcHandler.handler(payload.body);\n                    webView.emit(`RPC::RETURN_FROM_CLIENT_${payload.id}`, <RPCResult>{\n                        success: true,\n                        status: RPCResultStatus.Success,\n                        body: result,\n                    });\n                } catch (error) {\n                    if (error instanceof MangoError) {\n                        webView.emit(`RPC::RETURN_FROM_CLIENT_${payload.id}`, {\n                            success: false,\n                            status: error.status,\n                            error: { message: error.message, details: error.details },\n                        });\n                        return;\n                    }\n\n                    webView.emit(`RPC::RETURN_FROM_CLIENT_${payload.id}`, RPC_RESULT_UNKNOWN);\n                }\n            });\n\n            webView.on('RPC::CALL_SERVER', (payload) => {\n                this.eventService.emitServer('RPC::CALL_SERVER', <RPCPayload>{ ...payload, webViewId });\n            });\n        });\n\n        this.loggerService.log(`~lw~RPC handlers registered ~lk~(${Date.now() - time}ms)`);\n    }\n}\n", "import { Container, inject, injectable } from 'inversify';\nimport { GLOBAL_APP_CONTAINER, INTERNAL_APP_CONTAINER, type MangoPlugin } from '@ragemp-mango/core/app';\nimport { EVENT_SERVICE, LOGGER_SERVICE, RPC_SERVICE } from '@ragemp-mango/core';\nimport { ClientEventService, ClientLoggerService, ClientRPCService, ClientWebViewService, WebViewListService } from '../services';\nimport { WEBVIEW_LIST_SERVICE, WEBVIEW_SERVICE } from '../constants';\n\n@injectable()\nexport class ServiceBinderPlugin implements MangoPlugin {\n    @inject(INTERNAL_APP_CONTAINER) private readonly internalAppContainer: Container;\n    @inject(GLOBAL_APP_CONTAINER) private readonly globalAppContainer: Container;\n\n    public async onBuild() {\n        const time = Date.now();\n\n        this.globalAppContainer.bind(LOGGER_SERVICE).to(ClientLoggerService).inSingletonScope();\n        this.globalAppContainer.bind(EVENT_SERVICE).to(ClientEventService).inSingletonScope();\n        this.globalAppContainer.bind(RPC_SERVICE).to(ClientRPCService).inSingletonScope();\n        this.globalAppContainer.bind(WEBVIEW_SERVICE).to(ClientWebViewService).inSingletonScope();\n        this.globalAppContainer.bind(WEBVIEW_LIST_SERVICE).to(WebViewListService).inSingletonScope();\n\n        this.internalAppContainer.bind(LOGGER_SERVICE).toConstantValue(this.globalAppContainer.get(LOGGER_SERVICE));\n        this.internalAppContainer.bind(EVENT_SERVICE).toConstantValue(this.globalAppContainer.get(EVENT_SERVICE));\n        this.internalAppContainer.bind(RPC_SERVICE).toConstantValue(this.globalAppContainer.get(RPC_SERVICE));\n        this.internalAppContainer.bind(WEBVIEW_SERVICE).toConstantValue(this.globalAppContainer.get(WEBVIEW_SERVICE));\n        this.internalAppContainer.bind(WEBVIEW_LIST_SERVICE).toConstantValue(this.globalAppContainer.get(WEBVIEW_LIST_SERVICE));\n\n        const loggerService = this.globalAppContainer.get<ClientLoggerService>(LOGGER_SERVICE);\n        loggerService.log(`~lw~Internal services binded ~lk~(${Date.now() - time}ms)`);\n    }\n}\n", "import { BaseEventService, MULTIPLAYER_SERVICE, type ScriptEventHandler } from '@ragemp-mango/core/app';\nimport { inject, injectable } from 'inversify';\nimport { INTERNAL_EVENTS, WEBVIEW_LIST_SERVICE } from '../constants';\nimport type { WebViewListService } from './webview-list.service';\nimport type { ClientEventEmmiter, EventService } from '../interfaces';\nimport type { ClientMultiplayerService } from '../interfaces/multiplayer';\n\n@injectable()\nexport class ClientEventService extends BaseEventService<MangoEvents.CustomClientEvent> implements EventService {\n    @inject(WEBVIEW_LIST_SERVICE) private readonly $webViewListService: WebViewListService;\n    private $rageEvents: ClientEventEmmiter;\n\n    public constructor(@inject(MULTIPLAYER_SERVICE) multiplayerService: ClientMultiplayerService) {\n        super(multiplayerService.Events);\n        this.$rageEvents = multiplayerService.Events;\n        this.$internalEventNames = new Set(Object.values(INTERNAL_EVENTS));\n    }\n\n    public onServer<E extends string>(\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const wrapper = (...args: unknown[]) => callback(args[0]);\n        const eventHandler = this.$rageEvents.onServer(eventName, wrapper);\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public onceServer<E extends string>(\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const wrapper = (...args: unknown[]) => callback(args[0]);\n        const eventHandler = this.$rageEvents.onceServer(eventName, wrapper);\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public emitServer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>, body?: unknown) {\n        this.$rageEvents.emitServer(eventName, body);\n    }\n\n    public onWebView<E extends string>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const webView = this.$webViewListService.tryGet(id);\n        const wrapper = (...args: unknown[]) => callback(args[0]);\n\n        const eventHandler: ScriptEventHandler = {\n            destroy() {\n                webView.off(eventName, wrapper);\n            },\n        };\n\n        webView.on(eventName, wrapper);\n\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public onceWebView<E extends string>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const webView = this.$webViewListService.tryGet(id);\n        const wrapper = (...args: any[]) => callback(args[0]);\n\n        const eventHandler: ScriptEventHandler = {\n            destroy() {\n                webView.off(eventName, wrapper);\n            },\n        };\n\n        webView.once(eventName, wrapper);\n\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public emitWebView<E extends string>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomClientToWebViewEvent>,\n        body?: unknown,\n    ) {\n        const webView = this.$webViewListService.tryGet(id);\n        webView.emit(eventName, body);\n    }\n\n    // RageMP client-specific events\n    public onRender(callback: () => void): ScriptEventHandler {\n        return this.$rageEvents.on('render', callback);\n    }\n\n    public onBrowserDomReady(callback: (browser: BrowserMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('browserDomReady', callback);\n    }\n\n    public onBrowserLoadingFailed(callback: (browser: BrowserMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('browserLoadingFailed', callback);\n    }\n\n    public onPlayerChat(callback: (text: string) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerChat', callback);\n    }\n\n    public onPlayerCommand(callback: (command: string) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerCommand', callback);\n    }\n\n    public onPlayerDeath(callback: (killer?: PlayerMp, reason?: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerDeath', callback);\n    }\n\n    public onPlayerSpawn(callback: () => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerSpawn', callback);\n    }\n\n    public onPlayerEnterVehicle(callback: (vehicle: VehicleMp, seat: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterVehicle', callback);\n    }\n\n    public onPlayerExitVehicle(callback: (vehicle: VehicleMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitVehicle', callback);\n    }\n\n    public onPlayerEnterColshape(callback: (colshape: ColshapeMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterColshape', callback);\n    }\n\n    public onPlayerExitColshape(callback: (colshape: ColshapeMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitColshape', callback);\n    }\n\n    public onPlayerEnterCheckpoint(callback: (checkpoint: CheckpointMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterCheckpoint', callback);\n    }\n\n    public onPlayerExitCheckpoint(callback: (checkpoint: CheckpointMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitCheckpoint', callback);\n    }\n}\n", "import { injectable, inject } from 'inversify';\nimport { MANGO_LOG_PREFIX } from '@ragemp-mango/core/app';\nimport type { LoggerService } from '@ragemp-mango/core';\nimport { MULTIPLAYER_SERVICE, type MultiplayerService } from '../../../core/src/app';\n\n@injectable()\nexport class ClientLoggerService implements LoggerService {\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayerService: MultiplayerService;\n    public log(...args: unknown[]): void {\n        this.multiplayerService.log(`~w~[~y~${MANGO_LOG_PREFIX}Client~w~][~lb~Log~w~]`, ...args);\n    }\n\n    public warn(...args: unknown[]): void {\n        this.multiplayerService.logWarning(`[${MANGO_LOG_PREFIX}Client][Warn]`, ...args);\n    }\n\n    public error(...args: unknown[]): void {\n        this.multiplayerService.logError(`[${MANGO_LOG_PREFIX}Client][Error]`, ...args);\n    }\n\n    public debug(...args: unknown[]): void {\n        this.multiplayerService.logDebug(`~w~[~y~${MANGO_LOG_PREFIX}Client~w~][~lc~Debug~w~]`, ...args);\n    }\n}\n", "export enum ErrorMessage {\n    TooManyRequests = 'Too many requests.',\n\n    // Events\n    EventNameMustBeString = 'The event name must be a string.',\n    EventNameMustBeUnique = 'The event name must be unique.',\n    EventNotAllowedInClient = 'The event is not allowed in the client environment.',\n    EventNotAllowedInServer = 'The event is not allowed in the server environment.',\n    InvalidEventType = 'Invalid event type.',\n    InvalidInternalEventName = 'The name of the internal event is invalid.',\n    InvalidReturnInEvent = 'Cannot return a value from an event.',\n\n    // RPC\n    RPCNameMustBeString = 'The RPC name must be a string.',\n    RPCNameMustBeUnique = 'The RPC name must be unique.',\n    RPCNotAllowedInClient = 'The RPC is not allowed in the client environment.',\n    RPCNotAllowedInServer = 'The RPC is not allowed in the server environment.',\n    InvalidRPCType = 'Invalid RPC type.',\n    RPCHandlerAlreadyExists = 'The RPC handler already exists. Please provide a unique name for the RPC.',\n    RPCResponseAlreadySent = 'The RPC response has already been sent.',\n\n    // Error filters\n    InvalidErrorFilterDefinition = 'Invalid error filter. Error filters must be a class reference or an object with a catch method.',\n    ErrorAlreadyHandledByFilter = 'The error already points to a filter.',\n    ExceptionHandlingConflict = 'The same exception can only be caught once.',\n    AtLeastOneFilterRequired = 'At least one error filter must be provided.',\n    DuplicateErrorFilterDetected = 'Duplicate error filter found. Ensure that the same filter is not applied more than once.',\n\n    // WebView\n    WebViewNotFound = 'The WebView with the specified id does not exist.',\n    WebViewIdMustBeStringOrNumber = 'The WebView id must be a string or number.',\n\n    // Guard\n    InvalidGuardDefinition = 'Invalid guard. Guards must be a class reference or an object with a canActivate method.',\n    AtLeastOneGuardRequired = 'At least one guard must be provided.',\n\n    // Interceptor\n    InvalidInterceptorDefinition = 'Invalid interceptor. Interceptors must be a class reference or an object with an intercept method.',\n    AtLeastOneInterceptorRequired = 'At least one interceptor must be provided.',\n    InvalidInterceptorReturnValue = 'The interceptor must return a function.',\n\n    // Pipe\n    InvalidPipeDefinition = 'Invalid pipe. Pipes must be a class reference or an object with a transform method.',\n    AtLeastOnePipeRequired = 'At least one pipe must be provided.',\n\n    // App loading\n    AppAlreadyLoaded = 'App is already loaded. Please call the stop method before calling the start method.',\n    AppNotLoaded = 'App is not loaded. Please call the start method before calling the stop method.',\n\n    // Decorators\n    InvalidInjectionTokenSpecified = 'The specified injection token is invalid.',\n    InjectionTokenNotFound = 'The injection token could not be found.',\n    ParamKeyMustBeString = 'The param key must be a string.',\n    IndexKeyMustBeNumber = 'The index key must be a number.',\n    DuplicateDecoratorUsage = 'The same decorator can only be used once in the same class.',\n    InvalidControllerOptions = 'Invalid controller options found.',\n    InvalidInjectableOptions = 'Invalid injectable options found.',\n    InvalidModuleOptions = 'Invalid module options found.',\n    MultipleDecoratorsOnSingleParameterNotAllowed = 'Cannot apply multiple decorators to the same parameter.',\n\n    // Internal App\n    CircularDependencyDetected = 'Circular dependency detected.',\n    InvalidModuleDefinition = 'The module is invalid.',\n    InvalidExportDefinition = 'The export is invalid.',\n    InvalidProviderDefinition = 'The provider is invalid.',\n    InvalidParameterDecoratorUsage = 'Each parameter must have their its own decorator.',\n    ResponseDecoratorNotAllowedOnEvents = 'The @Response() decorator is not allowed on events.',\n    PlayerDecoratorNotAllowedOnClientEvents = 'The @Player() decorator is not allowed on client events.',\n\n    // Timers\n    TimerNameMustBeString = 'The timer name must be a string.',\n}\n", "export enum InjectableScope {\n    Request = 'request',\n    Transient = 'transient',\n    Singleton = 'singleton',\n}\n", "export enum RPCResultStatus {\n    Success = 1,\n    Timeout = 2,\n    HandlerNotFound = 3,\n    Unknown = 4,\n    CancelledByGuard = 5,\n    InvalidGuardReturn = 6,\n    TooManyRequests = 7,\n    PlayerDisconnected = 8,\n    PlayerNotFound = 9,\n}\n", "import { RPCResultStatus } from '../../enums';\nimport type { RPCResult } from '../../interfaces';\n\nexport const INTERNAL_APP_CONTAINER = 'INTERNAL_APP_CONTAINER';\nexport const GLOBAL_APP_CONTAINER = 'GLOBAL_APP_CONTAINER';\nexport const APP_ENVIROMENT = 'APP_ENVIROMENT';\n\nexport const GLOBAL_GUARDS = 'GLOBAL_GUARDS';\nexport const GLOBAL_INTERCEPTORS = 'GLOBAL_INTERCEPTORS';\nexport const GLOBAL_PIPES = 'GLOBAL_PIPES';\nexport const GLOBAL_ERROR_FILTERS = 'GLOBAL_ERROR_FILTERS';\n\nexport const PLUGINS = 'PLUGINS';\n\nexport const ENABLE_SHUTDOWN_HOOKS = 'ENABLE_SHUTDOWN_HOOKS';\nexport const CONTAINER_OPTIONS = 'CONTAINER_OPTIONS';\nexport const LOG_ERROR_STACKTRACE = 'LOG_ERROR_STACKTRACE';\n\nexport const MANGO_LOG_PREFIX = '🥭';\n\nexport const MANGO_REQUEST_FACTORY = 'MANGO_REQUEST_FACTORY';\nexport const MANGO_RESPONSE_FACTORY = 'MANGO_RESPONSE_FACTORY';\nexport const EXECUTION_CONTEXT_FACTORY = 'EXECUTION_CONTEXT_FACTORY';\n\nexport const MULTIPLAYER_SERVICE = 'MULTIPLAYER_SERVICE';\n\nexport const RPC_RESULT_TIMEOUT: RPCResult = {\n    success: false,\n    error: { message: 'RPC call timed out.' },\n    status: RPCResultStatus.Timeout,\n};\n\nexport const RPC_RESULT_HANDLER_NOT_FOUND: RPCResult = {\n    success: false,\n    error: { message: 'RPC handler not found.' },\n    status: RPCResultStatus.HandlerNotFound,\n};\n\nexport const RPC_RESULT_UNKNOWN: RPCResult = {\n    success: false,\n    error: { message: 'Unknown error.' },\n    status: RPCResultStatus.Unknown,\n};\n\nexport const RPC_RESULT_PLAYER_DISCONNECTED: RPCResult = {\n    success: false,\n    error: { message: 'Player disconnected.' },\n    status: RPCResultStatus.PlayerDisconnected,\n};\n\nexport const RPC_RESULT_PLAYER_NOT_FOUND: RPCResult = {\n    success: false,\n    error: { message: 'Player not found.' },\n    status: RPCResultStatus.PlayerNotFound,\n};\n", "import { inject, injectable } from 'inversify';\nimport type { ErrorFilter, Guard, Interceptor, InternalEventService, MultiplayerService } from '../interfaces';\nimport type { Newable } from '../../types';\nimport { APP_ENVIROMENT, EXECUTION_CONTEXT_FACTORY, MANGO_REQUEST_FACTORY, MULTIPLAYER_SERVICE } from '../constants';\nimport { isFunction, isNil, isObject } from '../../utils';\nimport { PipelineHandler } from './pipeline.handler';\nimport type { EventMetadata } from '../interfaces';\nimport { EVENT_SERVICE, LOGGER_SERVICE } from '../../constants';\nimport type { Controller } from './controller';\nimport { AppEnviroment, ExecutionContextType } from '../enums';\nimport { ExecutionContextBase, MangoResponseBase, type MangoRequestBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport { isAsyncFunction } from '../../utils';\nimport { ControllerFlowHandler } from './controller-flow.handler';\n\n@injectable()\nexport class ControllerEventHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayerService: MultiplayerService;\n    @inject(EVENT_SERVICE) private readonly eventService: InternalEventService;\n    @inject(ControllerFlowHandler) private readonly controllerFlowHandler: ControllerFlowHandler;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MANGO_REQUEST_FACTORY) private readonly createMangoRequest: (body: unknown, player?: PlayerMp) => MangoRequestBase;\n    @inject(EXECUTION_CONTEXT_FACTORY) private readonly createExecutionContext: (\n        type: ExecutionContextType,\n        classRef: Newable,\n        handler: Function,\n        request: MangoRequestBase,\n        response?: MangoResponseBase,\n        name?: string,\n    ) => ExecutionContextBase;\n\n    public registerEvent(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        event: EventMetadata,\n    ) {\n        if (event.type === 'on' || event.type === 'once') {\n            return this.eventService[event.type](event.name, async (body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);\n            });\n        } else if (event.type === 'onInternal' || event.type === 'onceInternal') {\n            return this.eventService[`$${event.type}`](event.name, async (...args) => {\n                const { player, body } = this.multiplayerService.parseInternalArgs<PlayerMp>(...args);\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        } else if (event.type === 'onPlayer' || event.type === 'oncePlayer') {\n            return this.eventService[event.type](event.name, async (player, body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        } else if (event.type === 'onServer' || event.type === 'onceServer') {\n            return this.eventService[event.type](event.name, async (body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);\n            });\n        } else if (event.type === 'onWebView' || event.type === 'onceWebView') {\n            return this.eventService[event.type](event.webViewId!, event.name, async (...args: unknown[]) => {\n                const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];\n                const player = this.appEnv === AppEnviroment.Server ? <PlayerMp>args[0] : undefined;\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        }\n\n        this.loggerService.error('An error occurred while trying to register event.');\n        throw new Error(ErrorMessage.InvalidEventType);\n    }\n\n    private async handleEvent(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        event: EventMetadata,\n        body: unknown,\n        player?: PlayerMp,\n    ) {\n        const request = this.createMangoRequest(body, player);\n        const executionContext = this.createExecutionContext(\n            ExecutionContextType.Event,\n            controller.metadata.classRef,\n            controller.metadata.classRef.prototype[event.method],\n            request,\n            undefined,\n            event.name,\n        );\n\n        try {\n            await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);\n            const args = await this.controllerFlowHandler.createArgs(controller, executionContext, event, pipes, player);\n            const controllerMethod = controller.instance[event.method]!;\n            const handle = isAsyncFunction(controllerMethod)\n                ? (): unknown => controller.instance[event.method]!.apply(controller.instance, args)\n                : (): Promise<unknown> => controller.instance[event.method]!.apply(controller.instance, args);\n            const callHandler: CallHandler = {\n                handle,\n                return: () => {\n                    this.loggerService.error('An error occurred while trying to return a value from an event.');\n                    throw new Error(ErrorMessage.InvalidReturnInEvent);\n                },\n            };\n\n            if (interceptors.length > 0) {\n                await this.pipelineHandler.goThroughInterceptors(executionContext, interceptors, controller.owner.container, callHandler);\n            } else {\n                await callHandler.handle();\n            }\n        } catch (error) {\n            const errorGroup = mappedErrorFilters.find(\n                ([errorType]) =>\n                    (isFunction(errorType) && error instanceof errorType) || errorType === 'MANGO_ANY_ERROR' || error === errorType,\n            );\n            if (isNil(errorGroup)) return;\n            const instance = isFunction(errorGroup[1])\n                ? controller.owner.container.get(errorGroup[1])\n                : isObject(errorGroup[1]) && isFunction(errorGroup[1]['catch'])\n                  ? errorGroup[1]\n                  : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through error filters.');\n                throw new Error(ErrorMessage.InvalidErrorFilterDefinition);\n            }\n            await Promise.resolve(instance.catch.call(instance, error, executionContext));\n        }\n    }\n}\n", "export function generateRandomId() {\n    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);\n}\n", "export const isUndefined = (obj: any): obj is undefined => typeof obj === 'undefined';\nexport const isObject = (fn: any): fn is object => !isNil(fn) && typeof fn === 'object';\nexport const isFunction = (val: any): val is Function => typeof val === 'function';\nexport const isString = (val: any): val is string => typeof val === 'string';\nexport const isNumber = (val: any): val is number => typeof val === 'number';\nexport const isConstructor = (val: any): boolean => val === 'constructor';\nexport const isNil = (val: any): val is null | undefined => isUndefined(val) || val === null;\nexport const isEmpty = (array: any): boolean => !(array && array.length > 0);\nexport const isSymbol = (val: any): val is symbol => typeof val === 'symbol';\nexport const isAsyncFunction = (val: any): boolean => isFunction(val) && val.constructor.name === 'AsyncFunction';\nexport const isBoolean = (val: any): val is boolean => typeof val === 'boolean';\nexport const isPromise = <T = any>(val: any): val is Promise<T> => val instanceof Promise;\n", "import { inject, injectable } from 'inversify';\nimport type { Guard, Interceptor } from '../interfaces';\nimport type { Newable } from '../../types';\nimport { GuardCancelError, GuardInvalidReturnError } from '../../errors';\nimport { isFunction, isNil, isObject } from '../../utils';\nimport type { ExecutionContextBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { ArgumentMetadata, CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport { LOGGER_SERVICE } from '../../constants';\nimport type { ModuleContainer } from '../module';\n\n@injectable()\nexport class PipelineHandler {\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    // @inject(GLOBAL_APP_CONTAINER) private readonly globalContainer: Container;\n\n    public async goTroughGuards(executionContext: ExecutionContextBase, guards: (Newable<Guard> | Guard)[], container: ModuleContainer) {\n        for (const guard of guards) {\n            const instance = isFunction(guard) ? container.get(guard) : isObject(guard) && isFunction(guard['canActivate']) ? guard : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through guards.');\n                throw new Error(ErrorMessage.InvalidGuardDefinition);\n            }\n            const canActivate = await instance.canActivate.call(instance, executionContext);\n            if (typeof canActivate !== 'boolean') {\n                this.loggerService.error('An error occurred while trying to go through guards.');\n                throw new GuardInvalidReturnError();\n            }\n            if (!canActivate) {\n                throw new GuardCancelError();\n            }\n        }\n    }\n\n    public async goThroughInterceptors(\n        executionContext: ExecutionContextBase,\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        container: ModuleContainer,\n        callHandler: CallHandler,\n    ) {\n        for (const interceptor of interceptors) {\n            const instance = isFunction(interceptor)\n                ? container.get(interceptor)\n                : isObject(interceptor) && isFunction(interceptor['intercept'])\n                  ? interceptor\n                  : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through interceptors.');\n                throw new Error(ErrorMessage.InvalidInterceptorDefinition);\n            }\n            await instance.intercept.call(instance, executionContext, callHandler);\n        }\n    }\n\n    public async goTroughPipes(\n        value: unknown,\n        pipes: (Newable<Pipe> | Pipe)[],\n        argumentMetadata: ArgumentMetadata,\n        container: ModuleContainer,\n    ) {\n        for (const pipe of pipes) {\n            const instance = isFunction(pipe) ? container.get(pipe) : isObject(pipe) ? pipe : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through pipes.');\n                throw new Error(ErrorMessage.InvalidPipeDefinition);\n            }\n            value = await Promise.resolve(instance.transform.call(instance, value, argumentMetadata));\n        }\n\n        return value;\n    }\n}\n", "import { RPCResultStatus } from '../enums';\n\nexport class MangoError<TDetails = unknown> extends Error {\n    public status: number = RPCResultStatus.Unknown;\n    public details: TDetails | undefined;\n\n    public constructor(message: string, status?: number, details?: TDetails) {\n        super(message);\n        this.status = status ?? RPCResultStatus.Unknown;\n        this.details = details;\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class GuardCancelError extends MangoError {\n    public constructor() {\n        super('Process cancelled by the guard.', RPCResultStatus.CancelledByGuard);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class GuardInvalidReturnError extends MangoError {\n    public constructor() {\n        super('Guard returned an invalid value. Expected boolean.', RPCResultStatus.InvalidGuardReturn);\n    }\n}\n", "export const LOGGER_SERVICE = 'LOGGER_SERVICE';\nexport const EVENT_SERVICE = 'EVENT_SERVICE';\nexport const RPC_SERVICE = 'RPC_SERVICE';\nexport const MODULE_CONTAINER = 'MODULE_CONTAINER';\nexport const REFLECTOR_SERVICE = 'REFLECTOR_SERVICE';\nexport const TIMER_SERVICE = 'TIMER_SERVICE';\n", "export enum AppEnviroment {\n    Client,\n    Server,\n}\n", "export enum CoreMetadataKey {\n    // General\n    Injectable = 'mango:injectable',\n    Inject = 'mango:inject',\n    Module = 'mango:module',\n    GlobalModule = 'mango:global-module',\n    Controller = 'mango:controller-options',\n    // Events & RPC\n    ControllerEvents = 'mango:controller-events',\n    ControllerRPCs = 'mango:controller-rpcs',\n    ControllerParams = 'mango:controller-rpc-params',\n    // Pipeline\n    Guards = 'mango:guards',\n    Interceptors = 'mango:interceptors',\n    Pipes = 'mango:pipes',\n    // Error\n    Catch = 'mango:catch',\n    ErrorFilters = 'mango:error-filters',\n    //\n    Timers = 'mango:timers',\n}\n", "export enum ExecutionContextType {\n    Event = 'event',\n    RPC = 'rpc',\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Controller } from './controller';\nimport type { ExecutionContextBase } from '../pipeline';\nimport type { EventMetadata, RPCMetadata } from '../interfaces';\nimport type { Newable } from '../../types';\nimport type { Pipe } from '../../interfaces';\nimport { PipelineHandler } from './pipeline.handler';\nimport { isObject } from '../../utils';\nimport { AppEnviroment } from '../enums';\nimport { APP_ENVIROMENT } from '../constants';\n\n@injectable()\nexport class ControllerFlowHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n\n    public async createArgs(\n        controller: Controller,\n        executionContext: ExecutionContextBase,\n        metadata: RPCMetadata | EventMetadata,\n        pipes: (Newable<Pipe> | Pipe)[],\n        player?: PlayerMp,\n    ) {\n        return Promise.all(\n            metadata.params.map(async (param) => {\n                const argumentMetadata = {\n                    type: param.type,\n                    data: param.data,\n                    metatype: param.metatype,\n                };\n\n                if (param.type === 'body') {\n                    // Body\n                    return this.pipelineHandler.goTroughPipes(\n                        executionContext.request.body,\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'param') {\n                    // Param\n                    if (!isObject(executionContext.request.body)) return undefined;\n                    return this.pipelineHandler.goTroughPipes(\n                        (<Record<string, unknown>>executionContext.request.body)[param.data],\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'index') {\n                    if (!Array.isArray(executionContext.request.body)) return undefined;\n                    return this.pipelineHandler.goTroughPipes(\n                        executionContext.request.body[param.data],\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'request') {\n                    return executionContext.request;\n                } else if (param.type === 'custom') {\n                    // Custom\n                    return this.pipelineHandler.goTroughPipes(\n                        param.factory(param.data, executionContext),\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'player' && this.appEnv === AppEnviroment.Server) {\n                    // Player (Server)\n                    return this.pipelineHandler.goTroughPipes(\n                        param.data ? player![<keyof PlayerMp>param.data] : player,\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                }\n                return undefined;\n            }),\n        );\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Guard, Interceptor, ErrorFilter, TimerMetadata } from '../interfaces';\nimport type { Newable } from '../../types';\nimport type { ControllerMetadata, EventMetadata, MethodParameter, RPCMetadata } from '../interfaces';\nimport { AppEnviroment, CoreMetadataKey } from '../enums';\nimport { APP_ENVIROMENT } from '../constants';\nimport { ErrorMessage } from '../../enums';\nimport type { LoggerService, Pipe } from '../../interfaces';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class ControllerMetadataReader {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async read(classRef: Newable) {\n        const options =\n            Reflect.getMetadata<Pick<ControllerMetadata, 'prefix'>>(CoreMetadataKey.Controller, classRef) ??\n            <Pick<ControllerMetadata, 'prefix'>>{};\n        const events = this.getEvents(classRef);\n        const rpcs = this.getRPCs(classRef);\n        const timers = this.getTimers(classRef);\n\n        return <ControllerMetadata>{\n            ...options,\n            classRef,\n            events,\n            rpcs,\n            ...this.getPipeline(classRef),\n            timers,\n        };\n    }\n\n    private getEvents(classRef: Newable) {\n        const events = Reflect.getMetadata<EventMetadata[]>(CoreMetadataKey.ControllerEvents, classRef.prototype) ?? [];\n\n        return events.map((event) => {\n            return <EventMetadata>{\n                ...event,\n                params: this.getMethodParams(classRef, event),\n                ...this.getPipeline(classRef, event.method),\n            };\n        });\n    }\n\n    private getRPCs(classRef: Newable) {\n        const rpcs = Reflect.getMetadata<RPCMetadata[]>(CoreMetadataKey.ControllerRPCs, classRef.prototype) ?? [];\n\n        return rpcs.map((rpc) => {\n            return <RPCMetadata>{\n                ...rpc,\n                params: this.getMethodParams(classRef, rpc),\n                ...this.getPipeline(classRef, rpc.method),\n            };\n        });\n    }\n\n    private getMethodParams(classRef: Newable, metadata: EventMetadata | RPCMetadata) {\n        const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, classRef.prototype, metadata.method) ?? [];\n\n        params.sort((a, b) => a.index - b.index);\n        params.forEach((param, index) => {\n            if (param.index !== index) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.InvalidParameterDecoratorUsage);\n            } else if (\n                (metadata.type === 'on' ||\n                    metadata.type === 'onPlayer' ||\n                    metadata.type === 'onInternal' ||\n                    metadata.type === 'onServer' ||\n                    metadata.type === 'onWebView' ||\n                    metadata.type === 'once' ||\n                    metadata.type === 'oncePlayer' ||\n                    metadata.type === 'onceInternal' ||\n                    metadata.type === 'onceServer' ||\n                    metadata.type === 'onceWebView') &&\n                param.type === 'response'\n            ) {\n                // Response\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.ResponseDecoratorNotAllowedOnEvents);\n            } else if (param.type === 'player' && this.appEnv === AppEnviroment.Client) {\n                // Player (Client) - Not allowed\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.PlayerDecoratorNotAllowedOnClientEvents);\n            } else if (metadata.type === 'onPlayerRequest' && this.appEnv === AppEnviroment.Client) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.RPCNotAllowedInClient);\n            } else if (metadata.type === 'onServerRequest' && this.appEnv === AppEnviroment.Server) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.RPCNotAllowedInServer);\n            } else if ((metadata.type === 'onPlayer' || metadata.type === 'oncePlayer') && this.appEnv === AppEnviroment.Client) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.EventNotAllowedInClient);\n            } else if ((metadata.type === 'onServer' || metadata.type === 'onceServer') && this.appEnv === AppEnviroment.Server) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.EventNotAllowedInServer);\n            }\n        });\n\n        return params;\n    }\n\n    private getPipeline(target: Newable | object, method?: string) {\n        const guards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, target, method) ?? [];\n        const interceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, target, method) ?? [];\n        const pipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, target, method) ?? [];\n        const errorFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, target, method) ?? [];\n\n        return { guards, interceptors, pipes, errorFilters };\n    }\n\n    private getTimers(classRef: Newable) {\n        return Reflect.getMetadata<TimerMetadata[]>(CoreMetadataKey.Timers, classRef.prototype) ?? [];\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { ErrorFilter, Guard, Interceptor, InternalRPCService } from '../interfaces';\nimport { LOGGER_SERVICE, RPC_SERVICE } from '../../constants';\nimport { APP_ENVIROMENT, EXECUTION_CONTEXT_FACTORY, MANGO_REQUEST_FACTORY, MANGO_RESPONSE_FACTORY } from '../constants';\nimport type { Newable } from '../../types';\nimport { isAsyncFunction, isFunction, isNil, isObject } from '../../utils';\nimport { PipelineHandler } from './pipeline.handler';\nimport type { RPCMetadata } from '../interfaces';\nimport { AppEnviroment, ExecutionContextType } from '../enums';\nimport { ExecutionContextBase, type MangoRequestBase, type MangoResponseBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport type { Controller } from './controller';\nimport { ControllerFlowHandler } from './controller-flow.handler';\n\n@injectable()\nexport class ControllerRPCHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(RPC_SERVICE) private readonly rpcService: InternalRPCService;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n    @inject(ControllerFlowHandler) private readonly controllerFlowHandler: ControllerFlowHandler;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MANGO_REQUEST_FACTORY) private readonly createMangoRequest: (data: unknown, player?: PlayerMp) => MangoRequestBase;\n    @inject(MANGO_RESPONSE_FACTORY) private readonly createMangoResponse: () => MangoResponseBase;\n    @inject(EXECUTION_CONTEXT_FACTORY) private readonly createExecutionContext: (\n        type: ExecutionContextType,\n        classRef: Newable,\n        handler: Function,\n        request: MangoRequestBase,\n        response: MangoResponseBase,\n        name: string,\n    ) => ExecutionContextBase;\n\n    public async registerRPC(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        rpc: RPCMetadata,\n    ) {\n        if (rpc.type === 'onRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);\n            });\n        } else if (rpc.type === 'onPlayerRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (player, body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);\n            });\n        } else if (rpc.type === 'onServerRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);\n            });\n        } else if (rpc.type === 'onWebViewRequest') {\n            return this.rpcService[rpc.type](rpc.webViewId!, rpc.name, async (...args: unknown[]) => {\n                const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];\n                const player = this.appEnv === AppEnviroment.Server ? <PlayerMp>args[0] : undefined;\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);\n            });\n        }\n\n        this.loggerService.error('An error occurred while trying to register RPC.');\n        throw new Error(ErrorMessage.InvalidRPCType);\n    }\n\n    private async handleRPC(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        rpc: RPCMetadata,\n        body: unknown,\n        player?: PlayerMp,\n    ) {\n        return new Promise(async (resolve) => {\n            const request = this.createMangoRequest(\n                body,\n                this.appEnv === AppEnviroment.Server && (rpc.type === 'onPlayerRequest' || rpc.type === 'onWebViewRequest')\n                    ? player\n                    : undefined,\n            );\n            const response = this.createMangoResponse();\n            response.$onSend((data) => resolve(data));\n            response.$onError((error) => resolve(error));\n            const executionContext = this.createExecutionContext(\n                ExecutionContextType.RPC,\n                controller.metadata.classRef,\n                controller.metadata.classRef.prototype[rpc.method],\n                request,\n                response,\n                rpc.name,\n            );\n\n            try {\n                await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);\n                const args = await this.controllerFlowHandler.createArgs(controller, executionContext, rpc, pipes, player);\n                const controllerMethod = controller.instance[rpc.method]!;\n                const handle = isAsyncFunction(controllerMethod)\n                    ? (options: { send: boolean } = { send: true }) => {\n                          const result = controller.instance[rpc.method]!.apply(controller.instance, args);\n                          if (options.send) {\n                              response.send(result);\n                          }\n                          return result;\n                      }\n                    : async (options: { send: boolean } = { send: true }) => {\n                          const result = await controller.instance[rpc.method]!.apply(controller.instance, args);\n                          if (options.send) {\n                              response.send(result);\n                          }\n                          return result;\n                      };\n                const callHandler: CallHandler = {\n                    handle,\n                    return: (value: unknown) => response.send(value),\n                };\n\n                if (interceptors.length > 0) {\n                    await this.pipelineHandler.goThroughInterceptors(\n                        executionContext,\n                        interceptors,\n                        controller.owner.container,\n                        callHandler,\n                    );\n                } else {\n                    await callHandler.handle();\n                }\n            } catch (error) {\n                const errorGroup = mappedErrorFilters.find(\n                    ([errorType]) =>\n                        (isFunction(errorType) && error instanceof errorType) || errorType === 'MANGO_ANY_ERROR' || error === errorType,\n                );\n                if (isNil(errorGroup)) return;\n                const instance = isFunction(errorGroup[1])\n                    ? controller.owner.container.get(errorGroup[1])\n                    : isObject(errorGroup[1]) && isFunction(errorGroup[1]['catch'])\n                      ? errorGroup[1]\n                      : null;\n                if (isNil(instance)) {\n                    return this.loggerService.error(ErrorMessage.InvalidErrorFilterDefinition);\n                }\n                await Promise.resolve(instance.catch.call(instance, error, executionContext));\n            }\n        });\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { ControllerMetadata, ScriptEventHandler } from '../interfaces';\nimport type { Module } from '../module';\nimport type { ScriptRPCHandler } from '../../interfaces';\n\n@injectable()\nexport class Controller {\n    public metadata: ControllerMetadata;\n    public instance: { [key: string]: Function };\n    public owner: Module;\n    public eventHandlers: ScriptEventHandler[] = [];\n    public rpcHandlers: ScriptRPCHandler[] = [];\n}\n", "import { inject, injectable } from 'inversify';\nimport type { InjectionToken, Newable } from '../../types';\nimport { CoreMetadataKey } from '../enums';\nimport type { InjectableMetadata, ErrorFilter, Guard, Interceptor } from '../interfaces';\nimport type { ModuleMetadata } from '../interfaces';\nimport type { ClassProvider, DynamicModule, LoggerService, ModuleOptions, Pipe, Provider } from '../../interfaces';\nimport { isFunction, isNil, isString, isSymbol } from '../../utils';\nimport { ErrorMessage } from '../../enums';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class ModuleMetadataReader {\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async read(module: Newable | DynamicModule | Promise<DynamicModule>) {\n        // Class reference\n        if (isFunction(module)) {\n            const options = Reflect.getMetadata<Required<ModuleOptions>>(CoreMetadataKey.Module, module) ?? <Required<ModuleOptions>>{};\n            const exportTokens = this.getExportTokens(options.exports);\n            const separatedProviders = this.separateProviders(options.providers, exportTokens);\n\n            return <ModuleMetadata>{\n                controllers: options.controllers,\n                imports: options.imports,\n                ...this.getPipeline(module),\n                ...separatedProviders,\n                classRef: module,\n                global: Reflect.getMetadata<boolean>(CoreMetadataKey.GlobalModule, module) ?? false,\n                container: options.container,\n            };\n        }\n        // Dynamic module\n        if (module instanceof Promise) module = await module;\n        if (!('module' in module)) {\n            this.loggerService.error('An error occurred while reading module metadata.');\n            throw new Error(ErrorMessage.InvalidModuleDefinition);\n        }\n\n        const { module: classRef, global, ...options } = <Required<DynamicModule>>module;\n        const exportTokens = this.getExportTokens(options.exports);\n        const separatedProviders = this.separateProviders(options.providers, exportTokens);\n\n        return <ModuleMetadata>{\n            controllers: options.controllers,\n            imports: options.imports,\n            ...this.getPipeline(classRef),\n            ...separatedProviders,\n            classRef,\n            global: global ?? false,\n            container: options.container,\n        };\n    }\n\n    private getPipeline(classRef: Newable) {\n        const guards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, classRef) ?? [];\n        const interceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, classRef) ?? [];\n        const pipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, classRef) ?? [];\n        const errorFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, classRef) ?? [];\n\n        return { guards, interceptors, pipes, errorFilters };\n    }\n\n    private getExportTokens(exports: Required<ModuleOptions>['exports']) {\n        return exports.map<InjectionToken>((providerExport) => {\n            if (isFunction(providerExport)) {\n                if (!Reflect.hasOwnMetadata(CoreMetadataKey.Injectable, providerExport)) {\n                    this.loggerService.error('An error occurred while reading module metadata.');\n                    throw new Error(ErrorMessage.InvalidExportDefinition);\n                }\n                return providerExport;\n            } else if (isString(providerExport) || isSymbol(providerExport)) {\n                return providerExport;\n            } else if ('provide' in providerExport) {\n                return providerExport.provide;\n            }\n\n            this.loggerService.error('An error occurred while reading module metadata.');\n            throw new Error(ErrorMessage.InvalidExportDefinition);\n        });\n    }\n\n    private separateProviders(providers: Required<ModuleOptions>['providers'], exportTokens: InjectionToken[]) {\n        return providers\n            .map((provider) => {\n                if (isFunction(provider)) {\n                    const injectableMetadata = Reflect.getMetadata<InjectableMetadata>(CoreMetadataKey.Injectable, provider);\n                    if (isNil(injectableMetadata)) {\n                        this.loggerService.error('An error occurred while reading module metadata.');\n                        throw new Error(ErrorMessage.InvalidProviderDefinition);\n                    }\n                    return <ClassProvider>{ provide: provider, useClass: provider, scope: injectableMetadata.scope };\n                } else if ('useClass' in provider || 'useValue' in provider || 'useFactory' in provider || 'useExisting' in provider) {\n                    return provider;\n                }\n\n                this.loggerService.error('An error occurred while reading module metadata.');\n                throw new Error(ErrorMessage.InvalidProviderDefinition);\n            })\n            .reduce(\n                (acc, provider) => {\n                    if (exportTokens.includes(provider.provide)) {\n                        acc.externalProviders.set(provider.provide, provider);\n                    } else {\n                        acc.internalProviders.set(provider.provide, provider);\n                    }\n                    return acc;\n                },\n                {\n                    internalProviders: new Map<InjectionToken, Exclude<Provider, Newable>>(),\n                    externalProviders: new Map<InjectionToken, Exclude<Provider, Newable>>(),\n                },\n            );\n    }\n}\n", "import { Container } from 'inversify';\n\nexport class ModuleContainer extends Container {}\n", "import { injectable } from 'inversify';\nimport { Controller } from '../controller';\nimport type { ModuleMetadata } from '../interfaces';\nimport { ModuleContainer } from './module-container';\n\n@injectable()\nexport class Module {\n    public readonly controllers: Controller[] = [];\n    public container: ModuleContainer;\n    public parent: Module | undefined;\n    public metadata: ModuleMetadata;\n    public instance: { [key: string]: Function };\n    public repetitiveImports: Set<Module> = new Set();\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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~loaded ~lk~(${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                    `~lw~Controller ~lc~${controller.metadata.classRef.name} ~lw~timers and listeners registered ~lk~(${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                `~lw~Module ~lb~${module.metadata.classRef.name} ~lw~dependencies binded ~lk~(${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 { 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 { isFunction, isNil, isObject } from '../../utils';\nimport type { ErrorFilter } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateErrorFilter<EF extends ErrorFilter = ErrorFilter>(value: EF | Newable<EF>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Error filter must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Error filter must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.catch)) {\n        return { valid: true, value, error: 'Error filter must have a catch method' };\n    }\n\n    if (isObject(value) && !isFunction((<ErrorFilter>value).catch)) {\n        return { valid: true, value, error: 'Error filter must have a catch method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Pipe } from '../../interfaces';\nimport type { Newable } from '../../types';\n\nexport function validatePipe(value: Pipe | Newable<Pipe>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Pipe must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Pipe must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.transform)) {\n        return { valid: false, value, error: 'Pipe must have a transform method' };\n    }\n\n    if (isObject(value) && !isFunction((<Pipe>value).transform)) {\n        return { valid: false, value, error: 'Pipe must have a transform method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Guard } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateGuard<G extends Guard = Guard>(value: G | Newable<G>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Guard must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Guard must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.canActivate)) {\n        return { valid: false, value, error: 'Guard must have a canActivate method' };\n    }\n\n    if (isObject(value) && !isFunction((<Guard>value).canActivate)) {\n        return { valid: false, value, error: 'Guard must have a canActivate method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Interceptor } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateInterceptor<I extends Interceptor = Interceptor>(value: I | Newable<I>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Interceptor must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Interceptor must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.intercept)) {\n        return { valid: false, value, error: 'Interceptor must have an intercept method' };\n    }\n\n    if (isObject(value) && !isFunction((<Interceptor>value).intercept)) {\n        return { valid: false, value, error: 'Interceptor must have an intercept method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isNil, isObject, isString } from '../utils';\nimport { InjectableScope } from '../enums';\nimport type { InjectableOptions } from '../interfaces';\n\nconst defaultInjectableOptions: InjectableOptions = { scope: InjectableScope.Singleton };\n\nexport function validateInjectableMetadata(value?: InjectableOptions) {\n    if (isNil(value)) {\n        return { valid: true, value: defaultInjectableOptions };\n    }\n\n    if (!isObject(value)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Injectable options must be an object' };\n    }\n\n    if (!('scope' in value)) {\n        return { valid: true, value: { ...defaultInjectableOptions, ...value } };\n    }\n    if ('scope' in value && !isString(value.scope)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Injectable scope must be a string' };\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Invalid injectable scope' };\n    }\n\n    return { valid: true, value };\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 { 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 { 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", "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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~scanned ~lk~(${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(`~lw~Module ~lb~${module.metadata.classRef.name} ~lw~scanned ~lk~(${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(`~lw~Controller ~lc~${classRef.name} ~lw~scanned ~lk~(${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", "export class TreeNode<T> {\n    public value: T;\n    public children: TreeNode<T>[];\n\n    public constructor(value: T) {\n        this.value = value;\n        this.children = [];\n    }\n\n    public addChild(child: TreeNode<T>) {\n        this.children.push(child);\n    }\n\n    public removeChild(child: TreeNode<T>) {\n        const index = this.children.indexOf(child);\n        if (index !== -1) {\n            this.children.splice(index, 1);\n        }\n    }\n}\n\nexport class Tree<T> {\n    public root: TreeNode<T>;\n\n    public constructor(value: T) {\n        this.root = new TreeNode<T>(value);\n    }\n\n    public traverse(callback: (node: TreeNode<T>) => void) {\n        function traverseNode(node: TreeNode<T>) {\n            callback(node);\n            node.children.forEach(traverseNode);\n        }\n\n        traverseNode(this.root);\n    }\n\n    public async asyncTraverse(callback: (node: TreeNode<T>) => Promise<void>) {\n        async function traverseNode(node: TreeNode<T>) {\n            await callback(node);\n            await Promise.all(node.children.map(traverseNode));\n        }\n\n        await traverseNode(this.root);\n    }\n\n    public toString(): string {\n        let result = '';\n        const lines: string[] = [];\n\n        function traverseNode(node: TreeNode<T>, depth: number) {\n            lines.push(`${'-'.repeat(depth * 2)}${node.value}`);\n            node.children.forEach((child) => traverseNode(child, depth + 1));\n        }\n\n        traverseNode(this.root, 0);\n        result = lines.join('\\n');\n\n        return result;\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { Newable } from '../../types';\nimport type { ExecutionContextType } from '../enums';\nimport type { ExecutionContext } from '../interfaces';\nimport type { MangoRequestBase } from './mango-request-base';\nimport type { MangoResponseBase } from './mango-response-base';\n\n@injectable()\nexport class ExecutionContextBase<\n    TRequest extends MangoRequestBase = MangoRequestBase,\n    TResponse extends MangoResponseBase = MangoResponseBase,\n> implements ExecutionContext<TRequest, TResponse>\n{\n    public $type: ExecutionContextType;\n    public $classRef: Newable;\n    public $handler: Function;\n    public $request: TRequest;\n    public $response?: TResponse;\n    public $name: string;\n\n    public get type() {\n        return this.$type;\n    }\n\n    public get classRef() {\n        return this.$classRef;\n    }\n\n    public get handler() {\n        return this.$handler;\n    }\n\n    public get request() {\n        return this.$request;\n    }\n\n    public get response() {\n        return this.$response!;\n    }\n\n    public get name() {\n        return this.$name;\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { MangoRequest } from '../interfaces';\n\n@injectable()\nexport class MangoRequestBase<TData = unknown> implements MangoRequest {\n    public $body: TData;\n    public $player?: PlayerMp;\n\n    public get body() {\n        return this.$body;\n    }\n\n    public get player() {\n        return this.$player;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { LoggerService, RPCError } from '../../interfaces';\nimport type { MangoResponse } from '../interfaces';\nimport { ErrorMessage } from '../../enums';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class MangoResponseBase implements MangoResponse {\n    @inject(LOGGER_SERVICE) private readonly $loggerService: LoggerService;\n    public $sendListeners: Set<(data: unknown) => void> = new Set();\n    public $errorListeners: Set<(error: RPCError) => void> = new Set();\n    public $isSent: boolean = false;\n\n    public send<TData = unknown>(data?: TData) {\n        if (this.$isSent) {\n            this.$loggerService.error('An error occurred while sending the RPC response.');\n            throw new Error(ErrorMessage.RPCResponseAlreadySent);\n        }\n\n        this.$sendListeners.forEach((listener) => listener(data));\n        this.$isSent = true;\n    }\n\n    public error<TDetails = unknown>(message: string, details?: TDetails) {\n        if (this.$isSent) {\n            this.$loggerService.error('An error occurred while sending the RPC response.');\n            throw new Error(ErrorMessage.RPCResponseAlreadySent);\n        }\n        this.$errorListeners.forEach((listener) => listener({ message, details }));\n        this.$isSent = true;\n    }\n\n    public $onSend(listener: (data: unknown) => void) {\n        this.$sendListeners.add(listener);\n    }\n\n    public $onError(listener: (error: RPCError) => void) {\n        this.$errorListeners.add(listener);\n    }\n}\n", "import { injectable } from 'inversify';\nimport { ErrorMessage } from '../../enums';\nimport type { EventEmmiter, ScriptEventHandler } from '../interfaces';\nimport type { EventHandler } from '../../interfaces';\n\n@injectable()\nexport abstract class BaseEventService<T extends Record<string, any>> {\n    protected readonly $localHandlers: Set<ScriptEventHandler> = new Set();\n    protected readonly $internalHandlers: Set<ScriptEventHandler> = new Set();\n    protected readonly $remoteHandlers: Set<ScriptEventHandler> = new Set();\n    protected $internalEventNames = new Set<string>();\n    constructor(protected $eventEmmiter: EventEmmiter) {}\n\n    public on<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;\n    public on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;\n    public on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.on(eventName, wrapper);\n        this.$localHandlers.add(eventHandler);\n        return eventHandler;\n    }\n    public once<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;\n    public once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;\n    public once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.once(eventName, wrapper);\n        this.$localHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public emit<E extends keyof T>(eventName: E, body?: T[E]): void;\n    public emit<E extends string>(eventName: E, body?: unknown): void;\n    public emit<E extends string>(eventName: E, body?: unknown) {\n        this.$eventEmmiter.emit(eventName, body);\n    }\n\n    protected $onInternal(eventName: string, handler: (body: unknown) => void | Promise<void>) {\n        if (!this.$internalEventNames.has(eventName)) {\n            throw new Error(ErrorMessage.InvalidInternalEventName);\n        }\n        const eventHandler = <EventHandler>this.$eventEmmiter.on(eventName, handler);\n        this.$internalHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    protected $onceInternal(eventName: string, handler: (body: unknown) => void | Promise<void>) {\n        if (!this.$internalEventNames.has(eventName)) {\n            throw new Error(ErrorMessage.InvalidInternalEventName);\n        }\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.once(eventName, handler);\n        this.$internalHandlers.add(eventHandler);\n        return eventHandler;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { RPCResult, RPCCallOptions, ScriptRPCHandler, LoggerService } from '../../interfaces';\nimport { RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_TIMEOUT, RPC_RESULT_UNKNOWN } from '../../app/constants';\nimport { ErrorMessage, RPCResultStatus } from '../../enums';\nimport { MangoError } from '../../errors';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class BaseRPCService<T extends Record<string, any>> {\n    @inject(LOGGER_SERVICE) protected readonly $loggerService: LoggerService;\n    protected readonly $TIMEOUT = 2000;\n    private readonly $localHandlers = new Map<string, ScriptRPCHandler>();\n\n    public async call<E extends keyof T>(\n        rpcName: E,\n        body?: Parameters<T[E]>[0],\n        options?: RPCCallOptions,\n    ): Promise<RPCResult<ReturnType<T[E]>>>;\n    public async call<E extends string>(rpcName: E, body?: unknown, options?: RPCCallOptions): Promise<RPCResult<unknown>>;\n    public async call<E extends string>(rpcName: E, body?: unknown, options: RPCCallOptions = { timeout: this.$TIMEOUT }) {\n        return new Promise(async (resolve) => {\n            const handler = this.$localHandlers.get(<string>rpcName)?.handler;\n            if (!handler) {\n                return resolve(RPC_RESULT_HANDLER_NOT_FOUND);\n            }\n\n            const timeoutId = setTimeout(() => {\n                resolve(RPC_RESULT_TIMEOUT);\n            }, options.timeout ?? this.$TIMEOUT);\n\n            try {\n                const result = await handler(body);\n                clearTimeout(timeoutId);\n                resolve({ success: true, status: RPCResultStatus.Success, body: result });\n            } catch (error) {\n                clearTimeout(timeoutId);\n\n                if (error instanceof MangoError) {\n                    return resolve({\n                        success: false,\n                        status: error.status,\n                        error: { message: error.message, details: error.details },\n                    });\n                }\n\n                resolve(RPC_RESULT_UNKNOWN);\n            }\n        });\n    }\n    public onRequest<E extends keyof T>(rpcName: E, handler: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptRPCHandler;\n    public onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;\n    public onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>) {\n        if (this.$localHandlers.has(rpcName)) {\n            this.$loggerService.error('An error occurred while trying to register RPC.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n\n        const rpcHandler: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\n                rpcHandler.valid = false;\n                this.$localHandlers.delete(rpcName);\n            },\n            rpcName: rpcName,\n            handler,\n            valid: true,\n        };\n\n        this.$localHandlers.set(rpcName, rpcHandler);\n\n        return rpcHandler;\n    }\n}\n", "import { validateErrorFilter, validateGuard, validateInterceptor, validatePipe } from '../schemas/events';\nimport {\n    INTERNAL_APP_CONTAINER,\n    GLOBAL_ERROR_FILTERS,\n    GLOBAL_GUARDS,\n    GLOBAL_INTERCEPTORS,\n    GLOBAL_PIPES,\n    ENABLE_SHUTDOWN_HOOKS,\n    PLUGINS,\n    GLOBAL_APP_CONTAINER,\n    APP_ENVIROMENT,\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 { inject, Container, injectable, 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 { ExecutionContextType } from './enums';\nimport { REFLECTOR_SERVICE } from '../constants';\nimport { ReflectorService } from '../services';\n\n@injectable()\nexport class AppBuilder<G extends Guard = Guard, I extends Interceptor = Interceptor, EF extends ErrorFilter = ErrorFilter> {\n    @inject(APP_ENVIROMENT) protected readonly enviroment: string;\n    @inject(INTERNAL_APP_CONTAINER) protected readonly internalAppContainer: Container;\n    @inject(MULTIPLAYER_SERVICE) protected readonly multiplayerService: MultiplayerService;\n    @inject(PLUGINS) protected readonly plugins: Newable<MangoPlugin>[];\n\n    private globalContainerOptions: interfaces.ContainerOptions = {};\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('~lw~Starting app...');\n        await this.runPluginMethods('beforeStart');\n\n        this.loggerService.log('~lw~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('~lw~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('~lw~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('~lw~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('~lw~Stopping app...');\n        await this.appRuntime.shutdown(this.moduleTree);\n        this.loaded = false;\n        this.loggerService.log('~lw~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 { APP_ENVIROMENT, INTERNAL_APP_CONTAINER, 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';\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: Newable<T>;\n    multiplayerService?: MultiplayerService;\n}) {\n    const internalAppContainer = new Container();\n\n    if (multiplayerService) internalAppContainer.bind(MULTIPLAYER_SERVICE).toConstantValue(multiplayerService);\n    internalAppContainer.bind(INTERNAL_APP_CONTAINER).toConstantValue(internalAppContainer);\n    internalAppContainer.bind(APP_ENVIROMENT).toConstantValue(enviroment);\n    internalAppContainer.bind(PLUGINS).toConstantValue(plugins);\n    internalAppContainer.bind(appBuilderInherit).toSelf().inSingletonScope();\n\n    return internalAppContainer.get(appBuilderInherit);\n}\n", "import { inject, injectable } from 'inversify';\nimport { BaseRPCService, EventDestination, type RPCPayload, RPC_RESULT_TIMEOUT } from '@ragemp-mango/core/app';\nimport {\n    ErrorMessage,\n    EVENT_SERVICE,\n    generateRandomId,\n    type RPCCallOptions,\n    type RPCResult,\n    type ScriptRPCHandler,\n} from '@ragemp-mango/core';\nimport type { RPCService } from '../interfaces';\nimport type { ClientEventService } from './client-event.service';\n\n@injectable()\nexport class ClientRPCService extends BaseRPCService<MangoRPC.CustomClientRPC> implements RPCService {\n    @inject(EVENT_SERVICE) private readonly $eventService: ClientEventService;\n    public readonly $serverHandlers = new Map<string, ScriptRPCHandler>();\n    public readonly $webViewHandlers = new Map<string, ScriptRPCHandler>();\n\n    public async callServer<E extends string>(\n        rpcName: Exclude<E, keyof MangoRPC.CustomClientToServerRPC>,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ) {\n        return this.$handleCall(rpcName, EventDestination.Server, options, body);\n    }\n\n    public onServerRequest<E extends string>(\n        rpcName: Exclude<E, keyof MangoRPC.CustomServerToClientRPC>,\n        handler: (body: unknown) => unknown | Promise<unknown>,\n    ) {\n        if (this.$serverHandlers.has(rpcName)) {\n            this.$loggerService.error('An error occurred while trying to register RPC.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n        const rpcHandler: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\n                rpcHandler.valid = false;\n                this.$serverHandlers.delete(rpcName);\n            },\n            rpcName,\n            handler,\n            valid: true,\n        };\n        this.$serverHandlers.set(rpcName, rpcHandler);\n        return rpcHandler;\n    }\n\n    public async callWebView<E extends string>(\n        id: string | number,\n        rpcName: Exclude<E, keyof MangoRPC.CustomClientToWebviewRPC>,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ) {\n        return this.$handleCall(rpcName, EventDestination.WebView, options, body, id);\n    }\n\n    public onWebViewRequest<E extends string>(\n        id: string | number,\n        rpcName: Exclude<E, keyof MangoRPC.CustomWebViewToClientRPC>,\n        handler: (body: unknown) => unknown | Promise<unknown>,\n    ) {\n        const key = `${id}::${rpcName}`;\n        if (this.$webViewHandlers.has(key)) {\n            this.$loggerService.error('An error occurred while trying to register RPC.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n\n        const rpcHandler = {\n            destroy: () => {\n                rpcHandler.valid = false;\n                this.$webViewHandlers.delete(key);\n            },\n            rpcName,\n            handler,\n            valid: true,\n        };\n\n        this.$webViewHandlers.set(key, rpcHandler);\n\n        return rpcHandler;\n    }\n\n    private async $handleCall<TResult>(\n        rpcName: string,\n        destination: EventDestination, // 'server' | 'webview',\n        options?: Partial<RPCCallOptions>,\n        body?: unknown,\n        webViewId?: string | number,\n    ) {\n        return new Promise<RPCResult<TResult>>((resolve) => {\n            const callId = generateRandomId();\n            let timeoutId: NodeJS.Timeout;\n\n            const onceHandle = (resultData: unknown) => {\n                clearTimeout(timeoutId);\n                resolve(<RPCResult<TResult>>resultData);\n            };\n            // Example: RPC::RETURN_FROM_SERVER_21ewrEq, RPC::RETURN_FROM_WEBVIEW_teEqd2\n            const eventHandler =\n                destination === EventDestination.WebView\n                    ? this.$eventService.onceWebView(webViewId!, `RPC::RETURN_FROM_WEBVIEW_${callId}`, onceHandle)\n                    : this.$eventService.onceServer(`RPC::RETURN_FROM_SERVER_${callId}`, onceHandle);\n\n            const payload: RPCPayload = {\n                source: EventDestination.Client,\n                destination,\n                id: callId,\n                rpcName,\n                body,\n            };\n            // Example: RPC::CALL_SERVER, RPC::CALL_WEBVIEW\n            destination === EventDestination.WebView\n                ? this.$eventService.emitWebView(webViewId!, <string>'RPC::CALL_WEBVIEW', payload)\n                : this.$eventService.emitServer(<string>'RPC::CALL_SERVER', payload);\n\n            timeoutId = setTimeout(() => {\n                eventHandler.destroy();\n                resolve(<RPCResult<TResult>>RPC_RESULT_TIMEOUT);\n            }, options?.timeout ?? this.$TIMEOUT);\n        });\n    }\n}\n", "\nimport { inject, injectable } from 'inversify';\nimport { ErrorMessage, LOGGER_SERVICE, isNil, type LoggerService } from '@ragemp-mango/core';\nimport type { MultiplayerWebView } from '../interfaces';\n\n@injectable()\nexport class WebViewListService {\n    @inject(LOGGER_SERVICE) private readonly $loggerService: LoggerService;\n\n    private readonly $webViews: Map<string | number, MultiplayerWebView> = new Map();\n\n    public set(id: string | number, webView: MultiplayerWebView) {\n        this.$webViews.set(id, webView);\n    }\n\n    public get(id: string | number) {\n        return this.$webViews.get(id);\n    }\n\n    public tryGet(id: string | number) {\n        const webView = this.$webViews.get(id);\n        if (isNil(webView) || !webView.valid) {\n            this.$loggerService.error('An error occurred while trying to get a WebView.');\n            throw new Error(ErrorMessage.WebViewNotFound);\n        }\n        return webView;\n    }\n\n    public delete(id: string | number) {\n        const webView = this.$webViews.get(id);\n        if (webView) {\n            webView.destroy();\n            this.$webViews.delete(id);\n        }\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport { WEBVIEW_LIST_SERVICE } from '../constants';\nimport type { WebViewListService } from './webview-list.service';\nimport { ErrorMessage, isNumber, isString, LOGGER_SERVICE, type LoggerService } from '@ragemp-mango/core';\nimport type { WebViewService } from '../interfaces';\nimport type {\n    ClientMultiplayerService,\n    MultiplayerWebView,\n    MultiplayerWebViewCreateOptionsDrawable,\n    MultiplayerWebViewCreateOptionsOverlay,\n} from '../interfaces/multiplayer';\nimport { MULTIPLAYER_SERVICE } from '@ragemp-mango/core/app';\n\n@injectable()\nexport class ClientWebViewService implements WebViewService {\n    @inject(LOGGER_SERVICE) private readonly $loggerService: LoggerService;\n    @inject(WEBVIEW_LIST_SERVICE) private readonly $webViewListService: WebViewListService;\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayer: ClientMultiplayerService;\n    private readonly $createListeners: ((id: string | number, webView: MultiplayerWebView) => void)[] = [];\n\n    public create(id: string | number, options: MultiplayerWebViewCreateOptionsOverlay): MultiplayerWebView;\n    public create(id: string | number, options: MultiplayerWebViewCreateOptionsDrawable): MultiplayerWebView;\n    public create(\n        id: string | number,\n        options: MultiplayerWebViewCreateOptionsOverlay | MultiplayerWebViewCreateOptionsDrawable,\n    ): MultiplayerWebView {\n        if (!isString(id) && !isNumber(id)) {\n            this.$loggerService.error('An error occurred while trying to create a WebView.');\n            throw new Error(ErrorMessage.WebViewIdMustBeStringOrNumber);\n        }\n\n        const webView = this.multiplayer.WebView.create(options);\n        this.$webViewListService.set(id, webView);\n        this.$createListeners.forEach((listener) => listener(id, webView));\n        return webView;\n    }\n\n    public get(id: string | number) {\n        return this.$webViewListService.get(id);\n    }\n\n    public tryGet(id: string | number) {\n        return this.$webViewListService.tryGet(id);\n    }\n\n    public destroy(id: string | number) {\n        const webView = this.$webViewListService.get(id);\n        if (webView) {\n            webView.destroy();\n            this.$webViewListService.delete(id);\n        }\n    }\n\n    public $onCreate(listener: (id: string | number, webView: MultiplayerWebView) => void) {\n        this.$createListeners.push(listener);\n    }\n}\n", "import { Container, inject, injectable } from 'inversify';\nimport { INTERNAL_APP_CONTAINER, type MangoPlugin } from '@ragemp-mango/core/app';\nimport { ADD_WEBVIEW, WEBVIEW_SERVICE } from '../constants';\nimport type { ClientLoggerService, ClientWebViewService } from '../services';\nimport { LOGGER_SERVICE } from '@ragemp-mango/core';\nimport type { MultiplayerWebViewCreateOptionsDrawable, MultiplayerWebViewCreateOptionsOverlay } from '../interfaces';\n\n@injectable()\nexport class WebViewPlugin implements MangoPlugin {\n    @inject(INTERNAL_APP_CONTAINER) private readonly internalAppContainer: Container;\n    @inject(WEBVIEW_SERVICE) private readonly webViewService: ClientWebViewService;\n    @inject(LOGGER_SERVICE) private readonly loggerService: ClientLoggerService;\n\n    public async beforeLoad() {\n        const time = Date.now();\n\n        const addWebViews = this.internalAppContainer.isBound(ADD_WEBVIEW)\n            ? this.internalAppContainer.get<\n                  {\n                      id: string | number;\n                      options: MultiplayerWebViewCreateOptionsDrawable | MultiplayerWebViewCreateOptionsOverlay;\n                  }[]\n              >(ADD_WEBVIEW)\n            : [];\n        if (addWebViews.length === 0) return;\n\n        addWebViews.forEach((webView) => {\n            this.webViewService.create(webView.id, webView.options);\n        });\n\n        this.loggerService.log(`~lw~WebViews created ~lk~(${Date.now() - time}ms)`);\n    }\n}\n", "import type { ScriptEventHandler } from '@ragemp-mango/core/app';\n\nexport class RageMPClientScriptEvent 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 { ScriptEventHandler } from '@ragemp-mango/core/app';\nimport type { ClientEventEmmiter } from '../../interfaces/event';\nimport { RageMPClientScriptEvent } from './ragemp-script-event-handler';\n\nexport class ClientRageMPEventEmmiter implements ClientEventEmmiter {\n    private mapEventsShared: Record<string, string> = {\n        // Map alt:V event names to RageMP equivalents\n        'entityColShapeEnter': 'playerEnterColshape',\n        'entityColShapeLeave': 'playerExitColshape',\n        'keyUp': 'keyup',\n        'keyDown': 'keydown',\n        'playerVehicleEntered': 'playerEnterVehicle',\n        'playerVehicleLeft': 'playerLeaveVehicle',\n        'playerStartVehicleEnter': 'playerStartEnterVehicle',\n    };\n\n    constructor(private mapEvents: Record<string, string> = {}) {}\n\n    private getEventName(eventName: string): string {\n        return this.mapEventsShared[eventName] || this.mapEvents[eventName] || eventName;\n    }\n\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        const mappedEventName = this.getEventName(eventName);\n        mp.events.add(mappedEventName, listener);\n        return new RageMPClientScriptEvent(mappedEventName, listener);\n    }\n\n    once(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        const mappedEventName = this.getEventName(eventName);\n        const onceWrapper = (...args: any[]) => {\n            mp.events.remove(mappedEventName, onceWrapper);\n            listener(...args);\n        };\n        mp.events.add(mappedEventName, onceWrapper);\n        return new RageMPClientScriptEvent(mappedEventName, onceWrapper);\n    }\n\n    off(eventName: string, listener: (...args: any[]) => void): void {\n        mp.events.remove(eventName, listener);\n    }\n\n    emitServer(eventName: string, ...args: any[]): void {\n        // In RageMP, use mp.events.callRemote to send events to server\n        // Data must be JSON stringified because RAGE:MP doesn't properly serialize complex objects\n        const serializedArgs = args.map(arg => {\n            if (typeof arg === 'string') {\n                // Check if already JSON serialized\n                try {\n                    JSON.parse(arg);\n                    return arg; // Already serialized\n                } catch {\n                    return JSON.stringify(arg); // Plain string, serialize it\n                }\n            }\n            return JSON.stringify(arg);\n        });\n        mp.events.callRemote(eventName, ...serializedArgs);\n    }\n\n    onServer(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        // In RageMP, server events come through mp.events.add\n        // Events from server are received the same way as local events\n        const mappedEventName = this.getEventName(eventName);\n        mp.events.add(mappedEventName, listener);\n        return new RageMPClientScriptEvent(mappedEventName, listener);\n    }\n\n    onceServer(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        const mappedEventName = this.getEventName(eventName);\n        const onceWrapper = (...args: any[]) => {\n            mp.events.remove(mappedEventName, onceWrapper);\n            listener(...args);\n        };\n        mp.events.add(mappedEventName, onceWrapper);\n        return new RageMPClientScriptEvent(mappedEventName, onceWrapper);\n    }\n\n    offServer(eventName: string, listener: (...args: any[]) => void): void {\n        mp.events.remove(eventName, listener);\n    }\n}\n", "import type { MultiplayerWebView } from '../../interfaces/multiplayer';\n\nexport class RageMPWebView implements MultiplayerWebView {\n    private eventListeners: Map<string, Set<(...args: unknown[]) => void>> = new Map();\n\n    constructor(private $raw: BrowserMp) {}\n\n    public get valid(): boolean {\n        // RageMP browsers don't have a 'valid' property, check if it exists\n        return this.$raw !== null && this.$raw !== undefined;\n    }\n\n    public destroy(): void {\n        this.$raw.destroy();\n    }\n\n    public get url(): string {\n        return this.$raw.url;\n    }\n\n    public set url(value: string) {\n        this.$raw.url = value;\n    }\n\n    public get visible(): boolean {\n        return this.$raw.active;\n    }\n\n    public set visible(value: boolean) {\n        this.$raw.active = value;\n    }\n\n    emit(eventName: string, ...args: unknown[]): void {\n        // In RageMP, use browser.call() to send events to CEF\n        // Data must be JSON stringified because RAGE:MP doesn't properly serialize complex objects\n        const serializedArgs = args.map(arg => {\n            if (typeof arg === 'string') {\n                // Check if already JSON serialized\n                try {\n                    JSON.parse(arg);\n                    return arg; // Already serialized\n                } catch {\n                    return JSON.stringify(arg); // Plain string, serialize it\n                }\n            }\n            return JSON.stringify(arg);\n        });\n        this.$raw.call(eventName, ...serializedArgs);\n    }\n\n    emitRaw(eventName: string, ...args: unknown[]): void {\n        this.$raw.call(eventName, ...args);\n    }\n\n    reload(ignoreCache: boolean): void {\n        this.$raw.reload(ignoreCache);\n    }\n\n    on(eventName: string, listener: (...args: unknown[]) => void): void {\n        // In RageMP, we need to listen through mp.events for browser events\n        // We'll create a wrapper that filters by browser instance\n        if (!this.eventListeners.has(eventName)) {\n            this.eventListeners.set(eventName, new Set());\n        }\n        this.eventListeners.get(eventName)!.add(listener);\n\n        // Add a global event listener if this is the first for this event\n        const listeners = this.eventListeners.get(eventName)!;\n        if (listeners.size === 1) {\n            mp.events.add(eventName, (...args: unknown[]) => {\n                for (const l of listeners) {\n                    l(...args);\n                }\n            });\n        }\n    }\n\n    once(eventName: string, listener: (...args: unknown[]) => void): void {\n        const onceWrapper = (...args: unknown[]) => {\n            this.off(eventName, onceWrapper);\n            listener(...args);\n        };\n        this.on(eventName, onceWrapper);\n    }\n\n    off(eventName: string, listener: (...args: unknown[]) => void): void {\n        const listeners = this.eventListeners.get(eventName);\n        if (listeners) {\n            listeners.delete(listener);\n        }\n    }\n\n    execute(code: string): void {\n        this.$raw.execute(code);\n    }\n\n    markAsChat(): void {\n        this.$raw.markAsChat();\n    }\n\n    public get raw(): BrowserMp {\n        return this.$raw;\n    }\n}\n", "import type {\n    MultiplayerWebView,\n    MultiplayerWebViewCreateOptionsDrawable,\n    MultiplayerWebViewCreateOptionsOverlay,\n    MultiplayerWebViewManager,\n} from '../../interfaces/multiplayer';\nimport { RageMPWebView } from './ragemp-webview';\n\nexport class RageMPWebViewManager implements MultiplayerWebViewManager {\n    private webViews: Map<number, RageMPWebView> = new Map();\n    private idCounter: number = 0;\n\n    public create(options: MultiplayerWebViewCreateOptionsDrawable): MultiplayerWebView;\n    public create(options: MultiplayerWebViewCreateOptionsOverlay): MultiplayerWebView;\n    public create(options: MultiplayerWebViewCreateOptionsOverlay | MultiplayerWebViewCreateOptionsDrawable): MultiplayerWebView {\n        let raw: BrowserMp;\n\n        if ('drawable' in options) {\n            // RageMP doesn't support drawable/texture targets directly like alt:V\n            // We'll create a regular browser and log a warning\n            mp.console.logWarning('RageMP does not support drawable WebViews. Creating overlay browser instead.');\n            raw = mp.browsers.new(options.url);\n        } else {\n            raw = mp.browsers.new(options.url);\n            if (options.visible !== undefined) {\n                raw.active = options.visible;\n            }\n        }\n\n        const webView = new RageMPWebView(raw);\n        const id = this.idCounter++;\n        this.webViews.set(id, webView);\n\n        return webView;\n    }\n\n    public getByID(id: number): MultiplayerWebView | null {\n        // RageMP browsers are stored in mp.browsers pool\n        // We need to find by ID or return from our cache\n        const cached = this.webViews.get(id);\n        if (cached) {\n            return cached;\n        }\n\n        // Try to get from RageMP's browser pool\n        const browser = mp.browsers.at(id);\n        if (browser) {\n            const webView = new RageMPWebView(browser);\n            this.webViews.set(id, webView);\n            return webView;\n        }\n\n        return null;\n    }\n}\n", "import type { ClientEventEmmiter } from '../../interfaces';\nimport type { ClientMultiplayerService, MultiplayerWebViewManager } from '../../interfaces/multiplayer';\nimport { RageMPMultiplayerService } from '@ragemp-mango/core/app';\nimport { ClientRageMPEventEmmiter } from './ragemp-event-emmiter';\nimport { RageMPWebViewManager } from './ragemp-webview-manager';\n\nexport class ClientRageMPMultiplayerService extends RageMPMultiplayerService implements ClientMultiplayerService {\n    public override Events: ClientEventEmmiter;\n    public WebView: MultiplayerWebViewManager;\n\n    constructor() {\n        super();\n        this.Events = new ClientRageMPEventEmmiter();\n        this.WebView = new RageMPWebViewManager();\n    }\n\n    public setAudioFactory(_factory: any): void {\n        // RageMP doesn't have audio factory like alt:V\n    }\n\n    public setAudioFilterFactory(_factory: any): void {\n        // RageMP doesn't have audio filter factory\n    }\n\n    public setAudioOutputAttachedFactory(_factory: any): void {\n        // RageMP doesn't have audio output attached factory\n    }\n\n    public setAudioOutputFrontendFactory(_factory: any): void {\n        // RageMP doesn't have audio output frontend factory\n    }\n\n    public setAudioOutputWorldFactory(_factory: any): void {\n        // RageMP doesn't have audio output world factory\n    }\n\n    public setBlipFactory(factory: any): void {\n        if (factory && (mp as any).Blip) {\n            Object.assign((mp as any).Blip.prototype, factory);\n        }\n    }\n\n    public setMarkerFactory(factory: any): void {\n        if (factory && (mp as any).Marker) {\n            Object.assign((mp as any).Marker.prototype, factory);\n        }\n    }\n\n    public setColshapeFactory(factory: any): void {\n        if (factory && (mp as any).Colshape) {\n            Object.assign((mp as any).Colshape.prototype, factory);\n        }\n    }\n\n    public setCheckpointFactory(factory: any): void {\n        if (factory && (mp as any).Checkpoint) {\n            Object.assign((mp as any).Checkpoint.prototype, factory);\n        }\n    }\n\n    public setObjectFactory(factory: any): void {\n        if (factory && (mp as any).Object) {\n            Object.assign((mp as any).Object.prototype, factory);\n        }\n    }\n\n    public setLocalObjectFactory(_factory: any): void {\n        // RageMP doesn't have LocalObject like alt:V\n    }\n\n    public setPedFactory(factory: any): void {\n        if (factory && (mp as any).Ped) {\n            Object.assign((mp as any).Ped.prototype, factory);\n        }\n    }\n\n    public setLocalPedFactory(_factory: any): void {\n        // RageMP doesn't have LocalPed like alt:V\n    }\n\n    public setLocalPlayerFactory(_factory: any): void {\n        // RageMP doesn't have LocalPlayer factory - use mp.players.local\n    }\n\n    public setLocalVehicleFactory(_factory: any): void {\n        // RageMP doesn't have LocalVehicle like alt:V\n    }\n\n    public setPlayerFactory(factory: any): void {\n        if (factory && (mp as any).Player) {\n            Object.assign((mp as any).Player.prototype, factory);\n        }\n    }\n\n    public setRmlDocumentFactory(_factory: any): void {\n        // RageMP doesn't have RmlDocument like alt:V\n    }\n\n    public setTextLabelFactory(factory: any): void {\n        if (factory && (mp as any).TextLabel) {\n            Object.assign((mp as any).TextLabel.prototype, factory);\n        }\n    }\n\n    public setVehicleFactory(factory: any): void {\n        if (factory && (mp as any).Vehicle) {\n            Object.assign((mp as any).Vehicle.prototype, factory);\n        }\n    }\n\n    public setVirtualEntityGroupFactory(_factory: any): void {\n        // RageMP doesn't have VirtualEntityGroup\n    }\n\n    public setVirtualEntityFactory(_factory: any): void {\n        // RageMP doesn't have VirtualEntity\n    }\n\n    public setWebSocketClientFactory(_factory: any): void {\n        // RageMP doesn't have WebSocketClient factory\n    }\n\n    public setWebViewFactory(factory: any): void {\n        if (factory && (mp as any).Browser) {\n            Object.assign((mp as any).Browser.prototype, factory);\n        }\n    }\n}\n", "import { UseFilters as $UseFilters, type Newable } from '@ragemp-mango/core';\nimport type { ErrorFilter } from '../../interfaces';\n\nexport function UseFilters(...filters: (Newable<ErrorFilter> | ErrorFilter)[]) {\n    return $UseFilters(...filters);\n}\n", "import { OnInternal, OnceInternal } from '@ragemp-mango/core';\nimport { INTERNAL_EVENTS } from '../../../constants';\n\nexport function OnScriptRPC() {\n    return OnInternal(INTERNAL_EVENTS.SCRIPT_RPC);\n}\n\nexport function OnceScriptRPC() {\n    return OnceInternal(INTERNAL_EVENTS.SCRIPT_RPC);\n}\nexport function OnScriptRPCAnswer() {\n    return OnInternal(INTERNAL_EVENTS.SCRIPT_RPC_ANSWER);\n}\n\nexport function OnceScriptRPCAnswer() {\n    return OnceInternal(INTERNAL_EVENTS.SCRIPT_RPC_ANSWER);\n}\nexport function OnKeyBoardEvent() {\n    return OnInternal(INTERNAL_EVENTS.KEYBOARD_EVENT);\n}\n\nexport function OnceKeyBoardEvent() {\n    return OnceInternal(INTERNAL_EVENTS.KEYBOARD_EVENT);\n}\nexport function OnKeyUp() {\n    return OnInternal(INTERNAL_EVENTS.KEY_UP);\n}\n\nexport function OnceKeyUp() {\n    return OnceInternal(INTERNAL_EVENTS.KEY_UP);\n}\nexport function OnKeyDown() {\n    return OnInternal(INTERNAL_EVENTS.KEY_DOWN);\n}\n\nexport function OnceKeyDown() {\n    return OnceInternal(INTERNAL_EVENTS.KEY_DOWN);\n}\nexport function OnWebViewEvent() {\n    return OnInternal(INTERNAL_EVENTS.WEB_VIEW_EVENT);\n}\n\nexport function OnceWebViewEvent() {\n    return OnceInternal(INTERNAL_EVENTS.WEB_VIEW_EVENT);\n}\nexport function OnWebSocketEvent() {\n    return OnInternal(INTERNAL_EVENTS.WEB_SOCKET_EVENT);\n}\n\nexport function OnceWebSocketEvent() {\n    return OnceInternal(INTERNAL_EVENTS.WEB_SOCKET_EVENT);\n}\nexport function OnAudioEvent() {\n    return OnInternal(INTERNAL_EVENTS.AUDIO_EVENT);\n}\n\nexport function OnceAudioEvent() {\n    return OnceInternal(INTERNAL_EVENTS.AUDIO_EVENT);\n}\nexport function OnRmluiEvent() {\n    return OnInternal(INTERNAL_EVENTS.RMLUI_EVENT);\n}\n\nexport function OnceRmluiEvent() {\n    return OnceInternal(INTERNAL_EVENTS.RMLUI_EVENT);\n}\nexport function OnWindowFocusChange() {\n    return OnInternal(INTERNAL_EVENTS.WINDOW_FOCUS_CHANGE);\n}\n\nexport function OnceWindowFocusChange() {\n    return OnceInternal(INTERNAL_EVENTS.WINDOW_FOCUS_CHANGE);\n}\nexport function OnWindowResolutionChange() {\n    return OnInternal(INTERNAL_EVENTS.WINDOW_RESOLUTION_CHANGE);\n}\n\nexport function OnceWindowResolutionChange() {\n    return OnceInternal(INTERNAL_EVENTS.WINDOW_RESOLUTION_CHANGE);\n}\nexport function OnConnectionComplete() {\n    return OnInternal(INTERNAL_EVENTS.CONNECTION_COMPLETE);\n}\n\nexport function OnceConnectionComplete() {\n    return OnceInternal(INTERNAL_EVENTS.CONNECTION_COMPLETE);\n}\nexport function OnDisconnect() {\n    return OnInternal(INTERNAL_EVENTS.DISCONNECT);\n}\n\nexport function OnceDisconnect() {\n    return OnceInternal(INTERNAL_EVENTS.DISCONNECT);\n}\nexport function OnSpawned() {\n    return OnInternal(INTERNAL_EVENTS.SPAWNED);\n}\n\nexport function OnceSpawned() {\n    return OnceInternal(INTERNAL_EVENTS.SPAWNED);\n}\nexport function OnGameEntityCreate() {\n    return OnInternal(INTERNAL_EVENTS.GAME_ENTITY_CREATE);\n}\n\nexport function OnceGameEntityCreate() {\n    return OnceInternal(INTERNAL_EVENTS.GAME_ENTITY_CREATE);\n}\nexport function OnGameEntityDestroy() {\n    return OnInternal(INTERNAL_EVENTS.GAME_ENTITY_DESTROY);\n}\n\nexport function OnceGameEntityDestroy() {\n    return OnceInternal(INTERNAL_EVENTS.GAME_ENTITY_DESTROY);\n}\nexport function OnEntityHitEntity() {\n    return OnInternal(INTERNAL_EVENTS.ENTITY_HIT_ENTITY);\n}\n\nexport function OnceEntityHitEntity() {\n    return OnceInternal(INTERNAL_EVENTS.ENTITY_HIT_ENTITY);\n}\nexport function OnTaskChange() {\n    return OnInternal(INTERNAL_EVENTS.TASK_CHANGE);\n}\n\nexport function OnceTaskChange() {\n    return OnceInternal(INTERNAL_EVENTS.TASK_CHANGE);\n}\nexport function OnPlayerWeaponShoot() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_WEAPON_SHOOT);\n}\n\nexport function OncePlayerWeaponShoot() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_WEAPON_SHOOT);\n}\nexport function OnPlayerBulletHit() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_BULLET_HIT);\n}\n\nexport function OncePlayerBulletHit() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_BULLET_HIT);\n}\nexport function OnPlayerWeaponChange() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_WEAPON_CHANGE);\n}\n\nexport function OncePlayerWeaponChange() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_WEAPON_CHANGE);\n}\nexport function OnPlayerStartVehicleEnter() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_START_VEHICLE_ENTER);\n}\n\nexport function OncePlayerStartVehicleEnter() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_START_VEHICLE_ENTER);\n}\nexport function OnPlayerStartVehicleLeave() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_START_VEHICLE_LEAVE);\n}\n\nexport function OncePlayerStartVehicleLeave() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_START_VEHICLE_LEAVE);\n}\nexport function OnPlayerVehicleEntered() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_ENTERED);\n}\n\nexport function OncePlayerVehicleEntered() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_ENTERED);\n}\nexport function OnPlayerVehicleLeft() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_LEFT);\n}\n\nexport function OncePlayerVehicleLeft() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_LEFT);\n}\nexport function OnPlayerVehicleSeatChange() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_SEAT_CHANGE);\n}\n\nexport function OncePlayerVehicleSeatChange() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_VEHICLE_SEAT_CHANGE);\n}\nexport function OnVoiceConnection() {\n    return OnInternal(INTERNAL_EVENTS.VOICE_CONNECTION);\n}\n\nexport function OnceVoiceConnection() {\n    return OnceInternal(INTERNAL_EVENTS.VOICE_CONNECTION);\n}\nexport function OnPlayerStartTalking() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_START_TALKING);\n}\n\nexport function OncePlayerStartTalking() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_START_TALKING);\n}\nexport function OnPlayerStopTalking() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_STOP_TALKING);\n}\n\nexport function OncePlayerStopTalking() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_STOP_TALKING);\n}\n\nexport function OnWorldObjectPositionChange() {\n    return OnInternal(INTERNAL_EVENTS.WORLD_OBJECT_POSITION_CHANGE);\n}\n\nexport function OnceWorldObjectPositionChange() {\n    return OnceInternal(INTERNAL_EVENTS.WORLD_OBJECT_POSITION_CHANGE);\n}\nexport function OnWorldObjectStreamIn() {\n    return OnInternal(INTERNAL_EVENTS.WORLD_OBJECT_STREAM_IN);\n}\n\nexport function OnceWorldObjectStreamIn() {\n    return OnceInternal(INTERNAL_EVENTS.WORLD_OBJECT_STREAM_IN);\n}\nexport function OnWorldObjectStreamOut() {\n    return OnInternal(INTERNAL_EVENTS.WORLD_OBJECT_STREAM_OUT);\n}\n\nexport function OnceWorldObjectStreamOut() {\n    return OnceInternal(INTERNAL_EVENTS.WORLD_OBJECT_STREAM_OUT);\n}\nexport function OnEvent() {\n    return OnInternal(INTERNAL_EVENTS.EVENT);\n}\n\nexport function OnceEvent() {\n    return OnceInternal(INTERNAL_EVENTS.EVENT);\n}\nexport function OnBaseObjectCreate() {\n    return OnInternal(INTERNAL_EVENTS.BASE_OBJECT_CREATE);\n}\n\nexport function OnceBaseObjectCreate() {\n    return OnceInternal(INTERNAL_EVENTS.BASE_OBJECT_CREATE);\n}\nexport function OnBaseObjectRemove() {\n    return OnInternal(INTERNAL_EVENTS.BASE_OBJECT_REMOVE);\n}\n\nexport function OnceBaseObjectRemove() {\n    return OnceInternal(INTERNAL_EVENTS.BASE_OBJECT_REMOVE);\n}\nexport function OnNetOwnerChange() {\n    return OnInternal(INTERNAL_EVENTS.NET_OWNER_CHANGE);\n}\n\nexport function OnceNetOwnerChange() {\n    return OnceInternal(INTERNAL_EVENTS.NET_OWNER_CHANGE);\n}\nexport function OnWeaponDamage() {\n    return OnInternal(INTERNAL_EVENTS.WEAPON_DAMAGE);\n}\n\nexport function OnceWeaponDamage() {\n    return OnceInternal(INTERNAL_EVENTS.WEAPON_DAMAGE);\n}\nexport function OnMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.META_CHANGE);\n}\n\nexport function OnceMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.META_CHANGE);\n}\nexport function OnLocalMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.LOCAL_META_CHANGE);\n}\n\nexport function OnceLocalMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.LOCAL_META_CHANGE);\n}\nexport function OnSyncedMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.SYNCED_META_CHANGE);\n}\n\nexport function OnceSyncedMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.SYNCED_META_CHANGE);\n}\nexport function OnStreamSyncedMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.STREAM_SYNCED_META_CHANGE);\n}\n\nexport function OnceStreamSyncedMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.STREAM_SYNCED_META_CHANGE);\n}\nexport function OnGlobalMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.GLOBAL_META_CHANGE);\n}\n\nexport function OnceGlobalMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.GLOBAL_META_CHANGE);\n}\nexport function OnGlobalSyncedMetaChange() {\n    return OnInternal(INTERNAL_EVENTS.GLOBAL_SYNCED_META_CHANGE);\n}\n\nexport function OnceGlobalSyncedMetaChange() {\n    return OnceInternal(INTERNAL_EVENTS.GLOBAL_SYNCED_META_CHANGE);\n}\nexport function OnEntityColShapeEnter() {\n    return OnInternal(INTERNAL_EVENTS.ENTITY_COL_SHAPE_ENTER);\n}\n\nexport function OnceEntityColShapeEnter() {\n    return OnceInternal(INTERNAL_EVENTS.ENTITY_COL_SHAPE_ENTER);\n}\nexport function OnEntityColShapeLeave() {\n    return OnInternal(INTERNAL_EVENTS.ENTITY_COL_SHAPE_LEAVE);\n}\n\nexport function OnceEntityColShapeLeave() {\n    return OnceInternal(INTERNAL_EVENTS.ENTITY_COL_SHAPE_LEAVE);\n}\nexport function OnEntityCheckpointEnter() {\n    return OnInternal(INTERNAL_EVENTS.ENTITY_CHECKPOINT_ENTER);\n}\n\nexport function OnceEntityCheckpointEnter() {\n    return OnceInternal(INTERNAL_EVENTS.ENTITY_CHECKPOINT_ENTER);\n}\nexport function OnEntityCheckpointLeave() {\n    return OnInternal(INTERNAL_EVENTS.ENTITY_CHECKPOINT_LEAVE);\n}\n\nexport function OnceEntityCheckpointLeave() {\n    return OnceInternal(INTERNAL_EVENTS.ENTITY_CHECKPOINT_LEAVE);\n}\nexport function OnColShapeEvent() {\n    return OnInternal(INTERNAL_EVENTS.COL_SHAPE_EVENT);\n}\n\nexport function OnceColShapeEvent() {\n    return OnceInternal(INTERNAL_EVENTS.COL_SHAPE_EVENT);\n}\nexport function OnConsoleCommand() {\n    return OnInternal(INTERNAL_EVENTS.CONSOLE_COMMAND);\n}\n\nexport function OnceConsoleCommand() {\n    return OnceInternal(INTERNAL_EVENTS.CONSOLE_COMMAND);\n}\nexport function OnError() {\n    return OnInternal(INTERNAL_EVENTS.ERROR);\n}\n\nexport function OnceError() {\n    return OnceInternal(INTERNAL_EVENTS.ERROR);\n}\nexport function OnLocalScriptEvent() {\n    return OnInternal(INTERNAL_EVENTS.LOCAL_SCRIPT_EVENT);\n}\n\nexport function OnceLocalScriptEvent() {\n    return OnceInternal(INTERNAL_EVENTS.LOCAL_SCRIPT_EVENT);\n}\nexport function OnRemoteScriptEvent() {\n    return OnInternal(INTERNAL_EVENTS.REMOTE_SCRIPT_EVENT);\n}\n\nexport function OnceRemoteScriptEvent() {\n    return OnceInternal(INTERNAL_EVENTS.REMOTE_SCRIPT_EVENT);\n}\nexport function OnResourceStart() {\n    return OnInternal(INTERNAL_EVENTS.RESOURCE_START);\n}\n\nexport function OnceResourceStart() {\n    return OnceInternal(INTERNAL_EVENTS.RESOURCE_START);\n}\nexport function OnResourceStop() {\n    return OnInternal(INTERNAL_EVENTS.RESOURCE_STOP);\n}\n\nexport function OnceResourceStop() {\n    return OnceInternal(INTERNAL_EVENTS.RESOURCE_STOP);\n}\nexport function OnResourceError() {\n    return OnInternal(INTERNAL_EVENTS.RESOURCE_ERROR);\n}\n\nexport function OnceResourceError() {\n    return OnceInternal(INTERNAL_EVENTS.RESOURCE_ERROR);\n}\n", "import { createEventDecorator } from '@ragemp-mango/core';\n\nexport function OnServer<E extends keyof MangoEvents.CustomServerToPlayerEvent>(eventName?: E): MethodDecorator;\nexport function OnServer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>): MethodDecorator;\nexport function OnServer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>) {\n    return createEventDecorator('onServer', eventName);\n}\n", "import { OnWebView as $OnWebView } from '@ragemp-mango/core';\n\nexport function OnWebView<E extends keyof MangoEvents.CustomWebViewToClientEvent>(id: string | number, eventName?: E): MethodDecorator;\nexport function OnWebView<E extends string>(\n    id: string | number,\n    eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>,\n): MethodDecorator;\nexport function OnWebView<E extends string>(id: string | number, eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>) {\n    return $OnWebView(id, eventName);\n}\n", "import { On as $On } from '@ragemp-mango/core';\n\nexport function On<E extends keyof MangoEvents.CustomClientEvent>(eventName?: E): MethodDecorator;\nexport function On<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomClientEvent>): MethodDecorator;\nexport function On<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomClientEvent>) {\n    return $On(eventName);\n}\n", "import { createEventDecorator } from '@ragemp-mango/core';\n\nexport function OnceServer<E extends keyof MangoEvents.CustomServerToPlayerEvent>(eventName?: E): MethodDecorator;\nexport function OnceServer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>): MethodDecorator;\nexport function OnceServer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>) {\n    return createEventDecorator('onceServer', eventName);\n}\n", "import { OnceWebView as $OnceWebView } from '@ragemp-mango/core';\n\nexport function OnceWebView<E extends keyof MangoEvents.CustomWebViewToClientEvent>(id: string | number, eventName?: E): MethodDecorator;\nexport function OnceWebView<E extends string>(\n    id: string | number,\n    eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>,\n): MethodDecorator;\nexport function OnceWebView<E extends string>(id: string | number, eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>) {\n    return $OnceWebView(id, eventName);\n}\n", "import { Once as $Once } from '@ragemp-mango/core';\n\nexport function Once<E extends keyof MangoEvents.CustomClientEvent>(eventName?: E): MethodDecorator;\nexport function Once<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomClientEvent>): MethodDecorator;\nexport function Once<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomClientEvent>) {\n    return $Once(eventName);\n}\n", "import type { Guard } from '../../interfaces';\nimport { UseGuards as $UseGuards, type Newable } from '@ragemp-mango/core';\n\nexport function UseGuards(...guards: (Newable<Guard> | Guard)[]) {\n    return $UseGuards(...guards);\n}\n", "import type { Interceptor } from '../../interfaces';\nimport { UseInterceptors as $UseInterceptors, type Newable } from '@ragemp-mango/core';\n\nexport function UseInterceptors(...interceptors: (Newable<Interceptor> | Interceptor)[]) {\n    return $UseInterceptors(...interceptors);\n}\n", "import { OnRequest as $OnRequest } from '@ragemp-mango/core';\n\nexport function OnRequest<E extends keyof MangoRPC.CustomClientRPC>(rpcName?: E): MethodDecorator;\nexport function OnRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomClientRPC>): MethodDecorator;\nexport function OnRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomClientRPC>) {\n    return $OnRequest(rpcName);\n}\n", "import { createRPCDecorator } from '@ragemp-mango/core';\n\nexport function OnServerRequest<E extends keyof MangoRPC.CustomServerToClientRPC>(rpcName?: E): MethodDecorator;\nexport function OnServerRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomServerToClientRPC>): MethodDecorator;\nexport function OnServerRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomServerToClientRPC>) {\n    return createRPCDecorator('onServerRequest', rpcName);\n}\n", "import { OnWebViewRequest as $OnWebViewRequest } from '@ragemp-mango/core';\n\nexport function OnWebViewRequest<E extends keyof MangoRPC.CustomWebViewToClientRPC>(id: string | number, rpcName?: E): MethodDecorator;\nexport function OnWebViewRequest<E extends string>(\n    id: string | number,\n    rpcName?: Exclude<E, keyof MangoRPC.CustomWebViewToClientRPC>,\n): MethodDecorator;\nexport function OnWebViewRequest<E extends string>(id: string | number, rpcName?: Exclude<E, keyof MangoRPC.CustomWebViewToClientRPC>) {\n    return $OnWebViewRequest(id, rpcName);\n}\n", "import { AppBuilder, AppEnviroment, createAppBuilder as $createAppBuilder } from '@ragemp-mango/core/app';\nimport { ADD_WEBVIEW } from './constants';\nimport { EventMediatorPlugin, RPCPlugin, ServiceBinderPlugin, WebViewPlugin } from './plugins';\nimport type {\n    ClientMultiplayerService,\n    ErrorFilter,\n    Guard,\n    Interceptor,\n    MultiplayerWebViewCreateOptionsDrawable,\n    MultiplayerWebViewCreateOptionsOverlay,\n} from './interfaces';\nimport { ClientRageMPMultiplayerService } from './multiplayer/ragemp';\n\nconst multiplayerService: ClientMultiplayerService = new ClientRageMPMultiplayerService();\n\nclass ClientAppBuilder extends AppBuilder<Guard, Interceptor, ErrorFilter> {\n    public addWebView(id: string | number, options: MultiplayerWebViewCreateOptionsDrawable): ClientAppBuilder;\n    public addWebView(id: string | number, options: MultiplayerWebViewCreateOptionsOverlay): ClientAppBuilder;\n    public addWebView(id: string | number, options: MultiplayerWebViewCreateOptionsOverlay) {\n        const addWebViews = this.internalAppContainer.isBound(ADD_WEBVIEW)\n            ? this.internalAppContainer.get<\n                  {\n                      id: string | number;\n                      options: MultiplayerWebViewCreateOptionsDrawable | MultiplayerWebViewCreateOptionsOverlay;\n                  }[]\n              >(ADD_WEBVIEW)\n            : [];\n        if (this.internalAppContainer.isBound(ADD_WEBVIEW)) {\n            this.internalAppContainer.rebind(ADD_WEBVIEW).toConstantValue([...addWebViews, { id, options }]);\n        } else {\n            this.internalAppContainer.bind(ADD_WEBVIEW).toConstantValue([{ id, options }]);\n        }\n        return this;\n    }\n\n    public setAudioFactory(factory: unknown) {\n        multiplayerService.setAudioFactory(factory);\n    }\n\n    public setAudioFilterFactory(factory: unknown) {\n        multiplayerService.setAudioFilterFactory(factory);\n    }\n\n    public setAudioOutputAttachedFactory(factory: unknown) {\n        multiplayerService.setAudioOutputAttachedFactory(factory);\n    }\n\n    public setAudioOutputFrontendFactory(factory: unknown) {\n        multiplayerService.setAudioOutputFrontendFactory(factory);\n    }\n\n    public setAudioOutputWorldFactory(factory: unknown) {\n        multiplayerService.setAudioOutputWorldFactory(factory);\n    }\n\n    public setBlipFactory(factory: unknown) {\n        multiplayerService.setBlipFactory(factory);\n    }\n\n    public setMarkerFactory(factory: unknown) {\n        multiplayerService.setMarkerFactory(factory);\n    }\n\n    public setColShapeFactory(factory: unknown) {\n        multiplayerService.setColshapeFactory(factory);\n    }\n\n    public setCheckpointFactory(factory: unknown) {\n        multiplayerService.setCheckpointFactory(factory);\n    }\n\n    public setObjectFactory(factory: unknown) {\n        multiplayerService.setObjectFactory(factory);\n    }\n\n    public setLocalObjectFactory(factory: unknown) {\n        multiplayerService.setLocalObjectFactory(factory);\n    }\n\n    public setPedFactory(factory: unknown) {\n        multiplayerService.setPedFactory(factory);\n    }\n\n    public setLocalPedFactory(factory: unknown) {\n        multiplayerService.setLocalPedFactory(factory);\n    }\n\n    public setLocalPlayerFactory(factory: unknown) {\n        multiplayerService.setLocalPlayerFactory(factory);\n    }\n\n    public setLocalVehicleFactory(factory: unknown) {\n        multiplayerService.setLocalVehicleFactory(factory);\n    }\n\n    public setPlayerFactory(factory: unknown) {\n        multiplayerService.setPlayerFactory(factory);\n    }\n\n    public setRmlDocumentFactory(factory: unknown) {\n        multiplayerService.setRmlDocumentFactory(factory);\n    }\n\n    public setTextLabelFactory(factory: unknown) {\n        multiplayerService.setTextLabelFactory(factory);\n    }\n\n    public setVehicleFactory(factory: unknown) {\n        multiplayerService.setVehicleFactory(factory);\n    }\n\n    public setVirtualEntityGroupFactory(factory: unknown) {\n        multiplayerService.setVirtualEntityGroupFactory(factory);\n    }\n\n    public setVirtualEntityFactory(factory: unknown) {\n        multiplayerService.setVirtualEntityFactory(factory);\n    }\n\n    public setWebSocketClientFactory(factory: unknown) {\n        multiplayerService.setWebSocketClientFactory(factory);\n    }\n\n    public setWebViewFactory(factory: unknown) {\n        multiplayerService.setWebViewFactory(factory);\n    }\n}\n\nexport async function createAppBuilder() {\n    return await $createAppBuilder({\n        enviroment: AppEnviroment.Client,\n        plugins: [ServiceBinderPlugin, EventMediatorPlugin, RPCPlugin, WebViewPlugin],\n        multiplayerService,\n        appBuilderInherit: ClientAppBuilder,\n    });\n}\n\nexport * from './exports';\n\nimport './extension.d.ts';\n\n"],
  "mappings": "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",
  "names": ["AppEnviroment", "CoreMetadataKey", "EventDestination", "ExecutionContextType", "MethodParamType", "LOGGER_SERVICE", "EVENT_SERVICE", "RPC_SERVICE", "MODULE_CONTAINER", "REFLECTOR_SERVICE", "TIMER_SERVICE", "ErrorMessage", "InjectableScope", "RPCResultStatus", "__defProp", "__name", "generateRandomId", "Math", "random", "toString", "substring", "isUndefined", "__name", "obj", "isObject", "fn", "isNil", "isFunction", "val", "isString", "isNumber", "isConstructor", "isEmpty", "array", "length", "isSymbol", "isAsyncFunction", "name", "isBoolean", "isPromise", "Promise", "inject", "injectable", "Container", "ModuleMetadataReader", "loggerService", "read", "module", "isFunction", "options", "Reflect", "getMetadata", "CoreMetadataKey", "Module", "exportTokens", "getExportTokens", "exports", "separatedProviders", "separateProviders", "providers", "controllers", "imports", "getPipeline", "classRef", "global", "GlobalModule", "container", "Promise", "error", "Error", "ErrorMessage", "InvalidModuleDefinition", "guards", "Guards", "interceptors", "Interceptors", "pipes", "Pipes", "errorFilters", "ErrorFilters", "map", "providerExport", "hasOwnMetadata", "Injectable", "InvalidExportDefinition", "isString", "isSymbol", "provide", "provider", "injectableMetadata", "isNil", "InvalidProviderDefinition", "useClass", "scope", "reduce", "acc", "includes", "externalProviders", "set", "internalProviders", "Map", "ModuleContainer", "Container", "parent", "metadata", "instance", "repetitiveImports", "Set", "injectable", "inject", "ExecutionContextBase", "$type", "$classRef", "$handler", "$request", "$response", "$name", "type", "classRef", "handler", "request", "response", "name", "MangoRequestBase", "$body", "$player", "body", "player", "MangoResponseBase", "$loggerService", "$sendListeners", "Set", "$errorListeners", "$isSent", "send", "data", "error", "Error", "ErrorMessage", "RPCResponseAlreadySent", "forEach", "listener", "message", "details", "$onSend", "add", "$onError", "TreeNode", "value", "children", "addChild", "child", "push", "removeChild", "index", "indexOf", "splice", "Tree", "root", "traverse", "callback", "traverseNode", "node", "forEach", "asyncTraverse", "Promise", "all", "map", "toString", "result", "lines", "depth", "repeat", "join", "defaultControllerOptions", "prefix", "validateControllerOptions", "options", "isNil", "valid", "value", "isObject", "error", "isString", "validateErrorFilter", "isFunction", "prototype", "catch", "validatePipe", "transform", "validateEventParameter", "key", "isNumber", "index", "type", "MethodParamType", "Body", "Player", "data", "Custom", "factory", "Param", "Index", "Request", "Response", "Array", "isArray", "pipes", "pipe", "validateEventMetadata", "name", "method", "params", "param", "validateGuard", "canActivate", "validateInterceptor", "intercept", "validateInjectionToken", "isSymbol", "validateProvider", "provide", "validateClassProvider", "validateValueProvider", "validateFactoryProvider", "validateExistingProvider", "scope", "InjectableScope", "Singleton", "Object", "values", "includes", "validateOptionalFactoryDependency", "token", "useFactory", "inject", "validateModuleOptions", "isDynamic", "controllers", "imports", "providers", "exports", "module", "global", "isBoolean", "imported", "isPromise", "controller", "provider", "exportItem", "defaultInjectableOptions", "validateInjectableMetadata", "INTERNAL_APP_CONTAINER", "GLOBAL_APP_CONTAINER", "APP_ENVIROMENT", "GLOBAL_GUARDS", "GLOBAL_INTERCEPTORS", "GLOBAL_PIPES", "GLOBAL_ERROR_FILTERS", "PLUGINS", "ENABLE_SHUTDOWN_HOOKS", "CONTAINER_OPTIONS", "MANGO_LOG_PREFIX", "MANGO_REQUEST_FACTORY", "MANGO_RESPONSE_FACTORY", "EXECUTION_CONTEXT_FACTORY", "MULTIPLAYER_SERVICE", "RPC_RESULT_TIMEOUT", "success", "error", "message", "status", "RPCResultStatus", "Timeout", "RPC_RESULT_HANDLER_NOT_FOUND", "HandlerNotFound", "RPC_RESULT_UNKNOWN", "Unknown", "RPC_RESULT_PLAYER_DISCONNECTED", "PlayerDisconnected", "RPC_RESULT_PLAYER_NOT_FOUND", "PlayerNotFound", "MangoError", "Error", "status", "RPCResultStatus", "Unknown", "details", "message", "GuardCancelError", "CancelledByGuard", "GuardInvalidReturnError", "InvalidGuardReturn", "TooManyRequests", "UnknownError", "inject", "injectable", "PipelineHandler", "loggerService", "goTroughGuards", "executionContext", "guards", "container", "guard", "instance", "isFunction", "get", "isObject", "isNil", "error", "Error", "ErrorMessage", "InvalidGuardDefinition", "canActivate", "call", "GuardInvalidReturnError", "GuardCancelError", "goThroughInterceptors", "interceptors", "callHandler", "interceptor", "InvalidInterceptorDefinition", "intercept", "goTroughPipes", "value", "pipes", "argumentMetadata", "pipe", "InvalidPipeDefinition", "Promise", "resolve", "transform", "ControllerFlowHandler", "appEnv", "pipelineHandler", "createArgs", "controller", "metadata", "player", "all", "params", "map", "param", "type", "data", "metatype", "request", "body", "owner", "undefined", "Array", "isArray", "factory", "AppEnviroment", "Server", "ControllerEventHandler", "multiplayerService", "eventService", "controllerFlowHandler", "createMangoRequest", "createExecutionContext", "registerEvent", "mappedErrorFilters", "event", "name", "handleEvent", "args", "parseInternalArgs", "webViewId", "InvalidEventType", "ExecutionContextType", "Event", "classRef", "prototype", "method", "controllerMethod", "handle", "isAsyncFunction", "apply", "return", "__name", "InvalidReturnInEvent", "length", "errorGroup", "find", "errorType", "InvalidErrorFilterDefinition", "catch", "ControllerMetadataReader", "read", "options", "Reflect", "getMetadata", "CoreMetadataKey", "Controller", "events", "getEvents", "rpcs", "getRPCs", "timers", "getTimers", "getPipeline", "ControllerEvents", "getMethodParams", "ControllerRPCs", "rpc", "ControllerParams", "sort", "a", "b", "index", "forEach", "InvalidParameterDecoratorUsage", "ResponseDecoratorNotAllowedOnEvents", "Client", "PlayerDecoratorNotAllowedOnClientEvents", "RPCNotAllowedInClient", "RPCNotAllowedInServer", "EventNotAllowedInClient", "EventNotAllowedInServer", "target", "Guards", "Interceptors", "Pipes", "errorFilters", "ErrorFilters", "Timers", "ControllerRPCHandler", "rpcService", "createMangoResponse", "registerRPC", "handleRPC", "InvalidRPCType", "response", "$onSend", "$onError", "RPC", "send", "result", "eventHandlers", "rpcHandlers", "injectable", "injectable", "inject", "optional", "inject", "injectable", "optional", "Container", "LazyServiceIdentifier", "minitz", "y", "m", "d", "h", "i", "s", "tz", "throwOnInvalid", "fromTZ", "tp", "fromTZISO", "localTimeStr", "parseISOLocal", "inDate", "Date", "UTC", "offset", "getTimezoneOffset", "dateGuess", "getTime", "dateOffsGuess", "dateGuess2", "dateOffsGuess2", "Error", "toTZ", "tzStr", "localDateString", "toLocaleString", "timeZone", "replace", "td", "getFullYear", "getMonth", "getDate", "getHours", "getMinutes", "getSeconds", "date", "timeZoneName", "split", "slice", "dateString", "parse", "dtStr", "pd", "isNaN", "stringEnd", "substring", "includes", "getUTCFullYear", "getUTCMonth", "getUTCDate", "getUTCHours", "getUTCMinutes", "getUTCSeconds", "CronOptions", "options", "name", "legacyMode", "paused", "maxRuns", "Infinity", "catch", "interval", "parseInt", "utcOffset", "unref", "startAt", "CronDate", "timezone", "stopAt", "LAST_OCCURRENCE", "ANY_OCCURRENCE", "OCCURRENCE_BITMASKS", "CronPattern", "pattern", "second", "Array", "fill", "minute", "hour", "day", "month", "dayOfWeek", "lastDayOfMonth", "starDOM", "starDOW", "prototype", "String", "TypeError", "indexOf", "handleNicknames", "trim", "parts", "length", "unshift", "replaceAlphaMonths", "replaceAlphaDays", "initDate", "getDay", "throwAtIllegalCharacters", "partToArray", "type", "conf", "valueIndexOffset", "defaultValue", "arr", "handleRangeWithStepping", "handleRange", "handleStepping", "handleNumber", "reValidCron", "test", "result", "extractNth", "setPart", "part", "index", "value", "Object", "hasOwnProperty", "call", "RangeError", "setNthWeekdayOfMonth", "matches", "match", "lower", "upper", "steps", "rest", "nth", "start", "cleanPattern", "toLowerCase", "nthWeekday", "DaysOfMonth", "RecursionSteps", "fromDate", "fromString", "fromCronDate", "isNthWeekdayOfMonth", "year", "weekday", "getUTCDay", "count", "daysInMonth", "ms", "getUTCMilliseconds", "apply", "getMilliseconds", "str", "findNext", "target", "originalTarget", "fDomWeekDay", "undefined", "dowMatch", "recurse", "doing", "res", "resetLevel", "increment", "hasPreviousRun", "internal", "isFunction", "v", "toString", "Function", "unrefTimer", "timer", "Deno", "maxDelay", "scheduledJobs", "Cron", "fnOrOptions1", "fnOrOptions2", "func", "_states", "kill", "blocking", "previousRun", "currentRun", "once", "currentTimeout", "existing", "find", "j", "push", "fn", "schedule", "nextRun", "prev", "next", "_next", "nextRuns", "n", "previous", "enumeration", "getPattern", "isRunning", "nextRunTime", "isScheduled", "notIsKilled", "isStopped", "isBusy", "msToNext", "stop", "clearTimeout", "jobIndex", "splice", "pause", "resume", "waitMs", "setTimeout", "_checkTrigger", "_trigger", "initiationDate", "context", "_e", "trigger", "now", "shouldRun", "isBlocked", "protect", "startAtInFutureWithInterval", "_calculatePreviousRun", "prevTimePlusInterval", "Controller", "options", "target", "Reflect", "hasMetadata", "CoreMetadataKey", "Error", "ErrorMessage", "DuplicateDecoratorUsage", "valid", "value", "error", "validateControllerOptions", "defineMetadata", "injectable", "Global", "GlobalModule", "Inject", "key", "propertyKey", "paramIndex", "isNil", "validateInjectionToken", "InvalidInjectionTokenSpecified", "token", "getMetadata", "InjectionTokenNotFound", "inject", "Injectable", "validateInjectableMetadata", "Module", "validateModuleOptions", "Optional", "optional", "SetMetadata", "decoratorFactory", "__name", "_method", "descriptor", "KEY", "Catch", "exceptions", "duplicates", "filter", "exception", "index", "indexOf", "length", "ExceptionHandlingConflict", "UseFilters", "filters", "method", "validatedFilters", "validateErrorFilter", "push", "AtLeastOneFilterRequired", "methodFilters", "ErrorFilters", "find", "includes", "DuplicateErrorFilterDetected", "classFilters", "AppRuntime", "eventHandler", "rpcHandler", "globalGuards", "globalInterceptors", "globalPipes", "globalErrorFilters", "loggerService", "enableShutdownHooks", "boot", "resolvedTree", "asyncTraverse", "node", "startTime", "Date", "now", "module", "instance", "container", "get", "metadata", "classRef", "controllers", "forEach", "controller", "internalProviders", "externalProviders", "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", "rpcs", "rpc", "registerRPC", "timers", "type", "createCronJob", "bind", "createEveryTick", "createInterval", "timeout", "createTimeout", "filterMap", "errors", "filterError", "ErrorAlreadyHandledByFilter", "Promise", "all", "map", "isObject", "providerInstance", "ModuleDependencyBinder", "globalAppContainer", "containerOptions", "ModuleContainer", "parent", "toSelf", "inSingletonScope", "global", "_", "provider", "bindProvider", "toDynamicValue", "importModule", "repetitiveImports", "MODULE_CONTAINER", "toConstantValue", "to", "TimerService", "provide", "useValue", "binding", "ctx", "deps", "dep", "err", "undefined", "useFactory", "scope", "inTransientScope", "inRequestScope", "useClass", "toService", "useExisting", "ModuleTreeScanner", "moduleMetadataReader", "controllerMetadataReader", "scan", "moduleMetadata", "read", "scanControllers", "moduleTree", "Tree", "scannedModules", "Map", "set", "importedModule", "imports", "scanModules", "root", "parentNode", "scannedModule", "add", "checkCircularDependency", "treeNode", "TreeNode", "addChild", "controllerMetadata", "parentMetadata", "CircularDependencyDetected", "RageMPScriptEvent", "eventName", "listener", "mp", "remove", "RageMPEventEmmiter", "emit", "args", "call", "on", "once", "onceWrapper", "off", "RageMPTimer", "lastTick", "id", "interval", "callback", "clearTimer", "RageMPTimers", "timerIncrementer", "everyTickHandlers", "isEveryTickRunning", "everyTickMainHandler", "values", "warningThreshold", "_value", "sourceLocationFrameSkipCount", "getByID", "createTimer", "clear", "callbackBind", "Array", "isArray", "timerId", "rageMPTimer", "delete", "setInterval", "cb", "clearInterval", "setTimeout", "clearTimeout", "everyTick", "bound", "isClientSide", "browsers", "e", "console", "logError", "intervalHandler", "_everyTickInterval", "size", "nextTick", "_name", "timeEnd", "RageMPMultiplayerService", "Timers", "Events", "parseInternalArgs", "player", "body", "arg", "message", "a", "JSON", "stringify", "String", "join", "logInfo", "logWarning", "logDebug", "App", "moduleTreeScanner", "moduleDependencyBinder", "appRuntime", "internalAppContainer", "plugins", "loaded", "start", "rootModule", "AppAlreadyLoaded", "runPluginMethods", "AppNotLoaded", "p", "plugin", "resolve", "AppBuilder", "enviroment", "multiplayerService", "globalContainerOptions", "useGlobalGuards", "validatedGuards", "guard", "validateGuard", "GLOBAL_GUARDS", "useGlobalInterceptors", "validatedInterceptors", "interceptor", "validateInterceptor", "GLOBAL_INTERCEPTORS", "useGlobalPipes", "validatedPipes", "pipe", "validatePipe", "GLOBAL_PIPES", "useGlobalFilters", "validatedFIlters", "GLOBAL_ERROR_FILTERS", "usePlugins", "internalPlugins", "PLUGINS", "rebind", "ENABLE_SHUTDOWN_HOOKS", "setContainerOptions", "onlyGlobal", "CONTAINER_OPTIONS", "build", "Container", "REFLECTOR_SERVICE", "ReflectorService", "MULTIPLAYER_SERVICE", "GLOBAL_APP_CONTAINER", "PipelineHandler", "ModuleMetadataReader", "ControllerMetadataReader", "ControllerFlowHandler", "ControllerEventHandler", "ControllerRPCHandler", "MangoRequestBase", "MANGO_REQUEST_FACTORY", "toFactory", "context", "request", "$body", "$player", "MangoResponseBase", "MANGO_RESPONSE_FACTORY", "ExecutionContextBase", "EXECUTION_CONTEXT_FACTORY", "response", "executionContext", "$type", "$request", "$response", "$handler", "$classRef", "$name", "pluginInstance", "onBuild", "isBound", "createAppBuilder", "appBuilderInherit", "INTERNAL_APP_CONTAINER", "APP_ENVIROMENT", "createEventDecorator", "webViewId", "isString", "EventNameMustBeString", "ControllerEvents", "some", "EventNameMustBeUnique", "OnInternal", "OnWebView", "On", "OnceInternal", "Once", "OnceWebView", "Body", "params", "ControllerParams", "param", "MultipleDecoratorsOnSingleParameterNotAllowed", "paramTypes", "metatype", "MethodParamType", "data", "Index", "isNumber", "IndexKeyMustBeNumber", "Request", "Req", "Param", "ParamKeyMustBeString", "Response", "Res", "UseGuards", "AtLeastOneGuardRequired", "methodGuards", "Guards", "classGuards", "UseInterceptors", "AtLeastOneInterceptorRequired", "methodInterceptors", "Interceptors", "classInterceptors", "UsePipes", "AtLeastOnePipeRequired", "methodPipes", "Pipes", "classPipes", "createRPCDecorator", "WebViewIdMustBeStringOrNumber", "RPCNameMustBeString", "ControllerRPCs", "RPCNameMustBeUnique", "OnRequest", "rpcName", "OnWebViewRequest", "createTimerDecorator", "TimerNameMustBeString", "Cron", "pattern", "EveryTick", "Interval", "nameOrTimeout", "intervalTimeout", "Timeout", "applyDecorators", "decorators", "decorator", "Function", "createParamDecorator", "factory", "Custom", "forwardRef", "fn", "LazyServiceIdentifier", "metadataKey", "getAll", "targets", "getAllAndMerge", "metadataCollection", "item", "isEmpty", "reduce", "b", "concat", "getAllAndOverride", "result", "createDecorator", "generateRandomId", "decoratorFn", "metadataValue", "transform", "$everyticks", "$intervals", "$timeouts", "$crons", "cronOptions", "cronJob", "everytick", "getByName", "getById", "injectable", "inject", "BaseEventService", "$localHandlers", "Set", "$internalHandlers", "$remoteHandlers", "$internalEventNames", "$eventEmmiter", "on", "eventName", "callback", "wrapper", "__name", "args", "eventHandler", "add", "once", "emit", "body", "$onInternal", "handler", "has", "Error", "ErrorMessage", "InvalidInternalEventName", "$onceInternal", "BaseRPCService", "$loggerService", "$TIMEOUT", "Map", "call", "rpcName", "options", "timeout", "Promise", "resolve", "get", "RPC_RESULT_HANDLER_NOT_FOUND", "timeoutId", "setTimeout", "RPC_RESULT_TIMEOUT", "result", "clearTimeout", "success", "status", "RPCResultStatus", "Success", "error", "MangoError", "message", "details", "RPC_RESULT_UNKNOWN", "onRequest", "RPCHandlerAlreadyExists", "rpcHandler", "destroy", "valid", "delete", "set", "WEBVIEW_SERVICE", "WEBVIEW_LIST_SERVICE", "ADD_WEBVIEW", "INTERNAL_EVENTS", "SCRIPT_RPC", "SCRIPT_RPC_ANSWER", "KEYBOARD_EVENT", "KEY_UP", "KEY_DOWN", "WEB_VIEW_EVENT", "WEB_SOCKET_EVENT", "AUDIO_EVENT", "RMLUI_EVENT", "WINDOW_FOCUS_CHANGE", "WINDOW_RESOLUTION_CHANGE", "CONNECTION_COMPLETE", "DISCONNECT", "SPAWNED", "GAME_ENTITY_CREATE", "GAME_ENTITY_DESTROY", "ENTITY_HIT_ENTITY", "TASK_CHANGE", "PLAYER_WEAPON_SHOOT", "PLAYER_BULLET_HIT", "PLAYER_WEAPON_CHANGE", "PLAYER_START_VEHICLE_ENTER", "PLAYER_START_VEHICLE_LEAVE", "PLAYER_VEHICLE_ENTERED", "PLAYER_VEHICLE_LEFT", "PLAYER_VEHICLE_SEAT_CHANGE", "VOICE_CONNECTION", "PLAYER_START_TALKING", "PLAYER_STOP_TALKING", "WORLD_OBJECT_POSITION_CHANGE", "WORLD_OBJECT_STREAM_IN", "WORLD_OBJECT_STREAM_OUT", "EVENT", "BASE_OBJECT_CREATE", "BASE_OBJECT_REMOVE", "NET_OWNER_CHANGE", "WEAPON_DAMAGE", "META_CHANGE", "LOCAL_META_CHANGE", "SYNCED_META_CHANGE", "STREAM_SYNCED_META_CHANGE", "GLOBAL_META_CHANGE", "GLOBAL_SYNCED_META_CHANGE", "ENTITY_COL_SHAPE_ENTER", "ENTITY_COL_SHAPE_LEAVE", "ENTITY_CHECKPOINT_ENTER", "ENTITY_CHECKPOINT_LEAVE", "COL_SHAPE_EVENT", "CONSOLE_COMMAND", "ERROR", "LOCAL_SCRIPT_EVENT", "REMOTE_SCRIPT_EVENT", "RESOURCE_START", "RESOURCE_STOP", "RESOURCE_ERROR", "inject", "injectable", "DefaultValuePipe", "defaultValue", "transform", "value", "isNil", "isNumber", "isNaN", "EventMediatorPlugin", "eventService", "webViewService", "loggerService", "beforeLoad", "time", "Date", "now", "onServer", "body", "get", "id", "emit", "eventName", "payload", "$onCreate", "webView", "on", "data", "JSON", "parse", "emitServer", "log", "inject", "injectable", "RPCPlugin", "eventService", "webViewService", "rpcService", "loggerService", "beforeLoad", "time", "Date", "now", "onServer", "payload", "rpcHandler", "$serverHandlers", "get", "rpcName", "isNil", "emitServer", "id", "RPC_RESULT_HANDLER_NOT_FOUND", "result", "handler", "body", "rpcResult", "success", "status", "RPCResultStatus", "Success", "error", "MangoError", "message", "details", "RPC_RESULT_UNKNOWN", "$onCreate", "webViewId", "webView", "on", "valid", "$webViewHandlers", "emit", "log", "Container", "inject", "injectable", "inject", "injectable", "ClientEventService", "BaseEventService", "$webViewListService", "$rageEvents", "multiplayerService", "Events", "$internalEventNames", "Set", "Object", "values", "INTERNAL_EVENTS", "onServer", "eventName", "callback", "wrapper", "args", "eventHandler", "$remoteHandlers", "add", "onceServer", "emitServer", "body", "onWebView", "id", "webView", "tryGet", "destroy", "off", "on", "onceWebView", "once", "emitWebView", "emit", "onRender", "onBrowserDomReady", "onBrowserLoadingFailed", "onPlayerChat", "onPlayerCommand", "onPlayerDeath", "onPlayerSpawn", "onPlayerEnterVehicle", "onPlayerExitVehicle", "onPlayerEnterColshape", "onPlayerExitColshape", "onPlayerEnterCheckpoint", "onPlayerExitCheckpoint", "injectable", "inject", "ErrorMessage", "InjectableScope", "RPCResultStatus", "INTERNAL_APP_CONTAINER", "GLOBAL_APP_CONTAINER", "APP_ENVIROMENT", "GLOBAL_GUARDS", "GLOBAL_INTERCEPTORS", "GLOBAL_PIPES", "GLOBAL_ERROR_FILTERS", "PLUGINS", "ENABLE_SHUTDOWN_HOOKS", "CONTAINER_OPTIONS", "MANGO_REQUEST_FACTORY", "MANGO_RESPONSE_FACTORY", "EXECUTION_CONTEXT_FACTORY", "MULTIPLAYER_SERVICE", "RPC_RESULT_TIMEOUT", "success", "error", "message", "status", "RPCResultStatus", "Timeout", "RPC_RESULT_HANDLER_NOT_FOUND", "HandlerNotFound", "RPC_RESULT_UNKNOWN", "Unknown", "RPC_RESULT_PLAYER_DISCONNECTED", "PlayerDisconnected", "RPC_RESULT_PLAYER_NOT_FOUND", "PlayerNotFound", "inject", "injectable", "generateRandomId", "Math", "random", "toString", "substring", "isUndefined", "obj", "isObject", "fn", "isNil", "isFunction", "val", "isString", "isNil", "val", "isUndefined", "isEmpty", "array", "length", "isSymbol", "isAsyncFunction", "isFunction", "name", "inject", "injectable", "MangoError", "Error", "status", "RPCResultStatus", "Unknown", "details", "message", "GuardCancelError", "MangoError", "RPCResultStatus", "CancelledByGuard", "GuardInvalidReturnError", "MangoError", "RPCResultStatus", "InvalidGuardReturn", "LOGGER_SERVICE", "EVENT_SERVICE", "RPC_SERVICE", "MODULE_CONTAINER", "REFLECTOR_SERVICE", "TIMER_SERVICE", "PipelineHandler", "loggerService", "goTroughGuards", "executionContext", "guards", "container", "guard", "instance", "isFunction", "get", "isObject", "isNil", "error", "Error", "ErrorMessage", "InvalidGuardDefinition", "canActivate", "call", "GuardInvalidReturnError", "GuardCancelError", "goThroughInterceptors", "interceptors", "callHandler", "interceptor", "InvalidInterceptorDefinition", "intercept", "goTroughPipes", "value", "pipes", "argumentMetadata", "pipe", "InvalidPipeDefinition", "Promise", "resolve", "transform", "AppEnviroment", "CoreMetadataKey", "ExecutionContextType", "inject", "injectable", "ControllerFlowHandler", "appEnv", "pipelineHandler", "createArgs", "controller", "executionContext", "metadata", "pipes", "player", "Promise", "all", "params", "map", "param", "argumentMetadata", "type", "data", "metatype", "goTroughPipes", "request", "body", "owner", "container", "isObject", "undefined", "Array", "isArray", "factory", "AppEnviroment", "Server", "ControllerEventHandler", "appEnv", "multiplayerService", "eventService", "controllerFlowHandler", "pipelineHandler", "loggerService", "createMangoRequest", "createExecutionContext", "registerEvent", "guards", "interceptors", "pipes", "mappedErrorFilters", "controller", "event", "type", "name", "body", "handleEvent", "args", "player", "parseInternalArgs", "webViewId", "AppEnviroment", "Server", "undefined", "error", "Error", "ErrorMessage", "InvalidEventType", "request", "executionContext", "ExecutionContextType", "Event", "metadata", "classRef", "prototype", "method", "goTroughGuards", "owner", "container", "createArgs", "controllerMethod", "instance", "handle", "isAsyncFunction", "apply", "callHandler", "return", "InvalidReturnInEvent", "length", "goThroughInterceptors", "errorGroup", "find", "errorType", "isFunction", "isNil", "get", "isObject", "InvalidErrorFilterDefinition", "Promise", "resolve", "catch", "call", "inject", "injectable", "ControllerMetadataReader", "appEnv", "loggerService", "read", "classRef", "options", "Reflect", "getMetadata", "CoreMetadataKey", "Controller", "events", "getEvents", "rpcs", "getRPCs", "timers", "getTimers", "getPipeline", "ControllerEvents", "prototype", "map", "event", "params", "getMethodParams", "method", "ControllerRPCs", "rpc", "metadata", "ControllerParams", "sort", "a", "b", "index", "forEach", "param", "error", "Error", "ErrorMessage", "InvalidParameterDecoratorUsage", "type", "ResponseDecoratorNotAllowedOnEvents", "AppEnviroment", "Client", "PlayerDecoratorNotAllowedOnClientEvents", "RPCNotAllowedInClient", "Server", "RPCNotAllowedInServer", "EventNotAllowedInClient", "EventNotAllowedInServer", "target", "guards", "Guards", "interceptors", "Interceptors", "pipes", "Pipes", "errorFilters", "ErrorFilters", "Timers", "inject", "injectable", "ControllerRPCHandler", "appEnv", "rpcService", "pipelineHandler", "controllerFlowHandler", "loggerService", "createMangoRequest", "createMangoResponse", "createExecutionContext", "registerRPC", "guards", "interceptors", "pipes", "mappedErrorFilters", "controller", "rpc", "type", "name", "body", "handleRPC", "player", "webViewId", "args", "AppEnviroment", "Server", "undefined", "error", "Error", "ErrorMessage", "InvalidRPCType", "Promise", "resolve", "request", "response", "$onSend", "data", "$onError", "executionContext", "ExecutionContextType", "RPC", "metadata", "classRef", "prototype", "method", "goTroughGuards", "owner", "container", "createArgs", "controllerMethod", "instance", "handle", "isAsyncFunction", "options", "send", "result", "apply", "callHandler", "return", "value", "length", "goThroughInterceptors", "errorGroup", "find", "errorType", "isFunction", "isNil", "get", "isObject", "InvalidErrorFilterDefinition", "catch", "call", "injectable", "Controller", "metadata", "instance", "owner", "eventHandlers", "rpcHandlers", "inject", "injectable", "ModuleMetadataReader", "loggerService", "read", "module", "isFunction", "options", "Reflect", "getMetadata", "CoreMetadataKey", "Module", "exportTokens", "getExportTokens", "exports", "separatedProviders", "separateProviders", "providers", "controllers", "imports", "getPipeline", "classRef", "global", "GlobalModule", "container", "Promise", "error", "Error", "ErrorMessage", "InvalidModuleDefinition", "guards", "Guards", "interceptors", "Interceptors", "pipes", "Pipes", "errorFilters", "ErrorFilters", "map", "providerExport", "hasOwnMetadata", "Injectable", "InvalidExportDefinition", "isString", "isSymbol", "provide", "provider", "injectableMetadata", "isNil", "InvalidProviderDefinition", "useClass", "scope", "reduce", "acc", "includes", "externalProviders", "set", "internalProviders", "Map", "Container", "ModuleContainer", "Container", "injectable", "Module", "controllers", "container", "parent", "metadata", "instance", "repetitiveImports", "Set", "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", "injectable", "validateErrorFilter", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "catch", "validatePipe", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "transform", "validateGuard", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "canActivate", "validateInterceptor", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "intercept", "defaultInjectableOptions", "scope", "InjectableScope", "Singleton", "injectable", "inject", "injectable", "injectable", "optional", "SetMetadata", "key", "value", "decoratorFactory", "target", "_method", "descriptor", "Reflect", "defineMetadata", "KEY", "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", "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", "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", "TreeNode", "value", "children", "addChild", "child", "push", "removeChild", "index", "indexOf", "splice", "Tree", "root", "traverse", "callback", "traverseNode", "node", "forEach", "asyncTraverse", "Promise", "all", "map", "toString", "result", "lines", "depth", "repeat", "join", "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", "injectable", "ExecutionContextBase", "$type", "$classRef", "$handler", "$request", "$response", "$name", "type", "classRef", "handler", "request", "response", "name", "injectable", "MangoRequestBase", "$body", "$player", "body", "player", "inject", "injectable", "MangoResponseBase", "$loggerService", "$sendListeners", "Set", "$errorListeners", "$isSent", "send", "data", "error", "Error", "ErrorMessage", "RPCResponseAlreadySent", "forEach", "listener", "message", "details", "$onSend", "add", "$onError", "injectable", "BaseEventService", "$localHandlers", "Set", "$internalHandlers", "$remoteHandlers", "$internalEventNames", "$eventEmmiter", "on", "eventName", "callback", "wrapper", "args", "eventHandler", "add", "once", "emit", "body", "$onInternal", "handler", "has", "Error", "ErrorMessage", "InvalidInternalEventName", "$onceInternal", "inject", "injectable", "BaseRPCService", "$loggerService", "$TIMEOUT", "$localHandlers", "Map", "call", "rpcName", "body", "options", "timeout", "Promise", "resolve", "handler", "get", "RPC_RESULT_HANDLER_NOT_FOUND", "timeoutId", "setTimeout", "RPC_RESULT_TIMEOUT", "result", "clearTimeout", "success", "status", "RPCResultStatus", "Success", "error", "MangoError", "message", "details", "RPC_RESULT_UNKNOWN", "onRequest", "has", "Error", "ErrorMessage", "RPCHandlerAlreadyExists", "rpcHandler", "destroy", "valid", "delete", "set", "inject", "Container", "injectable", "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", "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", "ClientLoggerService", "multiplayerService", "log", "args", "MANGO_LOG_PREFIX", "warn", "logWarning", "error", "logError", "debug", "logDebug", "inject", "injectable", "ClientRPCService", "BaseRPCService", "$eventService", "$serverHandlers", "Map", "$webViewHandlers", "callServer", "rpcName", "body", "options", "timeout", "$TIMEOUT", "$handleCall", "EventDestination", "Server", "onServerRequest", "handler", "has", "$loggerService", "error", "Error", "ErrorMessage", "RPCHandlerAlreadyExists", "rpcHandler", "destroy", "valid", "delete", "set", "callWebView", "id", "WebView", "onWebViewRequest", "key", "destination", "webViewId", "Promise", "resolve", "callId", "generateRandomId", "timeoutId", "onceHandle", "resultData", "clearTimeout", "eventHandler", "onceWebView", "onceServer", "payload", "source", "Client", "emitWebView", "emitServer", "setTimeout", "RPC_RESULT_TIMEOUT", "inject", "injectable", "WebViewListService", "$loggerService", "$webViews", "Map", "set", "id", "webView", "get", "tryGet", "isNil", "valid", "error", "Error", "ErrorMessage", "WebViewNotFound", "delete", "destroy", "inject", "injectable", "ClientWebViewService", "$loggerService", "$webViewListService", "multiplayer", "$createListeners", "create", "id", "options", "isString", "isNumber", "error", "Error", "ErrorMessage", "WebViewIdMustBeStringOrNumber", "webView", "WebView", "set", "forEach", "listener", "get", "tryGet", "destroy", "delete", "$onCreate", "push", "ServiceBinderPlugin", "internalAppContainer", "globalAppContainer", "onBuild", "time", "Date", "now", "bind", "LOGGER_SERVICE", "to", "ClientLoggerService", "inSingletonScope", "EVENT_SERVICE", "ClientEventService", "RPC_SERVICE", "ClientRPCService", "WEBVIEW_SERVICE", "ClientWebViewService", "WEBVIEW_LIST_SERVICE", "WebViewListService", "toConstantValue", "get", "loggerService", "log", "Container", "inject", "injectable", "WebViewPlugin", "internalAppContainer", "webViewService", "loggerService", "beforeLoad", "time", "Date", "now", "addWebViews", "isBound", "ADD_WEBVIEW", "get", "length", "forEach", "webView", "create", "id", "options", "log", "RageMPClientScriptEvent", "eventName", "listener", "destroy", "mp", "events", "remove", "ClientRageMPEventEmmiter", "mapEventsShared", "mapEvents", "getEventName", "eventName", "emit", "args", "mp", "events", "call", "on", "listener", "mappedEventName", "add", "RageMPClientScriptEvent", "once", "onceWrapper", "remove", "off", "emitServer", "serializedArgs", "map", "arg", "JSON", "parse", "stringify", "callRemote", "onServer", "onceServer", "offServer", "RageMPWebView", "eventListeners", "Map", "$raw", "valid", "undefined", "destroy", "url", "value", "visible", "active", "emit", "eventName", "args", "serializedArgs", "map", "arg", "JSON", "parse", "stringify", "call", "emitRaw", "reload", "ignoreCache", "on", "listener", "has", "set", "Set", "get", "add", "listeners", "size", "mp", "events", "l", "once", "onceWrapper", "off", "delete", "execute", "code", "markAsChat", "raw", "RageMPWebViewManager", "webViews", "Map", "idCounter", "create", "options", "raw", "mp", "console", "logWarning", "browsers", "new", "url", "visible", "undefined", "active", "webView", "RageMPWebView", "id", "set", "getByID", "cached", "get", "browser", "at", "ClientRageMPMultiplayerService", "RageMPMultiplayerService", "Events", "WebView", "ClientRageMPEventEmmiter", "RageMPWebViewManager", "setAudioFactory", "_factory", "setAudioFilterFactory", "setAudioOutputAttachedFactory", "setAudioOutputFrontendFactory", "setAudioOutputWorldFactory", "setBlipFactory", "factory", "mp", "Blip", "Object", "assign", "prototype", "setMarkerFactory", "Marker", "setColshapeFactory", "Colshape", "setCheckpointFactory", "Checkpoint", "setObjectFactory", "setLocalObjectFactory", "setPedFactory", "Ped", "setLocalPedFactory", "setLocalPlayerFactory", "setLocalVehicleFactory", "setPlayerFactory", "Player", "setRmlDocumentFactory", "setTextLabelFactory", "TextLabel", "setVehicleFactory", "Vehicle", "setVirtualEntityGroupFactory", "setVirtualEntityFactory", "setWebSocketClientFactory", "setWebViewFactory", "Browser", "UseFilters", "filters", "$UseFilters", "OnScriptRPC", "OnInternal", "INTERNAL_EVENTS", "SCRIPT_RPC", "OnceScriptRPC", "OnceInternal", "OnScriptRPCAnswer", "SCRIPT_RPC_ANSWER", "OnceScriptRPCAnswer", "OnKeyBoardEvent", "KEYBOARD_EVENT", "OnceKeyBoardEvent", "OnKeyUp", "KEY_UP", "OnceKeyUp", "OnKeyDown", "KEY_DOWN", "OnceKeyDown", "OnWebViewEvent", "WEB_VIEW_EVENT", "OnceWebViewEvent", "OnWebSocketEvent", "WEB_SOCKET_EVENT", "OnceWebSocketEvent", "OnAudioEvent", "AUDIO_EVENT", "OnceAudioEvent", "OnRmluiEvent", "RMLUI_EVENT", "OnceRmluiEvent", "OnWindowFocusChange", "WINDOW_FOCUS_CHANGE", "OnceWindowFocusChange", "OnWindowResolutionChange", "WINDOW_RESOLUTION_CHANGE", "OnceWindowResolutionChange", "OnConnectionComplete", "CONNECTION_COMPLETE", "OnceConnectionComplete", "OnDisconnect", "DISCONNECT", "OnceDisconnect", "OnSpawned", "SPAWNED", "OnceSpawned", "OnGameEntityCreate", "GAME_ENTITY_CREATE", "OnceGameEntityCreate", "OnGameEntityDestroy", "GAME_ENTITY_DESTROY", "OnceGameEntityDestroy", "OnEntityHitEntity", "ENTITY_HIT_ENTITY", "OnceEntityHitEntity", "OnTaskChange", "TASK_CHANGE", "OnceTaskChange", "OnPlayerWeaponShoot", "PLAYER_WEAPON_SHOOT", "OncePlayerWeaponShoot", "OnPlayerBulletHit", "PLAYER_BULLET_HIT", "OncePlayerBulletHit", "OnPlayerWeaponChange", "PLAYER_WEAPON_CHANGE", "OncePlayerWeaponChange", "OnPlayerStartVehicleEnter", "PLAYER_START_VEHICLE_ENTER", "OncePlayerStartVehicleEnter", "OnPlayerStartVehicleLeave", "PLAYER_START_VEHICLE_LEAVE", "OncePlayerStartVehicleLeave", "OnPlayerVehicleEntered", "PLAYER_VEHICLE_ENTERED", "OncePlayerVehicleEntered", "OnPlayerVehicleLeft", "PLAYER_VEHICLE_LEFT", "OncePlayerVehicleLeft", "OnPlayerVehicleSeatChange", "PLAYER_VEHICLE_SEAT_CHANGE", "OncePlayerVehicleSeatChange", "OnVoiceConnection", "VOICE_CONNECTION", "OnceVoiceConnection", "OnPlayerStartTalking", "PLAYER_START_TALKING", "OncePlayerStartTalking", "OnPlayerStopTalking", "PLAYER_STOP_TALKING", "OncePlayerStopTalking", "OnWorldObjectPositionChange", "WORLD_OBJECT_POSITION_CHANGE", "OnceWorldObjectPositionChange", "OnWorldObjectStreamIn", "WORLD_OBJECT_STREAM_IN", "OnceWorldObjectStreamIn", "OnWorldObjectStreamOut", "WORLD_OBJECT_STREAM_OUT", "OnceWorldObjectStreamOut", "OnEvent", "EVENT", "OnceEvent", "OnBaseObjectCreate", "BASE_OBJECT_CREATE", "OnceBaseObjectCreate", "OnBaseObjectRemove", "BASE_OBJECT_REMOVE", "OnceBaseObjectRemove", "OnNetOwnerChange", "NET_OWNER_CHANGE", "OnceNetOwnerChange", "OnWeaponDamage", "WEAPON_DAMAGE", "OnceWeaponDamage", "OnMetaChange", "META_CHANGE", "OnceMetaChange", "OnLocalMetaChange", "LOCAL_META_CHANGE", "OnceLocalMetaChange", "OnSyncedMetaChange", "SYNCED_META_CHANGE", "OnceSyncedMetaChange", "OnStreamSyncedMetaChange", "STREAM_SYNCED_META_CHANGE", "OnceStreamSyncedMetaChange", "OnGlobalMetaChange", "GLOBAL_META_CHANGE", "OnceGlobalMetaChange", "OnGlobalSyncedMetaChange", "GLOBAL_SYNCED_META_CHANGE", "OnceGlobalSyncedMetaChange", "OnEntityColShapeEnter", "ENTITY_COL_SHAPE_ENTER", "OnceEntityColShapeEnter", "OnEntityColShapeLeave", "ENTITY_COL_SHAPE_LEAVE", "OnceEntityColShapeLeave", "OnEntityCheckpointEnter", "ENTITY_CHECKPOINT_ENTER", "OnceEntityCheckpointEnter", "OnEntityCheckpointLeave", "ENTITY_CHECKPOINT_LEAVE", "OnceEntityCheckpointLeave", "OnColShapeEvent", "COL_SHAPE_EVENT", "OnceColShapeEvent", "OnConsoleCommand", "CONSOLE_COMMAND", "OnceConsoleCommand", "OnError", "ERROR", "OnceError", "OnLocalScriptEvent", "LOCAL_SCRIPT_EVENT", "OnceLocalScriptEvent", "OnRemoteScriptEvent", "REMOTE_SCRIPT_EVENT", "OnceRemoteScriptEvent", "OnResourceStart", "RESOURCE_START", "OnceResourceStart", "OnResourceStop", "RESOURCE_STOP", "OnceResourceStop", "OnResourceError", "RESOURCE_ERROR", "OnceResourceError", "OnServer", "eventName", "createEventDecorator", "OnWebView", "id", "eventName", "$OnWebView", "On", "eventName", "$On", "OnceServer", "eventName", "createEventDecorator", "OnceWebView", "id", "eventName", "$OnceWebView", "Once", "eventName", "$Once", "UseGuards", "guards", "$UseGuards", "UseInterceptors", "interceptors", "$UseInterceptors", "OnRequest", "rpcName", "$OnRequest", "OnServerRequest", "rpcName", "createRPCDecorator", "OnWebViewRequest", "id", "rpcName", "$OnWebViewRequest", "multiplayerService", "ClientRageMPMultiplayerService", "ClientAppBuilder", "AppBuilder", "addWebView", "id", "options", "addWebViews", "internalAppContainer", "isBound", "ADD_WEBVIEW", "get", "rebind", "toConstantValue", "bind", "setAudioFactory", "factory", "setAudioFilterFactory", "setAudioOutputAttachedFactory", "setAudioOutputFrontendFactory", "setAudioOutputWorldFactory", "setBlipFactory", "setMarkerFactory", "setColShapeFactory", "setColshapeFactory", "setCheckpointFactory", "setObjectFactory", "setLocalObjectFactory", "setPedFactory", "setLocalPedFactory", "setLocalPlayerFactory", "setLocalVehicleFactory", "setPlayerFactory", "setRmlDocumentFactory", "setTextLabelFactory", "setVehicleFactory", "setVirtualEntityGroupFactory", "setVirtualEntityFactory", "setWebSocketClientFactory", "setWebViewFactory", "createAppBuilder", "$createAppBuilder", "enviroment", "AppEnviroment", "Client", "plugins", "ServiceBinderPlugin", "EventMediatorPlugin", "RPCPlugin", "WebViewPlugin", "appBuilderInherit"]
}
