node-server-engine 1.0.5

package/dist/entities/Endpoint/Endpoint.d.ts

@@ -0,0 +1,39 @@
+import { Application } from 'express';
+import { EndpointOptions, EndpointAuthType, EndpointMethod } from './Endpoint.types';
+/**
+ * Object representing a REST endpoint served by server
+ */
+export declare class Endpoint<T extends EndpointAuthType> {
+    /** Path at which the endpoint is reachable */
+    readonly path: string;
+    /** HTTP method of the endpoint */
+    readonly method: EndpointMethod;
+    /** Authentication system required by this endpoint */
+    readonly authType: T;
+    /** Function handling the endpoint's business logic */
+    private handler;
+    /** Validation schema that the request must pass before reaching the handler */
+    private validator;
+    /** Authentication related options for this endpoint */
+    private authParams?;
+    /** Settings to upload files through this endpoint (this will automatically switch the expected request to be a multipart) */
+    private files?;
+    /** Express request handlers that should run on this endpoint before the business logic, they will run after the global middleware */
+    private middleware?;
+    /** Express error handlers that should be registered for this endpoint. they will run before the global error handler */
+    private errorMiddleware?;
+    /** Create a REST endpoint */
+    constructor(config: EndpointOptions<T>);
+    /**
+     * Register the endpoint to a react app
+     */
+    register(app: Application): void;
+    /**
+     * Catch exceptions thrown inside of middleware and pass them properly to express
+     */
+    private catchExceptionForExpress;
+    /**
+     * Get the authentication middleware for a given type of authentication
+     */
+    private getAuthMiddleware;
+}

package/dist/entities/Endpoint/Endpoint.js

@@ -0,0 +1,174 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Endpoint = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _EngineError = require("../EngineError");
+var _Endpoint2 = require("./Endpoint.types");
+var _const = require("../../const");
+var _middleware = require("../../middleware");
+var _report = require("../../utils/report");
+const namespace = 'engine:Endpoint';
+
+/**
+ * Object representing a REST endpoint served by server
+ */
+let Endpoint = exports.Endpoint = /*#__PURE__*/function () {
+  /** Create a REST endpoint */
+  function Endpoint(config) {
+    (0, _classCallCheck2.default)(this, Endpoint);
+    /** Path at which the endpoint is reachable */
+    this.path = void 0;
+    /** HTTP method of the endpoint */
+    this.method = void 0;
+    /** Authentication system required by this endpoint */
+    this.authType = void 0;
+    /** Function handling the endpoint's business logic */
+    this.handler = void 0;
+    /** Validation schema that the request must pass before reaching the handler */
+    this.validator = void 0;
+    /** Authentication related options for this endpoint */
+    this.authParams = void 0;
+    /** Settings to upload files through this endpoint (this will automatically switch the expected request to be a multipart) */
+    this.files = void 0;
+    /** Express request handlers that should run on this endpoint before the business logic, they will run after the global middleware */
+    this.middleware = void 0;
+    /** Express error handlers that should be registered for this endpoint. they will run before the global error handler */
+    this.errorMiddleware = void 0;
+    (0, _report.reportDebug)({
+      namespace,
+      message: `Creating Endpoint [${config.method} - ${config.path}]`,
+      data: {
+        method: config.method,
+        path: config.path,
+        authType: config.authType,
+        authParams: config.authParams,
+        file: config.file
+      }
+    });
+    if (typeof config.path !== 'string') throw new _EngineError.EngineError({
+      message: 'Endpoint path was not declared as a string'
+    });
+    this.path = config.path;
+    if (!_Endpoint2.EndpointMethods.includes(config.method)) throw new _EngineError.EngineError({
+      message: 'Endpoint method is not a valid HTTP method'
+    });
+    this.method = config.method;
+    if (typeof config.handler !== 'function') throw new _EngineError.EngineError({
+      message: 'Endpoint handler is not a function'
+    });
+    this.handler = config.handler;
+    if (!_Endpoint2.EndpointAuthTypes.includes(config.authType)) throw new _EngineError.EngineError({
+      message: 'Endpoint auth type is not valid'
+    });
+    this.authType = config.authType;
+    this.validator = config.validator;
+    this.authParams = config.authParams;
+    this.files = config.file ? [config.file] : config.files;
+
+    // Middleware can both be function or arrays
+    if (typeof config.middleware === 'function') this.middleware = [config.middleware];
+    if (config.middleware instanceof Array) this.middleware = config.middleware;
+    if (typeof config.errorMiddleware === 'function') this.errorMiddleware = [config.errorMiddleware];
+    if (config.errorMiddleware instanceof Array) this.errorMiddleware = config.errorMiddleware;
+  }
+
+  /**
+   * Register the endpoint to a react app
+   */
+  return (0, _createClass2.default)(Endpoint, [{
+    key: "register",
+    value: function register(app) {
+      // First initialize the handling calculation
+      const middlewareChain = [_middleware.requestMetrics];
+      // Register auth middleware
+      middlewareChain.push(...this.getAuthMiddleware(this.authType));
+      if (this.files) {
+        // Register file upload
+        // Validation is included in the file upload process as this uses multipart/form-data
+        middlewareChain.push((0, _middleware.fileUploader)(this.files, this.validator));
+      } else {
+        // Register validator for regular cases
+        middlewareChain.push((0, _middleware.validate)(this.validator));
+      }
+      // Register additional middleware
+      if (this.middleware) {
+        middlewareChain.push(...this.middleware);
+      }
+      // Register handler
+      middlewareChain.push(this.handler);
+      // Wrap middleware to await any async execution and catch any errors thrown
+      const safeMiddlewareChain = this.catchExceptionForExpress(middlewareChain);
+      // Register error middleware
+      if (this.errorMiddleware) {
+        safeMiddlewareChain.push(...this.errorMiddleware);
+      }
+      app[this.method](this.path, ...safeMiddlewareChain.flat());
+    }
+
+    /**
+     * Catch exceptions thrown inside of middleware and pass them properly to express
+     */
+  }, {
+    key: "catchExceptionForExpress",
+    value: function catchExceptionForExpress(middlewareChain) {
+      return middlewareChain.map(middleware => {
+        if (middleware instanceof Array) {
+          return this.catchExceptionForExpress(middleware);
+        }
+        if (typeof middleware === 'function') {
+          return (req, res, next) => {
+            (async () => {
+              try {
+                await middleware(req, res, next);
+              } catch (err) {
+                next(err);
+              }
+            })().catch(error => {
+              (0, _report.reportError)(error);
+            });
+          };
+        }
+        throw new _EngineError.EngineError({
+          message: 'Middleware is not a function nor an array',
+          data: {
+            type: typeof middleware
+          }
+        });
+      });
+    }
+
+    /**
+     * Get the authentication middleware for a given type of authentication
+     */
+  }, {
+    key: "getAuthMiddleware",
+    value: function getAuthMiddleware(authType) {
+      const middlewareChain = [];
+      const handler = _Endpoint2.EndpointAuthHandlers[authType];
+      if (!handler) {
+        (0, _report.reportInfo)({
+          severity: _const.LogSeverity.WARNING,
+          message: `Endpoint "${this.method} - ${this.path}" was declared with no authentication method`
+        });
+        return [];
+      }
+      const middleware = handler(this.authParams);
+      middlewareChain.push(async (request, response, next) => {
+        try {
+          await middleware(request, response, next);
+        } catch (error) {
+          if (!this.authParams?.acceptInvalid) throw error;
+          (0, _report.reportError)(error);
+          next();
+        }
+      });
+      return middlewareChain;
+    }
+  }]);
+}();
+//# sourceMappingURL=Endpoint.js.map

package/dist/entities/Endpoint/Endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Endpoint.js","names":["_EngineError","require","_Endpoint2","_const","_middleware","_report","namespace","Endpoint","exports","config","_classCallCheck2","default","path","method","authType","handler","validator","authParams","files","middleware","errorMiddleware","reportDebug","message","data","file","EngineError","EndpointMethods","includes","EndpointAuthTypes","Array","_createClass2","key","value","register","app","middlewareChain","requestMetrics","push","getAuthMiddleware","fileUploader","validate","safeMiddlewareChain","catchExceptionForExpress","flat","map","req","res","next","err","catch","error","reportError","type","EndpointAuthHandlers","reportInfo","severity","LogSeverity","WARNING","request","response","acceptInvalid"],"sources":["../../../src/entities/Endpoint/Endpoint.ts"],"sourcesContent":["import {\n  RequestHandler,\n  ErrorRequestHandler,\n  Application,\n  Request,\n  Response,\n  NextFunction\n} from 'express';\nimport { Schema } from 'express-validator';\nimport { EngineError } from '../EngineError';\nimport {\n  EndpointOptions,\n  EndpointAuthType,\n  EndpointAuthTypes,\n  EndpointMethod,\n  EndpointMethods,\n  EndpointAuthParams,\n  Middleware,\n  MiddlewareChainElement,\n  SafeMiddleWareChain,\n  EndpointAuthHandlers,\n  EndpointAuthHandler,\n  EndpointRequestType,\n  EndpointHandler\n} from './Endpoint.types';\nimport { LogSeverity } from 'const';\nimport { validate, fileUploader, requestMetrics } from 'middleware';\nimport { FileUploaderConfig } from 'middleware/fileUploader';\nimport { reportDebug, reportError, reportInfo } from 'utils/report';\n\nconst namespace = 'engine:Endpoint';\n\n/**\n * Object representing a REST endpoint served by server\n */\nexport class Endpoint<T extends EndpointAuthType> {\n  /** Path at which the endpoint is reachable */\n  public readonly path: string;\n  /** HTTP method of the endpoint */\n  public readonly method: EndpointMethod;\n  /** Authentication system required by this endpoint */\n  public readonly authType: T;\n  /** Function handling the endpoint's business logic */\n  private handler: EndpointHandler<T>;\n  /** Validation schema that the request must pass before reaching the handler */\n  private validator: Schema;\n  /** Authentication related options for this endpoint */\n  private authParams?: EndpointAuthParams<T>;\n  /** Settings to upload files through this endpoint (this will automatically switch the expected request to be a multipart) */\n  private files?: Array<FileUploaderConfig>;\n  /** Express request handlers that should run on this endpoint before the business logic, they will run after the global middleware */\n  private middleware?: Array<Middleware<T>>;\n  /** Express error handlers that should be registered for this endpoint. they will run before the global error handler */\n  private errorMiddleware?: Array<ErrorRequestHandler>;\n\n  /** Create a REST endpoint */\n  public constructor(config: EndpointOptions<T>) {\n    reportDebug({\n      namespace,\n      message: `Creating Endpoint [${config.method} - ${config.path}]`,\n      data: {\n        method: config.method,\n        path: config.path,\n        authType: config.authType,\n        authParams: config.authParams,\n        file: config.file\n      }\n    });\n\n    if (typeof config.path !== 'string')\n      throw new EngineError({\n        message: 'Endpoint path was not declared as a string'\n      });\n    this.path = config.path;\n\n    if (!EndpointMethods.includes(config.method))\n      throw new EngineError({\n        message: 'Endpoint method is not a valid HTTP method'\n      });\n    this.method = config.method;\n\n    if (typeof config.handler !== 'function')\n      throw new EngineError({ message: 'Endpoint handler is not a function' });\n    this.handler = config.handler;\n\n    if (!EndpointAuthTypes.includes(config.authType))\n      throw new EngineError({ message: 'Endpoint auth type is not valid' });\n    this.authType = config.authType;\n\n    this.validator = config.validator;\n    this.authParams = config.authParams;\n    this.files = config.file ? [config.file] : config.files;\n\n    // Middleware can both be function or arrays\n    if (typeof config.middleware === 'function')\n      this.middleware = [config.middleware];\n    if (config.middleware instanceof Array) this.middleware = config.middleware;\n    if (typeof config.errorMiddleware === 'function')\n      this.errorMiddleware = [config.errorMiddleware];\n    if (config.errorMiddleware instanceof Array)\n      this.errorMiddleware = config.errorMiddleware;\n  }\n\n  /**\n   * Register the endpoint to a react app\n   */\n  public register(app: Application): void {\n    // First initialize the handling calculation\n    const middlewareChain: Array<MiddlewareChainElement<T>> = [requestMetrics];\n    // Register auth middleware\n    middlewareChain.push(...this.getAuthMiddleware(this.authType));\n    if (this.files) {\n      // Register file upload\n      // Validation is included in the file upload process as this uses multipart/form-data\n      middlewareChain.push(fileUploader(this.files, this.validator));\n    } else {\n      // Register validator for regular cases\n      middlewareChain.push(validate(this.validator));\n    }\n    // Register additional middleware\n    if (this.middleware) {\n      middlewareChain.push(...this.middleware);\n    }\n    // Register handler\n    middlewareChain.push(this.handler);\n    // Wrap middleware to await any async execution and catch any errors thrown\n    const safeMiddlewareChain: SafeMiddleWareChain =\n      this.catchExceptionForExpress(middlewareChain);\n    // Register error middleware\n    if (this.errorMiddleware) {\n      safeMiddlewareChain.push(...this.errorMiddleware);\n    }\n    app[this.method](\n      this.path,\n      ...(safeMiddlewareChain.flat() as Array<\n        RequestHandler | ErrorRequestHandler\n      >)\n    );\n  }\n\n  /**\n   * Catch exceptions thrown inside of middleware and pass them properly to express\n   */\n  private catchExceptionForExpress(\n    middlewareChain: Array<MiddlewareChainElement<T>>\n  ): SafeMiddleWareChain {\n    return middlewareChain.map((middleware) => {\n      if (middleware instanceof Array) {\n        return this.catchExceptionForExpress(middleware);\n      }\n      if (typeof middleware === 'function') {\n        return (req: Request, res: Response, next: NextFunction) => {\n          (async (): Promise<void> => {\n            try {\n              await middleware(req as EndpointRequestType[T], res, next);\n            } catch (err) {\n              next(err);\n            }\n          })().catch((error) => {\n            reportError(error);\n          });\n        };\n      }\n      throw new EngineError({\n        message: 'Middleware is not a function nor an array',\n        data: { type: typeof middleware }\n      });\n    });\n  }\n\n  /**\n   * Get the authentication middleware for a given type of authentication\n   */\n  private getAuthMiddleware(authType: EndpointAuthType): Array<RequestHandler> {\n    const middlewareChain: Array<RequestHandler> = [];\n\n    const handler = EndpointAuthHandlers[authType] as EndpointAuthHandler<T>;\n    if (!handler) {\n      reportInfo({\n        severity: LogSeverity.WARNING,\n        message: `Endpoint \"${this.method} - ${this.path}\" was declared with no authentication method`\n      });\n      return [];\n    }\n\n    const middleware = handler(this.authParams);\n\n    middlewareChain.push(\n      async (request: Request, response: Response, next: NextFunction) => {\n        try {\n          await middleware(request, response, next);\n        } catch (error) {\n          if (!this.authParams?.acceptInvalid) throw error;\n          reportError(error);\n          next();\n        }\n      }\n    );\n\n    return middlewareChain;\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/entities/Endpoint/Endpoint.types.d.ts

@@ -0,0 +1,133 @@
+import { ErrorRequestHandler, Request, Response, NextFunction, RequestHandler } from 'express';
+import { ParamsDictionary } from 'express-serve-static-core';
+import { Schema } from 'express-validator';
+import { ParsedQs } from 'qs';
+import { authJwt, authHmac, authTls, authStatic, authAdmin, RequestUser, FileUploaderConfig, RequestAdminProps } from '../../middleware';
+export declare enum EndpointMethod {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    PATCH = "patch",
+    DELETE = "delete",
+    HEAD = "head",
+    ALL = "all"
+}
+export declare const EndpointMethods: EndpointMethod[];
+export declare enum EndpointAuthType {
+    NONE = "none",
+    JWT = "jwt",
+    TLS = "tls",
+    HMAC = "hmac",
+    STATIC = "static",
+    ADMIN = "admin"
+}
+export declare const EndpointAuthTypes: EndpointAuthType[];
+export type Middleware<T extends EndpointAuthType> = (request: EndpointRequestType[T], response: Response, next: NextFunction) => unknown | Promise<unknown>;
+export type MiddlewareChainElement<T extends EndpointAuthType> = Array<Middleware<T>> | Middleware<T>;
+/** Auth related parameters used with Admin authentication  */
+interface EndpointAuthAdminParams {
+    /** [Admin] User permission required to use this endpoint */
+    permission: string;
+}
+/** Auth related parameters used with HMAC authentication  */
+interface EndpointAuthHmacParams {
+    /** [HMAC] Secret used for signature */
+    secret?: string;
+    /** [HMAC] For Github webhook, the standard differs slightly, so this option must be selected */
+    isGithub?: boolean;
+}
+/** Auth related parameters used with mTLS authentication  */
+interface EndpointAuthTlsParams {
+    /** [TLS] List oh hosts that are allowed to use the endpoint, this is compared to the claims in the certificate */
+    whitelist?: Array<string>;
+}
+/** Mapping used to get auth specific parameters depending on the auth type used  */
+interface EndpointAuthSpecificParams {
+    /** Auth parameters for no authentication */
+    [EndpointAuthType.NONE]: any;
+    /** Auth parameters for JWT authentication */
+    [EndpointAuthType.JWT]: any;
+    /** Auth parameters for mTLS authentication */
+    [EndpointAuthType.TLS]: EndpointAuthTlsParams;
+    /** Auth parameters for HMAC authentication */
+    [EndpointAuthType.HMAC]: EndpointAuthHmacParams;
+    /** Auth parameters for static authentication */
+    [EndpointAuthType.STATIC]: any;
+    /** Auth parameters for admin token authentication */
+    [EndpointAuthType.ADMIN]: EndpointAuthAdminParams;
+}
+export type EndpointAuthParams<T extends EndpointAuthType> = EndpointAuthSpecificParams[T] & {
+    /** This will allow the business logic to run event if the authentication fails */
+    acceptInvalid?: boolean;
+};
+export type EndpointAuthHandler<T extends EndpointAuthType> = (options?: EndpointAuthParams<T>) => (request: Request, response: Response, next: NextFunction) => void | Promise<void>;
+export declare const EndpointAuthHandlers: {
+    /** Auth handler for no authentication */
+    none: undefined;
+    /** Auth handler for JWT authentication */
+    jwt: typeof authJwt;
+    /** Auth handler for mTLS authentication */
+    tls: typeof authTls;
+    /** Auth handler for HMAC authentication */
+    hmac: typeof authHmac;
+    /** Auth handler for static authentication */
+    static: typeof authStatic;
+    /** Auth handler for admin token authentication */
+    admin: typeof authAdmin;
+};
+export type EndpointHandler<T extends EndpointAuthType> = (request: EndpointRequestType[T], response: Response) => void | Promise<void>;
+/** Endpoint initialization options */
+export interface EndpointOptions<T extends EndpointAuthType> {
+    /** Path at which the endpoint is reachable */
+    path: string;
+    /** HTTP method of the endpoint */
+    method: EndpointMethod;
+    /** Function handling the endpoint's business logic */
+    handler: EndpointHandler<T>;
+    /** Validation schema that the request must pass before reaching the handler */
+    validator: Schema;
+    /** Authentication system required by this endpoint */
+    authType: T;
+    /** Authentication related options for this endpoint */
+    authParams?: EndpointAuthParams<T>;
+    /** @deprecated Setting to upload a file through this endpoint */
+    file?: FileUploaderConfig;
+    /** Settings to upload files through this endpoint (this will automatically switch the expected request to be a multipart) */
+    files?: Array<FileUploaderConfig>;
+    /** Express request handlers that should run on this endpoint before the business logic, they will run after the global middleware */
+    middleware?: MiddlewareChainElement<T>;
+    /** Express error handlers that should be registered for this endpoint. they will run before the global error handler */
+    errorMiddleware?: ErrorRequestHandler | Array<ErrorRequestHandler>;
+}
+/** Request type when using JWT authentication */
+export interface JwtRequest<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, Locals extends Record<string, any> = Record<string, any>> extends Request<P, ResBody, ReqBody, ReqQuery, Locals> {
+    /** User that identified using a JWT */
+    user: RequestUser;
+}
+/** Request type when using mTLS authentication */
+export interface TlsRequest<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, Locals extends Record<string, any> = Record<string, any>> extends Request<P, ResBody, ReqBody, ReqQuery, Locals> {
+    /** Host names provided by the mTLS authenticated client */
+    hosts: Array<string>;
+}
+/** Request type when using HMAC authentication */
+export interface AdminRequest<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, Locals extends Record<string, any> = Record<string, any>> extends Request<P, ResBody, ReqBody, ReqQuery, Locals> {
+    /** User that identified using a JWT */
+    admin: RequestAdminProps;
+}
+/** Mapping of request types in endpoints based on auth type used */
+export interface EndpointRequestType {
+    /** Request type for no authentication */
+    [EndpointAuthType.NONE]: Request;
+    /** Request type when using JWT authentication */
+    [EndpointAuthType.JWT]: JwtRequest;
+    /** Request type when using mTLS authentication */
+    [EndpointAuthType.TLS]: TlsRequest;
+    /** Request type when using HMAC authentication */
+    [EndpointAuthType.HMAC]: Request;
+    /** Auth handler for static authentication */
+    [EndpointAuthType.STATIC]: Request;
+    /** Auth handler for admin token authentication */
+    [EndpointAuthType.ADMIN]: AdminRequest;
+}
+export type SafeMiddleWareChain = Array<RequestHandler | ErrorRequestHandler | SafeMiddleWareChain>;
+export {};

package/dist/entities/Endpoint/Endpoint.types.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EndpointMethods = exports.EndpointMethod = exports.EndpointAuthTypes = exports.EndpointAuthType = exports.EndpointAuthHandlers = void 0;
+var _middleware = require("../../middleware");
+/* eslint-disable @typescript-eslint/no-explicit-any */
+let EndpointMethod = exports.EndpointMethod = /*#__PURE__*/function (EndpointMethod) {
+  EndpointMethod["GET"] = "get";
+  EndpointMethod["POST"] = "post";
+  EndpointMethod["PUT"] = "put";
+  EndpointMethod["PATCH"] = "patch";
+  EndpointMethod["DELETE"] = "delete";
+  EndpointMethod["HEAD"] = "head";
+  EndpointMethod["ALL"] = "all";
+  return EndpointMethod;
+}({});
+const EndpointMethods = exports.EndpointMethods = Object.values(EndpointMethod);
+let EndpointAuthType = exports.EndpointAuthType = /*#__PURE__*/function (EndpointAuthType) {
+  EndpointAuthType["NONE"] = "none";
+  EndpointAuthType["JWT"] = "jwt";
+  EndpointAuthType["TLS"] = "tls";
+  EndpointAuthType["HMAC"] = "hmac";
+  EndpointAuthType["STATIC"] = "static";
+  EndpointAuthType["ADMIN"] = "admin";
+  return EndpointAuthType;
+}({});
+const EndpointAuthTypes = exports.EndpointAuthTypes = Object.values(EndpointAuthType);
+
+/** Auth related parameters used with Admin authentication  */
+
+/** Auth related parameters used with HMAC authentication  */
+
+/** Auth related parameters used with mTLS authentication  */
+
+/** Mapping used to get auth specific parameters depending on the auth type used  */
+
+const EndpointAuthHandlers = exports.EndpointAuthHandlers = {
+  /** Auth handler for no authentication */
+  [EndpointAuthType.NONE]: undefined,
+  /** Auth handler for JWT authentication */
+  [EndpointAuthType.JWT]: _middleware.authJwt,
+  /** Auth handler for mTLS authentication */
+  [EndpointAuthType.TLS]: _middleware.authTls,
+  /** Auth handler for HMAC authentication */
+  [EndpointAuthType.HMAC]: _middleware.authHmac,
+  /** Auth handler for static authentication */
+  [EndpointAuthType.STATIC]: _middleware.authStatic,
+  /** Auth handler for admin token authentication */
+  [EndpointAuthType.ADMIN]: _middleware.authAdmin
+};
+
+/** Endpoint initialization options */
+
+/** Request type when using JWT authentication */
+
+/** Request type when using mTLS authentication */
+
+/** Request type when using HMAC authentication */
+
+/** Mapping of request types in endpoints based on auth type used */
+//# sourceMappingURL=Endpoint.types.js.map

package/dist/entities/Endpoint/Endpoint.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Endpoint.types.js","names":["_middleware","require","EndpointMethod","exports","EndpointMethods","Object","values","EndpointAuthType","EndpointAuthTypes","EndpointAuthHandlers","NONE","undefined","JWT","authJwt","TLS","authTls","HMAC","authHmac","STATIC","authStatic","ADMIN","authAdmin"],"sources":["../../../src/entities/Endpoint/Endpoint.types.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  ErrorRequestHandler,\n  Request,\n  Response,\n  NextFunction,\n  RequestHandler\n} from 'express';\nimport { ParamsDictionary } from 'express-serve-static-core';\nimport { Schema } from 'express-validator';\nimport { ParsedQs } from 'qs';\n\nimport {\n  authJwt,\n  authHmac,\n  authTls,\n  authStatic,\n  authAdmin,\n  RequestUser,\n  FileUploaderConfig,\n  RequestAdminProps\n} from 'middleware';\n\nexport enum EndpointMethod {\n  GET = 'get',\n  POST = 'post',\n  PUT = 'put',\n  PATCH = 'patch',\n  DELETE = 'delete',\n  HEAD = 'head',\n  ALL = 'all'\n}\n\nexport const EndpointMethods = Object.values(EndpointMethod);\n\nexport enum EndpointAuthType {\n  NONE = 'none',\n  JWT = 'jwt',\n  TLS = 'tls',\n  HMAC = 'hmac',\n  STATIC = 'static',\n  ADMIN = 'admin'\n}\n\nexport const EndpointAuthTypes = Object.values(EndpointAuthType);\n\nexport type Middleware<T extends EndpointAuthType> = (\n  request: EndpointRequestType[T],\n  response: Response,\n  next: NextFunction\n) => unknown | Promise<unknown>;\n\nexport type MiddlewareChainElement<T extends EndpointAuthType> =\n  | Array<Middleware<T>>\n  | Middleware<T>;\n\n/** Auth related parameters used with Admin authentication  */\ninterface EndpointAuthAdminParams {\n  /** [Admin] User permission required to use this endpoint */\n  permission: string;\n}\n\n/** Auth related parameters used with HMAC authentication  */\ninterface EndpointAuthHmacParams {\n  /** [HMAC] Secret used for signature */\n  secret?: string;\n  /** [HMAC] For Github webhook, the standard differs slightly, so this option must be selected */\n  isGithub?: boolean;\n}\n\n/** Auth related parameters used with mTLS authentication  */\ninterface EndpointAuthTlsParams {\n  /** [TLS] List oh hosts that are allowed to use the endpoint, this is compared to the claims in the certificate */\n  whitelist?: Array<string>;\n}\n\n/** Mapping used to get auth specific parameters depending on the auth type used  */\ninterface EndpointAuthSpecificParams {\n  /** Auth parameters for no authentication */\n  [EndpointAuthType.NONE]: any;\n  /** Auth parameters for JWT authentication */\n  [EndpointAuthType.JWT]: any;\n  /** Auth parameters for mTLS authentication */\n  [EndpointAuthType.TLS]: EndpointAuthTlsParams;\n  /** Auth parameters for HMAC authentication */\n  [EndpointAuthType.HMAC]: EndpointAuthHmacParams;\n  /** Auth parameters for static authentication */\n  [EndpointAuthType.STATIC]: any;\n  /** Auth parameters for admin token authentication */\n  [EndpointAuthType.ADMIN]: EndpointAuthAdminParams;\n}\n\nexport type EndpointAuthParams<T extends EndpointAuthType> =\n  EndpointAuthSpecificParams[T] & {\n    /** This will allow the business logic to run event if the authentication fails */\n    acceptInvalid?: boolean;\n  };\n\nexport type EndpointAuthHandler<T extends EndpointAuthType> = (\n  options?: EndpointAuthParams<T>\n) => (\n  request: Request,\n  response: Response,\n  next: NextFunction\n) => void | Promise<void>;\n\nexport const EndpointAuthHandlers = {\n  /** Auth handler for no authentication */\n  [EndpointAuthType.NONE]: undefined,\n  /** Auth handler for JWT authentication */\n  [EndpointAuthType.JWT]: authJwt,\n  /** Auth handler for mTLS authentication */\n  [EndpointAuthType.TLS]: authTls,\n  /** Auth handler for HMAC authentication */\n  [EndpointAuthType.HMAC]: authHmac,\n  /** Auth handler for static authentication */\n  [EndpointAuthType.STATIC]: authStatic,\n  /** Auth handler for admin token authentication */\n  [EndpointAuthType.ADMIN]: authAdmin\n};\n\nexport type EndpointHandler<T extends EndpointAuthType> = (\n  request: EndpointRequestType[T],\n  response: Response\n) => void | Promise<void>;\n\n/** Endpoint initialization options */\nexport interface EndpointOptions<T extends EndpointAuthType> {\n  /** Path at which the endpoint is reachable */\n  path: string;\n  /** HTTP method of the endpoint */\n  method: EndpointMethod;\n  /** Function handling the endpoint's business logic */\n  handler: EndpointHandler<T>;\n  /** Validation schema that the request must pass before reaching the handler */\n  validator: Schema;\n  /** Authentication system required by this endpoint */\n  authType: T;\n  /** Authentication related options for this endpoint */\n  authParams?: EndpointAuthParams<T>;\n  /** @deprecated Setting to upload a file through this endpoint */\n  file?: FileUploaderConfig;\n  /** Settings to upload files through this endpoint (this will automatically switch the expected request to be a multipart) */\n  files?: Array<FileUploaderConfig>;\n  /** Express request handlers that should run on this endpoint before the business logic, they will run after the global middleware */\n  middleware?: MiddlewareChainElement<T>;\n  /** Express error handlers that should be registered for this endpoint. they will run before the global error handler */\n  errorMiddleware?: ErrorRequestHandler | Array<ErrorRequestHandler>;\n}\n\n/** Request type when using JWT authentication */\nexport interface JwtRequest<\n  P = ParamsDictionary,\n  ResBody = any,\n  ReqBody = any,\n  ReqQuery = ParsedQs,\n  Locals extends Record<string, any> = Record<string, any>\n> extends Request<P, ResBody, ReqBody, ReqQuery, Locals> {\n  /** User that identified using a JWT */\n  user: RequestUser;\n}\n\n/** Request type when using mTLS authentication */\nexport interface TlsRequest<\n  P = ParamsDictionary,\n  ResBody = any,\n  ReqBody = any,\n  ReqQuery = ParsedQs,\n  Locals extends Record<string, any> = Record<string, any>\n> extends Request<P, ResBody, ReqBody, ReqQuery, Locals> {\n  /** Host names provided by the mTLS authenticated client */\n  hosts: Array<string>;\n}\n\n/** Request type when using HMAC authentication */\nexport interface AdminRequest<\n  P = ParamsDictionary,\n  ResBody = any,\n  ReqBody = any,\n  ReqQuery = ParsedQs,\n  Locals extends Record<string, any> = Record<string, any>\n> extends Request<P, ResBody, ReqBody, ReqQuery, Locals> {\n  /** User that identified using a JWT */\n  admin: RequestAdminProps;\n}\n\n/** Mapping of request types in endpoints based on auth type used */\nexport interface EndpointRequestType {\n  /** Request type for no authentication */\n  [EndpointAuthType.NONE]: Request;\n  /** Request type when using JWT authentication */\n  [EndpointAuthType.JWT]: JwtRequest;\n  /** Request type when using mTLS authentication */\n  [EndpointAuthType.TLS]: TlsRequest;\n  /** Request type when using HMAC authentication */\n  [EndpointAuthType.HMAC]: Request;\n  /** Auth handler for static authentication */\n  [EndpointAuthType.STATIC]: Request;\n  /** Auth handler for admin token authentication */\n  [EndpointAuthType.ADMIN]: AdminRequest;\n}\n\nexport type SafeMiddleWareChain = Array<\n  RequestHandler | ErrorRequestHandler | SafeMiddleWareChain\n>;\n"],"mappings":";;;;;;AAYA,IAAAA,WAAA,GAAAC,OAAA;AAZA;AAAA,IAuBYC,cAAc,GAAAC,OAAA,CAAAD,cAAA,0BAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA;AAUnB,MAAME,eAAe,GAAAD,OAAA,CAAAC,eAAA,GAAGC,MAAM,CAACC,MAAM,CAACJ,cAAc,CAAC;AAAC,IAEjDK,gBAAgB,GAAAJ,OAAA,CAAAI,gBAAA,0BAAhBA,gBAAgB;EAAhBA,gBAAgB;EAAhBA,gBAAgB;EAAhBA,gBAAgB;EAAhBA,gBAAgB;EAAhBA,gBAAgB;EAAhBA,gBAAgB;EAAA,OAAhBA,gBAAgB;AAAA;AASrB,MAAMC,iBAAiB,GAAAL,OAAA,CAAAK,iBAAA,GAAGH,MAAM,CAACC,MAAM,CAACC,gBAAgB,CAAC;;AAYhE;;AAMA;;AAQA;;AAMA;;AA8BO,MAAME,oBAAoB,GAAAN,OAAA,CAAAM,oBAAA,GAAG;EAClC;EACA,CAACF,gBAAgB,CAACG,IAAI,GAAGC,SAAS;EAClC;EACA,CAACJ,gBAAgB,CAACK,GAAG,GAAGC,mBAAO;EAC/B;EACA,CAACN,gBAAgB,CAACO,GAAG,GAAGC,mBAAO;EAC/B;EACA,CAACR,gBAAgB,CAACS,IAAI,GAAGC,oBAAQ;EACjC;EACA,CAACV,gBAAgB,CAACW,MAAM,GAAGC,sBAAU;EACrC;EACA,CAACZ,gBAAgB,CAACa,KAAK,GAAGC;AAC5B,CAAC;;AAOD;;AAwBA;;AAYA;;AAYA;;AAYA","ignoreList":[]}

package/dist/entities/Endpoint/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Endpoint';
+export * from './Endpoint.types';

package/dist/entities/Endpoint/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Endpoint = require("./Endpoint");
+Object.keys(_Endpoint).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Endpoint[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Endpoint[key];
+    }
+  });
+});
+var _Endpoint2 = require("./Endpoint.types");
+Object.keys(_Endpoint2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Endpoint2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Endpoint2[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/dist/entities/Endpoint/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_Endpoint","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_Endpoint2"],"sources":["../../../src/entities/Endpoint/index.ts"],"sourcesContent":["export * from './Endpoint';\nexport * from './Endpoint.types';\n"],"mappings":";;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,SAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,SAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,SAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,UAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,UAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,UAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,UAAA,CAAAL,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/dist/entities/EngineError/EngineError.d.ts

@@ -0,0 +1,17 @@
+import { EngineErrorOptions } from './EngineError.types';
+import { LogSeverity } from '../../const';
+/**
+ * Base error type for engine related errors
+ */
+export declare class EngineError extends Error {
+    /** Severity of the log entry */
+    severity: LogSeverity;
+    /** If this error is wrapping another one, this will contain the original error */
+    error?: Error;
+    /** Additional contextual data for debugging */
+    data?: unknown;
+    /** Human readable error message sent to the client */
+    hint?: unknown;
+    /** Create an EngineError, these errors represent errors in the engine itself */
+    constructor(config: EngineErrorOptions | string);
+}

package/dist/entities/EngineError/EngineError.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EngineError = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
+var _const = require("../../const");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function () { return !!t; })(); }
+/**
+ * Base error type for engine related errors
+ */
+let EngineError = exports.EngineError = /*#__PURE__*/function (_Error) {
+  /** Create an EngineError, these errors represent errors in the engine itself */
+  function EngineError(config) {
+    var _this;
+    (0, _classCallCheck2.default)(this, EngineError);
+    const options = typeof config === 'string' ? {
+      message: config
+    } : config;
+    _this = _callSuper(this, EngineError, [options.message]);
+    /** Severity of the log entry */
+    _this.severity = void 0;
+    /** If this error is wrapping another one, this will contain the original error */
+    _this.error = void 0;
+    /** Additional contextual data for debugging */
+    _this.data = void 0;
+    /** Human readable error message sent to the client */
+    _this.hint = void 0;
+    _this.severity = options.severity ?? _const.LogSeverity.CRITICAL;
+    _this.data = options.data;
+    _this.error = options.error;
+    _this.hint = options.hint;
+    return _this;
+  }
+  (0, _inherits2.default)(EngineError, _Error);
+  return (0, _createClass2.default)(EngineError);
+}(/*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+//# sourceMappingURL=EngineError.js.map

package/dist/entities/EngineError/EngineError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineError.js","names":["_const","require","_callSuper","t","o","e","_getPrototypeOf2","default","_possibleConstructorReturn2","_isNativeReflectConstruct","Reflect","construct","constructor","apply","Boolean","prototype","valueOf","call","EngineError","exports","_Error","config","_this","_classCallCheck2","options","message","severity","error","data","hint","LogSeverity","CRITICAL","_inherits2","_createClass2","_wrapNativeSuper2","Error"],"sources":["../../../src/entities/EngineError/EngineError.ts"],"sourcesContent":["import { EngineErrorOptions } from './EngineError.types';\nimport { LogSeverity } from 'const';\n\n/**\n * Base error type for engine related errors\n */\nexport class EngineError extends Error {\n  /** Severity of the log entry */\n  public severity: LogSeverity;\n  /** If this error is wrapping another one, this will contain the original error */\n  public error?: Error;\n  /** Additional contextual data for debugging */\n  public data?: unknown;\n  /** Human readable error message sent to the client */\n  public hint?: unknown;\n\n  /** Create an EngineError, these errors represent errors in the engine itself */\n  public constructor(config: EngineErrorOptions | string) {\n    const options: EngineErrorOptions =\n      typeof config === 'string' ? { message: config } : config;\n    super(options.message);\n\n    this.severity = options.severity ?? LogSeverity.CRITICAL;\n    this.data = options.data;\n    this.error = options.error;\n    this.hint = options.hint;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AAAoC,SAAAC,WAAAC,CAAA,EAAAC,CAAA,EAAAC,CAAA,WAAAD,CAAA,OAAAE,gBAAA,CAAAC,OAAA,EAAAH,CAAA,OAAAI,2BAAA,CAAAD,OAAA,EAAAJ,CAAA,EAAAM,yBAAA,KAAAC,OAAA,CAAAC,SAAA,CAAAP,CAAA,EAAAC,CAAA,YAAAC,gBAAA,CAAAC,OAAA,EAAAJ,CAAA,EAAAS,WAAA,IAAAR,CAAA,CAAAS,KAAA,CAAAV,CAAA,EAAAE,CAAA;AAAA,SAAAI,0BAAA,cAAAN,CAAA,IAAAW,OAAA,CAAAC,SAAA,CAAAC,OAAA,CAAAC,IAAA,CAAAP,OAAA,CAAAC,SAAA,CAAAG,OAAA,iCAAAX,CAAA,aAAAM,yBAAA,YAAAA,CAAA,aAAAN,CAAA;AAEpC;AACA;AACA;AAFA,IAGae,WAAW,GAAAC,OAAA,CAAAD,WAAA,0BAAAE,MAAA;EAUtB;EACA,SAAAF,YAAmBG,MAAmC,EAAE;IAAA,IAAAC,KAAA;IAAA,IAAAC,gBAAA,CAAAhB,OAAA,QAAAW,WAAA;IACtD,MAAMM,OAA2B,GAC/B,OAAOH,MAAM,KAAK,QAAQ,GAAG;MAAEI,OAAO,EAAEJ;IAAO,CAAC,GAAGA,MAAM;IAC3DC,KAAA,GAAApB,UAAA,OAAAgB,WAAA,GAAMM,OAAO,CAACC,OAAO;IAbvB;IAAAH,KAAA,CACOI,QAAQ;IACf;IAAAJ,KAAA,CACOK,KAAK;IACZ;IAAAL,KAAA,CACOM,IAAI;IACX;IAAAN,KAAA,CACOO,IAAI;IAQTP,KAAA,CAAKI,QAAQ,GAAGF,OAAO,CAACE,QAAQ,IAAII,kBAAW,CAACC,QAAQ;IACxDT,KAAA,CAAKM,IAAI,GAAGJ,OAAO,CAACI,IAAI;IACxBN,KAAA,CAAKK,KAAK,GAAGH,OAAO,CAACG,KAAK;IAC1BL,KAAA,CAAKO,IAAI,GAAGL,OAAO,CAACK,IAAI;IAAC,OAAAP,KAAA;EAC3B;EAAC,IAAAU,UAAA,CAAAzB,OAAA,EAAAW,WAAA,EAAAE,MAAA;EAAA,WAAAa,aAAA,CAAA1B,OAAA,EAAAW,WAAA;AAAA,mBAAAgB,iBAAA,CAAA3B,OAAA,EApB8B4B,KAAK","ignoreList":[]}

package/dist/entities/EngineError/EngineError.types.d.ts

@@ -0,0 +1,14 @@
+import { LogSeverity } from '../../const';
+/** EngineError initialization options */
+export interface EngineErrorOptions {
+    /** Main logged message */
+    message: string;
+    /** Severity of the log entry */
+    severity?: LogSeverity;
+    /** If this error is wrapping another one, this will contain the original error */
+    error?: Error;
+    /** Additional contextual data for debugging */
+    data?: unknown;
+    /** Human readable error message sent to the client */
+    hint?: unknown;
+}

package/dist/entities/EngineError/EngineError.types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=EngineError.types.js.map

package/dist/entities/EngineError/EngineError.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineError.types.js","names":[],"sources":["../../../src/entities/EngineError/EngineError.types.ts"],"sourcesContent":["import { LogSeverity } from 'const';\n\n/** EngineError initialization options */\nexport interface EngineErrorOptions {\n  /** Main logged message */\n  message: string;\n  /** Severity of the log entry */\n  severity?: LogSeverity;\n  /** If this error is wrapping another one, this will contain the original error */\n  error?: Error;\n  /** Additional contextual data for debugging */\n  data?: unknown;\n  /** Human readable error message sent to the client */\n  hint?: unknown;\n}\n"],"mappings":"","ignoreList":[]}

package/dist/entities/EngineError/index.d.ts

@@ -0,0 +1,2 @@
+export * from './EngineError';
+export * from './EngineError.types';

package/dist/entities/EngineError/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _EngineError = require("./EngineError");
+Object.keys(_EngineError).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _EngineError[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _EngineError[key];
+    }
+  });
+});
+var _EngineError2 = require("./EngineError.types");
+Object.keys(_EngineError2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _EngineError2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _EngineError2[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/dist/entities/EngineError/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_EngineError","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_EngineError2"],"sources":["../../../src/entities/EngineError/index.ts"],"sourcesContent":["export * from './EngineError';\nexport * from './EngineError.types';\n"],"mappings":";;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,YAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,YAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,YAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,aAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,aAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,aAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,aAAA,CAAAL,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}