@ragemp-mango/server 5.0.0 → 5.0.1

package/dist/index.js

@@ -5447,16 +5447,39 @@ var ServerRageMPEventEmmiter = class {
     if (NATIVE_SERVER_EVENTS.has(eventName)) {
       return this.on(eventName, listener);
     }
-    mp.events.add(eventName, listener);
-    return new RageMPServerScriptEvent(eventName, listener);
+    const wrapper = /* @__PURE__ */ __name((player, ...args) => {
+      const parsedArgs = args.map((arg) => {
+        if (typeof arg === "string") {
+          try {
+            return JSON.parse(arg);
+          } catch {
+            return arg;
+          }
+        }
+        return arg;
+      });
+      listener(player, ...parsedArgs);
+    }, "wrapper");
+    mp.events.add(eventName, wrapper);
+    return new RageMPServerScriptEvent(eventName, wrapper);
   }
   oncePlayer(eventName, listener) {
     if (NATIVE_SERVER_EVENTS.has(eventName)) {
       return this.once(eventName, listener);
     }
-    const onceWrapper = /* @__PURE__ */ __name((...args) => {
+    const onceWrapper = /* @__PURE__ */ __name((player, ...args) => {
       mp.events.remove(eventName, onceWrapper);
-      listener(...args);
+      const parsedArgs = args.map((arg) => {
+        if (typeof arg === "string") {
+          try {
+            return JSON.parse(arg);
+          } catch {
+            return arg;
+          }
+        }
+        return arg;
+      });
+      listener(player, ...parsedArgs);
     }, "onceWrapper");
     mp.events.add(eventName, onceWrapper);
     return new RageMPServerScriptEvent(eventName, onceWrapper);
@@ -6729,4 +6752,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/plugins/player-prototype.plugin.ts", "../../core/src/pipes/default-value.pipe.ts", "../src/plugins/rpc.plugin.ts", "../src/plugins/service-binder.plugin.ts", "../src/services/server-event.service.ts", "../src/constants/internal-events.consts.ts", "../src/services/server-logger.service.ts", "../src/services/server-rpc.service.ts", "../src/multiplayer/ragemp/ragemp-script-event-handler.ts", "../src/multiplayer/ragemp/ragemp-event-emmiter.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-player.decorator.ts", "../src/decorators/events/on-webview.decorator.ts", "../src/decorators/events/on.decorator.ts", "../src/decorators/events/once-player.decorator.ts", "../src/decorators/events/once-webview.decorator.ts", "../src/decorators/events/once.decorator.ts", "../src/decorators/params/player.decorator.ts", "../src/decorators/pipeline/use-guards.decorator.ts", "../src/decorators/pipeline/use-interceptors.decorator.ts", "../src/decorators/rpc/on-player-request.decorator.ts", "../src/decorators/rpc/on-request.decorator.ts", "../src/decorators/rpc/on-webview-request.decorator.ts", "../src/modules/throttler/throttler.constants.ts", "../src/modules/throttler/decorators/skip-throttle.decorator.ts", "../src/modules/throttler/decorators/throttle.decorator.ts", "../src/modules/throttler/throttler.guard.ts", "../src/modules/throttler/services/throttler-storage.service.ts", "../src/modules/throttler/throttler.module.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", "import { Container, inject, injectable } from 'inversify';\nimport type { RPCService, ServerMultiplayerService } from '../interfaces';\nimport { LOGGER_SERVICE, RPC_SERVICE, type LoggerService, type RPCCallOptions } from '@ragemp-mango/core';\nimport { GLOBAL_APP_CONTAINER, MULTIPLAYER_SERVICE, type MangoPlugin } from '@ragemp-mango/core/app';\n\n@injectable()\nexport class PlayerPrototypePlugin implements MangoPlugin {\n    @inject(GLOBAL_APP_CONTAINER) private readonly globalAppContainer: Container;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayerService: ServerMultiplayerService;\n\n    public beforeLoad() {\n        const time = Date.now();\n        const Player = this.multiplayerService.getPlayer();\n\n        Player.prototype.emitWebView = function (id: string | number, eventName: string, body?: unknown) {\n            this.emitRaw('SERVER::EMIT_WEBVIEW', {\n                id,\n                eventName,\n                payload: body,\n            });\n        };\n\n        const rpcService = this.globalAppContainer.get<RPCService>(RPC_SERVICE);\n\n        Player.prototype.call = function (rpcName: string, body?: unknown, options?: RPCCallOptions) {\n            return rpcService.callPlayer(this, rpcName, body, options);\n        };\n\n        Player.prototype.callWebView = function (id: string | number, rpcName: string, body?: unknown, options?: RPCCallOptions) {\n            return rpcService.callWebView(this, id, rpcName, body, options);\n        };\n\n        this.loggerService.log(`~lw~Player prototype 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 { RPC_RESULT_HANDLER_NOT_FOUND, type MangoPlugin, RPC_RESULT_UNKNOWN, EventDestination } from '@ragemp-mango/core/app';\nimport {\n    EVENT_SERVICE,\n    MangoError,\n    RPC_SERVICE,\n    RPCResultStatus,\n    type RPCResult,\n    LOGGER_SERVICE,\n    type LoggerService,\n} from '@ragemp-mango/core';\nimport type { EventService, RPCService } from '../interfaces';\n\n@injectable()\nexport class RPCPlugin implements MangoPlugin {\n    @inject(EVENT_SERVICE) private readonly eventService: EventService;\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.onPlayer('RPC::CALL_SERVER', async (player, body) => {\n            if (!player.valid) return;\n\n            const rpcHandler =\n                body.source === EventDestination.Client\n                    ? this.rpcService.$clientHandlers.get(body.rpcName)\n                    : body.source === EventDestination.WebView\n                    ? this.rpcService.$webViewHandlers.get(`${body.webViewId}::${body.rpcName}`)\n                    : undefined;\n            if (!rpcHandler) {\n                if (body.source === EventDestination.WebView) {\n                    player.emitWebView(\n                        body.webViewId as string | number,\n                        `RPC::RETURN_FROM_SERVER_${body.id}`,\n                        RPC_RESULT_HANDLER_NOT_FOUND,\n                    );\n                } else if (body.source === EventDestination.Client) {\n                    player.emitRaw(`RPC::RETURN_FROM_SERVER_${body.id}`, RPC_RESULT_HANDLER_NOT_FOUND);\n                }\n                return;\n            }\n\n            try {\n                const handlerResult = await rpcHandler.handler(player, body.body);\n                const rpcResult: RPCResult = {\n                    success: true,\n                    status: RPCResultStatus.Success,\n                    body: handlerResult,\n                };\n                if (body.source === EventDestination.WebView) {\n                    player.emitWebView(body.webViewId as string | number, `RPC::RETURN_FROM_SERVER_${body.id}`, rpcResult);\n                } else if (body.source === EventDestination.Client) {\n                    player.emitRaw(`RPC::RETURN_FROM_SERVER_${body.id}`, rpcResult);\n                }\n            } catch (error) {\n                if (body.source === EventDestination.WebView) {\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                        player.emitWebView(body.webViewId as string | number, `RPC::RETURN_FROM_SERVER_${body.id}`, rpcResult);\n                    } else {\n                        player.emitWebView(body.webViewId as string | number, `RPC::RETURN_FROM_SERVER_${body.id}`, RPC_RESULT_UNKNOWN);\n                    }\n                } else if (body.source === EventDestination.Client) {\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                        player.emitRaw(`RPC::RETURN_FROM_SERVER_${body.id}`, rpcResult);\n                    } else {\n                        player.emitRaw(`RPC::RETURN_FROM_SERVER_${body.id}`, RPC_RESULT_UNKNOWN);\n                    }\n                }\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, MULTIPLAYER_SERVICE, type MangoPlugin } from '@ragemp-mango/core/app';\nimport { EVENT_SERVICE, LOGGER_SERVICE, RPC_SERVICE } from '@ragemp-mango/core';\nimport { ServerEventService, ServerLoggerService, ServerRPCService } from '../services';\nimport type { ServerMultiplayerService } from '../interfaces';\nimport { ServerAltMultiplayerServceV1, ServerAltMultiplayerServceV2 } from '../multiplayer';\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(ServerLoggerService).inSingletonScope();\n        this.globalAppContainer.bind(EVENT_SERVICE).to(ServerEventService).inSingletonScope();\n        this.globalAppContainer.bind(RPC_SERVICE).to(ServerRPCService).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\n        const loggerService = this.globalAppContainer.get<ServerLoggerService>(LOGGER_SERVICE);\n        loggerService.log(`~lw~Internal services binded ~lk~(${Date.now() - time}ms)`);\n    }\n}\n", "import { BaseEventService, MULTIPLAYER_SERVICE } from '@ragemp-mango/core/app';\nimport { inject, injectable } from 'inversify';\nimport { INTERNAL_EVENTS } from '../constants';\nimport type { EventService, MultiplayerPlayer, ServerEventEmmiter, ServerMultiplayerService } from '../interfaces';\nimport type { ScriptEventHandler } from '@ragemp-mango/core';\n\n@injectable()\nexport class ServerEventService extends BaseEventService<MangoEvents.CustomServerEvent> implements EventService {\n    private $rageEvents: ServerEventEmmiter;\n    public constructor(@inject(MULTIPLAYER_SERVICE) multiplayerService: ServerMultiplayerService) {\n        super(multiplayerService.Events);\n        this.$rageEvents = multiplayerService.Events;\n        this.$internalEventNames = new Set(Object.values(INTERNAL_EVENTS));\n    }\n\n    public onPlayer<E extends string, U extends PlayerMp>(\n        eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        const wrapper = (player: U, ...args: unknown[]) => callback(player, args[0]);\n        const eventHandler = this.$rageEvents.onPlayer(eventName, wrapper);\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public oncePlayer<E extends string, U extends PlayerMp>(\n        eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        const wrapper = (player: U, ...args: unknown[]) => callback(player, args[0]!);\n        const eventHandler = this.$rageEvents.oncePlayer(eventName, wrapper);\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public onRemote<E extends string, U extends PlayerMp>(\n        eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        return this.onPlayer(eventName, callback);\n    }\n\n    public onceRemote<E extends string, U extends PlayerMp>(\n        eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        return this.oncePlayer(eventName, callback);\n    }\n\n    public emitPlayers<E extends string, U extends PlayerMp>(\n        players: U[],\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>,\n        body?: unknown,\n    ): void {\n        for (const player of players) {\n            player.call(eventName, [body]);\n        }\n    }\n\n    public emitPlayersUnreliable<E extends string, U extends MultiplayerPlayer>(\n        players: U[],\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>,\n        body?: unknown,\n    ): void {\n        // RageMP uses callUnreliable for unreliable messages\n        for (const player of players) {\n            player.callUnreliable(eventName, [body]);\n        }\n    }\n\n    public emitAllPlayers<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>, body?: unknown): void {\n        mp.players.call(eventName, [body]);\n    }\n\n    public emitAllPlayersUnreliable<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>, body?: unknown): void {\n        mp.players.callUnreliable(eventName, [body]);\n    }\n\n    public onWebView<E extends string, U extends PlayerMp>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        return this.onPlayer(<string>`SERVER::ON_WEBVIEW_${eventName}_${id}`, <any>callback);\n    }\n\n    public onceWebView<E extends string, U extends PlayerMp>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        return this.oncePlayer(<string>`SERVER::ON_WEBVIEW_${eventName}_${id}`, <any>callback);\n    }\n\n    public emitWebViews<E extends string, U extends PlayerMp>(\n        players: U[],\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>,\n        body?: unknown,\n    ): void {\n        (<EventService>this).emitPlayers(players, 'SERVER::EMIT_WEBVIEW', {\n            id,\n            eventName,\n            payload: body,\n        });\n    }\n\n    public emitAllWebViews<E extends string>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>,\n        body?: unknown,\n    ): void {\n        (<EventService>this).emitAllPlayers('SERVER::EMIT_WEBVIEW', {\n            id,\n            eventName,\n            payload: body,\n        });\n    }\n\n    public emitAllWebViewsUnreliable<E extends string>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>,\n        body?: unknown,\n    ): void {\n        (<EventService>this).emitAllPlayersUnreliable('SERVER::EMIT_WEBVIEW', {\n            id,\n            eventName,\n            payload: body,\n        });\n    }\n\n    // RageMP server events\n    public onPlayerJoin(callback: (player: PlayerMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerJoin', callback);\n    }\n\n    public onPlayerQuit(callback: (player: PlayerMp, exitType: string, reason: string) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerQuit', callback);\n    }\n\n    public onPlayerReady(callback: (player: PlayerMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerReady', callback);\n    }\n\n    public onPlayerDeath(callback: (player: PlayerMp, reason: number, killer?: PlayerMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerDeath', callback);\n    }\n\n    public onPlayerSpawn(callback: (player: PlayerMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerSpawn', callback);\n    }\n\n    public onPlayerChat(callback: (player: PlayerMp, text: string) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerChat', callback);\n    }\n\n    public onPlayerCommand(callback: (player: PlayerMp, command: string) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerCommand', callback);\n    }\n\n    public onPlayerEnterVehicle(callback: (player: PlayerMp, vehicle: VehicleMp, seat: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterVehicle', callback);\n    }\n\n    public onPlayerExitVehicle(callback: (player: PlayerMp, vehicle: VehicleMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitVehicle', callback);\n    }\n\n    public onPlayerStartEnterVehicle(callback: (player: PlayerMp, vehicle: VehicleMp, seat: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerStartEnterVehicle', callback);\n    }\n\n    public onPlayerStartExitVehicle(callback: (player: PlayerMp, vehicle: VehicleMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerStartExitVehicle', callback);\n    }\n\n    public onPlayerWeaponChange(callback: (player: PlayerMp, oldWeapon: number, newWeapon: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerWeaponChange', callback);\n    }\n\n    public onPlayerDamage(callback: (player: PlayerMp, healthLoss: number, armorLoss: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerDamage', callback);\n    }\n\n    public onVehicleDeath(callback: (vehicle: VehicleMp, hash: number, killer?: PlayerMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('vehicleDeath', callback);\n    }\n\n    public onVehicleDamage(callback: (vehicle: VehicleMp, bodyHealthLoss: number, engineHealthLoss: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('vehicleDamage', callback);\n    }\n\n    public onPlayerEnterColshape(callback: (player: PlayerMp, colshape: ColshapeMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterColshape', callback);\n    }\n\n    public onPlayerExitColshape(callback: (player: PlayerMp, colshape: ColshapeMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitColshape', callback);\n    }\n\n    public onPlayerEnterCheckpoint(callback: (player: PlayerMp, checkpoint: CheckpointMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterCheckpoint', callback);\n    }\n\n    public onPlayerExitCheckpoint(callback: (player: PlayerMp, checkpoint: CheckpointMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitCheckpoint', callback);\n    }\n\n    // Aliases for backward compatibility\n    public onPlayerConnect(callback: (player: PlayerMp) => void): ScriptEventHandler {\n        return this.onPlayerJoin(callback);\n    }\n\n    public onPlayerDisconnect(callback: (context: { player: PlayerMp; exitType: string; reason: string }) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerQuit', (player: PlayerMp, exitType: string, reason: string) => {\n            callback({ player, exitType, reason });\n        });\n    }\n}\n", "export const INTERNAL_EVENTS = {\n    SCRIPT_RPC: 'scriptRPC',\n    SCRIPT_RPC_ANSWER: 'scriptRPCAnswer',\n    SERVER_STARTED: 'serverStarted',\n    CONNECTION_QUEUE_ADD: 'connectionQueueAdd',\n    CONNECTION_QUEUE_REMOVE: 'connectionQueueRemove',\n    PLAYER_CONNECT: 'playerConnect',\n    PLAYER_CONNECT_DENIED: 'playerConnectDenied',\n    PLAYER_DISCONNECT: 'playerDisconnect',\n    PLAYER_DAMAGE: 'playerDamage',\n    PLAYER_DEATH: 'playerDeath',\n    PLAYER_HEAL: 'playerHeal',\n    PLAYER_CONTROL_REQUEST: 'playerControlRequest',\n    PLAYER_INTERIOR_CHANGE: 'playerInteriorChange',\n    PLAYER_DIMENSION_CHANGE: 'playerDimensionChange',\n    PLAYER_WEAPON_CHANGE: 'playerWeaponChange',\n    PLAYER_SYNCED_SCENE_REQUEST: 'playerSyncedSceneRequest',\n    PLAYER_SYNCED_SCENE_START: 'playerSyncedSceneStart',\n    PLAYER_SYNCED_SCENE_STOP: 'playerSyncedSceneStop',\n    PLAYER_SYNCED_SCENE_UPDATE: 'playerSyncedSceneUpdate',\n    PLAYER_SPAWN: 'playerSpawn',\n    PLAYER_ANIMATION_CHANGE: 'playerAnimationChange',\n    PLAYER_VEHICLE_ENTERED: 'playerVehicleEntered',\n    PLAYER_START_VEHICLE_ENTER: 'playerStartVehicleEnter',\n    PLAYER_VEHICLE_LEFT: 'playerVehicleLeft',\n    PLAYER_VEHICLE_SEAT_CHANGE: 'playerVehicleSeatChange',\n    PED_HEAL: 'pedHeal',\n    PED_DEATH: 'pedDeath',\n    PED_DAMAGE: 'pedDamage',\n    VEHICLE_DESTROY: 'vehicleDestroy',\n    VEHICLE_ATTACH: 'vehicleAttach',\n    VEHICLE_DETACH: 'vehicleDetach',\n    VEHICLE_DAMAGE: 'vehicleDamage',\n    VEHICLE_SIREN_STATE_CHANGE: 'vehicleSirenStateChange',\n    VEHICLE_HORN_STATE_CHANGE: 'vehicleHornStateChange',\n    VOICE_CONNECTION: 'voiceConnection',\n    CLIENT_OBJECT_DELETE: 'clientObjectDelete',\n    CLIENT_OBJECT_REQUEST: 'clientObjectRequest',\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    STREAM_SYNCED_META_CHANGE: 'streamSyncedMetaChange',\n    GLOBAL_META_CHANGE: 'globalMetaChange',\n    GLOBAL_SYNCED_META_CHANGE: 'globalSyncedMetaChange',\n    CONSOLE_COMMAND: 'consoleCommand',\n    ERROR: 'error',\n    COL_SHAPE_EVENT: 'colShapeEvent',\n    EXPLOSION: 'explosion',\n    FIRE_START: 'fireStart',\n    PROJECTILE_START: 'projectileStart',\n    ENTITY_COL_SHAPE_ENTER: 'entityColShapeEnter',\n    ENTITY_COL_SHAPE_LEAVE: 'entityColShapeLeave',\n    ENTITY_CHECKPOINT_ENTER: 'entityCheckpointEnter',\n    ENTITY_CHECKPOINT_LEAVE: 'entityCheckpointLeave',\n    GIVE_PED_SCRIPTED_TASK: 'givePedScriptedTask',\n    LOCAL_SCRIPT_EVENT: 'localScriptEvent',\n    REMOTE_SCRIPT_EVENT: 'remoteScriptEvent',\n\n    ANY_RESOURCE_START: 'anyResourceStart',\n    ANY_RESOURCE_STOP: 'anyResourceStop',\n\n    RESOURCE_START: 'resourceStart',\n    RESOURCE_STOP: 'resourceStop',\n    RESOURCE_ERROR: 'resourceError',\n    EVENT: 'event',\n};\n", "import { inject, injectable } from 'inversify';\nimport { MANGO_LOG_PREFIX, MULTIPLAYER_SERVICE } from '@ragemp-mango/core/app';\nimport type { LoggerService } from '@ragemp-mango/core';\nimport type { ServerMultiplayerService } from '../interfaces';\n\n@injectable()\nexport class ServerLoggerService implements LoggerService {\n    @inject(MULTIPLAYER_SERVICE) multiplayerService: ServerMultiplayerService;\n    public log(...args: unknown[]): void {\n        this.multiplayerService.log(`~w~[~y~${MANGO_LOG_PREFIX}Server~w~][~lb~Log~w~]`, ...args);\n    }\n\n    public warn(...args: unknown[]): void {\n        this.multiplayerService.logWarning(`[${MANGO_LOG_PREFIX}Server][Warn]`, ...args);\n    }\n\n    public error(...args: unknown[]): void {\n        this.multiplayerService.logError(`[${MANGO_LOG_PREFIX}Server][Error]`, ...args);\n    }\n\n    public debug(...args: unknown[]): void {\n        this.multiplayerService.logDebug(`~w~[~y~${MANGO_LOG_PREFIX}Server~w~][~lc~Debug~w~]`, ...args);\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport {\n    BaseRPCService,\n    EventDestination,\n    type RPCPayload,\n    RPC_RESULT_TIMEOUT,\n    RPC_RESULT_PLAYER_DISCONNECTED,\n    RPC_RESULT_PLAYER_NOT_FOUND,\n} from '@ragemp-mango/core/app';\nimport {\n    EVENT_SERVICE,\n    ErrorMessage,\n    type RPCCallOptions,\n    type RPCResult,\n    type ScriptRPCHandler,\n    generateRandomId,\n} from '@ragemp-mango/core';\nimport type { MultiplayerPlayer, RPCService } from '../interfaces';\nimport type { ServerEventService } from './server-event.service';\n\n@injectable()\nexport class ServerRPCService extends BaseRPCService<MangoRPC.CustomServerRPC> implements RPCService {\n    @inject(EVENT_SERVICE) private readonly $eventService: ServerEventService;\n    public readonly $clientHandlers = new Map<string, ScriptRPCHandler>();\n    public readonly $webViewHandlers = new Map<string, ScriptRPCHandler>();\n\n    public async callPlayer<E extends string, U extends MultiplayerPlayer>(\n        player: U,\n        rpcName: Exclude<E, keyof MangoRPC.CustomServerToClientRPC>,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ) {\n        return this.$handleCall(player, rpcName, EventDestination.Client, options, body);\n    }\n\n    public onPlayerRequest<E extends string, U extends MultiplayerPlayer>(\n        rpcName: Exclude<E, keyof MangoRPC.CustomClientToServerRPC>,\n        handler: (sender: U, body: unknown) => unknown | Promise<unknown>,\n    ) {\n        if (this.$clientHandlers.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.$clientHandlers.delete(rpcName);\n            },\n            rpcName,\n            handler,\n            valid: true,\n        };\n\n        this.$clientHandlers.set(rpcName, rpcHandler);\n\n        return rpcHandler;\n    }\n\n    public async callWebView<E extends string, U extends MultiplayerPlayer>(\n        player: U,\n        id: string | number,\n        rpcName: Exclude<E, keyof MangoRPC.CustomServerToWebViewRPC>,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ) {\n        return this.$handleCall(player, rpcName, EventDestination.WebView, options, body, id);\n    }\n\n    public onWebViewRequest<E extends keyof MangoRPC.CustomWebViewToServerRPC, U extends MultiplayerPlayer>(\n        id: string | number,\n        rpcName: Exclude<E, keyof MangoRPC.CustomWebViewToServerRPC>,\n        handler: (\n            player: U,\n            body: Parameters<MangoRPC.CustomWebViewToServerRPC[E]>[0],\n        ) => ReturnType<MangoRPC.CustomWebViewToServerRPC[E]>,\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: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\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        player: MultiplayerPlayer,\n        rpcName: string,\n        destination: EventDestination, // 'client' | 'webview',\n        options?: Partial<RPCCallOptions>,\n        body?: unknown,\n        webViewId?: string | number,\n    ) {\n        return new Promise<RPCResult<TResult>>((resolve) => {\n            if (!player.valid) {\n                resolve(<RPCResult<TResult>>RPC_RESULT_PLAYER_NOT_FOUND);\n                return;\n            }\n\n            const callId = generateRandomId();\n            let timeoutId: NodeJS.Timeout;\n\n            const disconnectHandler = this.$eventService.onPlayerDisconnect((context) => {\n                if (context.player === player) {\n                    clearTimeout(timeoutId);\n                    disconnectHandler.destroy();\n                    resolve(<RPCResult<TResult>>RPC_RESULT_PLAYER_DISCONNECTED);\n                }\n            });\n\n            const onceHandle = (_player: MultiplayerPlayer, body: unknown) => {\n                clearTimeout(timeoutId);\n                disconnectHandler.destroy();\n                resolve(<RPCResult<TResult>>body);\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.oncePlayer(`RPC::RETURN_FROM_CLIENT_${callId}`, onceHandle);\n\n            const payload: RPCPayload = {\n                source: EventDestination.Server,\n                destination,\n                id: callId,\n                rpcName,\n                body,\n            };\n            // Example: RPC::CALL_SERVER, RPC::CALL_WEBVIEW\n            destination === EventDestination.WebView\n                ? player.emitWebView(webViewId!, 'RPC::CALL_WEBVIEW', payload)\n                : player.emit('RPC::CALL_CLIENT', payload);\n\n            timeoutId = setTimeout(() => {\n                eventHandler.destroy();\n                resolve(<RPCResult<TResult>>RPC_RESULT_TIMEOUT);\n            }, options?.timeout ?? this.$TIMEOUT);\n        });\n    }\n}\n", "import type { ScriptEventHandler } from '@ragemp-mango/core/app';\n\nexport class RageMPServerScriptEvent 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 { MultiplayerPlayer, ServerEventEmmiter } from '../../interfaces';\nimport { RageMPServerScriptEvent } from './ragemp-script-event-handler';\n\ntype NativeServerEvent = keyof IServerEvents;\nconst NATIVE_SERVER_EVENTS = new Set<NativeServerEvent>([\n    'entityCreated',\n    'entityDestroyed',\n    'entityModelChange',\n    'incomingConnection',\n    'packagesLoaded',\n    'playerChat',\n    'playerCommand',\n    'playerDamage',\n    'playerDeath',\n    'playerEnterCheckpoint',\n    'playerEnterColshape',\n    'playerEnterVehicle',\n    'playerExitCheckpoint',\n    'playerExitColshape',\n    'playerExitVehicle',\n    'playerJoin',\n    'playerQuit',\n    'playerReachWaypoint',\n    'playerReady',\n    'playerSpawn',\n    'playerStartEnterVehicle',\n    'playerStartExitVehicle',\n    'playerStreamIn',\n    'playerStreamOut',\n    'playerWeaponChange',\n    'serverShutdown',\n    'trailerAttached',\n    'vehicleDamage',\n    'vehicleDeath',\n    'vehicleHornToggle',\n    'vehicleSirenToggle',\n]);\n\nexport class ServerRageMPEventEmmiter implements ServerEventEmmiter {\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        mp.events.add(eventName, listener);\n        return new RageMPServerScriptEvent(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 RageMPServerScriptEvent(eventName, onceWrapper);\n    }\n\n    off(eventName: string, listener: (...args: any[]) => void): void {\n        mp.events.remove(eventName, listener);\n    }\n\n    emitPlayer(player: MultiplayerPlayer, eventName: string, ...args: any[]): void {\n        // In RageMP, player.call() is used to emit events to clients\n        (player as any).call(eventName, args);\n    }\n\n    emitAllPlayersRaw(eventName: string, ...args: any[]): void {\n        // In RageMP, use mp.players.call() to emit to all players\n        mp.players.call(eventName, args);\n    }\n\n    emitAllPlayersUnreliableRaw(eventName: string, ...args: any[]): void {\n        // RageMP has callUnreliable for unreliable events\n        mp.players.callUnreliable(eventName, args);\n    }\n\n    emitUnreliableRaw(players: MultiplayerPlayer[], eventName: string, ...args: any[]): void {\n        for (const player of players) {\n            (player as any).callUnreliable(eventName, args);\n        }\n    }\n\n    onPlayer(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        // Native RAGEMP events should be registered with 'on' type\n        // They are triggered by the game engine, not by client-to-server communication\n        if (NATIVE_SERVER_EVENTS.has(eventName as NativeServerEvent)) {\n            return this.on(eventName, listener);\n        }\n        // Custom client-to-server events\n        mp.events.add(eventName, listener);\n        return new RageMPServerScriptEvent(eventName, listener);\n    }\n\n    oncePlayer(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        // Native RAGEMP events should be registered with 'once' type\n        if (NATIVE_SERVER_EVENTS.has(eventName as NativeServerEvent)) {\n            return this.once(eventName, listener);\n        }\n        // Custom client-to-server events\n        const onceWrapper = (...args: any[]) => {\n            mp.events.remove(eventName, onceWrapper);\n            listener(...args);\n        };\n        mp.events.add(eventName, onceWrapper);\n        return new RageMPServerScriptEvent(eventName, onceWrapper);\n    }\n\n    offPlayer(eventName: string, listener: (...args: any[]) => void): void {\n        mp.events.remove(eventName, listener);\n    }\n}\n", "import type { ServerEventEmmiter, ServerMultiplayerService } from '../../interfaces';\nimport { RageMPMultiplayerService } from '@ragemp-mango/core/app';\nimport { ServerRageMPEventEmmiter } from './ragemp-event-emmiter';\n\nexport class ServerRageMPMultiplayerService extends RageMPMultiplayerService implements ServerMultiplayerService {\n    public override Events: ServerEventEmmiter;\n\n    constructor() {\n        super();\n        this.Events = new ServerRageMPEventEmmiter();\n    }\n\n    public getPlayer() {\n        // Return the mp.Player constructor for factory purposes\n        return (mp as any).Player;\n    }\n\n    public setBlipFactory(factory: any): void {\n        // RageMP doesn't have factory pattern like alt:V\n        // We can extend the prototype instead\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 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 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 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        // Could log a warning or implement custom solution\n    }\n\n    public setVirtualEntityFactory(_factory: any): void {\n        // RageMP doesn't have VirtualEntity\n        // Could log a warning or implement custom solution\n    }\n\n    public setVoiceChannelFactory(_factory: any): void {\n        // RageMP voice is handled differently\n        // Could implement custom voice channel management\n    }\n\n    // Override logging methods - RageMP server uses console.log, not mp.console.logInfo\n    public override 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        console.log(message);\n    }\n\n    public override 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        console.error(message);\n    }\n\n    public override 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        console.warn(message);\n    }\n\n    public override logDebug(arg: any, ...args: any[]): void {\n        const message = [arg, ...args].map(a =>\n            typeof a === 'object' ? JSON.stringify(a) : String(a)\n        ).join(' ');\n        console.log(`[DEBUG] ${message}`);\n    }\n}\n", "import type { ErrorFilter } from '../../interfaces';\nimport { UseFilters as $UseFilters, type Newable } from '@ragemp-mango/core';\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 OnServerStarted() {\n    return OnInternal(INTERNAL_EVENTS.SERVER_STARTED);\n}\n\nexport function OnceServerStarted() {\n    return OnceInternal(INTERNAL_EVENTS.SERVER_STARTED);\n}\nexport function OnConnectionQueueAdd() {\n    return OnInternal(INTERNAL_EVENTS.CONNECTION_QUEUE_ADD);\n}\n\nexport function OnceConnectionQueueAdd() {\n    return OnceInternal(INTERNAL_EVENTS.CONNECTION_QUEUE_ADD);\n}\nexport function OnConnectionQueueRemove() {\n    return OnInternal(INTERNAL_EVENTS.CONNECTION_QUEUE_REMOVE);\n}\n\nexport function OnceConnectionQueueRemove() {\n    return OnceInternal(INTERNAL_EVENTS.CONNECTION_QUEUE_REMOVE);\n}\nexport function OnPlayerConnect() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_CONNECT);\n}\n\nexport function OncePlayerConnect() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_CONNECT);\n}\nexport function OnPlayerConnectDenied() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_CONNECT_DENIED);\n}\n\nexport function OncePlayerConnectDenied() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_CONNECT_DENIED);\n}\nexport function OnPlayerDisconnect() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_DISCONNECT);\n}\n\nexport function OncePlayerDisconnect() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_DISCONNECT);\n}\nexport function OnPlayerDamage() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_DAMAGE);\n}\n\nexport function OncePlayerDamage() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_DAMAGE);\n}\nexport function OnPlayerDeath() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_DEATH);\n}\n\nexport function OncePlayerDeath() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_DEATH);\n}\nexport function OnPlayerHeal() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_HEAL);\n}\n\nexport function OncePlayerHeal() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_HEAL);\n}\nexport function OnPlayerControlRequest() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_CONTROL_REQUEST);\n}\n\nexport function OncePlayerControlRequest() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_CONTROL_REQUEST);\n}\nexport function OnPlayerInteriorChange() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_INTERIOR_CHANGE);\n}\n\nexport function OncePlayerInteriorChange() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_INTERIOR_CHANGE);\n}\nexport function OnPlayerDimensionChange() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_DIMENSION_CHANGE);\n}\n\nexport function OncePlayerDimensionChange() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_DIMENSION_CHANGE);\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 OnPlayerSyncedSceneRequest() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_REQUEST);\n}\n\nexport function OncePlayerSyncedSceneRequest() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_REQUEST);\n}\nexport function OnPlayerSyncedSceneStart() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_START);\n}\n\nexport function OncePlayerSyncedSceneStart() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_START);\n}\nexport function OnPlayerSyncedSceneStop() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_STOP);\n}\n\nexport function OncePlayerSyncedSceneStop() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_STOP);\n}\nexport function OnPlayerSyncedSceneUpdate() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_UPDATE);\n}\n\nexport function OncePlayerSyncedSceneUpdate() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_UPDATE);\n}\nexport function OnPlayerSpawn() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_SPAWN);\n}\n\nexport function OncePlayerSpawn() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_SPAWN);\n}\nexport function OnPlayerAnimationChange() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_ANIMATION_CHANGE);\n}\n\nexport function OncePlayerAnimationChange() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_ANIMATION_CHANGE);\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 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 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}\n\nexport function OnPedHeal() {\n    return OnInternal(INTERNAL_EVENTS.PED_HEAL);\n}\n\nexport function OncePedHeal() {\n    return OnceInternal(INTERNAL_EVENTS.PED_HEAL);\n}\nexport function OnPedDeath() {\n    return OnInternal(INTERNAL_EVENTS.PED_DEATH);\n}\n\nexport function OncePedDeath() {\n    return OnceInternal(INTERNAL_EVENTS.PED_DEATH);\n}\nexport function OnPedDamage() {\n    return OnInternal(INTERNAL_EVENTS.PED_DAMAGE);\n}\n\nexport function OncePedDamage() {\n    return OnceInternal(INTERNAL_EVENTS.PED_DAMAGE);\n}\nexport function OnVehicleDestroy() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_DESTROY);\n}\n\nexport function OnceVehicleDestroy() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_DESTROY);\n}\nexport function OnVehicleAttach() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_ATTACH);\n}\n\nexport function OnceVehicleAttach() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_ATTACH);\n}\nexport function OnVehicleDetach() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_DETACH);\n}\n\nexport function OnceVehicleDetach() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_DETACH);\n}\nexport function OnVehicleDamage() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_DAMAGE);\n}\n\nexport function OnceVehicleDamage() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_DAMAGE);\n}\nexport function OnVehicleSirenStateChange() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_SIREN_STATE_CHANGE);\n}\n\nexport function OnceVehicleSirenStateChange() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_SIREN_STATE_CHANGE);\n}\nexport function OnVehicleHornStateChange() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_HORN_STATE_CHANGE);\n}\n\nexport function OnceVehicleHornStateChange() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_HORN_STATE_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 OnClientObjectDelete() {\n    return OnInternal(INTERNAL_EVENTS.CLIENT_OBJECT_DELETE);\n}\n\nexport function OnceClientObjectDelete() {\n    return OnceInternal(INTERNAL_EVENTS.CLIENT_OBJECT_DELETE);\n}\nexport function OnClientObjectRequest() {\n    return OnInternal(INTERNAL_EVENTS.CLIENT_OBJECT_REQUEST);\n}\n\nexport function OnceClientObjectRequest() {\n    return OnceInternal(INTERNAL_EVENTS.CLIENT_OBJECT_REQUEST);\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 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 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 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 OnExplosion() {\n    return OnInternal(INTERNAL_EVENTS.EXPLOSION);\n}\n\nexport function OnceExplosion() {\n    return OnceInternal(INTERNAL_EVENTS.EXPLOSION);\n}\nexport function OnFireStart() {\n    return OnInternal(INTERNAL_EVENTS.FIRE_START);\n}\n\nexport function OnceFireStart() {\n    return OnceInternal(INTERNAL_EVENTS.FIRE_START);\n}\nexport function OnProjectileStart() {\n    return OnInternal(INTERNAL_EVENTS.PROJECTILE_START);\n}\n\nexport function OnceProjectileStart() {\n    return OnceInternal(INTERNAL_EVENTS.PROJECTILE_START);\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 OnGivePedScriptedTask() {\n    return OnInternal(INTERNAL_EVENTS.GIVE_PED_SCRIPTED_TASK);\n}\n\nexport function OnceGivePedScriptedTask() {\n    return OnceInternal(INTERNAL_EVENTS.GIVE_PED_SCRIPTED_TASK);\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}\n\nexport function OnAnyResourceStart() {\n    return OnInternal(INTERNAL_EVENTS.ANY_RESOURCE_START);\n}\n\nexport function OnceAnyResourceStart() {\n    return OnceInternal(INTERNAL_EVENTS.ANY_RESOURCE_START);\n}\n\nexport function OnAnyResourceStop() {\n    return OnInternal(INTERNAL_EVENTS.ANY_RESOURCE_STOP);\n}\n\nexport function OnceAnyResourceStop() {\n    return OnceInternal(INTERNAL_EVENTS.ANY_RESOURCE_STOP);\n}\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}\nexport function OnEvent() {\n    return OnInternal(INTERNAL_EVENTS.EVENT);\n}\n\nexport function OnceEvent() {\n    return OnceInternal(INTERNAL_EVENTS.EVENT);\n}\n", "import { createEventDecorator } from '@ragemp-mango/core';\n\nexport function OnPlayer<E extends keyof MangoEvents.CustomPlayerToServerEvent>(eventName?: E): MethodDecorator;\nexport function OnPlayer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>): MethodDecorator;\nexport function OnPlayer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>) {\n    return createEventDecorator('onPlayer', eventName);\n}", "import { OnWebView as $OnWebView } from '@ragemp-mango/core';\n\nexport function OnWebView<E extends keyof MangoEvents.CustomWebViewToServerEvent>(id: string | number, eventName?: E): MethodDecorator;\nexport function OnWebView<E extends string>(\n    id: string | number,\n    eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>,\n): MethodDecorator;\nexport function OnWebView<E extends string>(id: string | number, eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>) {\n    return $OnWebView(id, eventName);\n}\n", "import { On as $On } from '@ragemp-mango/core';\n\nexport function On<E extends keyof MangoEvents.CustomServerEvent>(eventName?: E): MethodDecorator;\nexport function On<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerEvent>): MethodDecorator;\nexport function On<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerEvent>) {\n    return $On(eventName);\n}\n", "import { createEventDecorator } from '@ragemp-mango/core';\n\nexport function OncePlayer<E extends keyof MangoEvents.CustomPlayerToServerEvent>(eventName?: E): MethodDecorator;\nexport function OncePlayer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>): MethodDecorator;\nexport function OncePlayer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>) {\n    return createEventDecorator('oncePlayer', eventName);\n}\n", "import { OnceWebView as $OnceWebView } from '@ragemp-mango/core';\n\nexport function OnceWebView<E extends keyof MangoEvents.CustomWebViewToServerEvent>(id: string | number, eventName?: E): MethodDecorator;\nexport function OnceWebView<E extends string>(\n    id: string | number,\n    eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>,\n): MethodDecorator;\nexport function OnceWebView<E extends string>(id: string | number, eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>) {\n    return $OnceWebView(id, eventName);\n}\n", "import { Once as $Once } from '@ragemp-mango/core';\n\nexport function Once<E extends keyof MangoEvents.CustomServerEvent>(eventName?: E): MethodDecorator;\nexport function Once<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerEvent>): MethodDecorator;\nexport function Once<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerEvent>) {\n    return $Once(eventName);\n}\n", "import { CoreMetadataKey, MethodParamType, type MethodParameter } from '@ragemp-mango/core/app';\nimport { ErrorMessage, type Newable, type Pipe } from '@ragemp-mango/core';\n\nexport function Player(key?: string, ...pipes: Newable<Pipe>[]) {\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, pipes, type: MethodParamType.Player, data: key, metatype }],\n            target,\n            method,\n        );\n    });\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 { createRPCDecorator } from '@ragemp-mango/core';\n\nexport function OnPlayerRequest<E extends keyof MangoRPC.CustomClientToServerRPC>(rpcName?: E): MethodDecorator;\nexport function OnPlayerRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomClientToServerRPC>): MethodDecorator;\nexport function OnPlayerRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomClientToServerRPC>) {\n    return createRPCDecorator('onPlayerRequest', rpcName);\n}\n", "import { OnRequest as $OnRequest } from '@ragemp-mango/core';\n\nexport function OnRequest<E extends keyof MangoRPC.CustomServerRPC>(rpcName?: E): MethodDecorator;\nexport function OnRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomServerRPC>): MethodDecorator;\nexport function OnRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomServerRPC>) {\n    return $OnRequest(rpcName);\n}\n", "import { OnWebViewRequest as $OnWebViewRequest } from '@ragemp-mango/core';\n\nexport function OnWebViewRequest<E extends keyof MangoRPC.CustomWebViewToServerRPC>(id: string | number, rpcName?: E): MethodDecorator;\nexport function OnWebViewRequest<E extends string>(\n    id: string | number,\n    rpcName?: Exclude<E, keyof MangoRPC.CustomWebViewToServerRPC>,\n): MethodDecorator;\nexport function OnWebViewRequest<E extends string>(id: string | number, rpcName?: Exclude<E, keyof MangoRPC.CustomWebViewToServerRPC>) {\n    return $OnWebViewRequest(id, rpcName);\n}\n", "export const THROTTLER_LIMIT = 'THROTTLER_LIMIT';\nexport const THROTTLER_TTL = 'THROTTLER_TTL';\nexport const THROTTLER_OPTIONS = 'THROTTLER_MODULE_OPTIONS';\nexport const THROTTLER_SKIP = 'THROTTLER_SKIP';\nexport const THROTTLER_STORAGE = 'THROTTLER_STORAGE';\n", "import { THROTTLER_SKIP } from '../throttler.constants';\n\nexport function SkipThrottle(skip: Record<string, boolean> = { default: true }) {\n    return (target: any, _propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<any>) => {\n        for (const key in skip) {\n            if (descriptor) {\n                Reflect.defineMetadata(THROTTLER_SKIP + key, skip[key], descriptor.value);\n                return descriptor;\n            }\n            Reflect.defineMetadata(THROTTLER_SKIP + key, skip[key], target);\n            return target;\n        }\n    };\n}\n", "import type { ThrottlerMethodOrControllerOptions } from '../interfaces';\nimport { THROTTLER_LIMIT, THROTTLER_TTL } from '../throttler.constants';\n\nfunction setThrottlerMetadata(target: any, options: Record<string, ThrottlerMethodOrControllerOptions>): void {\n    for (const name in options) {\n        Reflect.defineMetadata(THROTTLER_TTL + name, options[name]!.ttl, target);\n        Reflect.defineMetadata(THROTTLER_LIMIT + name, options[name]!.limit, target);\n    }\n}\n\nexport function Throttle(options: Record<string, ThrottlerMethodOrControllerOptions>) {\n    return (target: any, _propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<any>) => {\n        if (descriptor) {\n            setThrottlerMetadata(descriptor.value, options);\n            return descriptor;\n        }\n        setThrottlerMetadata(target, options);\n        return target;\n    };\n}\n", "import type { Resolvable, ThrottlerLimitDetail, ThrottlerModuleOptions, ThrottlerOptions } from './interfaces';\nimport { THROTTLER_LIMIT, THROTTLER_OPTIONS, THROTTLER_SKIP, THROTTLER_STORAGE, THROTTLER_TTL } from './throttler.constants';\nimport { createHash } from 'crypto';\nimport type { ExecutionContext, Guard } from '../../interfaces';\nimport type { ThrottlerStorageService } from './services';\nimport {\n    isFunction,\n    TooManyRequests,\n    type OnModuleInit,\n    type ReflectorService,\n    ErrorMessage,\n    Injectable,\n    Inject,\n    REFLECTOR_SERVICE,\n} from '@ragemp-mango/core';\n\n@Injectable()\nexport class ThrottlerGuard implements Guard, OnModuleInit {\n    @Inject(THROTTLER_OPTIONS) protected readonly options: ThrottlerModuleOptions;\n    @Inject(THROTTLER_STORAGE) protected readonly storageService: ThrottlerStorageService;\n    @Inject(REFLECTOR_SERVICE) protected readonly reflector: ReflectorService;\n    protected throttlers: Array<ThrottlerOptions>;\n    protected commonOptions: Pick<ThrottlerOptions, 'skipIf'>;\n\n    public async onModuleInit() {\n        this.throttlers = (Array.isArray(this.options) ? this.options : this.options.throttlers)\n            .sort((first, second) => {\n                if (isFunction(first.ttl)) {\n                    return 1;\n                }\n                if (isFunction(second.ttl)) {\n                    return 0;\n                }\n                return first.ttl - second.ttl;\n            })\n            .map((opt) => ({ ...opt, name: opt.name ?? 'default' }));\n        if (Array.isArray(this.options)) {\n            this.commonOptions = {};\n        } else {\n            this.commonOptions = {\n                skipIf: this.options.skipIf!,\n            };\n        }\n    }\n\n    public async canActivate(context: ExecutionContext) {\n        const continues: boolean[] = [];\n        for (const namedThrottler of this.throttlers) {\n            // Return early if the current route should be skipped.\n            const skip = this.reflector.getAllAndOverride<boolean>(THROTTLER_SKIP + namedThrottler.name, [\n                context.handler,\n                context.classRef,\n            ]);\n            const skipIf = namedThrottler.skipIf || this.commonOptions.skipIf;\n            if (skip || skipIf?.(context)) {\n                continues.push(true);\n                continue;\n            }\n\n            // Return early when we have no limit or ttl data.\n            const routeOrClassLimit = this.reflector.getAllAndOverride<Resolvable<number>>(THROTTLER_LIMIT + namedThrottler.name, [\n                context.handler,\n                context.classRef,\n            ]);\n            const routeOrClassTtl = this.reflector.getAllAndOverride<Resolvable<number>>(THROTTLER_TTL + namedThrottler.name, [\n                context.handler,\n                context.classRef,\n            ]);\n\n            // Check if specific limits are set at class or route level, otherwise use global options.\n            const limit = await this.resolveValue(context, routeOrClassLimit || namedThrottler.limit);\n            const ttl = await this.resolveValue(context, routeOrClassTtl || namedThrottler.ttl);\n            continues.push(await this.handleRequest(context, limit, ttl, namedThrottler));\n        }\n        return continues.every((cont) => cont);\n    }\n\n    protected async handleRequest(context: ExecutionContext, limit: number, ttl: number, throttler: ThrottlerOptions) {\n        const player = context.request.player;\n        if(!player) throw new Error(`Player is not in context`);\n        const key = this.generateKey(context, throttler.name!);\n        const { totalHits, timeToExpire } = await this.storageService.increment(player, key, ttl);\n\n        if (totalHits > limit) {\n            await this.throwThrottlingException(context, {\n                limit,\n                ttl,\n                key,\n                player,\n                totalHits,\n                timeToExpire,\n            });\n        }\n\n        return true;\n    }\n\n    protected generateKey(context: ExecutionContext, name: string) {\n        const prefix = `${context.classRef.name}-${context.handler.name}-${name}`;\n        return createHash('md5').update(prefix).digest('hex').toString();\n    }\n\n    protected async throwThrottlingException(context: ExecutionContext, _throttlerLimitDetail: ThrottlerLimitDetail) {\n        throw new TooManyRequests(await this.getErrorMessage(context));\n    }\n\n    protected async getErrorMessage(_context: ExecutionContext) {\n        if (!Array.isArray(this.options)) {\n            return this.options.errorMessage ?? ErrorMessage.TooManyRequests;\n        }\n        return ErrorMessage.TooManyRequests;\n    }\n\n    private async resolveValue<T extends number | string | boolean>(context: ExecutionContext, resolvableValue: Resolvable<T>) {\n        return isFunction(resolvableValue) ? resolvableValue(context) : resolvableValue;\n    }\n}\n", "import { Injectable, type OnAppShutdown } from '@ragemp-mango/core';\nimport type { ThrottlerStorageOptions } from '../interfaces';\n\n@Injectable()\nexport class ThrottlerStorageService implements OnAppShutdown {\n    public readonly storage: WeakMap<PlayerMp, Map<string, ThrottlerStorageOptions>> = new WeakMap();\n    private timeoutIds: NodeJS.Timeout[] = [];\n\n    private getExpirationTime(player: PlayerMp, key: string) {\n        return Math.floor((this.storage.get(player)!.get(key)!.expiresAt - Date.now()) / 1000);\n    }\n\n    private setExpirationTime(player: PlayerMp, key: string, ttlMilliseconds: number) {\n        const timeoutId = setTimeout(() => {\n            this.storage.get(player)!.get(key)!.totalHits--;\n            clearTimeout(timeoutId);\n            this.timeoutIds = this.timeoutIds.filter((id) => id != timeoutId);\n        }, ttlMilliseconds);\n        this.timeoutIds.push(timeoutId);\n    }\n\n    public async increment(player: PlayerMp, key: string, ttl: number) {\n        const ttlMilliseconds = ttl;\n\n        if (!this.storage.get(player)) {\n            this.storage.set(player, new Map());\n        }\n\n        if (!this.storage.get(player)!.get(key)) {\n            this.storage.get(player)!.set(key, { totalHits: 0, expiresAt: Date.now() + ttlMilliseconds });\n        }\n\n        let timeToExpire = this.getExpirationTime(player, key);\n\n        // Reset the timeToExpire once it has been expired.\n        if (timeToExpire <= 0) {\n            this.storage.get(player)!.get(key)!.expiresAt = Date.now() + ttlMilliseconds;\n            timeToExpire = this.getExpirationTime(player, key);\n        }\n\n        this.storage.get(player)!.get(key)!.totalHits++;\n        this.setExpirationTime(player, key, ttlMilliseconds);\n\n        return {\n            totalHits: this.storage.get(player)!.get(key)!.totalHits,\n            timeToExpire,\n        };\n    }\n\n    public onAppShutdown() {\n        this.timeoutIds.forEach(clearTimeout);\n    }\n}\n", "import { Global, Module, type DynamicModule, type Provider, type FactoryProvider } from '@ragemp-mango/core';\nimport { THROTTLER_OPTIONS, THROTTLER_STORAGE } from './throttler.constants';\nimport type { ThrottlerAsyncOptions, ThrottlerModuleOptions, ThrottlerOptionsFactory } from './interfaces';\nimport { ThrottlerStorageService } from './services/throttler-storage.service';\n\n@Global()\n@Module()\nexport class ThrottlerModule {\n    public static forRoot(options: ThrottlerModuleOptions = []) {\n        return {\n            module: ThrottlerModule,\n            providers: [\n                {\n                    provide: THROTTLER_OPTIONS,\n                    useValue: options,\n                },\n                {\n                    provide: THROTTLER_STORAGE,\n                    useClass: ThrottlerStorageService,\n                },\n            ],\n            exports: [THROTTLER_STORAGE, THROTTLER_OPTIONS],\n        } as DynamicModule<ThrottlerModule>;\n    }\n\n    public static forRootAsync(options: ThrottlerAsyncOptions) {\n        const providers = [\n            ...this.createAsyncProviders(options),\n            {\n                provide: THROTTLER_STORAGE,\n                useClass: ThrottlerStorageService,\n            },\n        ];\n        return {\n            module: ThrottlerModule,\n            imports: options.imports ?? [],\n            providers,\n            exports: providers,\n        } as DynamicModule<ThrottlerModule>;\n    }\n\n    private static createAsyncProviders(options: ThrottlerAsyncOptions) {\n        if (options.useExisting || options.useFactory) {\n            return [this.createAsyncOptionsProvider(options)];\n        }\n        return [\n            this.createAsyncOptionsProvider(options),\n            {\n                provide: options.useClass,\n                useClass: options.useClass,\n            },\n        ] as Provider[];\n    }\n\n    private static createAsyncOptionsProvider(options: ThrottlerAsyncOptions) {\n        if (options.useFactory) {\n            return {\n                provide: THROTTLER_OPTIONS,\n                useFactory: options.useFactory,\n                inject: options.inject ?? [],\n            } as FactoryProvider;\n        }\n        return {\n            provide: THROTTLER_OPTIONS,\n            useFactory: async (optionsFactory: ThrottlerOptionsFactory) => await optionsFactory.createThrottlerOptions(),\n            inject: options.useClass ? [options.useClass] : options.useExisting ? [options.useExisting] : [],\n        } as FactoryProvider;\n    }\n}\n", "import { createAppBuilder as $createAppBuilder, AppBuilder, AppEnviroment } from '@ragemp-mango/core/app';\nimport { PlayerPrototypePlugin, RPCPlugin, ServiceBinderPlugin } from './plugins';\nimport type { ErrorFilter, Guard, Interceptor, ServerMultiplayerService } from './interfaces';\nimport { ServerRageMPMultiplayerService } from './multiplayer/ragemp';\n\nconst multiplayerService: ServerMultiplayerService = new ServerRageMPMultiplayerService();\n\nclass ServerAppBuilder extends AppBuilder<Guard, Interceptor, ErrorFilter> {\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 setPedFactory(factory: unknown) {\n        multiplayerService.setPedFactory(factory);\n    }\n\n    public setPlayerFactory(factory: unknown) {\n        multiplayerService.setPlayerFactory(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 setVoiceChannelFactory(factory: unknown) {\n        multiplayerService.setVoiceChannelFactory(factory);\n    }\n}\n\nexport async function createAppBuilder() {\n    return await $createAppBuilder({\n        enviroment: AppEnviroment.Server,\n        plugins: [ServiceBinderPlugin, PlayerPrototypePlugin, RPCPlugin],\n        appBuilderInherit: ServerAppBuilder,\n        multiplayerService\n    });\n}\n\nexport * from './exports';\n\nimport './extension.d.ts';\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", "Container", "inject", "injectable", "DefaultValuePipe", "defaultValue", "transform", "value", "isNil", "isNumber", "isNaN", "PlayerPrototypePlugin", "globalAppContainer", "loggerService", "multiplayerService", "beforeLoad", "time", "Date", "now", "Player", "getPlayer", "prototype", "emitWebView", "id", "eventName", "body", "emitRaw", "payload", "rpcService", "get", "RPC_SERVICE", "call", "rpcName", "options", "callPlayer", "callWebView", "log", "inject", "injectable", "RPCPlugin", "eventService", "rpcService", "loggerService", "beforeLoad", "time", "Date", "now", "onPlayer", "player", "body", "valid", "rpcHandler", "source", "EventDestination", "Client", "$clientHandlers", "get", "rpcName", "WebView", "$webViewHandlers", "webViewId", "undefined", "emitWebView", "id", "RPC_RESULT_HANDLER_NOT_FOUND", "emitRaw", "handlerResult", "handler", "rpcResult", "success", "status", "RPCResultStatus", "Success", "error", "MangoError", "message", "details", "RPC_RESULT_UNKNOWN", "log", "Container", "inject", "injectable", "inject", "injectable", "INTERNAL_EVENTS", "SCRIPT_RPC", "SCRIPT_RPC_ANSWER", "SERVER_STARTED", "CONNECTION_QUEUE_ADD", "CONNECTION_QUEUE_REMOVE", "PLAYER_CONNECT", "PLAYER_CONNECT_DENIED", "PLAYER_DISCONNECT", "PLAYER_DAMAGE", "PLAYER_DEATH", "PLAYER_HEAL", "PLAYER_CONTROL_REQUEST", "PLAYER_INTERIOR_CHANGE", "PLAYER_DIMENSION_CHANGE", "PLAYER_WEAPON_CHANGE", "PLAYER_SYNCED_SCENE_REQUEST", "PLAYER_SYNCED_SCENE_START", "PLAYER_SYNCED_SCENE_STOP", "PLAYER_SYNCED_SCENE_UPDATE", "PLAYER_SPAWN", "PLAYER_ANIMATION_CHANGE", "PLAYER_VEHICLE_ENTERED", "PLAYER_START_VEHICLE_ENTER", "PLAYER_VEHICLE_LEFT", "PLAYER_VEHICLE_SEAT_CHANGE", "PED_HEAL", "PED_DEATH", "PED_DAMAGE", "VEHICLE_DESTROY", "VEHICLE_ATTACH", "VEHICLE_DETACH", "VEHICLE_DAMAGE", "VEHICLE_SIREN_STATE_CHANGE", "VEHICLE_HORN_STATE_CHANGE", "VOICE_CONNECTION", "CLIENT_OBJECT_DELETE", "CLIENT_OBJECT_REQUEST", "BASE_OBJECT_CREATE", "BASE_OBJECT_REMOVE", "NET_OWNER_CHANGE", "WEAPON_DAMAGE", "META_CHANGE", "LOCAL_META_CHANGE", "STREAM_SYNCED_META_CHANGE", "GLOBAL_META_CHANGE", "GLOBAL_SYNCED_META_CHANGE", "CONSOLE_COMMAND", "ERROR", "COL_SHAPE_EVENT", "EXPLOSION", "FIRE_START", "PROJECTILE_START", "ENTITY_COL_SHAPE_ENTER", "ENTITY_COL_SHAPE_LEAVE", "ENTITY_CHECKPOINT_ENTER", "ENTITY_CHECKPOINT_LEAVE", "GIVE_PED_SCRIPTED_TASK", "LOCAL_SCRIPT_EVENT", "REMOTE_SCRIPT_EVENT", "ANY_RESOURCE_START", "ANY_RESOURCE_STOP", "RESOURCE_START", "RESOURCE_STOP", "RESOURCE_ERROR", "EVENT", "ServerEventService", "BaseEventService", "$rageEvents", "multiplayerService", "Events", "$internalEventNames", "Set", "Object", "values", "INTERNAL_EVENTS", "onPlayer", "eventName", "callback", "wrapper", "player", "args", "eventHandler", "$remoteHandlers", "add", "oncePlayer", "onRemote", "onceRemote", "emitPlayers", "players", "body", "call", "emitPlayersUnreliable", "callUnreliable", "emitAllPlayers", "mp", "emitAllPlayersUnreliable", "onWebView", "id", "onceWebView", "emitWebViews", "payload", "emitAllWebViews", "emitAllWebViewsUnreliable", "onPlayerJoin", "on", "onPlayerQuit", "onPlayerReady", "onPlayerDeath", "onPlayerSpawn", "onPlayerChat", "onPlayerCommand", "onPlayerEnterVehicle", "onPlayerExitVehicle", "onPlayerStartEnterVehicle", "onPlayerStartExitVehicle", "onPlayerWeaponChange", "onPlayerDamage", "onVehicleDeath", "onVehicleDamage", "onPlayerEnterColshape", "onPlayerExitColshape", "onPlayerEnterCheckpoint", "onPlayerExitCheckpoint", "onPlayerConnect", "onPlayerDisconnect", "exitType", "reason", "inject", "injectable", "ServerLoggerService", "multiplayerService", "log", "args", "MANGO_LOG_PREFIX", "warn", "logWarning", "error", "logError", "debug", "logDebug", "inject", "injectable", "ServerRPCService", "BaseRPCService", "$eventService", "$clientHandlers", "Map", "$webViewHandlers", "callPlayer", "player", "rpcName", "body", "options", "timeout", "$TIMEOUT", "$handleCall", "EventDestination", "Client", "onPlayerRequest", "handler", "has", "$loggerService", "error", "Error", "ErrorMessage", "RPCHandlerAlreadyExists", "rpcHandler", "destroy", "valid", "delete", "set", "callWebView", "id", "WebView", "onWebViewRequest", "key", "destination", "webViewId", "Promise", "resolve", "RPC_RESULT_PLAYER_NOT_FOUND", "callId", "generateRandomId", "timeoutId", "disconnectHandler", "onPlayerDisconnect", "context", "clearTimeout", "RPC_RESULT_PLAYER_DISCONNECTED", "onceHandle", "_player", "eventHandler", "onceWebView", "oncePlayer", "payload", "source", "Server", "emitWebView", "emit", "setTimeout", "RPC_RESULT_TIMEOUT", "ServiceBinderPlugin", "internalAppContainer", "globalAppContainer", "onBuild", "time", "Date", "now", "bind", "LOGGER_SERVICE", "to", "ServerLoggerService", "inSingletonScope", "EVENT_SERVICE", "ServerEventService", "RPC_SERVICE", "ServerRPCService", "toConstantValue", "get", "loggerService", "log", "RageMPServerScriptEvent", "eventName", "listener", "destroy", "mp", "events", "remove", "NATIVE_SERVER_EVENTS", "Set", "ServerRageMPEventEmmiter", "emit", "eventName", "args", "mp", "events", "call", "on", "listener", "add", "RageMPServerScriptEvent", "once", "onceWrapper", "remove", "off", "emitPlayer", "player", "emitAllPlayersRaw", "players", "emitAllPlayersUnreliableRaw", "callUnreliable", "emitUnreliableRaw", "onPlayer", "has", "oncePlayer", "offPlayer", "ServerRageMPMultiplayerService", "RageMPMultiplayerService", "Events", "ServerRageMPEventEmmiter", "getPlayer", "mp", "Player", "setBlipFactory", "factory", "Blip", "Object", "assign", "prototype", "setMarkerFactory", "Marker", "setColShapeFactory", "Colshape", "setCheckpointFactory", "Checkpoint", "setObjectFactory", "setPedFactory", "Ped", "setPlayerFactory", "setVehicleFactory", "Vehicle", "setVirtualEntityGroupFactory", "_factory", "setVirtualEntityFactory", "setVoiceChannelFactory", "log", "arg", "args", "message", "map", "a", "JSON", "stringify", "String", "join", "console", "logError", "error", "logWarning", "warn", "logDebug", "UseFilters", "filters", "$UseFilters", "OnScriptRPC", "OnInternal", "INTERNAL_EVENTS", "SCRIPT_RPC", "OnceScriptRPC", "OnceInternal", "OnScriptRPCAnswer", "SCRIPT_RPC_ANSWER", "OnceScriptRPCAnswer", "OnServerStarted", "SERVER_STARTED", "OnceServerStarted", "OnConnectionQueueAdd", "CONNECTION_QUEUE_ADD", "OnceConnectionQueueAdd", "OnConnectionQueueRemove", "CONNECTION_QUEUE_REMOVE", "OnceConnectionQueueRemove", "OnPlayerConnect", "PLAYER_CONNECT", "OncePlayerConnect", "OnPlayerConnectDenied", "PLAYER_CONNECT_DENIED", "OncePlayerConnectDenied", "OnPlayerDisconnect", "PLAYER_DISCONNECT", "OncePlayerDisconnect", "OnPlayerDamage", "PLAYER_DAMAGE", "OncePlayerDamage", "OnPlayerDeath", "PLAYER_DEATH", "OncePlayerDeath", "OnPlayerHeal", "PLAYER_HEAL", "OncePlayerHeal", "OnPlayerControlRequest", "PLAYER_CONTROL_REQUEST", "OncePlayerControlRequest", "OnPlayerInteriorChange", "PLAYER_INTERIOR_CHANGE", "OncePlayerInteriorChange", "OnPlayerDimensionChange", "PLAYER_DIMENSION_CHANGE", "OncePlayerDimensionChange", "OnPlayerWeaponChange", "PLAYER_WEAPON_CHANGE", "OncePlayerWeaponChange", "OnPlayerSyncedSceneRequest", "PLAYER_SYNCED_SCENE_REQUEST", "OncePlayerSyncedSceneRequest", "OnPlayerSyncedSceneStart", "PLAYER_SYNCED_SCENE_START", "OncePlayerSyncedSceneStart", "OnPlayerSyncedSceneStop", "PLAYER_SYNCED_SCENE_STOP", "OncePlayerSyncedSceneStop", "OnPlayerSyncedSceneUpdate", "PLAYER_SYNCED_SCENE_UPDATE", "OncePlayerSyncedSceneUpdate", "OnPlayerSpawn", "PLAYER_SPAWN", "OncePlayerSpawn", "OnPlayerAnimationChange", "PLAYER_ANIMATION_CHANGE", "OncePlayerAnimationChange", "OnPlayerVehicleEntered", "PLAYER_VEHICLE_ENTERED", "OncePlayerVehicleEntered", "OnPlayerStartVehicleEnter", "PLAYER_START_VEHICLE_ENTER", "OncePlayerStartVehicleEnter", "OnPlayerVehicleLeft", "PLAYER_VEHICLE_LEFT", "OncePlayerVehicleLeft", "OnPlayerVehicleSeatChange", "PLAYER_VEHICLE_SEAT_CHANGE", "OncePlayerVehicleSeatChange", "OnPedHeal", "PED_HEAL", "OncePedHeal", "OnPedDeath", "PED_DEATH", "OncePedDeath", "OnPedDamage", "PED_DAMAGE", "OncePedDamage", "OnVehicleDestroy", "VEHICLE_DESTROY", "OnceVehicleDestroy", "OnVehicleAttach", "VEHICLE_ATTACH", "OnceVehicleAttach", "OnVehicleDetach", "VEHICLE_DETACH", "OnceVehicleDetach", "OnVehicleDamage", "VEHICLE_DAMAGE", "OnceVehicleDamage", "OnVehicleSirenStateChange", "VEHICLE_SIREN_STATE_CHANGE", "OnceVehicleSirenStateChange", "OnVehicleHornStateChange", "VEHICLE_HORN_STATE_CHANGE", "OnceVehicleHornStateChange", "OnVoiceConnection", "VOICE_CONNECTION", "OnceVoiceConnection", "OnClientObjectDelete", "CLIENT_OBJECT_DELETE", "OnceClientObjectDelete", "OnClientObjectRequest", "CLIENT_OBJECT_REQUEST", "OnceClientObjectRequest", "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", "OnStreamSyncedMetaChange", "STREAM_SYNCED_META_CHANGE", "OnceStreamSyncedMetaChange", "OnGlobalMetaChange", "GLOBAL_META_CHANGE", "OnceGlobalMetaChange", "OnGlobalSyncedMetaChange", "GLOBAL_SYNCED_META_CHANGE", "OnceGlobalSyncedMetaChange", "OnConsoleCommand", "CONSOLE_COMMAND", "OnceConsoleCommand", "OnError", "ERROR", "OnceError", "OnColShapeEvent", "COL_SHAPE_EVENT", "OnceColShapeEvent", "OnExplosion", "EXPLOSION", "OnceExplosion", "OnFireStart", "FIRE_START", "OnceFireStart", "OnProjectileStart", "PROJECTILE_START", "OnceProjectileStart", "OnEntityColShapeEnter", "ENTITY_COL_SHAPE_ENTER", "OnceEntityColShapeEnter", "OnEntityColShapeLeave", "ENTITY_COL_SHAPE_LEAVE", "OnceEntityColShapeLeave", "OnEntityCheckpointEnter", "ENTITY_CHECKPOINT_ENTER", "OnceEntityCheckpointEnter", "OnEntityCheckpointLeave", "ENTITY_CHECKPOINT_LEAVE", "OnceEntityCheckpointLeave", "OnGivePedScriptedTask", "GIVE_PED_SCRIPTED_TASK", "OnceGivePedScriptedTask", "OnLocalScriptEvent", "LOCAL_SCRIPT_EVENT", "OnceLocalScriptEvent", "OnRemoteScriptEvent", "REMOTE_SCRIPT_EVENT", "OnceRemoteScriptEvent", "OnAnyResourceStart", "ANY_RESOURCE_START", "OnceAnyResourceStart", "OnAnyResourceStop", "ANY_RESOURCE_STOP", "OnceAnyResourceStop", "OnResourceStart", "RESOURCE_START", "OnceResourceStart", "OnResourceStop", "RESOURCE_STOP", "OnceResourceStop", "OnResourceError", "RESOURCE_ERROR", "OnceResourceError", "OnEvent", "EVENT", "OnceEvent", "OnPlayer", "eventName", "createEventDecorator", "OnWebView", "id", "eventName", "$OnWebView", "On", "eventName", "$On", "OncePlayer", "eventName", "createEventDecorator", "OnceWebView", "id", "eventName", "$OnceWebView", "Once", "eventName", "$Once", "Player", "key", "pipes", "target", "method", "index", "params", "Reflect", "getMetadata", "CoreMetadataKey", "ControllerParams", "some", "param", "Error", "ErrorMessage", "MultipleDecoratorsOnSingleParameterNotAllowed", "paramTypes", "metatype", "Array", "isArray", "undefined", "defineMetadata", "type", "MethodParamType", "data", "UseGuards", "guards", "$UseGuards", "UseInterceptors", "interceptors", "$UseInterceptors", "OnPlayerRequest", "rpcName", "createRPCDecorator", "OnRequest", "rpcName", "$OnRequest", "OnWebViewRequest", "id", "rpcName", "$OnWebViewRequest", "THROTTLER_LIMIT", "THROTTLER_TTL", "THROTTLER_OPTIONS", "THROTTLER_SKIP", "THROTTLER_STORAGE", "SkipThrottle", "skip", "default", "target", "_propertyKey", "descriptor", "key", "Reflect", "defineMetadata", "THROTTLER_SKIP", "value", "setThrottlerMetadata", "target", "options", "name", "Reflect", "defineMetadata", "THROTTLER_TTL", "ttl", "THROTTLER_LIMIT", "limit", "Throttle", "_propertyKey", "descriptor", "value", "createHash", "ThrottlerGuard", "options", "storageService", "reflector", "throttlers", "commonOptions", "onModuleInit", "Array", "isArray", "sort", "first", "second", "isFunction", "ttl", "map", "opt", "name", "skipIf", "canActivate", "context", "continues", "namedThrottler", "skip", "getAllAndOverride", "THROTTLER_SKIP", "handler", "classRef", "push", "routeOrClassLimit", "THROTTLER_LIMIT", "routeOrClassTtl", "THROTTLER_TTL", "limit", "resolveValue", "handleRequest", "every", "cont", "throttler", "player", "request", "Error", "key", "generateKey", "totalHits", "timeToExpire", "increment", "throwThrottlingException", "prefix", "createHash", "update", "digest", "toString", "_throttlerLimitDetail", "TooManyRequests", "getErrorMessage", "_context", "errorMessage", "ErrorMessage", "resolvableValue", "ThrottlerStorageService", "storage", "WeakMap", "timeoutIds", "getExpirationTime", "player", "key", "Math", "floor", "get", "expiresAt", "Date", "now", "setExpirationTime", "ttlMilliseconds", "timeoutId", "setTimeout", "totalHits", "clearTimeout", "filter", "id", "push", "increment", "ttl", "set", "Map", "timeToExpire", "onAppShutdown", "forEach", "ThrottlerModule", "forRoot", "options", "module", "providers", "provide", "THROTTLER_OPTIONS", "useValue", "THROTTLER_STORAGE", "useClass", "ThrottlerStorageService", "exports", "forRootAsync", "createAsyncProviders", "imports", "useExisting", "useFactory", "createAsyncOptionsProvider", "inject", "optionsFactory", "createThrottlerOptions", "multiplayerService", "ServerRageMPMultiplayerService", "ServerAppBuilder", "AppBuilder", "setBlipFactory", "factory", "setMarkerFactory", "setColShapeFactory", "setCheckpointFactory", "setObjectFactory", "setPedFactory", "setPlayerFactory", "setVehicleFactory", "setVirtualEntityGroupFactory", "setVirtualEntityFactory", "setVoiceChannelFactory", "createAppBuilder", "$createAppBuilder", "enviroment", "AppEnviroment", "Server", "plugins", "ServiceBinderPlugin", "PlayerPrototypePlugin", "RPCPlugin", "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/plugins/player-prototype.plugin.ts", "../../core/src/pipes/default-value.pipe.ts", "../src/plugins/rpc.plugin.ts", "../src/plugins/service-binder.plugin.ts", "../src/services/server-event.service.ts", "../src/constants/internal-events.consts.ts", "../src/services/server-logger.service.ts", "../src/services/server-rpc.service.ts", "../src/multiplayer/ragemp/ragemp-script-event-handler.ts", "../src/multiplayer/ragemp/ragemp-event-emmiter.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-player.decorator.ts", "../src/decorators/events/on-webview.decorator.ts", "../src/decorators/events/on.decorator.ts", "../src/decorators/events/once-player.decorator.ts", "../src/decorators/events/once-webview.decorator.ts", "../src/decorators/events/once.decorator.ts", "../src/decorators/params/player.decorator.ts", "../src/decorators/pipeline/use-guards.decorator.ts", "../src/decorators/pipeline/use-interceptors.decorator.ts", "../src/decorators/rpc/on-player-request.decorator.ts", "../src/decorators/rpc/on-request.decorator.ts", "../src/decorators/rpc/on-webview-request.decorator.ts", "../src/modules/throttler/throttler.constants.ts", "../src/modules/throttler/decorators/skip-throttle.decorator.ts", "../src/modules/throttler/decorators/throttle.decorator.ts", "../src/modules/throttler/throttler.guard.ts", "../src/modules/throttler/services/throttler-storage.service.ts", "../src/modules/throttler/throttler.module.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", "import { Container, inject, injectable } from 'inversify';\nimport type { RPCService, ServerMultiplayerService } from '../interfaces';\nimport { LOGGER_SERVICE, RPC_SERVICE, type LoggerService, type RPCCallOptions } from '@ragemp-mango/core';\nimport { GLOBAL_APP_CONTAINER, MULTIPLAYER_SERVICE, type MangoPlugin } from '@ragemp-mango/core/app';\n\n@injectable()\nexport class PlayerPrototypePlugin implements MangoPlugin {\n    @inject(GLOBAL_APP_CONTAINER) private readonly globalAppContainer: Container;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayerService: ServerMultiplayerService;\n\n    public beforeLoad() {\n        const time = Date.now();\n        const Player = this.multiplayerService.getPlayer();\n\n        Player.prototype.emitWebView = function (id: string | number, eventName: string, body?: unknown) {\n            this.emitRaw('SERVER::EMIT_WEBVIEW', {\n                id,\n                eventName,\n                payload: body,\n            });\n        };\n\n        const rpcService = this.globalAppContainer.get<RPCService>(RPC_SERVICE);\n\n        Player.prototype.call = function (rpcName: string, body?: unknown, options?: RPCCallOptions) {\n            return rpcService.callPlayer(this, rpcName, body, options);\n        };\n\n        Player.prototype.callWebView = function (id: string | number, rpcName: string, body?: unknown, options?: RPCCallOptions) {\n            return rpcService.callWebView(this, id, rpcName, body, options);\n        };\n\n        this.loggerService.log(`~lw~Player prototype 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 { RPC_RESULT_HANDLER_NOT_FOUND, type MangoPlugin, RPC_RESULT_UNKNOWN, EventDestination } from '@ragemp-mango/core/app';\nimport {\n    EVENT_SERVICE,\n    MangoError,\n    RPC_SERVICE,\n    RPCResultStatus,\n    type RPCResult,\n    LOGGER_SERVICE,\n    type LoggerService,\n} from '@ragemp-mango/core';\nimport type { EventService, RPCService } from '../interfaces';\n\n@injectable()\nexport class RPCPlugin implements MangoPlugin {\n    @inject(EVENT_SERVICE) private readonly eventService: EventService;\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.onPlayer('RPC::CALL_SERVER', async (player, body) => {\n            if (!player.valid) return;\n\n            const rpcHandler =\n                body.source === EventDestination.Client\n                    ? this.rpcService.$clientHandlers.get(body.rpcName)\n                    : body.source === EventDestination.WebView\n                    ? this.rpcService.$webViewHandlers.get(`${body.webViewId}::${body.rpcName}`)\n                    : undefined;\n            if (!rpcHandler) {\n                if (body.source === EventDestination.WebView) {\n                    player.emitWebView(\n                        body.webViewId as string | number,\n                        `RPC::RETURN_FROM_SERVER_${body.id}`,\n                        RPC_RESULT_HANDLER_NOT_FOUND,\n                    );\n                } else if (body.source === EventDestination.Client) {\n                    player.emitRaw(`RPC::RETURN_FROM_SERVER_${body.id}`, RPC_RESULT_HANDLER_NOT_FOUND);\n                }\n                return;\n            }\n\n            try {\n                const handlerResult = await rpcHandler.handler(player, body.body);\n                const rpcResult: RPCResult = {\n                    success: true,\n                    status: RPCResultStatus.Success,\n                    body: handlerResult,\n                };\n                if (body.source === EventDestination.WebView) {\n                    player.emitWebView(body.webViewId as string | number, `RPC::RETURN_FROM_SERVER_${body.id}`, rpcResult);\n                } else if (body.source === EventDestination.Client) {\n                    player.emitRaw(`RPC::RETURN_FROM_SERVER_${body.id}`, rpcResult);\n                }\n            } catch (error) {\n                if (body.source === EventDestination.WebView) {\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                        player.emitWebView(body.webViewId as string | number, `RPC::RETURN_FROM_SERVER_${body.id}`, rpcResult);\n                    } else {\n                        player.emitWebView(body.webViewId as string | number, `RPC::RETURN_FROM_SERVER_${body.id}`, RPC_RESULT_UNKNOWN);\n                    }\n                } else if (body.source === EventDestination.Client) {\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                        player.emitRaw(`RPC::RETURN_FROM_SERVER_${body.id}`, rpcResult);\n                    } else {\n                        player.emitRaw(`RPC::RETURN_FROM_SERVER_${body.id}`, RPC_RESULT_UNKNOWN);\n                    }\n                }\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, MULTIPLAYER_SERVICE, type MangoPlugin } from '@ragemp-mango/core/app';\nimport { EVENT_SERVICE, LOGGER_SERVICE, RPC_SERVICE } from '@ragemp-mango/core';\nimport { ServerEventService, ServerLoggerService, ServerRPCService } from '../services';\nimport type { ServerMultiplayerService } from '../interfaces';\nimport { ServerAltMultiplayerServceV1, ServerAltMultiplayerServceV2 } from '../multiplayer';\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(ServerLoggerService).inSingletonScope();\n        this.globalAppContainer.bind(EVENT_SERVICE).to(ServerEventService).inSingletonScope();\n        this.globalAppContainer.bind(RPC_SERVICE).to(ServerRPCService).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\n        const loggerService = this.globalAppContainer.get<ServerLoggerService>(LOGGER_SERVICE);\n        loggerService.log(`~lw~Internal services binded ~lk~(${Date.now() - time}ms)`);\n    }\n}\n", "import { BaseEventService, MULTIPLAYER_SERVICE } from '@ragemp-mango/core/app';\nimport { inject, injectable } from 'inversify';\nimport { INTERNAL_EVENTS } from '../constants';\nimport type { EventService, MultiplayerPlayer, ServerEventEmmiter, ServerMultiplayerService } from '../interfaces';\nimport type { ScriptEventHandler } from '@ragemp-mango/core';\n\n@injectable()\nexport class ServerEventService extends BaseEventService<MangoEvents.CustomServerEvent> implements EventService {\n    private $rageEvents: ServerEventEmmiter;\n    public constructor(@inject(MULTIPLAYER_SERVICE) multiplayerService: ServerMultiplayerService) {\n        super(multiplayerService.Events);\n        this.$rageEvents = multiplayerService.Events;\n        this.$internalEventNames = new Set(Object.values(INTERNAL_EVENTS));\n    }\n\n    public onPlayer<E extends string, U extends PlayerMp>(\n        eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        const wrapper = (player: U, ...args: unknown[]) => callback(player, args[0]);\n        const eventHandler = this.$rageEvents.onPlayer(eventName, wrapper);\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public oncePlayer<E extends string, U extends PlayerMp>(\n        eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        const wrapper = (player: U, ...args: unknown[]) => callback(player, args[0]!);\n        const eventHandler = this.$rageEvents.oncePlayer(eventName, wrapper);\n        this.$remoteHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public onRemote<E extends string, U extends PlayerMp>(\n        eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        return this.onPlayer(eventName, callback);\n    }\n\n    public onceRemote<E extends string, U extends PlayerMp>(\n        eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        return this.oncePlayer(eventName, callback);\n    }\n\n    public emitPlayers<E extends string, U extends PlayerMp>(\n        players: U[],\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>,\n        body?: unknown,\n    ): void {\n        for (const player of players) {\n            player.call(eventName, [body]);\n        }\n    }\n\n    public emitPlayersUnreliable<E extends string, U extends MultiplayerPlayer>(\n        players: U[],\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>,\n        body?: unknown,\n    ): void {\n        // RageMP uses callUnreliable for unreliable messages\n        for (const player of players) {\n            player.callUnreliable(eventName, [body]);\n        }\n    }\n\n    public emitAllPlayers<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>, body?: unknown): void {\n        mp.players.call(eventName, [body]);\n    }\n\n    public emitAllPlayersUnreliable<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>, body?: unknown): void {\n        mp.players.callUnreliable(eventName, [body]);\n    }\n\n    public onWebView<E extends string, U extends PlayerMp>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        return this.onPlayer(<string>`SERVER::ON_WEBVIEW_${eventName}_${id}`, <any>callback);\n    }\n\n    public onceWebView<E extends string, U extends PlayerMp>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>,\n        callback: (player: U, body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        return this.oncePlayer(<string>`SERVER::ON_WEBVIEW_${eventName}_${id}`, <any>callback);\n    }\n\n    public emitWebViews<E extends string, U extends PlayerMp>(\n        players: U[],\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>,\n        body?: unknown,\n    ): void {\n        (<EventService>this).emitPlayers(players, 'SERVER::EMIT_WEBVIEW', {\n            id,\n            eventName,\n            payload: body,\n        });\n    }\n\n    public emitAllWebViews<E extends string>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>,\n        body?: unknown,\n    ): void {\n        (<EventService>this).emitAllPlayers('SERVER::EMIT_WEBVIEW', {\n            id,\n            eventName,\n            payload: body,\n        });\n    }\n\n    public emitAllWebViewsUnreliable<E extends string>(\n        id: string | number,\n        eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>,\n        body?: unknown,\n    ): void {\n        (<EventService>this).emitAllPlayersUnreliable('SERVER::EMIT_WEBVIEW', {\n            id,\n            eventName,\n            payload: body,\n        });\n    }\n\n    // RageMP server events\n    public onPlayerJoin(callback: (player: PlayerMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerJoin', callback);\n    }\n\n    public onPlayerQuit(callback: (player: PlayerMp, exitType: string, reason: string) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerQuit', callback);\n    }\n\n    public onPlayerReady(callback: (player: PlayerMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerReady', callback);\n    }\n\n    public onPlayerDeath(callback: (player: PlayerMp, reason: number, killer?: PlayerMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerDeath', callback);\n    }\n\n    public onPlayerSpawn(callback: (player: PlayerMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerSpawn', callback);\n    }\n\n    public onPlayerChat(callback: (player: PlayerMp, text: string) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerChat', callback);\n    }\n\n    public onPlayerCommand(callback: (player: PlayerMp, command: string) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerCommand', callback);\n    }\n\n    public onPlayerEnterVehicle(callback: (player: PlayerMp, vehicle: VehicleMp, seat: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterVehicle', callback);\n    }\n\n    public onPlayerExitVehicle(callback: (player: PlayerMp, vehicle: VehicleMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitVehicle', callback);\n    }\n\n    public onPlayerStartEnterVehicle(callback: (player: PlayerMp, vehicle: VehicleMp, seat: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerStartEnterVehicle', callback);\n    }\n\n    public onPlayerStartExitVehicle(callback: (player: PlayerMp, vehicle: VehicleMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerStartExitVehicle', callback);\n    }\n\n    public onPlayerWeaponChange(callback: (player: PlayerMp, oldWeapon: number, newWeapon: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerWeaponChange', callback);\n    }\n\n    public onPlayerDamage(callback: (player: PlayerMp, healthLoss: number, armorLoss: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerDamage', callback);\n    }\n\n    public onVehicleDeath(callback: (vehicle: VehicleMp, hash: number, killer?: PlayerMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('vehicleDeath', callback);\n    }\n\n    public onVehicleDamage(callback: (vehicle: VehicleMp, bodyHealthLoss: number, engineHealthLoss: number) => void): ScriptEventHandler {\n        return this.$rageEvents.on('vehicleDamage', callback);\n    }\n\n    public onPlayerEnterColshape(callback: (player: PlayerMp, colshape: ColshapeMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterColshape', callback);\n    }\n\n    public onPlayerExitColshape(callback: (player: PlayerMp, colshape: ColshapeMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitColshape', callback);\n    }\n\n    public onPlayerEnterCheckpoint(callback: (player: PlayerMp, checkpoint: CheckpointMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerEnterCheckpoint', callback);\n    }\n\n    public onPlayerExitCheckpoint(callback: (player: PlayerMp, checkpoint: CheckpointMp) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerExitCheckpoint', callback);\n    }\n\n    // Aliases for backward compatibility\n    public onPlayerConnect(callback: (player: PlayerMp) => void): ScriptEventHandler {\n        return this.onPlayerJoin(callback);\n    }\n\n    public onPlayerDisconnect(callback: (context: { player: PlayerMp; exitType: string; reason: string }) => void): ScriptEventHandler {\n        return this.$rageEvents.on('playerQuit', (player: PlayerMp, exitType: string, reason: string) => {\n            callback({ player, exitType, reason });\n        });\n    }\n}\n", "export const INTERNAL_EVENTS = {\n    SCRIPT_RPC: 'scriptRPC',\n    SCRIPT_RPC_ANSWER: 'scriptRPCAnswer',\n    SERVER_STARTED: 'serverStarted',\n    CONNECTION_QUEUE_ADD: 'connectionQueueAdd',\n    CONNECTION_QUEUE_REMOVE: 'connectionQueueRemove',\n    PLAYER_CONNECT: 'playerConnect',\n    PLAYER_CONNECT_DENIED: 'playerConnectDenied',\n    PLAYER_DISCONNECT: 'playerDisconnect',\n    PLAYER_DAMAGE: 'playerDamage',\n    PLAYER_DEATH: 'playerDeath',\n    PLAYER_HEAL: 'playerHeal',\n    PLAYER_CONTROL_REQUEST: 'playerControlRequest',\n    PLAYER_INTERIOR_CHANGE: 'playerInteriorChange',\n    PLAYER_DIMENSION_CHANGE: 'playerDimensionChange',\n    PLAYER_WEAPON_CHANGE: 'playerWeaponChange',\n    PLAYER_SYNCED_SCENE_REQUEST: 'playerSyncedSceneRequest',\n    PLAYER_SYNCED_SCENE_START: 'playerSyncedSceneStart',\n    PLAYER_SYNCED_SCENE_STOP: 'playerSyncedSceneStop',\n    PLAYER_SYNCED_SCENE_UPDATE: 'playerSyncedSceneUpdate',\n    PLAYER_SPAWN: 'playerSpawn',\n    PLAYER_ANIMATION_CHANGE: 'playerAnimationChange',\n    PLAYER_VEHICLE_ENTERED: 'playerVehicleEntered',\n    PLAYER_START_VEHICLE_ENTER: 'playerStartVehicleEnter',\n    PLAYER_VEHICLE_LEFT: 'playerVehicleLeft',\n    PLAYER_VEHICLE_SEAT_CHANGE: 'playerVehicleSeatChange',\n    PED_HEAL: 'pedHeal',\n    PED_DEATH: 'pedDeath',\n    PED_DAMAGE: 'pedDamage',\n    VEHICLE_DESTROY: 'vehicleDestroy',\n    VEHICLE_ATTACH: 'vehicleAttach',\n    VEHICLE_DETACH: 'vehicleDetach',\n    VEHICLE_DAMAGE: 'vehicleDamage',\n    VEHICLE_SIREN_STATE_CHANGE: 'vehicleSirenStateChange',\n    VEHICLE_HORN_STATE_CHANGE: 'vehicleHornStateChange',\n    VOICE_CONNECTION: 'voiceConnection',\n    CLIENT_OBJECT_DELETE: 'clientObjectDelete',\n    CLIENT_OBJECT_REQUEST: 'clientObjectRequest',\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    STREAM_SYNCED_META_CHANGE: 'streamSyncedMetaChange',\n    GLOBAL_META_CHANGE: 'globalMetaChange',\n    GLOBAL_SYNCED_META_CHANGE: 'globalSyncedMetaChange',\n    CONSOLE_COMMAND: 'consoleCommand',\n    ERROR: 'error',\n    COL_SHAPE_EVENT: 'colShapeEvent',\n    EXPLOSION: 'explosion',\n    FIRE_START: 'fireStart',\n    PROJECTILE_START: 'projectileStart',\n    ENTITY_COL_SHAPE_ENTER: 'entityColShapeEnter',\n    ENTITY_COL_SHAPE_LEAVE: 'entityColShapeLeave',\n    ENTITY_CHECKPOINT_ENTER: 'entityCheckpointEnter',\n    ENTITY_CHECKPOINT_LEAVE: 'entityCheckpointLeave',\n    GIVE_PED_SCRIPTED_TASK: 'givePedScriptedTask',\n    LOCAL_SCRIPT_EVENT: 'localScriptEvent',\n    REMOTE_SCRIPT_EVENT: 'remoteScriptEvent',\n\n    ANY_RESOURCE_START: 'anyResourceStart',\n    ANY_RESOURCE_STOP: 'anyResourceStop',\n\n    RESOURCE_START: 'resourceStart',\n    RESOURCE_STOP: 'resourceStop',\n    RESOURCE_ERROR: 'resourceError',\n    EVENT: 'event',\n};\n", "import { inject, injectable } from 'inversify';\nimport { MANGO_LOG_PREFIX, MULTIPLAYER_SERVICE } from '@ragemp-mango/core/app';\nimport type { LoggerService } from '@ragemp-mango/core';\nimport type { ServerMultiplayerService } from '../interfaces';\n\n@injectable()\nexport class ServerLoggerService implements LoggerService {\n    @inject(MULTIPLAYER_SERVICE) multiplayerService: ServerMultiplayerService;\n    public log(...args: unknown[]): void {\n        this.multiplayerService.log(`~w~[~y~${MANGO_LOG_PREFIX}Server~w~][~lb~Log~w~]`, ...args);\n    }\n\n    public warn(...args: unknown[]): void {\n        this.multiplayerService.logWarning(`[${MANGO_LOG_PREFIX}Server][Warn]`, ...args);\n    }\n\n    public error(...args: unknown[]): void {\n        this.multiplayerService.logError(`[${MANGO_LOG_PREFIX}Server][Error]`, ...args);\n    }\n\n    public debug(...args: unknown[]): void {\n        this.multiplayerService.logDebug(`~w~[~y~${MANGO_LOG_PREFIX}Server~w~][~lc~Debug~w~]`, ...args);\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport {\n    BaseRPCService,\n    EventDestination,\n    type RPCPayload,\n    RPC_RESULT_TIMEOUT,\n    RPC_RESULT_PLAYER_DISCONNECTED,\n    RPC_RESULT_PLAYER_NOT_FOUND,\n} from '@ragemp-mango/core/app';\nimport {\n    EVENT_SERVICE,\n    ErrorMessage,\n    type RPCCallOptions,\n    type RPCResult,\n    type ScriptRPCHandler,\n    generateRandomId,\n} from '@ragemp-mango/core';\nimport type { MultiplayerPlayer, RPCService } from '../interfaces';\nimport type { ServerEventService } from './server-event.service';\n\n@injectable()\nexport class ServerRPCService extends BaseRPCService<MangoRPC.CustomServerRPC> implements RPCService {\n    @inject(EVENT_SERVICE) private readonly $eventService: ServerEventService;\n    public readonly $clientHandlers = new Map<string, ScriptRPCHandler>();\n    public readonly $webViewHandlers = new Map<string, ScriptRPCHandler>();\n\n    public async callPlayer<E extends string, U extends MultiplayerPlayer>(\n        player: U,\n        rpcName: Exclude<E, keyof MangoRPC.CustomServerToClientRPC>,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ) {\n        return this.$handleCall(player, rpcName, EventDestination.Client, options, body);\n    }\n\n    public onPlayerRequest<E extends string, U extends MultiplayerPlayer>(\n        rpcName: Exclude<E, keyof MangoRPC.CustomClientToServerRPC>,\n        handler: (sender: U, body: unknown) => unknown | Promise<unknown>,\n    ) {\n        if (this.$clientHandlers.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.$clientHandlers.delete(rpcName);\n            },\n            rpcName,\n            handler,\n            valid: true,\n        };\n\n        this.$clientHandlers.set(rpcName, rpcHandler);\n\n        return rpcHandler;\n    }\n\n    public async callWebView<E extends string, U extends MultiplayerPlayer>(\n        player: U,\n        id: string | number,\n        rpcName: Exclude<E, keyof MangoRPC.CustomServerToWebViewRPC>,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ) {\n        return this.$handleCall(player, rpcName, EventDestination.WebView, options, body, id);\n    }\n\n    public onWebViewRequest<E extends keyof MangoRPC.CustomWebViewToServerRPC, U extends MultiplayerPlayer>(\n        id: string | number,\n        rpcName: Exclude<E, keyof MangoRPC.CustomWebViewToServerRPC>,\n        handler: (\n            player: U,\n            body: Parameters<MangoRPC.CustomWebViewToServerRPC[E]>[0],\n        ) => ReturnType<MangoRPC.CustomWebViewToServerRPC[E]>,\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: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\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        player: MultiplayerPlayer,\n        rpcName: string,\n        destination: EventDestination, // 'client' | 'webview',\n        options?: Partial<RPCCallOptions>,\n        body?: unknown,\n        webViewId?: string | number,\n    ) {\n        return new Promise<RPCResult<TResult>>((resolve) => {\n            if (!player.valid) {\n                resolve(<RPCResult<TResult>>RPC_RESULT_PLAYER_NOT_FOUND);\n                return;\n            }\n\n            const callId = generateRandomId();\n            let timeoutId: NodeJS.Timeout;\n\n            const disconnectHandler = this.$eventService.onPlayerDisconnect((context) => {\n                if (context.player === player) {\n                    clearTimeout(timeoutId);\n                    disconnectHandler.destroy();\n                    resolve(<RPCResult<TResult>>RPC_RESULT_PLAYER_DISCONNECTED);\n                }\n            });\n\n            const onceHandle = (_player: MultiplayerPlayer, body: unknown) => {\n                clearTimeout(timeoutId);\n                disconnectHandler.destroy();\n                resolve(<RPCResult<TResult>>body);\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.oncePlayer(`RPC::RETURN_FROM_CLIENT_${callId}`, onceHandle);\n\n            const payload: RPCPayload = {\n                source: EventDestination.Server,\n                destination,\n                id: callId,\n                rpcName,\n                body,\n            };\n            // Example: RPC::CALL_SERVER, RPC::CALL_WEBVIEW\n            destination === EventDestination.WebView\n                ? player.emitWebView(webViewId!, 'RPC::CALL_WEBVIEW', payload)\n                : player.emit('RPC::CALL_CLIENT', payload);\n\n            timeoutId = setTimeout(() => {\n                eventHandler.destroy();\n                resolve(<RPCResult<TResult>>RPC_RESULT_TIMEOUT);\n            }, options?.timeout ?? this.$TIMEOUT);\n        });\n    }\n}\n", "import type { ScriptEventHandler } from '@ragemp-mango/core/app';\n\nexport class RageMPServerScriptEvent 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 { MultiplayerPlayer, ServerEventEmmiter } from '../../interfaces';\nimport { RageMPServerScriptEvent } from './ragemp-script-event-handler';\n\ntype NativeServerEvent = keyof IServerEvents;\nconst NATIVE_SERVER_EVENTS = new Set<NativeServerEvent>([\n    'entityCreated',\n    'entityDestroyed',\n    'entityModelChange',\n    'incomingConnection',\n    'packagesLoaded',\n    'playerChat',\n    'playerCommand',\n    'playerDamage',\n    'playerDeath',\n    'playerEnterCheckpoint',\n    'playerEnterColshape',\n    'playerEnterVehicle',\n    'playerExitCheckpoint',\n    'playerExitColshape',\n    'playerExitVehicle',\n    'playerJoin',\n    'playerQuit',\n    'playerReachWaypoint',\n    'playerReady',\n    'playerSpawn',\n    'playerStartEnterVehicle',\n    'playerStartExitVehicle',\n    'playerStreamIn',\n    'playerStreamOut',\n    'playerWeaponChange',\n    'serverShutdown',\n    'trailerAttached',\n    'vehicleDamage',\n    'vehicleDeath',\n    'vehicleHornToggle',\n    'vehicleSirenToggle',\n]);\n\nexport class ServerRageMPEventEmmiter implements ServerEventEmmiter {\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        mp.events.add(eventName, listener);\n        return new RageMPServerScriptEvent(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 RageMPServerScriptEvent(eventName, onceWrapper);\n    }\n\n    off(eventName: string, listener: (...args: any[]) => void): void {\n        mp.events.remove(eventName, listener);\n    }\n\n    emitPlayer(player: MultiplayerPlayer, eventName: string, ...args: any[]): void {\n        // In RageMP, player.call() is used to emit events to clients\n        (player as any).call(eventName, args);\n    }\n\n    emitAllPlayersRaw(eventName: string, ...args: any[]): void {\n        // In RageMP, use mp.players.call() to emit to all players\n        mp.players.call(eventName, args);\n    }\n\n    emitAllPlayersUnreliableRaw(eventName: string, ...args: any[]): void {\n        // RageMP has callUnreliable for unreliable events\n        mp.players.callUnreliable(eventName, args);\n    }\n\n    emitUnreliableRaw(players: MultiplayerPlayer[], eventName: string, ...args: any[]): void {\n        for (const player of players) {\n            (player as any).callUnreliable(eventName, args);\n        }\n    }\n\n    onPlayer(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        // Native RAGEMP events should be registered with 'on' type\n        // They are triggered by the game engine, not by client-to-server communication\n        if (NATIVE_SERVER_EVENTS.has(eventName as NativeServerEvent)) {\n            return this.on(eventName, listener);\n        }\n        // Custom client-to-server events - data is JSON stringified from client\n        const wrapper = (player: PlayerMp, ...args: any[]) => {\n            const parsedArgs = args.map(arg => {\n                if (typeof arg === 'string') {\n                    try {\n                        return JSON.parse(arg);\n                    } catch {\n                        return arg;\n                    }\n                }\n                return arg;\n            });\n            listener(player, ...parsedArgs);\n        };\n        mp.events.add(eventName, wrapper);\n        return new RageMPServerScriptEvent(eventName, wrapper);\n    }\n\n    oncePlayer(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler {\n        // Native RAGEMP events should be registered with 'once' type\n        if (NATIVE_SERVER_EVENTS.has(eventName as NativeServerEvent)) {\n            return this.once(eventName, listener);\n        }\n        // Custom client-to-server events - data is JSON stringified from client\n        const onceWrapper = (player: PlayerMp, ...args: any[]) => {\n            mp.events.remove(eventName, onceWrapper);\n            const parsedArgs = args.map(arg => {\n                if (typeof arg === 'string') {\n                    try {\n                        return JSON.parse(arg);\n                    } catch {\n                        return arg;\n                    }\n                }\n                return arg;\n            });\n            listener(player, ...parsedArgs);\n        };\n        mp.events.add(eventName, onceWrapper);\n        return new RageMPServerScriptEvent(eventName, onceWrapper);\n    }\n\n    offPlayer(eventName: string, listener: (...args: any[]) => void): void {\n        mp.events.remove(eventName, listener);\n    }\n}\n", "import type { ServerEventEmmiter, ServerMultiplayerService } from '../../interfaces';\nimport { RageMPMultiplayerService } from '@ragemp-mango/core/app';\nimport { ServerRageMPEventEmmiter } from './ragemp-event-emmiter';\n\nexport class ServerRageMPMultiplayerService extends RageMPMultiplayerService implements ServerMultiplayerService {\n    public override Events: ServerEventEmmiter;\n\n    constructor() {\n        super();\n        this.Events = new ServerRageMPEventEmmiter();\n    }\n\n    public getPlayer() {\n        // Return the mp.Player constructor for factory purposes\n        return (mp as any).Player;\n    }\n\n    public setBlipFactory(factory: any): void {\n        // RageMP doesn't have factory pattern like alt:V\n        // We can extend the prototype instead\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 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 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 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        // Could log a warning or implement custom solution\n    }\n\n    public setVirtualEntityFactory(_factory: any): void {\n        // RageMP doesn't have VirtualEntity\n        // Could log a warning or implement custom solution\n    }\n\n    public setVoiceChannelFactory(_factory: any): void {\n        // RageMP voice is handled differently\n        // Could implement custom voice channel management\n    }\n\n    // Override logging methods - RageMP server uses console.log, not mp.console.logInfo\n    public override 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        console.log(message);\n    }\n\n    public override 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        console.error(message);\n    }\n\n    public override 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        console.warn(message);\n    }\n\n    public override logDebug(arg: any, ...args: any[]): void {\n        const message = [arg, ...args].map(a =>\n            typeof a === 'object' ? JSON.stringify(a) : String(a)\n        ).join(' ');\n        console.log(`[DEBUG] ${message}`);\n    }\n}\n", "import type { ErrorFilter } from '../../interfaces';\nimport { UseFilters as $UseFilters, type Newable } from '@ragemp-mango/core';\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 OnServerStarted() {\n    return OnInternal(INTERNAL_EVENTS.SERVER_STARTED);\n}\n\nexport function OnceServerStarted() {\n    return OnceInternal(INTERNAL_EVENTS.SERVER_STARTED);\n}\nexport function OnConnectionQueueAdd() {\n    return OnInternal(INTERNAL_EVENTS.CONNECTION_QUEUE_ADD);\n}\n\nexport function OnceConnectionQueueAdd() {\n    return OnceInternal(INTERNAL_EVENTS.CONNECTION_QUEUE_ADD);\n}\nexport function OnConnectionQueueRemove() {\n    return OnInternal(INTERNAL_EVENTS.CONNECTION_QUEUE_REMOVE);\n}\n\nexport function OnceConnectionQueueRemove() {\n    return OnceInternal(INTERNAL_EVENTS.CONNECTION_QUEUE_REMOVE);\n}\nexport function OnPlayerConnect() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_CONNECT);\n}\n\nexport function OncePlayerConnect() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_CONNECT);\n}\nexport function OnPlayerConnectDenied() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_CONNECT_DENIED);\n}\n\nexport function OncePlayerConnectDenied() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_CONNECT_DENIED);\n}\nexport function OnPlayerDisconnect() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_DISCONNECT);\n}\n\nexport function OncePlayerDisconnect() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_DISCONNECT);\n}\nexport function OnPlayerDamage() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_DAMAGE);\n}\n\nexport function OncePlayerDamage() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_DAMAGE);\n}\nexport function OnPlayerDeath() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_DEATH);\n}\n\nexport function OncePlayerDeath() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_DEATH);\n}\nexport function OnPlayerHeal() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_HEAL);\n}\n\nexport function OncePlayerHeal() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_HEAL);\n}\nexport function OnPlayerControlRequest() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_CONTROL_REQUEST);\n}\n\nexport function OncePlayerControlRequest() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_CONTROL_REQUEST);\n}\nexport function OnPlayerInteriorChange() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_INTERIOR_CHANGE);\n}\n\nexport function OncePlayerInteriorChange() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_INTERIOR_CHANGE);\n}\nexport function OnPlayerDimensionChange() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_DIMENSION_CHANGE);\n}\n\nexport function OncePlayerDimensionChange() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_DIMENSION_CHANGE);\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 OnPlayerSyncedSceneRequest() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_REQUEST);\n}\n\nexport function OncePlayerSyncedSceneRequest() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_REQUEST);\n}\nexport function OnPlayerSyncedSceneStart() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_START);\n}\n\nexport function OncePlayerSyncedSceneStart() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_START);\n}\nexport function OnPlayerSyncedSceneStop() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_STOP);\n}\n\nexport function OncePlayerSyncedSceneStop() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_STOP);\n}\nexport function OnPlayerSyncedSceneUpdate() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_UPDATE);\n}\n\nexport function OncePlayerSyncedSceneUpdate() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_SYNCED_SCENE_UPDATE);\n}\nexport function OnPlayerSpawn() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_SPAWN);\n}\n\nexport function OncePlayerSpawn() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_SPAWN);\n}\nexport function OnPlayerAnimationChange() {\n    return OnInternal(INTERNAL_EVENTS.PLAYER_ANIMATION_CHANGE);\n}\n\nexport function OncePlayerAnimationChange() {\n    return OnceInternal(INTERNAL_EVENTS.PLAYER_ANIMATION_CHANGE);\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 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 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}\n\nexport function OnPedHeal() {\n    return OnInternal(INTERNAL_EVENTS.PED_HEAL);\n}\n\nexport function OncePedHeal() {\n    return OnceInternal(INTERNAL_EVENTS.PED_HEAL);\n}\nexport function OnPedDeath() {\n    return OnInternal(INTERNAL_EVENTS.PED_DEATH);\n}\n\nexport function OncePedDeath() {\n    return OnceInternal(INTERNAL_EVENTS.PED_DEATH);\n}\nexport function OnPedDamage() {\n    return OnInternal(INTERNAL_EVENTS.PED_DAMAGE);\n}\n\nexport function OncePedDamage() {\n    return OnceInternal(INTERNAL_EVENTS.PED_DAMAGE);\n}\nexport function OnVehicleDestroy() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_DESTROY);\n}\n\nexport function OnceVehicleDestroy() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_DESTROY);\n}\nexport function OnVehicleAttach() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_ATTACH);\n}\n\nexport function OnceVehicleAttach() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_ATTACH);\n}\nexport function OnVehicleDetach() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_DETACH);\n}\n\nexport function OnceVehicleDetach() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_DETACH);\n}\nexport function OnVehicleDamage() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_DAMAGE);\n}\n\nexport function OnceVehicleDamage() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_DAMAGE);\n}\nexport function OnVehicleSirenStateChange() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_SIREN_STATE_CHANGE);\n}\n\nexport function OnceVehicleSirenStateChange() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_SIREN_STATE_CHANGE);\n}\nexport function OnVehicleHornStateChange() {\n    return OnInternal(INTERNAL_EVENTS.VEHICLE_HORN_STATE_CHANGE);\n}\n\nexport function OnceVehicleHornStateChange() {\n    return OnceInternal(INTERNAL_EVENTS.VEHICLE_HORN_STATE_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 OnClientObjectDelete() {\n    return OnInternal(INTERNAL_EVENTS.CLIENT_OBJECT_DELETE);\n}\n\nexport function OnceClientObjectDelete() {\n    return OnceInternal(INTERNAL_EVENTS.CLIENT_OBJECT_DELETE);\n}\nexport function OnClientObjectRequest() {\n    return OnInternal(INTERNAL_EVENTS.CLIENT_OBJECT_REQUEST);\n}\n\nexport function OnceClientObjectRequest() {\n    return OnceInternal(INTERNAL_EVENTS.CLIENT_OBJECT_REQUEST);\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 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 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 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 OnExplosion() {\n    return OnInternal(INTERNAL_EVENTS.EXPLOSION);\n}\n\nexport function OnceExplosion() {\n    return OnceInternal(INTERNAL_EVENTS.EXPLOSION);\n}\nexport function OnFireStart() {\n    return OnInternal(INTERNAL_EVENTS.FIRE_START);\n}\n\nexport function OnceFireStart() {\n    return OnceInternal(INTERNAL_EVENTS.FIRE_START);\n}\nexport function OnProjectileStart() {\n    return OnInternal(INTERNAL_EVENTS.PROJECTILE_START);\n}\n\nexport function OnceProjectileStart() {\n    return OnceInternal(INTERNAL_EVENTS.PROJECTILE_START);\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 OnGivePedScriptedTask() {\n    return OnInternal(INTERNAL_EVENTS.GIVE_PED_SCRIPTED_TASK);\n}\n\nexport function OnceGivePedScriptedTask() {\n    return OnceInternal(INTERNAL_EVENTS.GIVE_PED_SCRIPTED_TASK);\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}\n\nexport function OnAnyResourceStart() {\n    return OnInternal(INTERNAL_EVENTS.ANY_RESOURCE_START);\n}\n\nexport function OnceAnyResourceStart() {\n    return OnceInternal(INTERNAL_EVENTS.ANY_RESOURCE_START);\n}\n\nexport function OnAnyResourceStop() {\n    return OnInternal(INTERNAL_EVENTS.ANY_RESOURCE_STOP);\n}\n\nexport function OnceAnyResourceStop() {\n    return OnceInternal(INTERNAL_EVENTS.ANY_RESOURCE_STOP);\n}\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}\nexport function OnEvent() {\n    return OnInternal(INTERNAL_EVENTS.EVENT);\n}\n\nexport function OnceEvent() {\n    return OnceInternal(INTERNAL_EVENTS.EVENT);\n}\n", "import { createEventDecorator } from '@ragemp-mango/core';\n\nexport function OnPlayer<E extends keyof MangoEvents.CustomPlayerToServerEvent>(eventName?: E): MethodDecorator;\nexport function OnPlayer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>): MethodDecorator;\nexport function OnPlayer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>) {\n    return createEventDecorator('onPlayer', eventName);\n}", "import { OnWebView as $OnWebView } from '@ragemp-mango/core';\n\nexport function OnWebView<E extends keyof MangoEvents.CustomWebViewToServerEvent>(id: string | number, eventName?: E): MethodDecorator;\nexport function OnWebView<E extends string>(\n    id: string | number,\n    eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>,\n): MethodDecorator;\nexport function OnWebView<E extends string>(id: string | number, eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>) {\n    return $OnWebView(id, eventName);\n}\n", "import { On as $On } from '@ragemp-mango/core';\n\nexport function On<E extends keyof MangoEvents.CustomServerEvent>(eventName?: E): MethodDecorator;\nexport function On<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerEvent>): MethodDecorator;\nexport function On<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerEvent>) {\n    return $On(eventName);\n}\n", "import { createEventDecorator } from '@ragemp-mango/core';\n\nexport function OncePlayer<E extends keyof MangoEvents.CustomPlayerToServerEvent>(eventName?: E): MethodDecorator;\nexport function OncePlayer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>): MethodDecorator;\nexport function OncePlayer<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>) {\n    return createEventDecorator('oncePlayer', eventName);\n}\n", "import { OnceWebView as $OnceWebView } from '@ragemp-mango/core';\n\nexport function OnceWebView<E extends keyof MangoEvents.CustomWebViewToServerEvent>(id: string | number, eventName?: E): MethodDecorator;\nexport function OnceWebView<E extends string>(\n    id: string | number,\n    eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>,\n): MethodDecorator;\nexport function OnceWebView<E extends string>(id: string | number, eventName?: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>) {\n    return $OnceWebView(id, eventName);\n}\n", "import { Once as $Once } from '@ragemp-mango/core';\n\nexport function Once<E extends keyof MangoEvents.CustomServerEvent>(eventName?: E): MethodDecorator;\nexport function Once<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerEvent>): MethodDecorator;\nexport function Once<E extends string>(eventName?: Exclude<E, keyof MangoEvents.CustomServerEvent>) {\n    return $Once(eventName);\n}\n", "import { CoreMetadataKey, MethodParamType, type MethodParameter } from '@ragemp-mango/core/app';\nimport { ErrorMessage, type Newable, type Pipe } from '@ragemp-mango/core';\n\nexport function Player(key?: string, ...pipes: Newable<Pipe>[]) {\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, pipes, type: MethodParamType.Player, data: key, metatype }],\n            target,\n            method,\n        );\n    });\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 { createRPCDecorator } from '@ragemp-mango/core';\n\nexport function OnPlayerRequest<E extends keyof MangoRPC.CustomClientToServerRPC>(rpcName?: E): MethodDecorator;\nexport function OnPlayerRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomClientToServerRPC>): MethodDecorator;\nexport function OnPlayerRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomClientToServerRPC>) {\n    return createRPCDecorator('onPlayerRequest', rpcName);\n}\n", "import { OnRequest as $OnRequest } from '@ragemp-mango/core';\n\nexport function OnRequest<E extends keyof MangoRPC.CustomServerRPC>(rpcName?: E): MethodDecorator;\nexport function OnRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomServerRPC>): MethodDecorator;\nexport function OnRequest<E extends string>(rpcName?: Exclude<E, keyof MangoRPC.CustomServerRPC>) {\n    return $OnRequest(rpcName);\n}\n", "import { OnWebViewRequest as $OnWebViewRequest } from '@ragemp-mango/core';\n\nexport function OnWebViewRequest<E extends keyof MangoRPC.CustomWebViewToServerRPC>(id: string | number, rpcName?: E): MethodDecorator;\nexport function OnWebViewRequest<E extends string>(\n    id: string | number,\n    rpcName?: Exclude<E, keyof MangoRPC.CustomWebViewToServerRPC>,\n): MethodDecorator;\nexport function OnWebViewRequest<E extends string>(id: string | number, rpcName?: Exclude<E, keyof MangoRPC.CustomWebViewToServerRPC>) {\n    return $OnWebViewRequest(id, rpcName);\n}\n", "export const THROTTLER_LIMIT = 'THROTTLER_LIMIT';\nexport const THROTTLER_TTL = 'THROTTLER_TTL';\nexport const THROTTLER_OPTIONS = 'THROTTLER_MODULE_OPTIONS';\nexport const THROTTLER_SKIP = 'THROTTLER_SKIP';\nexport const THROTTLER_STORAGE = 'THROTTLER_STORAGE';\n", "import { THROTTLER_SKIP } from '../throttler.constants';\n\nexport function SkipThrottle(skip: Record<string, boolean> = { default: true }) {\n    return (target: any, _propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<any>) => {\n        for (const key in skip) {\n            if (descriptor) {\n                Reflect.defineMetadata(THROTTLER_SKIP + key, skip[key], descriptor.value);\n                return descriptor;\n            }\n            Reflect.defineMetadata(THROTTLER_SKIP + key, skip[key], target);\n            return target;\n        }\n    };\n}\n", "import type { ThrottlerMethodOrControllerOptions } from '../interfaces';\nimport { THROTTLER_LIMIT, THROTTLER_TTL } from '../throttler.constants';\n\nfunction setThrottlerMetadata(target: any, options: Record<string, ThrottlerMethodOrControllerOptions>): void {\n    for (const name in options) {\n        Reflect.defineMetadata(THROTTLER_TTL + name, options[name]!.ttl, target);\n        Reflect.defineMetadata(THROTTLER_LIMIT + name, options[name]!.limit, target);\n    }\n}\n\nexport function Throttle(options: Record<string, ThrottlerMethodOrControllerOptions>) {\n    return (target: any, _propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<any>) => {\n        if (descriptor) {\n            setThrottlerMetadata(descriptor.value, options);\n            return descriptor;\n        }\n        setThrottlerMetadata(target, options);\n        return target;\n    };\n}\n", "import type { Resolvable, ThrottlerLimitDetail, ThrottlerModuleOptions, ThrottlerOptions } from './interfaces';\nimport { THROTTLER_LIMIT, THROTTLER_OPTIONS, THROTTLER_SKIP, THROTTLER_STORAGE, THROTTLER_TTL } from './throttler.constants';\nimport { createHash } from 'crypto';\nimport type { ExecutionContext, Guard } from '../../interfaces';\nimport type { ThrottlerStorageService } from './services';\nimport {\n    isFunction,\n    TooManyRequests,\n    type OnModuleInit,\n    type ReflectorService,\n    ErrorMessage,\n    Injectable,\n    Inject,\n    REFLECTOR_SERVICE,\n} from '@ragemp-mango/core';\n\n@Injectable()\nexport class ThrottlerGuard implements Guard, OnModuleInit {\n    @Inject(THROTTLER_OPTIONS) protected readonly options: ThrottlerModuleOptions;\n    @Inject(THROTTLER_STORAGE) protected readonly storageService: ThrottlerStorageService;\n    @Inject(REFLECTOR_SERVICE) protected readonly reflector: ReflectorService;\n    protected throttlers: Array<ThrottlerOptions>;\n    protected commonOptions: Pick<ThrottlerOptions, 'skipIf'>;\n\n    public async onModuleInit() {\n        this.throttlers = (Array.isArray(this.options) ? this.options : this.options.throttlers)\n            .sort((first, second) => {\n                if (isFunction(first.ttl)) {\n                    return 1;\n                }\n                if (isFunction(second.ttl)) {\n                    return 0;\n                }\n                return first.ttl - second.ttl;\n            })\n            .map((opt) => ({ ...opt, name: opt.name ?? 'default' }));\n        if (Array.isArray(this.options)) {\n            this.commonOptions = {};\n        } else {\n            this.commonOptions = {\n                skipIf: this.options.skipIf!,\n            };\n        }\n    }\n\n    public async canActivate(context: ExecutionContext) {\n        const continues: boolean[] = [];\n        for (const namedThrottler of this.throttlers) {\n            // Return early if the current route should be skipped.\n            const skip = this.reflector.getAllAndOverride<boolean>(THROTTLER_SKIP + namedThrottler.name, [\n                context.handler,\n                context.classRef,\n            ]);\n            const skipIf = namedThrottler.skipIf || this.commonOptions.skipIf;\n            if (skip || skipIf?.(context)) {\n                continues.push(true);\n                continue;\n            }\n\n            // Return early when we have no limit or ttl data.\n            const routeOrClassLimit = this.reflector.getAllAndOverride<Resolvable<number>>(THROTTLER_LIMIT + namedThrottler.name, [\n                context.handler,\n                context.classRef,\n            ]);\n            const routeOrClassTtl = this.reflector.getAllAndOverride<Resolvable<number>>(THROTTLER_TTL + namedThrottler.name, [\n                context.handler,\n                context.classRef,\n            ]);\n\n            // Check if specific limits are set at class or route level, otherwise use global options.\n            const limit = await this.resolveValue(context, routeOrClassLimit || namedThrottler.limit);\n            const ttl = await this.resolveValue(context, routeOrClassTtl || namedThrottler.ttl);\n            continues.push(await this.handleRequest(context, limit, ttl, namedThrottler));\n        }\n        return continues.every((cont) => cont);\n    }\n\n    protected async handleRequest(context: ExecutionContext, limit: number, ttl: number, throttler: ThrottlerOptions) {\n        const player = context.request.player;\n        if(!player) throw new Error(`Player is not in context`);\n        const key = this.generateKey(context, throttler.name!);\n        const { totalHits, timeToExpire } = await this.storageService.increment(player, key, ttl);\n\n        if (totalHits > limit) {\n            await this.throwThrottlingException(context, {\n                limit,\n                ttl,\n                key,\n                player,\n                totalHits,\n                timeToExpire,\n            });\n        }\n\n        return true;\n    }\n\n    protected generateKey(context: ExecutionContext, name: string) {\n        const prefix = `${context.classRef.name}-${context.handler.name}-${name}`;\n        return createHash('md5').update(prefix).digest('hex').toString();\n    }\n\n    protected async throwThrottlingException(context: ExecutionContext, _throttlerLimitDetail: ThrottlerLimitDetail) {\n        throw new TooManyRequests(await this.getErrorMessage(context));\n    }\n\n    protected async getErrorMessage(_context: ExecutionContext) {\n        if (!Array.isArray(this.options)) {\n            return this.options.errorMessage ?? ErrorMessage.TooManyRequests;\n        }\n        return ErrorMessage.TooManyRequests;\n    }\n\n    private async resolveValue<T extends number | string | boolean>(context: ExecutionContext, resolvableValue: Resolvable<T>) {\n        return isFunction(resolvableValue) ? resolvableValue(context) : resolvableValue;\n    }\n}\n", "import { Injectable, type OnAppShutdown } from '@ragemp-mango/core';\nimport type { ThrottlerStorageOptions } from '../interfaces';\n\n@Injectable()\nexport class ThrottlerStorageService implements OnAppShutdown {\n    public readonly storage: WeakMap<PlayerMp, Map<string, ThrottlerStorageOptions>> = new WeakMap();\n    private timeoutIds: NodeJS.Timeout[] = [];\n\n    private getExpirationTime(player: PlayerMp, key: string) {\n        return Math.floor((this.storage.get(player)!.get(key)!.expiresAt - Date.now()) / 1000);\n    }\n\n    private setExpirationTime(player: PlayerMp, key: string, ttlMilliseconds: number) {\n        const timeoutId = setTimeout(() => {\n            this.storage.get(player)!.get(key)!.totalHits--;\n            clearTimeout(timeoutId);\n            this.timeoutIds = this.timeoutIds.filter((id) => id != timeoutId);\n        }, ttlMilliseconds);\n        this.timeoutIds.push(timeoutId);\n    }\n\n    public async increment(player: PlayerMp, key: string, ttl: number) {\n        const ttlMilliseconds = ttl;\n\n        if (!this.storage.get(player)) {\n            this.storage.set(player, new Map());\n        }\n\n        if (!this.storage.get(player)!.get(key)) {\n            this.storage.get(player)!.set(key, { totalHits: 0, expiresAt: Date.now() + ttlMilliseconds });\n        }\n\n        let timeToExpire = this.getExpirationTime(player, key);\n\n        // Reset the timeToExpire once it has been expired.\n        if (timeToExpire <= 0) {\n            this.storage.get(player)!.get(key)!.expiresAt = Date.now() + ttlMilliseconds;\n            timeToExpire = this.getExpirationTime(player, key);\n        }\n\n        this.storage.get(player)!.get(key)!.totalHits++;\n        this.setExpirationTime(player, key, ttlMilliseconds);\n\n        return {\n            totalHits: this.storage.get(player)!.get(key)!.totalHits,\n            timeToExpire,\n        };\n    }\n\n    public onAppShutdown() {\n        this.timeoutIds.forEach(clearTimeout);\n    }\n}\n", "import { Global, Module, type DynamicModule, type Provider, type FactoryProvider } from '@ragemp-mango/core';\nimport { THROTTLER_OPTIONS, THROTTLER_STORAGE } from './throttler.constants';\nimport type { ThrottlerAsyncOptions, ThrottlerModuleOptions, ThrottlerOptionsFactory } from './interfaces';\nimport { ThrottlerStorageService } from './services/throttler-storage.service';\n\n@Global()\n@Module()\nexport class ThrottlerModule {\n    public static forRoot(options: ThrottlerModuleOptions = []) {\n        return {\n            module: ThrottlerModule,\n            providers: [\n                {\n                    provide: THROTTLER_OPTIONS,\n                    useValue: options,\n                },\n                {\n                    provide: THROTTLER_STORAGE,\n                    useClass: ThrottlerStorageService,\n                },\n            ],\n            exports: [THROTTLER_STORAGE, THROTTLER_OPTIONS],\n        } as DynamicModule<ThrottlerModule>;\n    }\n\n    public static forRootAsync(options: ThrottlerAsyncOptions) {\n        const providers = [\n            ...this.createAsyncProviders(options),\n            {\n                provide: THROTTLER_STORAGE,\n                useClass: ThrottlerStorageService,\n            },\n        ];\n        return {\n            module: ThrottlerModule,\n            imports: options.imports ?? [],\n            providers,\n            exports: providers,\n        } as DynamicModule<ThrottlerModule>;\n    }\n\n    private static createAsyncProviders(options: ThrottlerAsyncOptions) {\n        if (options.useExisting || options.useFactory) {\n            return [this.createAsyncOptionsProvider(options)];\n        }\n        return [\n            this.createAsyncOptionsProvider(options),\n            {\n                provide: options.useClass,\n                useClass: options.useClass,\n            },\n        ] as Provider[];\n    }\n\n    private static createAsyncOptionsProvider(options: ThrottlerAsyncOptions) {\n        if (options.useFactory) {\n            return {\n                provide: THROTTLER_OPTIONS,\n                useFactory: options.useFactory,\n                inject: options.inject ?? [],\n            } as FactoryProvider;\n        }\n        return {\n            provide: THROTTLER_OPTIONS,\n            useFactory: async (optionsFactory: ThrottlerOptionsFactory) => await optionsFactory.createThrottlerOptions(),\n            inject: options.useClass ? [options.useClass] : options.useExisting ? [options.useExisting] : [],\n        } as FactoryProvider;\n    }\n}\n", "import { createAppBuilder as $createAppBuilder, AppBuilder, AppEnviroment } from '@ragemp-mango/core/app';\nimport { PlayerPrototypePlugin, RPCPlugin, ServiceBinderPlugin } from './plugins';\nimport type { ErrorFilter, Guard, Interceptor, ServerMultiplayerService } from './interfaces';\nimport { ServerRageMPMultiplayerService } from './multiplayer/ragemp';\n\nconst multiplayerService: ServerMultiplayerService = new ServerRageMPMultiplayerService();\n\nclass ServerAppBuilder extends AppBuilder<Guard, Interceptor, ErrorFilter> {\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 setPedFactory(factory: unknown) {\n        multiplayerService.setPedFactory(factory);\n    }\n\n    public setPlayerFactory(factory: unknown) {\n        multiplayerService.setPlayerFactory(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 setVoiceChannelFactory(factory: unknown) {\n        multiplayerService.setVoiceChannelFactory(factory);\n    }\n}\n\nexport async function createAppBuilder() {\n    return await $createAppBuilder({\n        enviroment: AppEnviroment.Server,\n        plugins: [ServiceBinderPlugin, PlayerPrototypePlugin, RPCPlugin],\n        appBuilderInherit: ServerAppBuilder,\n        multiplayerService\n    });\n}\n\nexport * from './exports';\n\nimport './extension.d.ts';\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", "Container", "inject", "injectable", "DefaultValuePipe", "defaultValue", "transform", "value", "isNil", "isNumber", "isNaN", "PlayerPrototypePlugin", "globalAppContainer", "loggerService", "multiplayerService", "beforeLoad", "time", "Date", "now", "Player", "getPlayer", "prototype", "emitWebView", "id", "eventName", "body", "emitRaw", "payload", "rpcService", "get", "RPC_SERVICE", "call", "rpcName", "options", "callPlayer", "callWebView", "log", "inject", "injectable", "RPCPlugin", "eventService", "rpcService", "loggerService", "beforeLoad", "time", "Date", "now", "onPlayer", "player", "body", "valid", "rpcHandler", "source", "EventDestination", "Client", "$clientHandlers", "get", "rpcName", "WebView", "$webViewHandlers", "webViewId", "undefined", "emitWebView", "id", "RPC_RESULT_HANDLER_NOT_FOUND", "emitRaw", "handlerResult", "handler", "rpcResult", "success", "status", "RPCResultStatus", "Success", "error", "MangoError", "message", "details", "RPC_RESULT_UNKNOWN", "log", "Container", "inject", "injectable", "inject", "injectable", "INTERNAL_EVENTS", "SCRIPT_RPC", "SCRIPT_RPC_ANSWER", "SERVER_STARTED", "CONNECTION_QUEUE_ADD", "CONNECTION_QUEUE_REMOVE", "PLAYER_CONNECT", "PLAYER_CONNECT_DENIED", "PLAYER_DISCONNECT", "PLAYER_DAMAGE", "PLAYER_DEATH", "PLAYER_HEAL", "PLAYER_CONTROL_REQUEST", "PLAYER_INTERIOR_CHANGE", "PLAYER_DIMENSION_CHANGE", "PLAYER_WEAPON_CHANGE", "PLAYER_SYNCED_SCENE_REQUEST", "PLAYER_SYNCED_SCENE_START", "PLAYER_SYNCED_SCENE_STOP", "PLAYER_SYNCED_SCENE_UPDATE", "PLAYER_SPAWN", "PLAYER_ANIMATION_CHANGE", "PLAYER_VEHICLE_ENTERED", "PLAYER_START_VEHICLE_ENTER", "PLAYER_VEHICLE_LEFT", "PLAYER_VEHICLE_SEAT_CHANGE", "PED_HEAL", "PED_DEATH", "PED_DAMAGE", "VEHICLE_DESTROY", "VEHICLE_ATTACH", "VEHICLE_DETACH", "VEHICLE_DAMAGE", "VEHICLE_SIREN_STATE_CHANGE", "VEHICLE_HORN_STATE_CHANGE", "VOICE_CONNECTION", "CLIENT_OBJECT_DELETE", "CLIENT_OBJECT_REQUEST", "BASE_OBJECT_CREATE", "BASE_OBJECT_REMOVE", "NET_OWNER_CHANGE", "WEAPON_DAMAGE", "META_CHANGE", "LOCAL_META_CHANGE", "STREAM_SYNCED_META_CHANGE", "GLOBAL_META_CHANGE", "GLOBAL_SYNCED_META_CHANGE", "CONSOLE_COMMAND", "ERROR", "COL_SHAPE_EVENT", "EXPLOSION", "FIRE_START", "PROJECTILE_START", "ENTITY_COL_SHAPE_ENTER", "ENTITY_COL_SHAPE_LEAVE", "ENTITY_CHECKPOINT_ENTER", "ENTITY_CHECKPOINT_LEAVE", "GIVE_PED_SCRIPTED_TASK", "LOCAL_SCRIPT_EVENT", "REMOTE_SCRIPT_EVENT", "ANY_RESOURCE_START", "ANY_RESOURCE_STOP", "RESOURCE_START", "RESOURCE_STOP", "RESOURCE_ERROR", "EVENT", "ServerEventService", "BaseEventService", "$rageEvents", "multiplayerService", "Events", "$internalEventNames", "Set", "Object", "values", "INTERNAL_EVENTS", "onPlayer", "eventName", "callback", "wrapper", "player", "args", "eventHandler", "$remoteHandlers", "add", "oncePlayer", "onRemote", "onceRemote", "emitPlayers", "players", "body", "call", "emitPlayersUnreliable", "callUnreliable", "emitAllPlayers", "mp", "emitAllPlayersUnreliable", "onWebView", "id", "onceWebView", "emitWebViews", "payload", "emitAllWebViews", "emitAllWebViewsUnreliable", "onPlayerJoin", "on", "onPlayerQuit", "onPlayerReady", "onPlayerDeath", "onPlayerSpawn", "onPlayerChat", "onPlayerCommand", "onPlayerEnterVehicle", "onPlayerExitVehicle", "onPlayerStartEnterVehicle", "onPlayerStartExitVehicle", "onPlayerWeaponChange", "onPlayerDamage", "onVehicleDeath", "onVehicleDamage", "onPlayerEnterColshape", "onPlayerExitColshape", "onPlayerEnterCheckpoint", "onPlayerExitCheckpoint", "onPlayerConnect", "onPlayerDisconnect", "exitType", "reason", "inject", "injectable", "ServerLoggerService", "multiplayerService", "log", "args", "MANGO_LOG_PREFIX", "warn", "logWarning", "error", "logError", "debug", "logDebug", "inject", "injectable", "ServerRPCService", "BaseRPCService", "$eventService", "$clientHandlers", "Map", "$webViewHandlers", "callPlayer", "player", "rpcName", "body", "options", "timeout", "$TIMEOUT", "$handleCall", "EventDestination", "Client", "onPlayerRequest", "handler", "has", "$loggerService", "error", "Error", "ErrorMessage", "RPCHandlerAlreadyExists", "rpcHandler", "destroy", "valid", "delete", "set", "callWebView", "id", "WebView", "onWebViewRequest", "key", "destination", "webViewId", "Promise", "resolve", "RPC_RESULT_PLAYER_NOT_FOUND", "callId", "generateRandomId", "timeoutId", "disconnectHandler", "onPlayerDisconnect", "context", "clearTimeout", "RPC_RESULT_PLAYER_DISCONNECTED", "onceHandle", "_player", "eventHandler", "onceWebView", "oncePlayer", "payload", "source", "Server", "emitWebView", "emit", "setTimeout", "RPC_RESULT_TIMEOUT", "ServiceBinderPlugin", "internalAppContainer", "globalAppContainer", "onBuild", "time", "Date", "now", "bind", "LOGGER_SERVICE", "to", "ServerLoggerService", "inSingletonScope", "EVENT_SERVICE", "ServerEventService", "RPC_SERVICE", "ServerRPCService", "toConstantValue", "get", "loggerService", "log", "RageMPServerScriptEvent", "eventName", "listener", "destroy", "mp", "events", "remove", "NATIVE_SERVER_EVENTS", "Set", "ServerRageMPEventEmmiter", "emit", "eventName", "args", "mp", "events", "call", "on", "listener", "add", "RageMPServerScriptEvent", "once", "onceWrapper", "remove", "off", "emitPlayer", "player", "emitAllPlayersRaw", "players", "emitAllPlayersUnreliableRaw", "callUnreliable", "emitUnreliableRaw", "onPlayer", "has", "wrapper", "parsedArgs", "map", "arg", "JSON", "parse", "oncePlayer", "offPlayer", "ServerRageMPMultiplayerService", "RageMPMultiplayerService", "Events", "ServerRageMPEventEmmiter", "getPlayer", "mp", "Player", "setBlipFactory", "factory", "Blip", "Object", "assign", "prototype", "setMarkerFactory", "Marker", "setColShapeFactory", "Colshape", "setCheckpointFactory", "Checkpoint", "setObjectFactory", "setPedFactory", "Ped", "setPlayerFactory", "setVehicleFactory", "Vehicle", "setVirtualEntityGroupFactory", "_factory", "setVirtualEntityFactory", "setVoiceChannelFactory", "log", "arg", "args", "message", "map", "a", "JSON", "stringify", "String", "join", "console", "logError", "error", "logWarning", "warn", "logDebug", "UseFilters", "filters", "$UseFilters", "OnScriptRPC", "OnInternal", "INTERNAL_EVENTS", "SCRIPT_RPC", "OnceScriptRPC", "OnceInternal", "OnScriptRPCAnswer", "SCRIPT_RPC_ANSWER", "OnceScriptRPCAnswer", "OnServerStarted", "SERVER_STARTED", "OnceServerStarted", "OnConnectionQueueAdd", "CONNECTION_QUEUE_ADD", "OnceConnectionQueueAdd", "OnConnectionQueueRemove", "CONNECTION_QUEUE_REMOVE", "OnceConnectionQueueRemove", "OnPlayerConnect", "PLAYER_CONNECT", "OncePlayerConnect", "OnPlayerConnectDenied", "PLAYER_CONNECT_DENIED", "OncePlayerConnectDenied", "OnPlayerDisconnect", "PLAYER_DISCONNECT", "OncePlayerDisconnect", "OnPlayerDamage", "PLAYER_DAMAGE", "OncePlayerDamage", "OnPlayerDeath", "PLAYER_DEATH", "OncePlayerDeath", "OnPlayerHeal", "PLAYER_HEAL", "OncePlayerHeal", "OnPlayerControlRequest", "PLAYER_CONTROL_REQUEST", "OncePlayerControlRequest", "OnPlayerInteriorChange", "PLAYER_INTERIOR_CHANGE", "OncePlayerInteriorChange", "OnPlayerDimensionChange", "PLAYER_DIMENSION_CHANGE", "OncePlayerDimensionChange", "OnPlayerWeaponChange", "PLAYER_WEAPON_CHANGE", "OncePlayerWeaponChange", "OnPlayerSyncedSceneRequest", "PLAYER_SYNCED_SCENE_REQUEST", "OncePlayerSyncedSceneRequest", "OnPlayerSyncedSceneStart", "PLAYER_SYNCED_SCENE_START", "OncePlayerSyncedSceneStart", "OnPlayerSyncedSceneStop", "PLAYER_SYNCED_SCENE_STOP", "OncePlayerSyncedSceneStop", "OnPlayerSyncedSceneUpdate", "PLAYER_SYNCED_SCENE_UPDATE", "OncePlayerSyncedSceneUpdate", "OnPlayerSpawn", "PLAYER_SPAWN", "OncePlayerSpawn", "OnPlayerAnimationChange", "PLAYER_ANIMATION_CHANGE", "OncePlayerAnimationChange", "OnPlayerVehicleEntered", "PLAYER_VEHICLE_ENTERED", "OncePlayerVehicleEntered", "OnPlayerStartVehicleEnter", "PLAYER_START_VEHICLE_ENTER", "OncePlayerStartVehicleEnter", "OnPlayerVehicleLeft", "PLAYER_VEHICLE_LEFT", "OncePlayerVehicleLeft", "OnPlayerVehicleSeatChange", "PLAYER_VEHICLE_SEAT_CHANGE", "OncePlayerVehicleSeatChange", "OnPedHeal", "PED_HEAL", "OncePedHeal", "OnPedDeath", "PED_DEATH", "OncePedDeath", "OnPedDamage", "PED_DAMAGE", "OncePedDamage", "OnVehicleDestroy", "VEHICLE_DESTROY", "OnceVehicleDestroy", "OnVehicleAttach", "VEHICLE_ATTACH", "OnceVehicleAttach", "OnVehicleDetach", "VEHICLE_DETACH", "OnceVehicleDetach", "OnVehicleDamage", "VEHICLE_DAMAGE", "OnceVehicleDamage", "OnVehicleSirenStateChange", "VEHICLE_SIREN_STATE_CHANGE", "OnceVehicleSirenStateChange", "OnVehicleHornStateChange", "VEHICLE_HORN_STATE_CHANGE", "OnceVehicleHornStateChange", "OnVoiceConnection", "VOICE_CONNECTION", "OnceVoiceConnection", "OnClientObjectDelete", "CLIENT_OBJECT_DELETE", "OnceClientObjectDelete", "OnClientObjectRequest", "CLIENT_OBJECT_REQUEST", "OnceClientObjectRequest", "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", "OnStreamSyncedMetaChange", "STREAM_SYNCED_META_CHANGE", "OnceStreamSyncedMetaChange", "OnGlobalMetaChange", "GLOBAL_META_CHANGE", "OnceGlobalMetaChange", "OnGlobalSyncedMetaChange", "GLOBAL_SYNCED_META_CHANGE", "OnceGlobalSyncedMetaChange", "OnConsoleCommand", "CONSOLE_COMMAND", "OnceConsoleCommand", "OnError", "ERROR", "OnceError", "OnColShapeEvent", "COL_SHAPE_EVENT", "OnceColShapeEvent", "OnExplosion", "EXPLOSION", "OnceExplosion", "OnFireStart", "FIRE_START", "OnceFireStart", "OnProjectileStart", "PROJECTILE_START", "OnceProjectileStart", "OnEntityColShapeEnter", "ENTITY_COL_SHAPE_ENTER", "OnceEntityColShapeEnter", "OnEntityColShapeLeave", "ENTITY_COL_SHAPE_LEAVE", "OnceEntityColShapeLeave", "OnEntityCheckpointEnter", "ENTITY_CHECKPOINT_ENTER", "OnceEntityCheckpointEnter", "OnEntityCheckpointLeave", "ENTITY_CHECKPOINT_LEAVE", "OnceEntityCheckpointLeave", "OnGivePedScriptedTask", "GIVE_PED_SCRIPTED_TASK", "OnceGivePedScriptedTask", "OnLocalScriptEvent", "LOCAL_SCRIPT_EVENT", "OnceLocalScriptEvent", "OnRemoteScriptEvent", "REMOTE_SCRIPT_EVENT", "OnceRemoteScriptEvent", "OnAnyResourceStart", "ANY_RESOURCE_START", "OnceAnyResourceStart", "OnAnyResourceStop", "ANY_RESOURCE_STOP", "OnceAnyResourceStop", "OnResourceStart", "RESOURCE_START", "OnceResourceStart", "OnResourceStop", "RESOURCE_STOP", "OnceResourceStop", "OnResourceError", "RESOURCE_ERROR", "OnceResourceError", "OnEvent", "EVENT", "OnceEvent", "OnPlayer", "eventName", "createEventDecorator", "OnWebView", "id", "eventName", "$OnWebView", "On", "eventName", "$On", "OncePlayer", "eventName", "createEventDecorator", "OnceWebView", "id", "eventName", "$OnceWebView", "Once", "eventName", "$Once", "Player", "key", "pipes", "target", "method", "index", "params", "Reflect", "getMetadata", "CoreMetadataKey", "ControllerParams", "some", "param", "Error", "ErrorMessage", "MultipleDecoratorsOnSingleParameterNotAllowed", "paramTypes", "metatype", "Array", "isArray", "undefined", "defineMetadata", "type", "MethodParamType", "data", "UseGuards", "guards", "$UseGuards", "UseInterceptors", "interceptors", "$UseInterceptors", "OnPlayerRequest", "rpcName", "createRPCDecorator", "OnRequest", "rpcName", "$OnRequest", "OnWebViewRequest", "id", "rpcName", "$OnWebViewRequest", "THROTTLER_LIMIT", "THROTTLER_TTL", "THROTTLER_OPTIONS", "THROTTLER_SKIP", "THROTTLER_STORAGE", "SkipThrottle", "skip", "default", "target", "_propertyKey", "descriptor", "key", "Reflect", "defineMetadata", "THROTTLER_SKIP", "value", "setThrottlerMetadata", "target", "options", "name", "Reflect", "defineMetadata", "THROTTLER_TTL", "ttl", "THROTTLER_LIMIT", "limit", "Throttle", "_propertyKey", "descriptor", "value", "createHash", "ThrottlerGuard", "options", "storageService", "reflector", "throttlers", "commonOptions", "onModuleInit", "Array", "isArray", "sort", "first", "second", "isFunction", "ttl", "map", "opt", "name", "skipIf", "canActivate", "context", "continues", "namedThrottler", "skip", "getAllAndOverride", "THROTTLER_SKIP", "handler", "classRef", "push", "routeOrClassLimit", "THROTTLER_LIMIT", "routeOrClassTtl", "THROTTLER_TTL", "limit", "resolveValue", "handleRequest", "every", "cont", "throttler", "player", "request", "Error", "key", "generateKey", "totalHits", "timeToExpire", "increment", "throwThrottlingException", "prefix", "createHash", "update", "digest", "toString", "_throttlerLimitDetail", "TooManyRequests", "getErrorMessage", "_context", "errorMessage", "ErrorMessage", "resolvableValue", "ThrottlerStorageService", "storage", "WeakMap", "timeoutIds", "getExpirationTime", "player", "key", "Math", "floor", "get", "expiresAt", "Date", "now", "setExpirationTime", "ttlMilliseconds", "timeoutId", "setTimeout", "totalHits", "clearTimeout", "filter", "id", "push", "increment", "ttl", "set", "Map", "timeToExpire", "onAppShutdown", "forEach", "ThrottlerModule", "forRoot", "options", "module", "providers", "provide", "THROTTLER_OPTIONS", "useValue", "THROTTLER_STORAGE", "useClass", "ThrottlerStorageService", "exports", "forRootAsync", "createAsyncProviders", "imports", "useExisting", "useFactory", "createAsyncOptionsProvider", "inject", "optionsFactory", "createThrottlerOptions", "multiplayerService", "ServerRageMPMultiplayerService", "ServerAppBuilder", "AppBuilder", "setBlipFactory", "factory", "setMarkerFactory", "setColShapeFactory", "setCheckpointFactory", "setObjectFactory", "setPedFactory", "setPlayerFactory", "setVehicleFactory", "setVirtualEntityGroupFactory", "setVirtualEntityFactory", "setVoiceChannelFactory", "createAppBuilder", "$createAppBuilder", "enviroment", "AppEnviroment", "Server", "plugins", "ServiceBinderPlugin", "PlayerPrototypePlugin", "RPCPlugin", "appBuilderInherit"]
}
