@depup/nx 22.5.4-depup.0

package/src/project-graph/build-project-graph.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileMap = getFileMap;
+exports.hydrateFileMap = hydrateFileMap;
+exports.buildProjectGraphUsingProjectFileMap = buildProjectGraphUsingProjectFileMap;
+exports.applyProjectMetadata = applyProjectMetadata;
+const workspace_root_1 = require("../utils/workspace-root");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
+const assert_workspace_validity_1 = require("../utils/assert-workspace-validity");
+const nx_deps_cache_1 = require("./nx-deps-cache");
+const implicit_project_dependencies_1 = require("./utils/implicit-project-dependencies");
+const normalize_project_nodes_1 = require("./utils/normalize-project-nodes");
+const typescript_1 = require("../plugins/js/utils/typescript");
+const fileutils_1 = require("../utils/fileutils");
+const project_graph_builder_1 = require("./project-graph-builder");
+const configuration_1 = require("../config/configuration");
+const fs_1 = require("fs");
+const error_types_1 = require("./error-types");
+const project_configuration_utils_1 = require("./utils/project-configuration-utils");
+const delayed_spinner_1 = require("../utils/delayed-spinner");
+const file_hasher_1 = require("../hasher/file-hasher");
+let storedFileMap = null;
+let storedAllWorkspaceFiles = null;
+let storedRustReferences = null;
+function getFileMap() {
+    if (!!storedFileMap) {
+        return {
+            fileMap: storedFileMap,
+            allWorkspaceFiles: storedAllWorkspaceFiles,
+            rustReferences: storedRustReferences,
+        };
+    }
+    else {
+        return {
+            fileMap: {
+                nonProjectFiles: [],
+                projectFileMap: {},
+            },
+            allWorkspaceFiles: [],
+            rustReferences: null,
+        };
+    }
+}
+function hydrateFileMap(fileMap, allWorkspaceFiles, rustReferences) {
+    storedFileMap = fileMap;
+    storedAllWorkspaceFiles = allWorkspaceFiles;
+    storedRustReferences = rustReferences;
+}
+async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, plugins, sourceMap) {
+    storedFileMap = fileMap;
+    storedAllWorkspaceFiles = allWorkspaceFiles;
+    storedRustReferences = rustReferences;
+    const projects = {};
+    for (const root in projectRootMap) {
+        const project = projectRootMap[root];
+        projects[project.name] = project;
+    }
+    const errors = [];
+    const nxJson = (0, configuration_1.readNxJson)();
+    const projectGraphVersion = '6.0';
+    try {
+        (0, assert_workspace_validity_1.assertWorkspaceValidity)(projects, nxJson);
+    }
+    catch (e) {
+        if ((0, error_types_1.isWorkspaceValidityError)(e)) {
+            errors.push(e);
+        }
+    }
+    const packageJsonDeps = readCombinedDeps();
+    const rootTsConfig = readRootTsConfig();
+    const externalNodesHash = hashExternalNodes(externalNodes);
+    let filesToProcess;
+    let cachedFileData;
+    const useCacheData = fileMapCache &&
+        !(0, nx_deps_cache_1.shouldRecomputeWholeGraph)(fileMapCache, packageJsonDeps, projects, nxJson, rootTsConfig, externalNodesHash);
+    if (useCacheData) {
+        const fromCache = (0, nx_deps_cache_1.extractCachedFileData)(fileMap, fileMapCache);
+        filesToProcess = fromCache.filesToProcess;
+        cachedFileData = fromCache.cachedFileData;
+    }
+    else {
+        filesToProcess = fileMap;
+        cachedFileData = {
+            nonProjectFiles: {},
+            projectFileMap: {},
+        };
+    }
+    let projectGraph;
+    let projectFileMapCache;
+    try {
+        const context = createContext(projects, nxJson, externalNodes, fileMap, filesToProcess);
+        projectGraph = await buildProjectGraphUsingContext(externalNodes, context, cachedFileData, projectGraphVersion, plugins, sourceMap);
+        projectFileMapCache = (0, nx_deps_cache_1.createProjectFileMapCache)(nxJson, packageJsonDeps, fileMap, rootTsConfig, externalNodesHash);
+    }
+    catch (e) {
+        // we need to include the workspace validity errors in the final error
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
+            errors.push(...e.errors);
+            throw new error_types_1.AggregateProjectGraphError(errors, e.partialProjectGraph);
+        }
+        else {
+            throw e;
+        }
+    }
+    if (errors.length > 0) {
+        throw new error_types_1.AggregateProjectGraphError(errors, projectGraph);
+    }
+    return {
+        projectGraph,
+        projectFileMapCache,
+    };
+}
+function readCombinedDeps() {
+    const installationPackageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, '.nx', 'installation', 'package.json');
+    const installationPackageJson = (0, fs_1.existsSync)(installationPackageJsonPath)
+        ? (0, fileutils_1.readJsonFile)(installationPackageJsonPath)
+        : {};
+    const rootPackageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json');
+    const rootPackageJson = (0, fs_1.existsSync)(rootPackageJsonPath)
+        ? (0, fileutils_1.readJsonFile)(rootPackageJsonPath)
+        : {};
+    return {
+        ...rootPackageJson.dependencies,
+        ...rootPackageJson.devDependencies,
+        ...installationPackageJson.dependencies,
+        ...installationPackageJson.devDependencies,
+    };
+}
+async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFileData, projectGraphVersion, plugins, sourceMap) {
+    const builder = new project_graph_builder_1.ProjectGraphBuilder(null, ctx.fileMap.projectFileMap);
+    builder.setVersion(projectGraphVersion);
+    for (const node in knownExternalNodes) {
+        builder.addExternalNode(knownExternalNodes[node]);
+    }
+    await (0, normalize_project_nodes_1.normalizeProjectNodes)(ctx, builder);
+    const initProjectGraph = builder.getUpdatedProjectGraph();
+    let updatedGraph;
+    let error;
+    try {
+        updatedGraph = await updateProjectGraphWithPlugins(ctx, initProjectGraph, plugins, sourceMap);
+    }
+    catch (e) {
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
+            updatedGraph = e.partialProjectGraph;
+            error = e;
+        }
+        else {
+            throw e;
+        }
+    }
+    const updatedBuilder = new project_graph_builder_1.ProjectGraphBuilder(updatedGraph, ctx.fileMap.projectFileMap);
+    for (const proj of Object.keys(cachedFileData.projectFileMap)) {
+        for (const f of ctx.fileMap.projectFileMap[proj] || []) {
+            const cached = cachedFileData.projectFileMap[proj][f.file];
+            if (cached && cached.deps) {
+                f.deps = [...cached.deps];
+            }
+        }
+    }
+    for (const file of ctx.fileMap.nonProjectFiles) {
+        const cached = cachedFileData.nonProjectFiles[file.file];
+        if (cached?.deps) {
+            file.deps = [...cached.deps];
+        }
+    }
+    (0, implicit_project_dependencies_1.applyImplicitDependencies)(ctx.projects, updatedBuilder);
+    const finalGraph = updatedBuilder.getUpdatedProjectGraph();
+    if (!error) {
+        return finalGraph;
+    }
+    else {
+        throw new error_types_1.AggregateProjectGraphError(error.errors, finalGraph);
+    }
+}
+function createContext(projects, nxJson, externalNodes, fileMap, filesToProcess) {
+    return {
+        nxJsonConfiguration: nxJson,
+        projects,
+        externalNodes,
+        workspaceRoot: workspace_root_1.workspaceRoot,
+        fileMap,
+        filesToProcess,
+    };
+}
+async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins, sourceMap) {
+    let graph = initProjectGraph;
+    const errors = [];
+    const builder = new project_graph_builder_1.ProjectGraphBuilder(graph, context.fileMap.projectFileMap, context.fileMap.nonProjectFiles);
+    const createDependencyPlugins = plugins.filter((plugin) => plugin.createDependencies);
+    perf_hooks_1.performance.mark('createDependencies:start');
+    let spinner;
+    const inProgressPlugins = new Set();
+    function updateSpinner() {
+        if (!spinner || inProgressPlugins.size === 0) {
+            return;
+        }
+        if (inProgressPlugins.size === 1) {
+            spinner.setMessage(`Creating project graph dependencies with ${inProgressPlugins.values().next().value}`);
+        }
+        else if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            spinner.setMessage([
+                `Creating project graph dependencies with ${inProgressPlugins.size} plugins`,
+                ...Array.from(inProgressPlugins).map((p) => `  - ${p}`),
+            ].join('\n'));
+        }
+        else {
+            spinner.setMessage(`Creating project graph dependencies with ${inProgressPlugins.size} plugins`);
+        }
+    }
+    spinner = new delayed_spinner_1.DelayedSpinner(`Creating project graph dependencies with ${createDependencyPlugins.length} plugins`);
+    await Promise.all(createDependencyPlugins.map(async (plugin) => {
+        perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - start`);
+        inProgressPlugins.add(plugin.name);
+        try {
+            const dependencies = await plugin
+                .createDependencies({
+                ...context,
+            })
+                .finally(() => {
+                inProgressPlugins.delete(plugin.name);
+                updateSpinner();
+            });
+            for (const dep of dependencies) {
+                builder.addDependency(dep.source, dep.target, dep.type, 'sourceFile' in dep ? dep.sourceFile : null);
+            }
+        }
+        catch (cause) {
+            errors.push(new error_types_1.ProcessDependenciesError(plugin.name, {
+                cause,
+            }));
+        }
+        perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - end`);
+        perf_hooks_1.performance.measure(`${plugin.name}:createDependencies`, `${plugin.name}:createDependencies - start`, `${plugin.name}:createDependencies - end`);
+    }));
+    perf_hooks_1.performance.mark('createDependencies:end');
+    perf_hooks_1.performance.measure(`createDependencies`, `createDependencies:start`, `createDependencies:end`);
+    spinner?.cleanup();
+    const graphWithDeps = builder.getUpdatedProjectGraph();
+    const { errors: metadataErrors, graph: updatedGraph } = await applyProjectMetadata(graphWithDeps, plugins, {
+        nxJsonConfiguration: context.nxJsonConfiguration,
+        workspaceRoot: workspace_root_1.workspaceRoot,
+    }, sourceMap);
+    errors.push(...metadataErrors);
+    if (errors.length > 0) {
+        throw new error_types_1.AggregateProjectGraphError(errors, updatedGraph);
+    }
+    return updatedGraph;
+}
+function readRootTsConfig() {
+    try {
+        const tsConfigPath = (0, typescript_1.getRootTsConfigPath)();
+        if (tsConfigPath) {
+            return (0, fileutils_1.readJsonFile)(tsConfigPath, { expectComments: true });
+        }
+    }
+    catch (e) {
+        return {};
+    }
+}
+async function applyProjectMetadata(graph, plugins, context, sourceMap) {
+    const results = [];
+    const errors = [];
+    perf_hooks_1.performance.mark('createMetadata:start');
+    let spinner;
+    const inProgressPlugins = new Set();
+    function updateSpinner() {
+        if (!spinner || inProgressPlugins.size === 0) {
+            return;
+        }
+        if (inProgressPlugins.size === 1) {
+            spinner.setMessage(`Creating project metadata with ${inProgressPlugins.values().next().value}`);
+        }
+        else if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            spinner.setMessage([
+                `Creating project metadata with ${inProgressPlugins.size} plugins`,
+                ...Array.from(inProgressPlugins).map((p) => `  - ${p}`),
+            ].join('\n'));
+        }
+        else {
+            spinner.setMessage(`Creating project metadata with ${inProgressPlugins.size} plugins`);
+        }
+    }
+    const createMetadataPlugins = plugins.filter((plugin) => plugin.createMetadata);
+    spinner = new delayed_spinner_1.DelayedSpinner(`Creating project metadata with ${createMetadataPlugins.length} plugins`);
+    const promises = createMetadataPlugins.map(async (plugin) => {
+        perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - start`);
+        inProgressPlugins.add(plugin.name);
+        try {
+            const metadata = await plugin.createMetadata(graph, context);
+            results.push({ metadata, pluginName: plugin.name });
+        }
+        catch (e) {
+            errors.push(new error_types_1.CreateMetadataError(e, plugin.name));
+        }
+        finally {
+            inProgressPlugins.delete(plugin.name);
+            updateSpinner();
+            perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - end`);
+            perf_hooks_1.performance.measure(`${plugin.name}:createMetadata`, `${plugin.name}:createMetadata - start`, `${plugin.name}:createMetadata - end`);
+        }
+    });
+    await Promise.all(promises);
+    spinner?.cleanup();
+    for (const { metadata: projectsMetadata, pluginName } of results) {
+        for (const project in projectsMetadata) {
+            const projectConfiguration = graph.nodes[project]?.data;
+            if (projectConfiguration) {
+                projectConfiguration.metadata = (0, project_configuration_utils_1.mergeMetadata)(sourceMap[project], [null, pluginName], 'metadata', projectsMetadata[project].metadata, projectConfiguration.metadata);
+            }
+        }
+    }
+    perf_hooks_1.performance.mark('createMetadata:end');
+    perf_hooks_1.performance.measure(`createMetadata`, `createMetadata:start`, `createMetadata:end`);
+    return { errors, graph };
+}
+function hashExternalNodes(externalNodes) {
+    return (0, file_hasher_1.hashObject)(Object.entries(externalNodes).reduce((acc, [name, node]) => {
+        acc[name] = node.data.version;
+        return acc;
+    }, {}));
+}

package/src/project-graph/error-types.d.ts

@@ -0,0 +1,140 @@
+import { ConfigurationResult, ConfigurationSourceMaps } from './utils/project-configuration-utils';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { ProjectGraph } from '../config/project-graph';
+import { CreateNodesFunctionV2 } from './plugins/public-api';
+export type ProjectGraphErrorTypes = AggregateCreateNodesError | MergeNodesError | CreateMetadataError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | WorkspaceValidityError;
+export declare class StaleProjectGraphCacheError extends Error {
+    constructor();
+}
+export declare class ProjectGraphError extends Error {
+    #private;
+    private readonly errors;
+    constructor(errors: Array<ProjectGraphErrorTypes>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps | null);
+    /**
+     * The daemon cannot throw errors which contain methods as they are not serializable.
+     *
+     * This method creates a new {@link ProjectGraphError} from a {@link DaemonProjectGraphError} with the methods based on the same serialized data.
+     */
+    static fromDaemonProjectGraphError(e: DaemonProjectGraphError): ProjectGraphError;
+    /**
+     * This gets the partial project graph despite the errors which occured.
+     * This partial project graph may be missing nodes, properties of nodes, or dependencies.
+     * This is useful mostly for visualization/debugging. It should not be used for running tasks.
+     */
+    getPartialProjectGraph(): ProjectGraph;
+    getPartialSourcemaps(): ConfigurationSourceMaps;
+    getErrors(): ProjectGraphErrorTypes[];
+}
+export declare class MultipleProjectsWithSameNameError extends Error {
+    conflicts: Map<string, string[]>;
+    projects: Record<string, ProjectConfiguration>;
+    constructor(conflicts: Map<string, string[]>, projects: Record<string, ProjectConfiguration>);
+}
+export declare class ProjectWithExistingNameError extends Error {
+    projectName: string;
+    projectRoot: string;
+    constructor(projectName: string, projectRoot: string);
+}
+export declare function isProjectWithExistingNameError(e: unknown): e is ProjectWithExistingNameError;
+export declare function isMultipleProjectsWithSameNameError(e: unknown): e is MultipleProjectsWithSameNameError;
+export declare class ProjectsWithNoNameError extends Error {
+    projectRoots: string[];
+    projects: Record<string, ProjectConfiguration>;
+    constructor(projectRoots: string[], projects: Record<string, ProjectConfiguration>);
+}
+export declare function isProjectsWithNoNameError(e: unknown): e is ProjectsWithNoNameError;
+export declare class ProjectWithNoNameError extends Error {
+    projectRoot: string;
+    constructor(projectRoot: string);
+}
+export declare function isProjectWithNoNameError(e: unknown): e is ProjectWithNoNameError;
+export declare class ProjectConfigurationsError extends Error {
+    readonly errors: Array<MergeNodesError | AggregateCreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | WorkspaceValidityError>;
+    readonly partialProjectConfigurationsResult: ConfigurationResult;
+    constructor(errors: Array<MergeNodesError | AggregateCreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | WorkspaceValidityError>, partialProjectConfigurationsResult: ConfigurationResult);
+}
+export declare function isProjectConfigurationsError(e: unknown): e is ProjectConfigurationsError;
+/**
+ * This error should be thrown when a `createNodesV2` function hits a recoverable error.
+ * It allows Nx to recieve partial results and continue processing for better UX.
+ */
+export declare class AggregateCreateNodesError extends Error {
+    readonly errors: Array<[file: string | null, error: Error]>;
+    readonly partialResults: Awaited<ReturnType<CreateNodesFunctionV2>>;
+    pluginIndex: number | undefined;
+    /**
+     * Throwing this error from a `createNodesV2` function will allow Nx to continue processing and recieve partial results from your plugin.
+     * @example
+     * export async function createNodesV2(
+     *  files: string[],
+     * ) {
+     *   const partialResults = [];
+     *   const errors = [];
+     *   await Promise.all(files.map(async (file) => {
+     *     try {
+     *        const result = await createNodes(file);
+     *        partialResults.push(result);
+     *     } catch (e) {
+     *        errors.push([file, e]);
+     *     }
+     *   }));
+     *  if (errors.length > 0) {
+     *     throw new AggregateCreateNodesError(errors, partialResults);
+     *   }
+     *   return partialResults;
+     * }
+     *
+     * @param errors An array of tuples that represent errors encountered when processing a given file. An example entry might look like ['path/to/project.json', [Error: 'Invalid JSON. Unexpected token 'a' in JSON at position 0]]
+     * @param partialResults The partial results of the `createNodesV2` function. This should be the results for each file that didn't encounter an issue.
+     */
+    constructor(errors: Array<[file: string | null, error: Error]>, partialResults: Awaited<ReturnType<CreateNodesFunctionV2>>);
+}
+export declare function formatAggregateCreateNodesError(error: AggregateCreateNodesError, pluginName: string): void;
+export declare class MergeNodesError extends Error {
+    file: string;
+    pluginName: string;
+    pluginIndex: number;
+    constructor({ file, pluginName, error, pluginIndex, }: {
+        file: string;
+        pluginName: string;
+        error: Error;
+        pluginIndex?: number;
+    });
+}
+export declare class CreateMetadataError extends Error {
+    readonly error: Error;
+    readonly plugin: string;
+    constructor(error: Error, plugin: string);
+}
+export declare class ProcessDependenciesError extends Error {
+    readonly pluginName: string;
+    constructor(pluginName: string, { cause }: {
+        cause: any;
+    });
+}
+export declare class WorkspaceValidityError extends Error {
+    message: string;
+    constructor(message: string);
+    toString(): string;
+}
+export declare function isWorkspaceValidityError(e: unknown): e is WorkspaceValidityError;
+export declare class AggregateProjectGraphError extends Error {
+    readonly errors: Array<CreateMetadataError | ProcessDependenciesError | WorkspaceValidityError>;
+    readonly partialProjectGraph: ProjectGraph;
+    constructor(errors: Array<CreateMetadataError | ProcessDependenciesError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph);
+}
+export declare function isAggregateProjectGraphError(e: unknown): e is AggregateProjectGraphError;
+export declare function isCreateMetadataError(e: unknown): e is CreateMetadataError;
+export declare function isAggregateCreateNodesError(e: unknown): e is AggregateCreateNodesError;
+export declare function isMergeNodesError(e: unknown): e is MergeNodesError;
+export declare class DaemonProjectGraphError extends Error {
+    errors: any[];
+    readonly projectGraph: ProjectGraph;
+    readonly sourceMaps: ConfigurationSourceMaps;
+    constructor(errors: any[], projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps);
+}
+export declare class LoadPluginError extends Error {
+    plugin: string;
+    constructor(plugin: string, cause: Error);
+}
+//# sourceMappingURL=error-types.d.ts.map

package/src/project-graph/error-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-types.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/project-graph/error-types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,MAAM,MAAM,sBAAsB,GAC9B,yBAAyB,GACzB,eAAe,GACf,mBAAmB,GACnB,uBAAuB,GACvB,iCAAiC,GACjC,wBAAwB,GACxB,sBAAsB,CAAC;AAE3B,qBAAa,2BAA4B,SAAQ,KAAK;;CAMrD;AAED,qBAAa,iBAAkB,SAAQ,KAAK;;IAKxC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,KAAK,CAAC,sBAAsB,CAAC,EACtD,mBAAmB,EAAE,YAAY,EACjC,iBAAiB,EAAE,uBAAuB,GAAG,IAAI;IAkDnD;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAAC,CAAC,EAAE,uBAAuB;IAI7D;;;;OAIG;IACH,sBAAsB;IAItB,oBAAoB;IAIpB,SAAS;CAGV;AAED,qBAAa,iCAAkC,SAAQ,KAAK;IAEjD,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC;gBAD9C,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC;CAcxD;AAED,qBAAa,4BAA6B,SAAQ,KAAK;IAE5C,WAAW,EAAE,MAAM;IACnB,WAAW,EAAE,MAAM;gBADnB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM;CAK7B;AAED,wBAAgB,8BAA8B,CAC5C,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,4BAA4B,CAOnC;AAED,wBAAgB,mCAAmC,CACjD,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,iCAAiC,CAOxC;AAED,qBAAa,uBAAwB,SAAQ,KAAK;IAEvC,YAAY,EAAE,MAAM,EAAE;IACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC;gBAD9C,YAAY,EAAE,MAAM,EAAE,EACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC;CASxD;AAED,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,uBAAuB,CAO9B;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAC5B,WAAW,EAAE,MAAM;gBAAnB,WAAW,EAAE,MAAM;CAIvC;AAED,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,sBAAsB,CAO7B;AAED,qBAAa,0BAA2B,SAAQ,KAAK;aAEjC,MAAM,EAAE,KAAK,CACzB,eAAe,GACf,yBAAyB,GACzB,uBAAuB,GACvB,iCAAiC,GACjC,sBAAsB,CACzB;aACe,kCAAkC,EAAE,mBAAmB;gBAPvD,MAAM,EAAE,KAAK,CACzB,eAAe,GACf,yBAAyB,GACzB,uBAAuB,GACvB,iCAAiC,GACjC,sBAAsB,CACzB,EACe,kCAAkC,EAAE,mBAAmB;CAqC1E;AAED,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,0BAA0B,CAOjC;AAED;;;GAGG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;aA4BhC,MAAM,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;aAClD,cAAc,EAAE,OAAO,CAAC,UAAU,CAAC,qBAAqB,CAAC,CAAC;IA5BrE,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;gBAEe,MAAM,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,EAClD,cAAc,EAAE,OAAO,CAAC,UAAU,CAAC,qBAAqB,CAAC,CAAC;CAoB7E;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,yBAAyB,EAChC,UAAU,EAAE,MAAM,QA6BnB;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;gBAER,EACV,IAAI,EACJ,UAAU,EACV,KAAK,EACL,WAAW,GACZ,EAAE;QACD,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,KAAK,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB;CAiBF;AAED,qBAAa,mBAAoB,SAAQ,KAAK;aAE1B,KAAK,EAAE,KAAK;aACZ,MAAM,EAAE,MAAM;gBADd,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM;CAUjC;AAED,qBAAa,wBAAyB,SAAQ,KAAK;aAE/B,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM,EAClC,EAAE,KAAK,EAAE;;KAAA;CAWZ;AAWD,qBAAa,sBAAuB,SAAQ,KAAK;IAC5B,OAAO,EAAE,MAAM;gBAAf,OAAO,EAAE,MAAM;IAMlC,QAAQ;CAGT;AAED,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,sBAAsB,CAO7B;AACD,qBAAa,0BAA2B,SAAQ,KAAK;aAEjC,MAAM,EAAE,KAAK,CAC3B,mBAAmB,GAAG,wBAAwB,GAAG,sBAAsB,CACxE;aACe,mBAAmB,EAAE,YAAY;gBAHjC,MAAM,EAAE,KAAK,CAC3B,mBAAmB,GAAG,wBAAwB,GAAG,sBAAsB,CACxE,EACe,mBAAmB,EAAE,YAAY;CAKpD;AAED,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,0BAA0B,CAOjC;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,mBAAmB,CAO1E;AAED,wBAAgB,2BAA2B,CACzC,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,yBAAyB,CAOhC;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,eAAe,CAKlE;AAED,qBAAa,uBAAwB,SAAQ,KAAK;IAEvC,MAAM,EAAE,GAAG,EAAE;IACpB,QAAQ,CAAC,YAAY,EAAE,YAAY;IACnC,QAAQ,CAAC,UAAU,EAAE,uBAAuB;gBAFrC,MAAM,EAAE,GAAG,EAAE,EACX,YAAY,EAAE,YAAY,EAC1B,UAAU,EAAE,uBAAuB;CAO/C;AAED,qBAAa,eAAgB,SAAQ,KAAK;IAE/B,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM,EACrB,KAAK,EAAE,KAAK;CAOf"}