@buildvision/nest-sdk-generator 2.3.0 → 3.0.0

package/build/engine/analyze.js

@@ -0,0 +1,786 @@
+"use strict";
+/**
+ * @file Source API analyzer running on top of an `AnalysisHost` (tsgo or in-process TypeScript)
+ *
+ * This is a port of the legacy ts-morph analyzer (`src/analyzer`). It performs the same operations, in the same
+ * order, with the same messages, so that given the same type checker it produces the same SDK content.
+ * The parity tests enforce this by running it against the TypeScript program ts-morph builds.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeWithHost = analyzeWithHost;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const chalk = require("chalk");
+const builtin_1 = require("../analyzer/builtin");
+const route_1 = require("../analyzer/route");
+const sdk_1 = require("../analyzer/sdk");
+const typedeps_1 = require("../analyzer/typedeps");
+const logging_1 = require("../logging");
+const utils_1 = require("../utils");
+const ast_1 = require("./ast");
+/**
+ * Analyze the source API
+ * @param config Generator configuration
+ * @param createHost Creates the engine for a given tsconfig file
+ */
+async function analyzeWithHost(config, createHost) {
+    const started = Date.now();
+    const sourcePath = path.resolve(process.cwd(), config.apiInputPath);
+    if (!sourcePath)
+        (0, logging_1.panic)('Please provide a source directory');
+    if (!fs.existsSync(sourcePath))
+        (0, logging_1.panic)('Provided source path {magentaBright} does not exist', sourcePath);
+    if (!fs.lstatSync(sourcePath).isDirectory())
+        (0, logging_1.panic)('Provided source path is not a directory');
+    (0, logging_1.debug)(`Analyzing from source directory {yellow}`, sourcePath);
+    if (config.jsonOutput) {
+        const jsonOutputParentDir = path.dirname(path.resolve(process.cwd(), config.jsonOutput));
+        if (!fs.existsSync(jsonOutputParentDir)) {
+            (0, logging_1.panic)("Output file's parent directory {magentaBright} does not exist.", jsonOutputParentDir);
+        }
+        (0, logging_1.debug)('Writing output to {yellow}', config.jsonOutput, config.jsonPrettyOutput ? 'beautified' : 'minified');
+    }
+    // ====== Find & parse 'tsconfig.json' ====== //
+    if (config.tsconfigFile && config.tsconfigFile.includes('/')) {
+        (0, logging_1.panic)('Provided tsconfig file name contains slashes');
+    }
+    const tsConfigFileName = config.tsconfigFile ?? 'tsconfig.json';
+    const tsConfigFilePath = path.join(sourcePath, tsConfigFileName);
+    if (!fs.existsSync(tsConfigFilePath)) {
+        (0, logging_1.panic)('No {yellow} file found in provided source path {yellow}', tsConfigFileName, sourcePath);
+    }
+    const host = createHost(tsConfigFilePath);
+    try {
+        // Get the list of all TypeScript files in the source directory
+        const sourceTSFiles = host.getProjectFilePaths().map((file) => path.relative(sourcePath, file));
+        (0, logging_1.debug)(`Found {magentaBright} source files.`, sourceTSFiles.length);
+        // Add them
+        (0, logging_1.debug)('\nAdding them to the source project...');
+        let progressByTenth = 0;
+        const strLen = sourceTSFiles.length.toString().length;
+        const hasProgress = (filesTreated) => filesTreated / sourceTSFiles.length >= (progressByTenth + 1) / 10;
+        const controllers = [];
+        for (let i = 0; i < sourceTSFiles.length; i++) {
+            const file = sourceTSFiles[i];
+            if (file.endsWith('.controller.ts')) {
+                controllers.push(file);
+            }
+            if (hasProgress(i + 1)) {
+                while (hasProgress(i + 1))
+                    progressByTenth++;
+                (0, logging_1.debug)('| Progress: {yellow} ({magentaBright} files) - {green} controller{} found', (progressByTenth * 10).toString().padStart(3, ' ') + '%', `${(i + 1).toString().padStart(strLen, ' ')} / ${sourceTSFiles.length}`, controllers.length.toString().padStart(strLen, ''), controllers.length > 1 ? 's' : '');
+            }
+        }
+        (0, logging_1.debug)('All files were added successfully.\n');
+        const modules = analyzeControllers(host, controllers, sourcePath);
+        // Builtin magic types are concatenated **after** the configuration's ones, as this allows users to
+        // override the builtin ones if they want. Do **not** change the concatenation order!
+        const magicTypes = (config.magicTypes ?? []).concat(builtin_1.builtinMagicTypes);
+        const typesCache = new TypesExtractor(host, sourcePath, magicTypes);
+        const typesToExtract = (0, sdk_1.locateTypesFile)((0, sdk_1.flattenSdkResolvedTypes)(modules));
+        (0, logging_1.debug)('\n==== Extracting {} type' + (typesToExtract.length > 1 ? 's' : '') + ' ====\n', typesToExtract.length);
+        for (const loc of typesToExtract) {
+            const result = typesCache.extractType(loc);
+            if (result instanceof Error) {
+                (0, logging_1.panic)(result.message);
+            }
+        }
+        const content = {
+            modules,
+            types: typesCache.extracted,
+        };
+        if (config.jsonOutput) {
+            fs.writeFileSync(config.jsonOutput, (0, sdk_1.serializeSdkContent)(content, !!config.jsonPrettyOutput), 'utf8');
+        }
+        (0, logging_1.debug)('\n===== Done in {green}! ====', ((Date.now() - started) / 1000).toFixed(2) + 's');
+        return content;
+    }
+    finally {
+        host.dispose();
+    }
+}
+/**
+ * Get a source file from the program, throwing like ts-morph's `project.getSourceFileOrThrow()`
+ */
+function getSourceFileOrThrow(host, absolutePath) {
+    const file = host.getSourceFile(absolutePath);
+    if (!file) {
+        throw new Error(`Could not find source file in project at the provided path: ${absolutePath}`);
+    }
+    return file;
+}
+// =============================================================================================================== //
+// Controllers & modules (see src/analyzer/controllers.ts, src/analyzer/controller.ts, src/analyzer/module.ts)     //
+// =============================================================================================================== //
+function analyzeControllers(host, controllers, absoluteSrcPath) {
+    /** Hierarchised SDK informations */
+    const collected = new Map();
+    const usedControllerNames = new Set();
+    /**
+     * Modules cache: contains for a given directory the nearest module file's path and name
+     * This allows to avoid having to analyze the whole directory structure for each controller
+     */
+    const modulesCache = new Map();
+    /**
+     * Path of the declared modules
+     * When a module is detected and put in the cache, its name is registered here along with its path
+     * This allows to ensure there is no name clash between two different modules
+     */
+    const declaredModulesPath = new Map();
+    (0, logging_1.debug)(`Analyzing {yellow} controllers...`, controllers.length);
+    controllers.forEach((relativeControllerPath, i) => {
+        const absoluteControllerPath = path.resolve(absoluteSrcPath, relativeControllerPath);
+        (0, logging_1.debug)('\n{cyan} {yellow}: {magentaBright} {cyan}\n', '===== Analyzing controller', `${i + 1}/${controllers.length}`, relativeControllerPath, '=====');
+        const basePath = path.dirname(absoluteControllerPath);
+        let moduleName = modulesCache.get(basePath);
+        // Check if the module's name is in cache
+        if (!moduleName) {
+            // Else, find the nearest module file
+            const absoluteModulePath = (0, utils_1.findFileAbove)(/^.*\.module\.ts$/, path.resolve(absoluteSrcPath, basePath));
+            if (absoluteModulePath === null) {
+                (0, logging_1.panic)('No module file was found for controller at path: {yellow}', absoluteControllerPath);
+            }
+            const relativeModulePath = path.relative(absoluteSrcPath, absoluteModulePath);
+            // Get the module's name
+            moduleName = getModuleName(host, relativeModulePath, absoluteSrcPath);
+            (0, logging_1.debug)('Discovered module: {yellow}', moduleName);
+            // Ensure this module is unique
+            const cachedModulePath = declaredModulesPath.get(moduleName);
+            if (cachedModulePath) {
+                (0, logging_1.panic)(`Two modules were declared with the same name {yellow}:\n` + `- One in {yellow}\n` + `- One in {yellow}`, moduleName, cachedModulePath, relativeModulePath);
+            }
+            modulesCache.set(basePath, moduleName);
+        }
+        if (moduleName in {}) {
+            (0, logging_1.panic)(`Detected module whose name {yellow} collides with a JavaScript's native object property`, moduleName);
+        }
+        let moduleSdkInfos = collected.get(moduleName);
+        if (!moduleSdkInfos) {
+            moduleSdkInfos = new Map();
+            collected.set(moduleName, moduleSdkInfos);
+        }
+        if (i === 0) {
+            if (process.platform === 'linux' && os.release().toLocaleLowerCase().includes('microsoft') && absoluteSrcPath.startsWith('/mnt/')) {
+                (0, logging_1.warn)("NOTE: On WSL, the first type analysis on a project located in Windows's filesystem may take a long time to complete.");
+                (0, logging_1.warn)('Please consider moving your project to WSL, or running this tool directly from Windows');
+            }
+        }
+        const metadata = analyzeController(host, relativeControllerPath, absoluteSrcPath);
+        if (metadata instanceof Error) {
+            throw new Error((0, logging_1.format)('Failed to analyze controller at path {magenta}:\n{}', relativeControllerPath, metadata.message));
+        }
+        if (metadata) {
+            if (metadata.registrationName in {}) {
+                (0, logging_1.panic)(`Detected controller whose registration name {yellow} collides with a JavaScript's native object property`, metadata.registrationName);
+            }
+            // Ensure the each controller has a unique name across modules
+            if (usedControllerNames.has(metadata.className)) {
+                (0, logging_1.panic)(`Detected two controllers with the same name {yellow}. Second occurrence found in {yellow}`, metadata.registrationName, metadata.path);
+            }
+            else {
+                usedControllerNames.add(metadata.className);
+            }
+            moduleSdkInfos.set(metadata.className, metadata);
+        }
+    });
+    return collected;
+}
+function getModuleName(host, modulePath, sourcePath) {
+    const SK = host.SyntaxKind;
+    // Prepare the source file to analyze
+    const file = getSourceFileOrThrow(host, path.resolve(sourcePath, modulePath));
+    // Find the module class declaration
+    const classDecl = file.statements.find((node) => node.kind === SK.ClassDeclaration && (0, ast_1.getDecorators)(host, node).length > 0);
+    if (!classDecl) {
+        (0, logging_1.panic)('No class declaration found in module at {yellow}', modulePath);
+    }
+    const moduleName = (0, ast_1.nodeName)(classDecl, file);
+    if (moduleName === undefined) {
+        (0, logging_1.panic)('Internal error: failed to retrieve name of declared class');
+    }
+    const decorators = (0, ast_1.getDecorators)(host, classDecl);
+    const moduleDecorator = decorators.find((dec) => (0, ast_1.decoratorName)(host, dec, file) === 'Module');
+    if (!moduleDecorator) {
+        (0, logging_1.panic)((0, logging_1.format)(`Module class {yellow} is missing {yellow} decorator\nModule path is: {yellow}`, moduleName, '@Module', modulePath));
+    }
+    return moduleName;
+}
+function analyzeController(host, controllerPath, absoluteSrcPath) {
+    const SK = host.SyntaxKind;
+    (0, logging_1.debug)('Analyzing: {yellow}', controllerPath);
+    // Prepare the source file to analyze
+    const file = getSourceFileOrThrow(host, path.resolve(absoluteSrcPath, controllerPath));
+    // Find the controller class declaration
+    const classDecl = file.statements.find((node) => node.kind === SK.ClassDeclaration);
+    if (!classDecl) {
+        (0, logging_1.warn)('No controller found in this file.');
+        return null;
+    }
+    const className = (0, ast_1.nodeName)(classDecl, file);
+    if (className === undefined) {
+        return new Error('Internal error: failed to retrieve name of declared class');
+    }
+    // By default, a controller is registered under its class name
+    // This is unless it provides an argument to its @Controller() decorator
+    let registrationName = (0, sdk_1.camelcase)(className);
+    let controllerUriPrefix = null;
+    (0, logging_1.debug)('Found class declaration: {yellow}', className);
+    // Get the @Controller() decorator
+    const decorator = (0, ast_1.getDecorators)(host, classDecl).find((dec) => (0, ast_1.decoratorName)(host, dec, file) === 'Controller');
+    if (!decorator) {
+        (0, logging_1.warn)('Skipping this controller as it does not have a @Controller() decorator');
+        return null;
+    }
+    // Get the decorator's call expression
+    const decCallExpr = (0, ast_1.decoratorCallExpression)(host, decorator);
+    if (!decCallExpr) {
+        (0, logging_1.warn)('Skipping this controller as its @Controller() decorator is not called');
+        return null;
+    }
+    // Get the decorator's arguments
+    const decExpr = decCallExpr.arguments;
+    if (decExpr.length > 1) {
+        (0, logging_1.warn)('Skipping this controller as its @Controller() decorator is called with more than 1 argument');
+        return null;
+    }
+    // Get the first argument, which is expected to be the controller's registration name
+    // Example: `@Controller("SuperName")` will register the controller under the name "SuperName"
+    if (decExpr[0]) {
+        const nameArg = decExpr[0];
+        // Variables are not supported
+        if (!(0, ast_1.isStringLiteral)(host, nameArg)) {
+            (0, logging_1.warn)("Skipping this controller as its @Controller() decorator's argument is not a string literal");
+            return null;
+        }
+        // Update the registration name
+        registrationName = nameArg.text;
+        controllerUriPrefix = registrationName;
+        (0, logging_1.debug)('Registering controller {yellow} as {yellow} (as specified in @Controller())', className, registrationName);
+    }
+    else {
+        // No argument was provided to the @Controller() decorator, so we stick with the original controller's name
+        (0, logging_1.debug)('@Controller() was called without argument, registering controller under name {yellow}', registrationName);
+    }
+    // Generate a SDK interface for the controller's methods
+    const methods = analyzeMethods(host, file, classDecl, controllerUriPrefix, controllerPath, absoluteSrcPath);
+    if (methods instanceof Error) {
+        return methods;
+    }
+    // Success!
+    (0, logging_1.debug)(`└─ Done for controller {yellow}`, controllerPath);
+    return {
+        path: controllerPath,
+        className,
+        registrationName,
+        methods,
+    };
+}
+// =============================================================================================================== //
+// Methods & parameters (see src/analyzer/methods.ts, src/analyzer/params.ts)                                      //
+// =============================================================================================================== //
+function analyzeMethods(host, sourceFile, controllerClass, controllerUriPrefix, filePath, absoluteSrcPath) {
+    // Output variable
+    const collected = new Array();
+    // Get the list of all methods
+    const methods = controllerClass.members.filter((node) => node.kind === host.SyntaxKind.MethodDeclaration);
+    for (const method of methods) {
+        const methodName = (0, ast_1.nodeName)(method, sourceFile);
+        (0, logging_1.debug)('├─ Found method: {yellow}', methodName);
+        // Get the HTTP decorator(s) of the method
+        const decorators = (0, ast_1.getDecorators)(host, method).filter((dec) => Object.keys(sdk_1.SdkHttpMethod).includes((0, ast_1.decoratorName)(host, dec, sourceFile)));
+        // We expect to have exactly one HTTP decorator
+        if (decorators.length > 1) {
+            // If there is more than one decorator, that's invalid, so we can't analyze the method
+            return new Error((0, logging_1.format)('├─── Detected multiple HTTP decorators on method: {yellow}' +
+                decorators.map((dec) => (0, ast_1.decoratorName)(host, dec, sourceFile)).join(',')));
+        }
+        else if (decorators.length === 0) {
+            // If there isn't any HTTP decorator, this is simply not a method available from the outside and so we won't generate an interface for it
+            (0, logging_1.debug)('├─── Skipping this method as it does not have an HTTP decorator');
+            continue;
+        }
+        // Get the HTTP decorator
+        const dec = decorators[0];
+        const httpMethod = sdk_1.SdkHttpMethod[(0, ast_1.decoratorName)(host, dec, sourceFile)];
+        (0, logging_1.debug)('├─── Detected HTTP method: {magentaBright}', httpMethod.toLocaleUpperCase());
+        // Get the arguments provided to the HTTP decorator (we expect one, the URI path)
+        const decArgs = (0, ast_1.decoratorArguments)(host, dec);
+        // The method's URI path
+        let uriPath;
+        // We expect the decorator to have exactly one argument
+        if (decArgs.length > 1) {
+            // If we have more than one argument, that's invalid (or at least not supported here), so we can't analyze the method
+            return new Error(`Multiple (${decArgs.length}) arguments were provided to the HTTP decorator`);
+        }
+        else if (decArgs.length === 0) {
+            // If there is no argument, we take the method's name as the URI path
+            (0, logging_1.debug)('├─── No argument found for decorator, using base URI path.');
+            uriPath = '';
+        }
+        else {
+            // If we have exactly one argument, hurray! That's our URI path.
+            const uriNameDec = decArgs[0];
+            // Variables are not supported
+            if (!(0, ast_1.isStringLiteral)(host, uriNameDec)) {
+                return new Error((0, logging_1.format)('├─── The argument provided to the HTTP decorator is not a string literal:\n>> {cyan}', (0, ast_1.nodeText)(uriNameDec, sourceFile)));
+            }
+            // Update the method's URI path
+            uriPath = uriNameDec.text;
+            (0, logging_1.debug)('├─── Detected argument in HTTP decorator, mapping this method to custom URI name');
+        }
+        (0, logging_1.debug)('├─── Detected URI name: {yellow}', uriPath);
+        // Analyze the method's URI
+        const route = (0, route_1.analyzeUri)(controllerUriPrefix ? (uriPath ? `/${controllerUriPrefix}/${uriPath}` : `/` + controllerUriPrefix) : uriPath);
+        if (route instanceof Error) {
+            return new Error('├─── Detected unsupported URI format:\n' +
+                route.message
+                    .split('\n')
+                    .map((line) => '├───── ' + line)
+                    .join('\n'));
+        }
+        (0, logging_1.debug)('├─── Parsed URI name to route: {yellow}', (0, route_1.debugUri)(route, chalk.blue));
+        // Analyze the method's arguments
+        (0, logging_1.debug)('├─── Analyzing arguments...');
+        const params = extractParams({ host, sourceFile, controllerClass, httpMethod, route, method, filePath, absoluteSrcPath });
+        // Get the method's return type
+        (0, logging_1.debug)('├─── Resolving return type...');
+        const returnType = (0, typedeps_1.resolveTypeTextDependencies)(host.typeToString(host.getReturnTypeOfDeclaration(method)), filePath, absoluteSrcPath);
+        (0, logging_1.debug)('├─── Detected return type: {cyan}', returnType.resolvedType);
+        // Success!
+        collected.push({
+            name: methodName,
+            httpMethod,
+            returnType,
+            route,
+            uriPath,
+            params,
+        });
+    }
+    return collected;
+}
+function extractParams(context) {
+    const { httpMethod, route } = context;
+    const { Body, Param, Query } = extractDecoratedArgs(context);
+    const resolvedParams = {
+        routeParams: mergeDecoratedArgs(Param),
+        queryParams: mergeDecoratedArgs(Query),
+        bodyParams: mergeDecoratedArgs(Body),
+        context,
+    };
+    /**
+     * Validate Body Params are not used in GET requests
+     */
+    if (httpMethod === sdk_1.SdkHttpMethod.Get && resolvedParams.bodyParams) {
+        panicWithContext(`${httpMethod} request should not have @Body params, use @Query params instead`, context);
+    }
+    /**
+     * Validate Query Params are not used in non-GET requests
+     */
+    if (httpMethod !== sdk_1.SdkHttpMethod.Get && resolvedParams.queryParams) {
+        panicWithContext(`${httpMethod} request should not have @Query params, use @Body params instead`, context);
+    }
+    /**
+     * Validate Route Params exist in route URL
+     */
+    const { routeParams } = resolvedParams;
+    if (routeParams) {
+        const allowedRouteParams = new Set((0, route_1.paramsFromRoute)(route));
+        // Like the legacy analyzer, this checks the keys of the resolved params object. For a generic `@Param()` argument,
+        // these are the keys of the resolved type's description (rawType, resolvedType...), which are rejected.
+        const usedRouteParams = Object.keys(routeParams);
+        for (const usedParam of usedRouteParams) {
+            if (!allowedRouteParams.has(usedParam)) {
+                panicWithContext(`Route param ${usedParam} does not appear in route URL`, context);
+            }
+        }
+    }
+    return resolvedParams;
+}
+function extractDecoratedArgs(context) {
+    const decoratedArgs = {
+        [sdk_1.ArgDecorator.Param]: [],
+        [sdk_1.ArgDecorator.Query]: [],
+        [sdk_1.ArgDecorator.Body]: [],
+    };
+    const { controllerClass, host, method, sourceFile } = context;
+    const args = method.parameters;
+    for (const arg of args) {
+        const argName = (0, ast_1.nodeName)(arg, sourceFile);
+        (0, logging_1.debug)('├───── Detected argument: {yellow}', argName);
+        // Arguments are collected as soon as they have a decorator like @Query() or @Body()
+        const argDecorators = (0, ast_1.getDecorators)(host, arg).filter((dec) => Object.values(sdk_1.ArgDecorator).includes((0, ast_1.decoratorName)(host, dec, sourceFile)));
+        if (argDecorators.length === 0) {
+            // If we have no argument, this is not an argument we are interested in, so we just skip it
+            (0, logging_1.debug)('├───── Skipping this argument as it does not have a decorator');
+            continue;
+        }
+        else if (argDecorators.length > 1) {
+            (0, logging_1.panic)(`${(0, ast_1.nodeName)(controllerClass, sourceFile)} ${(0, ast_1.nodeName)(method, sourceFile)} has multiple decorators on argument ${argName} ${argDecorators
+                .map((dec) => (0, ast_1.decoratorName)(host, dec, sourceFile))
+                .join(', ')}`);
+        }
+        // Get the only decrator
+        const decorator = argDecorators[0];
+        const decoratorType = (0, ast_1.decoratorName)(host, decorator, sourceFile);
+        const argParamKey = extractArgParamKey({ ...context, arg, decorator });
+        const argType = host.getTypeAtLocation(arg);
+        if (!argParamKey && !host.isObjectType(argType)) {
+            (0, logging_1.panic)(`${(0, ast_1.nodeName)(controllerClass, sourceFile)} ${(0, ast_1.nodeName)(method, sourceFile)} generic controller argument ${decoratorType}() ${argName} must be an object type`);
+        }
+        decoratedArgs[decoratorType].push({
+            arg,
+            argParamKey,
+            decorator,
+            decoratorType,
+            context,
+        });
+    }
+    return decoratedArgs;
+}
+function extractArgParamKey(context) {
+    const { arg, controllerClass, decorator, host, method, sourceFile } = context;
+    const decoratorArgs = (0, ast_1.decoratorArguments)(host, decorator);
+    if (decoratorArgs.length > 1) {
+        (0, logging_1.panic)(`${(0, ast_1.nodeName)(controllerClass, sourceFile)} ${(0, ast_1.nodeName)(method, sourceFile)} ${(0, ast_1.decoratorName)(host, decorator, sourceFile)}() ${(0, ast_1.nodeName)(arg, sourceFile)} argument decorator has multiple parameters`);
+    }
+    else if (decoratorArgs.length === 0) {
+        return null;
+    }
+    const decoratorArg = decoratorArgs[0];
+    if (!(0, ast_1.isStringLiteral)(host, decoratorArg)) {
+        (0, logging_1.panic)('The argument provided to the decorator is not a string literal:\n>>> {cyan}', (0, ast_1.nodeText)(arg, sourceFile));
+    }
+    const paramKey = decoratorArg.text;
+    if (paramKey in {}) {
+        panicWithContext(`${(0, ast_1.decoratorName)(host, decorator, sourceFile)}('${paramKey}') param name collides with JavaScript native object property`, context);
+    }
+    return paramKey;
+}
+function mergeDecoratedArgs(decoratedArgs) {
+    let genericParam = null;
+    const paramMap = {};
+    for (const decoratedArg of decoratedArgs) {
+        const { arg, argParamKey, context, decoratorType } = decoratedArg;
+        const resolvedType = (0, typedeps_1.resolveTypeTextDependencies)(context.host.typeToString(context.host.getTypeAtLocation(arg)), context.filePath, context.absoluteSrcPath);
+        if (argParamKey) {
+            if (paramMap[argParamKey]) {
+                panicWithContext(`${decoratorType}('${argParamKey}') used twice in controller method`, decoratedArg.context);
+            }
+            paramMap[argParamKey] = resolvedType;
+        }
+        else {
+            if (genericParam) {
+                panicWithContext(`${decoratorType}() used twice in controller method`, decoratedArg.context);
+            }
+            genericParam = resolvedType;
+        }
+    }
+    const hasArgsByKey = Object.keys(paramMap).length > 0;
+    if (genericParam && hasArgsByKey) {
+        panicWithContext(`Cannot mix generic and specific ${decoratedArgs[0].decoratorType}()`, decoratedArgs[0].context);
+    }
+    return hasArgsByKey ? paramMap : genericParam;
+}
+const panicWithContext = (message, context) => {
+    const { controllerClass, filePath, httpMethod, method, sourceFile } = context;
+    const ctx = {
+        controller: (0, ast_1.nodeName)(controllerClass, sourceFile),
+        method: (0, ast_1.nodeName)(method, sourceFile),
+        httpMethod,
+        filePath,
+    };
+    (0, logging_1.panic)(`${message}\n${JSON.stringify(ctx, null, 2)}`);
+};
+// =============================================================================================================== //
+// Types extraction (see src/analyzer/extractor.ts, src/analyzer/classdeps.ts)                                     //
+// =============================================================================================================== //
+function analyzeClassDeps(host, decl, sourceFile, relativeFilePath, absoluteSrcPath) {
+    if (path.isAbsolute(relativeFilePath)) {
+        (0, logging_1.unreachable)('Internal error: got absolute file path in class dependencies analyzer, when expecting a relative one (got {magentaBright})', relativeFilePath);
+    }
+    const toLookup = new Array();
+    for (const sup of (0, ast_1.getExtendsTypeNodes)(host, decl)) {
+        toLookup.push(host.getTypeAtLocation(sup));
+    }
+    for (const prop of (0, ast_1.getDeclarationProperties)(host, decl, sourceFile)) {
+        toLookup.push(host.getTypeAtLocation(prop));
+    }
+    return toLookup.map((type) => (0, typedeps_1.resolveTypeTextDependencies)(host.typeToString(type), relativeFilePath, absoluteSrcPath));
+}
+/**
+ * Types extractor
+ */
+class TypesExtractor {
+    host;
+    absoluteSrcPath;
+    magicTypes;
+    extracted;
+    constructor(
+    /** Analysis engine */
+    host, 
+    /** Absolute source path */
+    absoluteSrcPath, 
+    /** Magic types to replace non-portable types */
+    magicTypes, 
+    /** Extracted types */
+    extracted = new Map()) {
+        this.host = host;
+        this.absoluteSrcPath = absoluteSrcPath;
+        this.magicTypes = magicTypes;
+        this.extracted = extracted;
+    }
+    /**
+     * Find if a type has previously been extracted, without providing its extension
+     * @param loc
+     * @returns
+     */
+    findExtractedTypeWithoutExt(loc) {
+        for (const ext of sdk_1.MODULE_EXTENSIONS) {
+            const typ = this.extracted.get(loc.relativePathNoExt + ext)?.get(loc.typename);
+            if (typ) {
+                return typ;
+            }
+        }
+        return null;
+    }
+    /**
+     * Find the relative file location of a type
+     * @param loc
+     * @returns
+     */
+    findTypeRelativeFilePath(loc) {
+        if (path.isAbsolute(loc.relativePathNoExt)) {
+            (0, logging_1.unreachable)('Internal error: got absolute file path in types extractor, when expecting a relative one (got {magentaBright})', loc.relativePathNoExt);
+        }
+        const absolutePathNoExt = path.resolve(this.absoluteSrcPath, loc.relativePathNoExt);
+        const cached = this.findExtractedTypeWithoutExt(loc);
+        if (cached) {
+            return cached.relativePath;
+        }
+        let relativeFilePath = null;
+        for (const ext of sdk_1.MODULE_EXTENSIONS) {
+            if (this.host.getSourceFile(absolutePathNoExt + ext)) {
+                relativeFilePath = loc.relativePathNoExt + ext;
+            }
+        }
+        return (relativeFilePath ??
+            new Error((0, logging_1.format)('File {magenta} was not found (was expected to contain dependency type {yellow})', loc.relativePathNoExt, loc.typename)));
+    }
+    /**
+     * Extract a type
+     * @param loc
+     * @param typesPath
+     * @returns
+     */
+    extractType(loc, typesPath = []) {
+        const { host } = this;
+        const SK = host.SyntaxKind;
+        if (path.isAbsolute(loc.relativePathNoExt)) {
+            (0, logging_1.unreachable)('Internal error: got absolute file path in types extractor, when expecting a relative one (got {magentaBright})', loc.relativePathNoExt);
+        }
+        // Get the absolute path of the type's parent file
+        // We don't know its extension yet as imported file names in import statements don't have an extension
+        const absolutePathNoExt = path.resolve(this.absoluteSrcPath, loc.relativePathNoExt);
+        // If the type is already in cache, return it directly
+        const cached = this.findExtractedTypeWithoutExt(loc);
+        if (cached) {
+            return cached;
+        }
+        // Try to find the path with extension of the file and get it as a source file
+        // (like the legacy analyzer, the last matching extension wins)
+        let fileAndPath = null;
+        for (const ext of sdk_1.MODULE_EXTENSIONS) {
+            const sourceFile = host.getSourceFile(absolutePathNoExt + ext);
+            if (sourceFile) {
+                fileAndPath = [sourceFile, loc.relativePathNoExt + ext];
+            }
+        }
+        if (!fileAndPath) {
+            return new Error((0, logging_1.format)('File {magenta} was not found (was expected to contain dependency type {yellow})', loc.relativePathNoExt, loc.typename));
+        }
+        const [file, relativeFilePath] = fileAndPath;
+        // Use magic types to replace non-portable types
+        for (const magicType of this.magicTypes) {
+            if (relativeFilePath.endsWith(`node_modules/${magicType.nodeModuleFilePath}`) && loc.typename === magicType.typeName) {
+                (0, logging_1.debug)('-> '.repeat(typesPath.length + 1) +
+                    'Found magic type {yellow} from external module file {magentaBright}, using provided placeholder.', loc.typename, relativeFilePath);
+                const extracted = {
+                    content: '/** @file Magic placeholder from configuration file */\n\n' + magicType.placeholderContent,
+                    relativePath: relativeFilePath,
+                    relativePathNoExt: loc.relativePathNoExt,
+                    typename: loc.typename,
+                    typeParams: [],
+                    dependencies: [],
+                };
+                typesPath.pop();
+                let types = this.extracted.get(relativeFilePath);
+                if (!types) {
+                    types = new Map();
+                    this.extracted.set(relativeFilePath, types);
+                }
+                types.set(loc.typename, extracted);
+                return extracted;
+            }
+        }
+        (0, logging_1.debug)('-> '.repeat(typesPath.length + 1) + 'Extracting type {yellow} from file {magentaBright}...', loc.typename, relativeFilePath);
+        // Analyze the type's declaration
+        const decl = file.statements.find((node) => {
+            return ((node.kind === SK.EnumDeclaration ||
+                node.kind === SK.TypeAliasDeclaration ||
+                node.kind === SK.InterfaceDeclaration ||
+                node.kind === SK.ClassDeclaration ||
+                node.kind === SK.FunctionDeclaration) &&
+                (0, ast_1.nodeName)(node, file) === loc.typename);
+        });
+        if (!decl) {
+            return new Error((0, logging_1.format)(`Type {yellow} was not found in file {magenta}`, loc.typename, relativeFilePath));
+        }
+        // Handle a limitation of the tool: you can't import two types from two files at the same path with just two different extensions
+        // Example: importing a type named "User" from two files in the same directory called "user.entity.ts" and "user.entity.js"
+        const typ = this.findExtractedTypeWithoutExt(loc);
+        if (typ && typ.relativePath !== relativeFilePath) {
+            (0, logging_1.panic)('Found two conflicting files at same path but with different extensions:\n> {magentaBright}\n> {magentaBright}', typ.relativePath, relativeFilePath);
+        }
+        /** Resolved type's dependencies */
+        let resolvedDeps;
+        /** Type's parameters (e.g. <T>) */
+        let typeParams;
+        /** Type declaration */
+        let extractedDecl = (0, ast_1.nodeText)(decl, file);
+        // Handle enumerations
+        if (decl.kind === SK.EnumDeclaration) {
+            resolvedDeps = [];
+            typeParams = [];
+        }
+        // Handle type aliases
+        else if (decl.kind === SK.TypeAliasDeclaration) {
+            resolvedDeps = [(0, typedeps_1.resolveTypeTextDependencies)(host.typeToString(host.getTypeAtLocation(decl)), relativeFilePath, this.absoluteSrcPath)];
+            typeParams = [];
+        }
+        // Handle interfaces
+        else if (decl.kind === SK.InterfaceDeclaration) {
+            resolvedDeps = analyzeClassDeps(host, decl, file, relativeFilePath, this.absoluteSrcPath);
+            typeParams = (decl.typeParameters ?? []).map((tp) => (0, ast_1.nodeText)(tp, file));
+        }
+        // Handle classes
+        // Methods are not handled because they shouldn't be used as DTOs and won't be decodable from JSON in all cases
+        // This part is tricky as we remake the class from scratch using the informations we have on it, given we have to get rid
+        //  of methods as well as removing decorators
+        else if (decl.kind === SK.ClassDeclaration) {
+            const classHead = (0, ast_1.nodeText)(decl, file).match(/\b(export[^{]+class[^{]+{)/);
+            if (!classHead) {
+                (0, logging_1.unreachable)('Internal error: failed to match class head in declaration: {yellow}', (0, ast_1.nodeText)(decl, file));
+            }
+            extractedDecl = classHead[1];
+            const index = host.getIndexType(host.getTypeAtLocation(decl), 'string') ?? host.getIndexType(host.getTypeAtLocation(decl), 'number');
+            if (index) {
+                extractedDecl += '\npublic [input: string | number]: ' + (0, typedeps_1.getImportResolvedTypeText)(host.typeToString(index));
+            }
+            // Export all members
+            for (const member of (0, ast_1.getClassMembers)(host, decl, file)) {
+                if (member.kind !== SK.PropertyDeclaration) {
+                    (0, logging_1.warn)('Found non-property member in class {cyan}: {magenta}', (0, ast_1.nodeName)(decl, file) ?? '<anonymous>', (0, ast_1.nodeText)(member, file));
+                    continue;
+                }
+                const memberType = host.getTypeAtLocation(member);
+                const memberText = (0, ast_1.nodeText)(member, file);
+                extractedDecl += `\npublic ${(0, ast_1.nodeName)(member, file)}${memberText.includes('?') ? '?' : memberText.includes('!:') ? '!' : ''}: ${(0, typedeps_1.getImportResolvedTypeText)(host.typeToString(memberType))};`;
+            }
+            extractedDecl += '\n}';
+            resolvedDeps = analyzeClassDeps(host, decl, file, relativeFilePath, this.absoluteSrcPath);
+            typeParams = (decl.typeParameters ?? []).map((tp) => (0, ast_1.nodeText)(tp, file));
+        }
+        // Handle functions
+        else if (decl.kind === SK.FunctionDeclaration) {
+            resolvedDeps = [];
+            typeParams = [];
+        }
+        // Handle unknown types
+        else {
+            (0, logging_1.panic)('Unknown node type when extracting types: ' + decl.kind);
+        }
+        /** Normalized dependencies */
+        const dependencies = [];
+        // Ensure we're not stuck in an infinite loop where we analyze a type A, then its dependency B, which itself depends on A, and so on
+        if (typesPath.includes(loc.typename)) {
+            (0, logging_1.unreachable)(`Internal error: infinite loop detected in types extracted: {yellow}`, typesPath.join(' -> '));
+        }
+        typesPath.push(loc.typename);
+        // Analyze all dependencies
+        for (const dependencyLoc of (0, sdk_1.locateTypesFile)(resolvedDeps)) {
+            // If the "dependency" is one of the type's parameters (e.g. "T"), ignore this part
+            if (typeParams.includes(dependencyLoc.typename)) {
+                continue;
+            }
+            // Find the dependency's relative path
+            let relativePath;
+            const cached = this.findExtractedTypeWithoutExt(dependencyLoc);
+            if (cached) {
+                relativePath = cached.relativePath;
+            }
+            else if (typesPath.includes(dependencyLoc.typename)) {
+                relativePath = this.findTypeRelativeFilePath(dependencyLoc);
+            }
+            else {
+                const extracted = this.extractType(dependencyLoc, typesPath);
+                relativePath = extracted instanceof Error ? extracted : extracted.relativePath;
+            }
+            if (relativePath instanceof Error) {
+                return new Error((0, logging_1.format)('├─ Failed to extract type {yellow} due to an error in dependency type {yellow}\nfrom file {magenta} :\n{}', loc.typename, dependencyLoc.typename, relativeFilePath, relativePath.message.replace(/^/gm, '  ')));
+            }
+            // Update dependencies
+            dependencies.push({ ...dependencyLoc, relativePath });
+        }
+        const extracted = {
+            ...loc,
+            relativePath: relativeFilePath,
+            typeParams,
+            content: extractedDecl,
+            dependencies,
+        };
+        typesPath.pop();
+        let types = this.extracted.get(relativeFilePath);
+        if (!types) {
+            types = new Map();
+            this.extracted.set(relativeFilePath, types);
+        }
+        // Save the dependency
+        types.set(loc.typename, extracted);
+        return extracted;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyze.js","sourceRoot":"","sources":["../../src/engine/analyze.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,MAAY,EAAE,+BAAU;AACxB,MAAY,EAAE,+BAAU;AACxB,MAAY,IAAI,iCAAY;AAE5B,MAAO,KAAK,oBAAmB;AAE/B,iDAAuD;AACvD,6CAAgF;AAChF,yCAmBwB;AACxB,mDAA+G;AAE/G,wCAAoE;AACpE,oCAAwC;AAExC,+BAWc;AAGd;;;;GAIG;AACI,KAAK,0BAA0B,MAAc,EAAE,UAAsD;IAC1G,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;IAE1B,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,YAAY,CAAC,CAAA;IAEnE,IAAI,CAAC,UAAU;QAAE,IAAA,eAAK,EAAC,mCAAmC,CAAC,CAAA;IAE3D,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;QAAE,IAAA,eAAK,EAAC,qDAAqD,EAAE,UAAU,CAAC,CAAA;IACxG,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE;QAAE,IAAA,eAAK,EAAC,yCAAyC,CAAC,CAAA;IAE7F,IAAA,eAAK,EAAC,0CAA0C,EAAE,UAAU,CAAC,CAAA;IAE7D,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;QACtB,MAAM,mBAAmB,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAA;QAExF,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC,EAAE,CAAC;YACxC,IAAA,eAAK,EAAC,gEAAgE,EAAE,mBAAmB,CAAC,CAAA;QAC9F,CAAC;QAED,IAAA,eAAK,EAAC,4BAA4B,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,CAAA;IAC7G,CAAC;IAED,gDAAgD;IAChD,IAAI,MAAM,CAAC,YAAY,IAAI,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7D,IAAA,eAAK,EAAC,8CAA8C,CAAC,CAAA;IACvD,CAAC;IAED,MAAM,gBAAgB,GAAG,MAAM,CAAC,YAAY,IAAI,eAAe,CAAA;IAC/D,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAA;IAEhE,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACrC,IAAA,eAAK,EAAC,yDAAyD,EAAE,gBAAgB,EAAE,UAAU,CAAC,CAAA;IAChG,CAAC;IAED,MAAM,IAAI,GAAG,UAAU,CAAC,gBAAgB,CAAC,CAAA;IAEzC,IAAI,CAAC;QACH,+DAA+D;QAC/D,MAAM,aAAa,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAA;QAC/F,IAAA,eAAK,EAAC,qCAAqC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;QAElE,WAAW;QACX,IAAA,eAAK,EAAC,wCAAwC,CAAC,CAAA;QAE/C,IAAI,eAAe,GAAG,CAAC,CAAA;QACvB,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAA;QAErD,MAAM,WAAW,GAAG,CAAC,YAAoB,EAAE,EAAE,CAAC,YAAY,GAAG,aAAa,CAAC,MAAM,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC,GAAG,EAAE,CAAA;QAE/G,MAAM,WAAW,GAAG,EAAE,CAAA;QAEtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9C,MAAM,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;YAE7B,IAAI,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;gBACpC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YACxB,CAAC;YAED,IAAI,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBACvB,OAAO,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC;oBAAE,eAAe,EAAE,CAAA;gBAE5C,IAAA,eAAK,EACH,2EAA2E,EAC3E,CAAC,eAAe,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,EACxD,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,aAAa,CAAC,MAAM,EAAE,EACvE,WAAW,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,EAClD,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAClC,CAAA;YACH,CAAC;QACH,CAAC;QAED,IAAA,eAAK,EAAC,sCAAsC,CAAC,CAAA;QAE7C,MAAM,OAAO,GAAG,kBAAkB,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,CAAC,CAAA;QAEjE,mGAAmG;QACnG,qFAAqF;QACrF,MAAM,UAAU,GAAG,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,2BAAiB,CAAC,CAAA;QAEtE,MAAM,UAAU,GAAG,IAAI,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,CAAC,CAAA;QAEnE,MAAM,cAAc,GAAG,IAAA,qBAAe,EAAC,IAAA,6BAAuB,EAAC,OAAO,CAAC,CAAC,CAAA;QAExE,IAAA,eAAK,EAAC,2BAA2B,GAAG,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,cAAc,CAAC,MAAM,CAAC,CAAA;QAE9G,KAAK,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;YACjC,MAAM,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;YAE1C,IAAI,MAAM,YAAY,KAAK,EAAE,CAAC;gBAC5B,IAAA,eAAK,EAAC,MAAM,CAAC,OAAO,CAAC,CAAA;YACvB,CAAC;QACH,CAAC;QAED,MAAM,OAAO,GAAe;YAC1B,OAAO;YACP,KAAK,EAAE,UAAU,CAAC,SAAS;SAC5B,CAAA;QAED,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;YACtB,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,UAAU,EAAE,IAAA,yBAAmB,EAAC,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC,CAAA;QACtG,CAAC;QAED,IAAA,eAAK,EAAC,+BAA+B,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAA;QAExF,OAAO,OAAO,CAAA;IAChB,CAAC;YAAS,CAAC;QACT,IAAI,CAAC,OAAO,EAAE,CAAA;IAChB,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,oBAAoB,CAAC,IAAkB,EAAE,YAAoB;IACpE,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAA;IAE7C,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,+DAA+D,YAAY,EAAE,CAAC,CAAA;IAChG,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED,qHAAqH;AACrH,qHAAqH;AACrH,qHAAqH;AAErH,SAAS,kBAAkB,CAAC,IAAkB,EAAE,WAAqB,EAAE,eAAuB;IAC5F,oCAAoC;IACpC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAsC,CAAA;IAC/D,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAU,CAAA;IAE7C;;;OAGG;IACH,MAAM,YAAY,GAAG,IAAI,GAAG,EAAkB,CAAA;IAE9C;;;;OAIG;IACH,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAkB,CAAA;IAErD,IAAA,eAAK,EAAC,mCAAmC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAE9D,WAAW,CAAC,OAAO,CAAC,CAAC,sBAAsB,EAAE,CAAC,EAAE,EAAE;QAChD,MAAM,sBAAsB,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAAA;QAEpF,IAAA,eAAK,EACH,6CAA6C,EAC7C,4BAA4B,EAC5B,GAAG,CAAC,GAAG,CAAC,IAAI,WAAW,CAAC,MAAM,EAAE,EAChC,sBAAsB,EACtB,OAAO,CACR,CAAA;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAA;QAErD,IAAI,UAAU,GAAG,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QAE3C,yCAAyC;QACzC,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,qCAAqC;YACrC,MAAM,kBAAkB,GAAG,IAAA,qBAAa,EAAC,kBAAkB,EAAE,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC,CAAA;YAErG,IAAI,kBAAkB,KAAK,IAAI,EAAE,CAAC;gBAChC,IAAA,eAAK,EAAC,2DAA2D,EAAE,sBAAsB,CAAC,CAAA;YAC5F,CAAC;YAED,MAAM,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAAA;YAE7E,wBAAwB;YACxB,UAAU,GAAG,aAAa,CAAC,IAAI,EAAE,kBAAkB,EAAE,eAAe,CAAC,CAAA;YAErE,IAAA,eAAK,EAAC,6BAA6B,EAAE,UAAU,CAAC,CAAA;YAEhD,+BAA+B;YAC/B,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;YAE5D,IAAI,gBAAgB,EAAE,CAAC;gBACrB,IAAA,eAAK,EACH,0DAA0D,GAAG,qBAAqB,GAAG,mBAAmB,EACxG,UAAU,EACV,gBAAgB,EAChB,kBAAkB,CACnB,CAAA;YACH,CAAC;YAED,YAAY,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;QACxC,CAAC;QAED,IAAI,UAAU,IAAI,EAAE,EAAE,CAAC;YACrB,IAAA,eAAK,EAAC,yFAAyF,EAAE,UAAU,CAAC,CAAA;QAC9G,CAAC;QAED,IAAI,cAAc,GAAG,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;QAE9C,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,cAAc,GAAG,IAAI,GAAG,EAAE,CAAA;YAC1B,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,cAAc,CAAC,CAAA;QAC3C,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACZ,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,iBAAiB,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,eAAe,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;gBAClI,IAAA,cAAI,EAAC,sHAAsH,CAAC,CAAA;gBAC5H,IAAA,cAAI,EAAC,wFAAwF,CAAC,CAAA;YAChG,CAAC;QACH,CAAC;QAED,MAAM,QAAQ,GAAG,iBAAiB,CAAC,IAAI,EAAE,sBAAsB,EAAE,eAAe,CAAC,CAAA;QAEjF,IAAI,QAAQ,YAAY,KAAK,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,IAAA,gBAAM,EAAC,qDAAqD,EAAE,sBAAsB,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAA;QAC1H,CAAC;QAED,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,QAAQ,CAAC,gBAAgB,IAAI,EAAE,EAAE,CAAC;gBACpC,IAAA,eAAK,EACH,0GAA0G,EAC1G,QAAQ,CAAC,gBAAgB,CAC1B,CAAA;YACH,CAAC;YAED,8DAA8D;YAC9D,IAAI,mBAAmB,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;gBAChD,IAAA,eAAK,EACH,2FAA2F,EAC3F,QAAQ,CAAC,gBAAgB,EACzB,QAAQ,CAAC,IAAI,CACd,CAAA;YACH,CAAC;iBAAM,CAAC;gBACN,mBAAmB,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAA;YAC7C,CAAC;YAED,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;QAClD,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,SAAS,aAAa,CAAC,IAAkB,EAAE,UAAkB,EAAE,UAAkB;IAC/E,MAAM,EAAE,GAAG,IAAI,CAAC,UAAU,CAAA;IAE1B,qCAAqC;IACrC,MAAM,IAAI,GAAG,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAA;IAE7E,oCAAoC;IACpC,MAAM,SAAS,GAAI,IAAI,CAAC,UAAuB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,gBAAgB,IAAI,IAAA,mBAAa,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;IAEzI,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,IAAA,eAAK,EAAC,kDAAkD,EAAE,UAAU,CAAC,CAAA;IACvE,CAAC;IAED,MAAM,UAAU,GAAG,IAAA,cAAQ,EAAC,SAAS,EAAE,IAAI,CAAC,CAAA;IAE5C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,IAAA,eAAK,EAAC,2DAA2D,CAAC,CAAA;IACpE,CAAC;IAED,MAAM,UAAU,GAAG,IAAA,mBAAa,EAAC,IAAI,EAAE,SAAS,CAAC,CAAA;IACjD,MAAM,eAAe,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAA,mBAAa,EAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,KAAK,QAAQ,CAAC,CAAA;IAE7F,IAAI,CAAC,eAAe,EAAE,CAAC;QACrB,IAAA,eAAK,EAAC,IAAA,gBAAM,EAAC,+EAA+E,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAA;IACnI,CAAC;IAED,OAAO,UAAU,CAAA;AACnB,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAkB,EAAE,cAAsB,EAAE,eAAuB;IAC5F,MAAM,EAAE,GAAG,IAAI,CAAC,UAAU,CAAA;IAE1B,IAAA,eAAK,EAAC,qBAAqB,EAAE,cAAc,CAAC,CAAA;IAE5C,qCAAqC;IACrC,MAAM,IAAI,GAAG,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC,CAAA;IAEtF,wCAAwC;IACxC,MAAM,SAAS,GAAI,IAAI,CAAC,UAAuB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,gBAAgB,CAAC,CAAA;IAEjG,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,IAAA,cAAI,EAAC,mCAAmC,CAAC,CAAA;QACzC,OAAO,IAAI,CAAA;IACb,CAAC;IAED,MAAM,SAAS,GAAG,IAAA,cAAQ,EAAC,SAAS,EAAE,IAAI,CAAC,CAAA;IAE3C,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAA;IAC/E,CAAC;IAED,8DAA8D;IAC9D,wEAAwE;IACxE,IAAI,gBAAgB,GAAG,IAAA,eAAS,EAAC,SAAS,CAAC,CAAA;IAC3C,IAAI,mBAAmB,GAAkB,IAAI,CAAA;IAE7C,IAAA,eAAK,EAAC,mCAAmC,EAAE,SAAS,CAAC,CAAA;IAErD,kCAAkC;IAClC,MAAM,SAAS,GAAG,IAAA,mBAAa,EAAC,IAAI,EAAE,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAA,mBAAa,EAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,KAAK,YAAY,CAAC,CAAA;IAE/G,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,IAAA,cAAI,EAAC,wEAAwE,CAAC,CAAA;QAC9E,OAAO,IAAI,CAAA;IACb,CAAC;IAED,sCAAsC;IACtC,MAAM,WAAW,GAAG,IAAA,6BAAuB,EAAC,IAAI,EAAE,SAAS,CAAC,CAAA;IAE5D,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,IAAA,cAAI,EAAC,uEAAuE,CAAC,CAAA;QAC7E,OAAO,IAAI,CAAA;IACb,CAAC;IAED,gCAAgC;IAChC,MAAM,OAAO,GAAa,WAAW,CAAC,SAAS,CAAA;IAE/C,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,IAAA,cAAI,EAAC,6FAA6F,CAAC,CAAA;QACnG,OAAO,IAAI,CAAA;IACb,CAAC;IAED,qFAAqF;IACrF,8FAA8F;IAC9F,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QACf,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;QAE1B,8BAA8B;QAC9B,IAAI,CAAC,IAAA,qBAAe,EAAC,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;YACpC,IAAA,cAAI,EAAC,4FAA4F,CAAC,CAAA;YAClG,OAAO,IAAI,CAAA;QACb,CAAC;QAED,+BAA+B;QAC/B,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAA;QAC/B,mBAAmB,GAAG,gBAAgB,CAAA;QACtC,IAAA,eAAK,EAAC,6EAA6E,EAAE,SAAS,EAAE,gBAAgB,CAAC,CAAA;IACnH,CAAC;SAAM,CAAC;QACN,2GAA2G;QAC3G,IAAA,eAAK,EAAC,uFAAuF,EAAE,gBAAgB,CAAC,CAAA;IAClH,CAAC;IAED,wDAAwD;IACxD,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,mBAAmB,EAAE,cAAc,EAAE,eAAe,CAAC,CAAA;IAE3G,IAAI,OAAO,YAAY,KAAK,EAAE,CAAC;QAC7B,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,WAAW;IACX,IAAA,eAAK,EAAC,iCAAiC,EAAE,cAAc,CAAC,CAAA;IAExD,OAAO;QACL,IAAI,EAAE,cAAc;QACpB,SAAS;QACT,gBAAgB;QAChB,OAAO;KACR,CAAA;AACH,CAAC;AAED,qHAAqH;AACrH,qHAAqH;AACrH,qHAAqH;AAErH,SAAS,cAAc,CACrB,IAAkB,EAClB,UAAkB,EAClB,eAAuB,EACvB,mBAAkC,EAClC,QAAgB,EAChB,eAAuB;IAEvB,kBAAkB;IAClB,MAAM,SAAS,GAAG,IAAI,KAAK,EAAa,CAAA;IAExC,8BAA8B;IAC9B,MAAM,OAAO,GAAI,eAAe,CAAC,OAAoB,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAA;IAEvH,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,UAAU,GAAG,IAAA,cAAQ,EAAC,MAAM,EAAE,UAAU,CAAE,CAAA;QAEhD,IAAA,eAAK,EAAC,2BAA2B,EAAE,UAAU,CAAC,CAAA;QAE9C,0CAA0C;QAC1C,MAAM,UAAU,GAAG,IAAA,mBAAa,EAAC,IAAI,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAC5D,MAAM,CAAC,IAAI,CAAC,mBAAa,CAAC,CAAC,QAAQ,CAAC,IAAA,mBAAa,EAAC,IAAI,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAC1E,CAAA;QAED,+CAA+C;QAC/C,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1B,sFAAsF;YACtF,OAAO,IAAI,KAAK,CACd,IAAA,gBAAM,EACJ,4DAA4D;gBAC1D,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAA,mBAAa,EAAC,IAAI,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAC1E,CACF,CAAA;QACH,CAAC;aAAM,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnC,yIAAyI;YACzI,IAAA,eAAK,EAAC,iEAAiE,CAAC,CAAA;YACxE,SAAQ;QACV,CAAC;QAED,yBAAyB;QACzB,MAAM,GAAG,GAAG,UAAU,CAAC,CAAC,CAAC,CAAA;QAEzB,MAAM,UAAU,GAAG,mBAAa,CAAC,IAAA,mBAAa,EAAC,IAAI,EAAE,GAAG,EAAE,UAAU,CAA+B,CAAC,CAAA;QAEpG,IAAA,eAAK,EAAC,4CAA4C,EAAE,UAAU,CAAC,iBAAiB,EAAE,CAAC,CAAA;QAEnF,iFAAiF;QACjF,MAAM,OAAO,GAAG,IAAA,wBAAkB,EAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QAE7C,wBAAwB;QACxB,IAAI,OAAe,CAAA;QAEnB,uDAAuD;QACvD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvB,qHAAqH;YACrH,OAAO,IAAI,KAAK,CAAC,aAAa,OAAO,CAAC,MAAM,iDAAiD,CAAC,CAAA;QAChG,CAAC;aAAM,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChC,qEAAqE;YACrE,IAAA,eAAK,EAAC,4DAA4D,CAAC,CAAA;YACnE,OAAO,GAAG,EAAE,CAAA;QACd,CAAC;aAAM,CAAC;YACN,gEAAgE;YAChE,MAAM,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;YAE7B,8BAA8B;YAC9B,IAAI,CAAC,IAAA,qBAAe,EAAC,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC;gBACvC,OAAO,IAAI,KAAK,CACd,IAAA,gBAAM,EAAC,sFAAsF,EAAE,IAAA,cAAQ,EAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CACjI,CAAA;YACH,CAAC;YAED,+BAA+B;YAC/B,OAAO,GAAG,UAAU,CAAC,IAAI,CAAA;YAEzB,IAAA,eAAK,EAAC,kFAAkF,CAAC,CAAA;QAC3F,CAAC;QAED,IAAA,eAAK,EAAC,kCAAkC,EAAE,OAAO,CAAC,CAAA;QAElD,2BAA2B;QAC3B,MAAM,KAAK,GAAG,IAAA,kBAAU,EAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,mBAAmB,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAA;QAEtI,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;YAC3B,OAAO,IAAI,KAAK,CACd,yCAAyC;gBACvC,KAAK,CAAC,OAAO;qBACV,KAAK,CAAC,IAAI,CAAC;qBACX,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,GAAG,IAAI,CAAC;qBAC/B,IAAI,CAAC,IAAI,CAAC,CAChB,CAAA;QACH,CAAC;QAED,IAAA,eAAK,EAAC,yCAAyC,EAAE,IAAA,gBAAQ,EAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAA;QAE7E,iCAAiC;QACjC,IAAA,eAAK,EAAC,6BAA6B,CAAC,CAAA;QACpC,MAAM,MAAM,GAAG,aAAa,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC,CAAA;QAEzH,+BAA+B;QAC/B,IAAA,eAAK,EAAC,+BAA+B,CAAC,CAAA;QACtC,MAAM,UAAU,GAAG,IAAA,sCAA2B,EAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,0BAA0B,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAA;QAErI,IAAA,eAAK,EAAC,mCAAmC,EAAE,UAAU,CAAC,YAAY,CAAC,CAAA;QAEnE,WAAW;QACX,SAAS,CAAC,IAAI,CAAC;YACb,IAAI,EAAE,UAAU;YAChB,UAAU;YACV,UAAU;YACV,KAAK;YACL,OAAO;YACP,MAAM;SACP,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC;AAqBD,SAAS,aAAa,CAAC,OAAsB;IAC3C,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,OAAO,CAAA;IACrC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAA;IAC5D,MAAM,cAAc,GAAoB;QACtC,WAAW,EAAE,kBAAkB,CAAC,KAAK,CAAC;QACtC,WAAW,EAAE,kBAAkB,CAAC,KAAK,CAAC;QACtC,UAAU,EAAE,kBAAkB,CAAC,IAAI,CAAC;QACpC,OAAO;KACR,CAAA;IAED;;OAEG;IACH,IAAI,UAAU,KAAK,mBAAa,CAAC,GAAG,IAAI,cAAc,CAAC,UAAU,EAAE,CAAC;QAClE,gBAAgB,CAAC,GAAG,UAAU,kEAAkE,EAAE,OAAO,CAAC,CAAA;IAC5G,CAAC;IAED;;OAEG;IACH,IAAI,UAAU,KAAK,mBAAa,CAAC,GAAG,IAAI,cAAc,CAAC,WAAW,EAAE,CAAC;QACnE,gBAAgB,CAAC,GAAG,UAAU,kEAAkE,EAAE,OAAO,CAAC,CAAA;IAC5G,CAAC;IAED;;OAEG;IACH,MAAM,EAAE,WAAW,EAAE,GAAG,cAAc,CAAA;IACtC,IAAI,WAAW,EAAE,CAAC;QAChB,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC,IAAA,uBAAe,EAAC,KAAK,CAAC,CAAC,CAAA;QAC1D,mHAAmH;QACnH,wGAAwG;QACxG,MAAM,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QAEhD,KAAK,MAAM,SAAS,IAAI,eAAe,EAAE,CAAC;YACxC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;gBACvC,gBAAgB,CAAC,eAAe,SAAS,+BAA+B,EAAE,OAAO,CAAC,CAAA;YACpF,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,cAAc,CAAA;AACvB,CAAC;AAED,SAAS,oBAAoB,CAAC,OAAsB;IAClD,MAAM,aAAa,GAAG;QACpB,CAAC,kBAAY,CAAC,KAAK,CAAC,EAAE,EAAoB;QAC1C,CAAC,kBAAY,CAAC,KAAK,CAAC,EAAE,EAAoB;QAC1C,CAAC,kBAAY,CAAC,IAAI,CAAC,EAAE,EAAoB;KAC1C,CAAA;IAED,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAA;IAC7D,MAAM,IAAI,GAAa,MAAM,CAAC,UAAU,CAAA;IAExC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,OAAO,GAAG,IAAA,cAAQ,EAAC,GAAG,EAAE,UAAU,CAAC,CAAA;QAEzC,IAAA,eAAK,EAAC,oCAAoC,EAAE,OAAQ,CAAC,CAAA;QAErD,oFAAoF;QACpF,MAAM,aAAa,GAAG,IAAA,mBAAa,EAAC,IAAI,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAC3D,MAAM,CAAC,MAAM,CAAC,kBAAY,CAAc,CAAC,QAAQ,CAAC,IAAA,mBAAa,EAAC,IAAI,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CACzF,CAAA;QAED,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/B,2FAA2F;YAC3F,IAAA,eAAK,EAAC,+DAA+D,CAAC,CAAA;YACtE,SAAQ;QACV,CAAC;aAAM,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpC,IAAA,eAAK,EACH,GAAG,IAAA,cAAQ,EAAC,eAAe,EAAE,UAAU,CAAC,IAAI,IAAA,cAAQ,EAAC,MAAM,EAAE,UAAU,CAAC,wCAAwC,OAAO,IAAI,aAAa;iBACrI,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAA,mBAAa,EAAC,IAAI,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;iBAClD,IAAI,CAAC,IAAI,CAAC,EAAE,CAChB,CAAA;QACH,CAAC;QACD,wBAAwB;QACxB,MAAM,SAAS,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;QAClC,MAAM,aAAa,GAAG,IAAA,mBAAa,EAAC,IAAI,EAAE,SAAS,EAAE,UAAU,CAAiB,CAAA;QAChF,MAAM,WAAW,GAAG,kBAAkB,CAAC,EAAE,GAAG,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAA;QACtE,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAA;QAE3C,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC;YAChD,IAAA,eAAK,EACH,GAAG,IAAA,cAAQ,EAAC,eAAe,EAAE,UAAU,CAAC,IAAI,IAAA,cAAQ,EAAC,MAAM,EAAE,UAAU,CAAC,gCAAgC,aAAa,MAAM,OAAO,yBAAyB,CAC5J,CAAA;QACH,CAAC;QAED,aAAa,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC;YAChC,GAAG;YACH,WAAW;YACX,SAAS;YACT,aAAa;YACb,OAAO;SACR,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,aAAa,CAAA;AACtB,CAAC;AAED,SAAS,kBAAkB,CACzB,OAGC;IAED,MAAM,EAAE,GAAG,EAAE,eAAe,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAA;IAC7E,MAAM,aAAa,GAAG,IAAA,wBAAkB,EAAC,IAAI,EAAE,SAAS,CAAC,CAAA;IAEzD,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC7B,IAAA,eAAK,EACH,GAAG,IAAA,cAAQ,EAAC,eAAe,EAAE,UAAU,CAAC,IAAI,IAAA,cAAQ,EAAC,MAAM,EAAE,UAAU,CAAC,IAAI,IAAA,mBAAa,EAAC,IAAI,EAAE,SAAS,EAAE,UAAU,CAAC,MAAM,IAAA,cAAQ,EAClI,GAAG,EACH,UAAU,CACX,6CAA6C,CAC/C,CAAA;IACH,CAAC;SAAM,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtC,OAAO,IAAI,CAAA;IACb,CAAC;IAED,MAAM,YAAY,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;IAErC,IAAI,CAAC,IAAA,qBAAe,EAAC,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC;QACzC,IAAA,eAAK,EAAC,6EAA6E,EAAE,IAAA,cAAQ,EAAC,GAAG,EAAE,UAAU,CAAC,CAAC,CAAA;IACjH,CAAC;IAED,MAAM,QAAQ,GAAW,YAAY,CAAC,IAAI,CAAA;IAC1C,IAAI,QAAQ,IAAI,EAAE,EAAE,CAAC;QACnB,gBAAgB,CACd,GAAG,IAAA,mBAAa,EAAC,IAAI,EAAE,SAAS,EAAE,UAAU,CAAC,KAAK,QAAQ,+DAA+D,EACzH,OAAO,CACR,CAAA;IACH,CAAC;IAED,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED,SAAS,kBAAkB,CAAC,aAA6B;IACvD,IAAI,YAAY,GAA0B,IAAI,CAAA;IAC9C,MAAM,QAAQ,GAAsB,EAAE,CAAA;IAEtC,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;QACzC,MAAM,EAAE,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,YAAY,CAAA;QACjE,MAAM,YAAY,GAAG,IAAA,sCAA2B,EAC9C,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,EAC9D,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,eAAe,CACxB,CAAA;QAED,IAAI,WAAW,EAAE,CAAC;YAChB,IAAI,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC1B,gBAAgB,CAAC,GAAG,aAAa,KAAK,WAAW,oCAAoC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;YAC9G,CAAC;YAED,QAAQ,CAAC,WAAW,CAAC,GAAG,YAAY,CAAA;QACtC,CAAC;aAAM,CAAC;YACN,IAAI,YAAY,EAAE,CAAC;gBACjB,gBAAgB,CAAC,GAAG,aAAa,oCAAoC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;YAC9F,CAAC;YAED,YAAY,GAAG,YAAY,CAAA;QAC7B,CAAC;IACH,CAAC;IAED,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC,CAAA;IAErD,IAAI,YAAY,IAAI,YAAY,EAAE,CAAC;QACjC,gBAAgB,CAAC,mCAAmC,aAAa,CAAC,CAAC,CAAC,CAAC,aAAa,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAA;IACnH,CAAC;IAED,OAAO,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAA;AAC/C,CAAC;AAED,MAAM,gBAAgB,GAAG,CAAC,OAAe,EAAE,OAAsB,EAAE,EAAE;IACnE,MAAM,EAAE,eAAe,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAA;IAC7E,MAAM,GAAG,GAAG;QACV,UAAU,EAAE,IAAA,cAAQ,EAAC,eAAe,EAAE,UAAU,CAAC;QACjD,MAAM,EAAE,IAAA,cAAQ,EAAC,MAAM,EAAE,UAAU,CAAC;QACpC,UAAU;QACV,QAAQ;KACT,CAAA;IACD,IAAA,eAAK,EAAC,GAAG,OAAO,KAAK,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAA;AACtD,CAAC,CAAA;AAED,qHAAqH;AACrH,qHAAqH;AACrH,qHAAqH;AAErH,SAAS,gBAAgB,CACvB,IAAkB,EAClB,IAAY,EACZ,UAAkB,EAClB,gBAAwB,EACxB,eAAuB;IAEvB,IAAI,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACtC,IAAA,qBAAW,EACT,4HAA4H,EAC5H,gBAAgB,CACjB,CAAA;IACH,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,KAAK,EAAU,CAAA;IAEpC,KAAK,MAAM,GAAG,IAAI,IAAA,yBAAmB,EAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;QAClD,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAA;IAC5C,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,IAAA,8BAAwB,EAAC,IAAI,EAAE,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC;QACpE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAA;IAC7C,CAAC;IAED,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAA,sCAA2B,EAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,gBAAgB,EAAE,eAAe,CAAC,CAAC,CAAA;AACxH,CAAC;AAED;;GAEG;AACH,MAAM,cAAc;IAGA,IAAI;IAGJ,eAAe;IAGf,UAAU;IAGV,SAAS;IAX3B;IACE,sBAAsB;IACN,IAAkB;IAElC,2BAA2B;IACX,eAAuB;IAEvC,gDAAgD;IAChC,UAA4B;IAE5C,sBAAsB;IACN,SAAS,GAA0B,IAAI,GAAG,EAAE;oBAT5C,IAAI;+BAGJ,eAAe;0BAGf,UAAU;yBAGV,SAAS;IACxB,CAAC;IAEJ;;;;OAIG;IACH,2BAA2B,CAAC,GAAiB;QAC3C,KAAK,MAAM,GAAG,IAAI,uBAAiB,EAAE,CAAC;YACpC,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,iBAAiB,GAAG,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;YAE9E,IAAI,GAAG,EAAE,CAAC;gBACR,OAAO,GAAG,CAAA;YACZ,CAAC;QACH,CAAC;QAED,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,wBAAwB,CAAC,GAAiB;QACxC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAC3C,IAAA,qBAAW,EACT,gHAAgH,EAChH,GAAG,CAAC,iBAAiB,CACtB,CAAA;QACH,CAAC;QAED,MAAM,iBAAiB,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAA;QAEnF,MAAM,MAAM,GAAG,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,CAAA;QAEpD,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAC,YAAY,CAAA;QAC5B,CAAC;QAED,IAAI,gBAAgB,GAAkB,IAAI,CAAA;QAE1C,KAAK,MAAM,GAAG,IAAI,uBAAiB,EAAE,CAAC;YACpC,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,iBAAiB,GAAG,GAAG,CAAC,EAAE,CAAC;gBACrD,gBAAgB,GAAG,GAAG,CAAC,iBAAiB,GAAG,GAAG,CAAA;YAChD,CAAC;QACH,CAAC;QAED,OAAO,CACL,gBAAgB;YAChB,IAAI,KAAK,CACP,IAAA,gBAAM,EAAC,iFAAiF,EAAE,GAAG,CAAC,iBAAiB,EAAE,GAAG,CAAC,QAAQ,CAAC,CAC/H,CACF,CAAA;IACH,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,GAAiB,EAAE,SAAS,GAAa,EAAE;QACrD,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAA;QACrB,MAAM,EAAE,GAAG,IAAI,CAAC,UAAU,CAAA;QAE1B,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAC3C,IAAA,qBAAW,EACT,gHAAgH,EAChH,GAAG,CAAC,iBAAiB,CACtB,CAAA;QACH,CAAC;QAED,kDAAkD;QAClD,sGAAsG;QACtG,MAAM,iBAAiB,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAA;QAEnF,sDAAsD;QACtD,MAAM,MAAM,GAAG,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,CAAA;QAEpD,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAA;QACf,CAAC;QAED,8EAA8E;QAC9E,+DAA+D;QAC/D,IAAI,WAAW,GAA4B,IAAI,CAAA;QAE/C,KAAK,MAAM,GAAG,IAAI,uBAAiB,EAAE,CAAC;YACpC,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,iBAAiB,GAAG,GAAG,CAAC,CAAA;YAE9D,IAAI,UAAU,EAAE,CAAC;gBACf,WAAW,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,iBAAiB,GAAG,GAAG,CAAC,CAAA;YACzD,CAAC;QACH,CAAC;QAED,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,IAAI,KAAK,CACd,IAAA,gBAAM,EAAC,iFAAiF,EAAE,GAAG,CAAC,iBAAiB,EAAE,GAAG,CAAC,QAAQ,CAAC,CAC/H,CAAA;QACH,CAAC;QAED,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC,GAAG,WAAW,CAAA;QAE5C,gDAAgD;QAChD,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,IAAI,gBAAgB,CAAC,QAAQ,CAAC,gBAAgB,SAAS,CAAC,kBAAkB,EAAE,CAAC,IAAI,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,QAAQ,EAAE,CAAC;gBACrH,IAAA,eAAK,EACH,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;oBAChC,kGAAkG,EACpG,GAAG,CAAC,QAAQ,EACZ,gBAAgB,CACjB,CAAA;gBAED,MAAM,SAAS,GAAkB;oBAC/B,OAAO,EAAE,4DAA4D,GAAG,SAAS,CAAC,kBAAkB;oBACpG,YAAY,EAAE,gBAAgB;oBAC9B,iBAAiB,EAAE,GAAG,CAAC,iBAAiB;oBACxC,QAAQ,EAAE,GAAG,CAAC,QAAQ;oBACtB,UAAU,EAAE,EAAE;oBACd,YAAY,EAAE,EAAE;iBACjB,CAAA;gBAED,SAAS,CAAC,GAAG,EAAE,CAAA;gBAEf,IAAI,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAA;gBAEhD,IAAI,CAAC,KAAK,EAAE,CAAC;oBACX,KAAK,GAAG,IAAI,GAAG,EAAE,CAAA;oBACjB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAA;gBAC7C,CAAC;gBAED,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAA;gBAElC,OAAO,SAAS,CAAA;YAClB,CAAC;QACH,CAAC;QAED,IAAA,eAAK,EAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,uDAAuD,EAAE,GAAG,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAA;QAEnI,iCAAiC;QACjC,MAAM,IAAI,GAAI,IAAI,CAAC,UAAuB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;YACvD,OAAO,CACL,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,eAAe;gBAC/B,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,oBAAoB;gBACrC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,oBAAoB;gBACrC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,gBAAgB;gBACjC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,mBAAmB,CAAC;gBACvC,IAAA,cAAQ,EAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,CAAC,QAAQ,CACtC,CAAA;QACH,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,IAAI,KAAK,CAAC,IAAA,gBAAM,EAAC,+CAA+C,EAAE,GAAG,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAA;QAC3G,CAAC;QAED,iIAAiI;QACjI,2HAA2H;QAC3H,MAAM,GAAG,GAAG,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,CAAA;QAEjD,IAAI,GAAG,IAAI,GAAG,CAAC,YAAY,KAAK,gBAAgB,EAAE,CAAC;YACjD,IAAA,eAAK,EACH,+GAA+G,EAC/G,GAAG,CAAC,YAAY,EAChB,gBAAgB,CACjB,CAAA;QACH,CAAC;QAED,mCAAmC;QACnC,IAAI,YAAgC,CAAA;QAEpC,mCAAmC;QACnC,IAAI,UAAoB,CAAA;QAExB,uBAAuB;QACvB,IAAI,aAAa,GAAG,IAAA,cAAQ,EAAC,IAAI,EAAE,IAAI,CAAC,CAAA;QAExC,sBAAsB;QACtB,IAAI,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,eAAe,EAAE,CAAC;YACrC,YAAY,GAAG,EAAE,CAAA;YACjB,UAAU,GAAG,EAAE,CAAA;QACjB,CAAC;QAED,sBAAsB;aACjB,IAAI,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,oBAAoB,EAAE,CAAC;YAC/C,YAAY,GAAG,CAAC,IAAA,sCAA2B,EAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,EAAE,gBAAgB,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAA;YACrI,UAAU,GAAG,EAAE,CAAA;QACjB,CAAC;QAED,oBAAoB;aACf,IAAI,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,oBAAoB,EAAE,CAAC;YAC/C,YAAY,GAAG,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,CAAC,eAAe,CAAC,CAAA;YACzF,UAAU,GAAG,CAAC,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAU,EAAE,EAAE,CAAC,IAAA,cAAQ,EAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAA;QAClF,CAAC;QAED,iBAAiB;QACjB,+GAA+G;QAC/G,yHAAyH;QACzH,6CAA6C;aACxC,IAAI,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,gBAAgB,EAAE,CAAC;YAC3C,MAAM,SAAS,GAAG,IAAA,cAAQ,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAA;YAE1E,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,IAAA,qBAAW,EAAC,qEAAqE,EAAE,IAAA,cAAQ,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;YAC1G,CAAC;YAED,aAAa,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;YAE5B,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAA;YAEpI,IAAI,KAAK,EAAE,CAAC;gBACV,aAAa,IAAI,qCAAqC,GAAG,IAAA,oCAAyB,EAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAA;YAC9G,CAAC;YAED,qBAAqB;YACrB,KAAK,MAAM,MAAM,IAAI,IAAA,qBAAe,EAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;gBACvD,IAAI,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC,mBAAmB,EAAE,CAAC;oBAC3C,IAAA,cAAI,EAAC,sDAAsD,EAAE,IAAA,cAAQ,EAAC,IAAI,EAAE,IAAI,CAAC,IAAI,aAAa,EAAE,IAAA,cAAQ,EAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAA;oBAC3H,SAAQ;gBACV,CAAC;gBAED,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAA;gBACjD,MAAM,UAAU,GAAG,IAAA,cAAQ,EAAC,MAAM,EAAE,IAAI,CAAC,CAAA;gBAEzC,aAAa,IAAI,YAAY,IAAA,cAAQ,EAAC,MAAM,EAAE,IAAI,CAAC,GACjD,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EACrE,KAAK,IAAA,oCAAyB,EAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,GAAG,CAAA;YAClE,CAAC;YAED,aAAa,IAAI,KAAK,CAAA;YAEtB,YAAY,GAAG,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,CAAC,eAAe,CAAC,CAAA;YACzF,UAAU,GAAG,CAAC,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAU,EAAE,EAAE,CAAC,IAAA,cAAQ,EAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAA;QAClF,CAAC;QAED,mBAAmB;aACd,IAAI,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,mBAAmB,EAAE,CAAC;YAC9C,YAAY,GAAG,EAAE,CAAA;YACjB,UAAU,GAAG,EAAE,CAAA;QACjB,CAAC;QAED,uBAAuB;aAClB,CAAC;YACJ,IAAA,eAAK,EAAC,2CAA2C,GAAG,IAAI,CAAC,IAAI,CAAC,CAAA;QAChE,CAAC;QAED,8BAA8B;QAC9B,MAAM,YAAY,GAA0B,EAAE,CAAA;QAE9C,oIAAoI;QACpI,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YACrC,IAAA,qBAAW,EAAC,qEAAqE,EAAE,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;QAC5G,CAAC;QAED,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QAE5B,2BAA2B;QAC3B,KAAK,MAAM,aAAa,IAAI,IAAA,qBAAe,EAAC,YAAY,CAAC,EAAE,CAAC;YAC1D,mFAAmF;YACnF,IAAI,UAAU,CAAC,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAChD,SAAQ;YACV,CAAC;YAED,sCAAsC;YACtC,IAAI,YAA4B,CAAA;YAEhC,MAAM,MAAM,GAAG,IAAI,CAAC,2BAA2B,CAAC,aAAa,CAAC,CAAA;YAE9D,IAAI,MAAM,EAAE,CAAC;gBACX,YAAY,GAAG,MAAM,CAAC,YAAY,CAAA;YACpC,CAAC;iBAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACtD,YAAY,GAAG,IAAI,CAAC,wBAAwB,CAAC,aAAa,CAAC,CAAA;YAC7D,CAAC;iBAAM,CAAC;gBACN,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,SAAS,CAAC,CAAA;gBAC5D,YAAY,GAAG,SAAS,YAAY,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,YAAY,CAAA;YAChF,CAAC;YAED,IAAI,YAAY,YAAY,KAAK,EAAE,CAAC;gBAClC,OAAO,IAAI,KAAK,CACd,IAAA,gBAAM,EACJ,2GAA2G,EAC3G,GAAG,CAAC,QAAQ,EACZ,aAAa,CAAC,QAAQ,EACtB,gBAAgB,EAChB,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAC1C,CACF,CAAA;YACH,CAAC;YAED,sBAAsB;YACtB,YAAY,CAAC,IAAI,CAAC,EAAE,GAAG,aAAa,EAAE,YAAY,EAAE,CAAC,CAAA;QACvD,CAAC;QAED,MAAM,SAAS,GAAkB;YAC/B,GAAG,GAAG;YACN,YAAY,EAAE,gBAAgB;YAC9B,UAAU;YACV,OAAO,EAAE,aAAa;YACtB,YAAY;SACb,CAAA;QAED,SAAS,CAAC,GAAG,EAAE,CAAA;QAEf,IAAI,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAA;QAEhD,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,KAAK,GAAG,IAAI,GAAG,EAAE,CAAA;YACjB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAA;QAC7C,CAAC;QAED,sBAAsB;QACtB,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAA;QAElC,OAAO,SAAS,CAAA;IAClB,CAAC;CACF"}