@depup/nx 22.5.4-depup.0

package/src/command-line/init/command-object.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsInitCommand = void 0;
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsInitCommand = {
+    command: 'init',
+    describe: 'Adds Nx to any type of workspace. It installs nx, creates an nx.json configuration file and optionally sets up remote caching. For more info, check https://nx.dev/recipes/adopting-nx.',
+    builder: (yargs) => withInitOptions(yargs),
+    handler: async (args) => {
+        // Node 24 has stricter readline behavior, and enquirer is not checking for closed state
+        // when invoking operations, thus you get an ERR_USE_AFTER_CLOSE error.
+        process.on('uncaughtException', (error) => {
+            if (error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                error['code'] === 'ERR_USE_AFTER_CLOSE')
+                return;
+            throw error;
+        });
+        try {
+            const useV2 = await isInitV2();
+            if (useV2) {
+                await require('./init-v2').initHandler(args);
+            }
+            else {
+                await require('./init-v1').initHandler(args);
+            }
+            process.exit(0);
+        }
+        catch {
+            // Ensure the cursor is always restored just in case the user has bailed during interactive prompts
+            process.stdout.write('\x1b[?25h');
+            process.exit(1);
+        }
+    },
+};
+async function isInitV2() {
+    return (process.env['NX_ADD_PLUGINS'] !== 'false' &&
+        (await Promise.resolve().then(() => require('../../config/nx-json'))).readNxJson().useInferencePlugins !==
+            false);
+}
+async function withInitOptions(yargs) {
+    const useV2 = await isInitV2();
+    if (useV2) {
+        return yargs
+            .option('nxCloud', {
+            type: 'boolean',
+            description: 'Set up distributed caching with Nx Cloud.',
+        })
+            .option('interactive', {
+            describe: 'When false disables interactive input prompts for options.',
+            type: 'boolean',
+            default: true,
+        })
+            .option('useDotNxInstallation', {
+            type: 'boolean',
+            description: 'Initialize an Nx workspace setup in the .nx directory of the current repository.',
+            default: false,
+        })
+            .option('force', {
+            describe: 'Force the migration to continue and ignore custom webpack setup or uncommitted changes. Only for CRA projects.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('aiAgents', {
+            type: 'array',
+            string: true,
+            description: 'List of AI agents to set up.',
+            choices: ['claude', 'codex', 'copilot', 'cursor', 'gemini', 'opencode'],
+        });
+    }
+    else {
+        return yargs
+            .option('nxCloud', {
+            type: 'boolean',
+            description: 'Set up remote caching with Nx Cloud.',
+        })
+            .option('interactive', {
+            describe: 'When false disables interactive input prompts for options.',
+            type: 'boolean',
+            default: true,
+        })
+            .option('integrated', {
+            type: 'boolean',
+            description: 'Migrate to an Nx integrated layout workspace. Only for Angular CLI workspaces and CRA projects.',
+            default: false,
+        })
+            .option('addE2e', {
+            describe: 'Set up Cypress E2E tests in integrated workspaces. Only for CRA projects.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('useDotNxInstallation', {
+            type: 'boolean',
+            description: 'Initialize an Nx workspace setup in the .nx directory of the current repository.',
+            default: false,
+        })
+            .option('force', {
+            describe: 'Force the migration to continue and ignore custom webpack setup or uncommitted changes. Only for CRA projects.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('vite', {
+            type: 'boolean',
+            description: 'Use Vite as the bundler. Only for CRA projects.',
+            default: true,
+        })
+            .option('cacheable', {
+            type: 'string',
+            description: 'Comma-separated list of cacheable operations. Only used for internal testing.',
+            coerce: shared_options_1.parseCSV,
+            hidden: true,
+        });
+    }
+}

package/src/command-line/init/configure-plugins.d.ts

@@ -0,0 +1,35 @@
+import { PackageManagerCommands } from '../../utils/package-manager';
+export declare function installPluginPackages(repoRoot: string, pmc: PackageManagerCommands, plugins: string[]): void;
+/**
+ * Installs a plugin by running its init generator. It will change the file system tree passed in.
+ * @param plugin The name of the plugin to install
+ * @param repoRoot repo root
+ * @param pmc package manager commands
+ * @param updatePackageScripts whether to update package scripts
+ * @param verbose whether to run in verbose mode
+ * @returns void
+ */
+export declare function runPluginInitGenerator(plugin: string, repoRoot?: string, updatePackageScripts?: boolean, verbose?: boolean, pmc?: PackageManagerCommands): Promise<void>;
+/**
+ * Install plugins
+ * Get the implementation of the plugin's init generator and run it
+ * @returns a list of succeeded plugins and a map of failed plugins to errors
+ */
+export declare function runPluginInitGenerators(plugins: string[], updatePackageScripts: boolean, pmc: PackageManagerCommands, repoRoot?: string, verbose?: boolean): Promise<{
+    succeededPlugins: string[];
+    failedPlugins: {
+        [plugin: string]: Error;
+    };
+}>;
+/**
+ * Configures plugins, installs them, and outputs the results
+ * @returns a list of succeeded plugins and a map of failed plugins to errors
+ */
+export declare function configurePlugins(plugins: string[], updatePackageScripts: boolean, pmc: PackageManagerCommands, repoRoot?: string, verbose?: boolean): Promise<{
+    succeededPlugins: string[];
+    failedPlugins: {
+        [plugin: string]: Error;
+    };
+}>;
+export declare function getFailedToInstallPluginErrorMessages(e: any): string[];
+//# sourceMappingURL=configure-plugins.d.ts.map

package/src/command-line/init/configure-plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure-plugins.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/init/configure-plugins.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,sBAAsB,EACvB,MAAM,6BAA6B,CAAC;AAoBrC,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,sBAAmD,EACxD,OAAO,EAAE,MAAM,EAAE,QAkBlB;AAED;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAsB,EAChC,oBAAoB,GAAE,OAAe,EACrC,OAAO,GAAE,OAAe,EACxB,GAAG,GAAE,sBAAmD,GACvD,OAAO,CAAC,IAAI,CAAC,CAgCf;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,MAAM,EAAE,EACjB,oBAAoB,EAAE,OAAO,EAC7B,GAAG,EAAE,sBAAsB,EAC3B,QAAQ,GAAE,MAAsB,EAChC,OAAO,GAAE,OAAe,GACvB,OAAO,CAAC;IACT,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,EAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAA;KAAE,CAAC;CAC5C,CAAC,CAkCD;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EAAE,EACjB,oBAAoB,EAAE,OAAO,EAC7B,GAAG,EAAE,sBAAsB,EAC3B,QAAQ,GAAE,MAAsB,EAChC,OAAO,GAAE,OAAe,GACvB,OAAO,CAAC;IACT,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,EAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAA;KAAE,CAAC;CAC5C,CAAC,CAgDD;AAqBD,wBAAgB,qCAAqC,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAwCtE"}

package/src/command-line/init/configure-plugins.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPluginPackages = installPluginPackages;
+exports.runPluginInitGenerator = runPluginInitGenerator;
+exports.runPluginInitGenerators = runPluginInitGenerators;
+exports.configurePlugins = configurePlugins;
+exports.getFailedToInstallPluginErrorMessages = getFailedToInstallPluginErrorMessages;
+const picocolors_1 = require("picocolors");
+const package_manager_1 = require("../../utils/package-manager");
+const output_1 = require("../../utils/output");
+const workspace_root_1 = require("../../utils/workspace-root");
+const utils_1 = require("./implementation/utils");
+const angular_json_1 = require("../../adapter/angular-json");
+const error_types_1 = require("../../project-graph/error-types");
+const generator_utils_1 = require("../generate/generator-utils");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const configuration_1 = require("../../config/configuration");
+const versions_1 = require("../../utils/versions");
+const child_process_1 = require("../../utils/child-process");
+const fileutils_1 = require("../../utils/fileutils");
+const spinner_1 = require("../../utils/spinner");
+function installPluginPackages(repoRoot, pmc = (0, package_manager_1.getPackageManagerCommand)(), plugins) {
+    if (plugins.length === 0) {
+        return;
+    }
+    if ((0, fs_1.existsSync)((0, path_1.join)(repoRoot, 'package.json'))) {
+        (0, utils_1.addDepsToPackageJson)(repoRoot, plugins);
+        (0, utils_1.runInstall)(repoRoot, pmc);
+    }
+    else {
+        const nxJson = (0, configuration_1.readNxJson)(repoRoot);
+        nxJson.installation.plugins ??= {};
+        for (const plugin of plugins) {
+            nxJson.installation.plugins[plugin] = versions_1.nxVersion;
+        }
+        (0, fileutils_1.writeJsonFile)((0, path_1.join)(repoRoot, 'nx.json'), nxJson);
+        // Invoking nx wrapper to install plugins.
+        (0, child_process_1.runNxSync)('--version', { stdio: 'ignore' });
+    }
+}
+/**
+ * Installs a plugin by running its init generator. It will change the file system tree passed in.
+ * @param plugin The name of the plugin to install
+ * @param repoRoot repo root
+ * @param pmc package manager commands
+ * @param updatePackageScripts whether to update package scripts
+ * @param verbose whether to run in verbose mode
+ * @returns void
+ */
+async function runPluginInitGenerator(plugin, repoRoot = workspace_root_1.workspaceRoot, updatePackageScripts = false, verbose = false, pmc = (0, package_manager_1.getPackageManagerCommand)()) {
+    let command = `g ${plugin}:init ${verbose ? '--verbose' : ''}`;
+    try {
+        const { schema } = (0, generator_utils_1.getGeneratorInformation)(plugin, 'init', workspace_root_1.workspaceRoot, {});
+        if (!!schema.properties['keepExistingVersions']) {
+            command += ` --keepExistingVersions`;
+        }
+        if (updatePackageScripts && !!schema.properties['updatePackageScripts']) {
+            command += ` --updatePackageScripts`;
+        }
+    }
+    catch {
+        // init generator does not exist, so this function should noop
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            output_1.output.log({
+                title: `No "init" generator found in ${plugin}. Skipping initialization.`,
+            });
+        }
+        return;
+    }
+    (0, child_process_1.runNxSync)(command, {
+        stdio: [0, 1, 2],
+        cwd: repoRoot,
+        windowsHide: false,
+        packageManagerCommand: pmc,
+    });
+}
+/**
+ * Install plugins
+ * Get the implementation of the plugin's init generator and run it
+ * @returns a list of succeeded plugins and a map of failed plugins to errors
+ */
+async function runPluginInitGenerators(plugins, updatePackageScripts, pmc, repoRoot = workspace_root_1.workspaceRoot, verbose = false) {
+    if (plugins.length === 0) {
+        return {
+            succeededPlugins: [],
+            failedPlugins: {},
+        };
+    }
+    let succeededPlugins = [];
+    const failedPlugins = {};
+    for (const plugin of plugins) {
+        const spinner = spinner_1.globalSpinner.start('Installing plugin ' + plugin);
+        try {
+            await runPluginInitGenerator(plugin, repoRoot, updatePackageScripts, verbose, pmc);
+            succeededPlugins.push(plugin);
+            spinner.succeed('Installed plugin ' + plugin);
+        }
+        catch (e) {
+            failedPlugins[plugin] = e;
+            spinner.fail('Failed to install plugin ' + plugin);
+        }
+    }
+    return {
+        succeededPlugins,
+        failedPlugins,
+    };
+}
+/**
+ * Configures plugins, installs them, and outputs the results
+ * @returns a list of succeeded plugins and a map of failed plugins to errors
+ */
+async function configurePlugins(plugins, updatePackageScripts, pmc, repoRoot = workspace_root_1.workspaceRoot, verbose = false) {
+    if (plugins.length === 0) {
+        return {
+            succeededPlugins: [],
+            failedPlugins: {},
+        };
+    }
+    output_1.output.log({ title: '🔨 Configuring plugins' });
+    let { succeededPlugins, failedPlugins } = await runPluginInitGenerators(plugins, updatePackageScripts, pmc, repoRoot, verbose);
+    if (succeededPlugins.length > 0) {
+        output_1.output.success({
+            title: 'Installed Plugins',
+            bodyLines: succeededPlugins.map((p) => `- ${(0, picocolors_1.bold)(p)}`),
+        });
+    }
+    if (Object.keys(failedPlugins).length > 0) {
+        output_1.output.error({
+            title: `Failed to install plugins`,
+            bodyLines: [
+                'The following plugins were not installed:',
+                ...Object.keys(failedPlugins).map((p) => `- ${(0, picocolors_1.bold)(p)}`),
+            ],
+        });
+        Object.entries(failedPlugins).forEach(([plugin, error]) => {
+            output_1.output.error({
+                title: `Failed to install ${plugin}`,
+                bodyLines: getFailedToInstallPluginErrorMessages(error),
+            });
+        });
+        output_1.output.error({
+            title: `To install the plugins manually`,
+            bodyLines: [
+                'You may need to run commands to install the plugins:',
+                ...Object.keys(failedPlugins).map((p) => `- ${(0, picocolors_1.bold)(pmc.exec + ' nx add ' + p)}`),
+            ],
+        });
+    }
+    return { succeededPlugins, failedPlugins };
+}
+function findInitGenerator(generators) {
+    if (generators['init']) {
+        return 'init';
+    }
+    const angularPluginInstalled = (0, angular_json_1.isAngularPluginInstalled)();
+    if (angularPluginInstalled && generators['ng-add']) {
+        return 'ng-add';
+    }
+    return Object.keys(generators).find((name) => generators[name].aliases?.includes('init') ||
+        (angularPluginInstalled && generators[name].aliases?.includes('ng-add')));
+}
+function getFailedToInstallPluginErrorMessages(e) {
+    const errorBodyLines = [];
+    if ((0, error_types_1.isProjectConfigurationsError)(e) && e.errors.length > 0) {
+        for (const error of e.errors) {
+            if ((0, error_types_1.isAggregateCreateNodesError)(error)) {
+                const innerErrors = error.errors;
+                for (const [file, e] of innerErrors) {
+                    if (file) {
+                        errorBodyLines.push(`  - ${(0, picocolors_1.bold)(file)}: ${e.message}`);
+                    }
+                    else {
+                        errorBodyLines.push(`  - ${e.message}`);
+                    }
+                    if (e.stack) {
+                        const innerStackTrace = '    ' + e.stack.split('\n')?.join('\n    ');
+                        errorBodyLines.push(innerStackTrace);
+                    }
+                }
+            }
+            else if (!(0, error_types_1.isProjectsWithNoNameError)(error)) {
+                // swallow ProjectsWithNameError
+                if (error.message) {
+                    errorBodyLines.push(`  - ${error.message}`);
+                }
+                if (error.stack) {
+                    const innerStackTrace = '    ' + error.stack.split('\n')?.join('\n    ');
+                    errorBodyLines.push(innerStackTrace);
+                }
+            }
+        }
+    }
+    else {
+        if (e.message) {
+            errorBodyLines.push(`  - ${e.message}`);
+        }
+        if (e.stack) {
+            const innerStackTrace = '    ' + e.stack.split('\n')?.join('\n    ');
+            errorBodyLines.push(innerStackTrace);
+        }
+    }
+    return errorBodyLines;
+}

package/src/command-line/init/implementation/add-nx-to-monorepo.d.ts

@@ -0,0 +1,7 @@
+import { InitArgs } from '../init-v1';
+type Options = Pick<InitArgs, 'nxCloud' | 'interactive' | 'cacheable'> & {
+    legacy?: boolean;
+};
+export declare function addNxToMonorepo(options: Options, guided?: boolean): Promise<void>;
+export {};
+//# sourceMappingURL=add-nx-to-monorepo.d.ts.map

package/src/command-line/init/implementation/add-nx-to-monorepo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-nx-to-monorepo.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/init/implementation/add-nx-to-monorepo.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAYtC,KAAK,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,CAAC,GAAG;IACvE,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,wBAAsB,eAAe,CACnC,OAAO,EAAE,OAAO,EAChB,MAAM,GAAE,OAAc,iBA6FvB"}

package/src/command-line/init/implementation/add-nx-to-monorepo.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToMonorepo = addNxToMonorepo;
+const enquirer_1 = require("enquirer");
+const fs_1 = require("fs");
+const ignore = require("ignore");
+const path_1 = require("path");
+const fileutils_1 = require("../../../utils/fileutils");
+const output_1 = require("../../../utils/output");
+const utils_1 = require("./utils");
+const connect_to_nx_cloud_1 = require("../../nx-cloud/connect/connect-to-nx-cloud");
+async function addNxToMonorepo(options, guided = true) {
+    const repoRoot = process.cwd();
+    output_1.output.log({ title: '🐳 Nx initialization' });
+    const packageJsonFiles = allProjectPackageJsonFiles(repoRoot);
+    const scripts = combineAllScriptNames(repoRoot, packageJsonFiles);
+    let targetDefaults;
+    let cacheableOperations;
+    let scriptOutputs = {};
+    let useNxCloud;
+    if (options.interactive && scripts.length > 0 && guided) {
+        output_1.output.log({
+            title: '🧑‍🔧 Please answer the following questions about the scripts found in your workspace in order to generate task runner configuration',
+        });
+        targetDefaults = (await (0, enquirer_1.prompt)([
+            {
+                type: 'multiselect',
+                name: 'targetDefaults',
+                message: 'Which scripts need to be run in order? (e.g. before building a project, dependent projects must be built)',
+                choices: scripts,
+                /**
+                 * limit is missing from the interface but it limits the amount of options shown
+                 */
+                limit: process.stdout.rows - 4, // 4 leaves room for the header above, the prompt and some whitespace
+            },
+        ])).targetDefaults;
+        cacheableOperations = (await (0, enquirer_1.prompt)([
+            {
+                type: 'multiselect',
+                name: 'cacheableOperations',
+                message: 'Which scripts are cacheable? (Produce the same output given the same input, e.g. build, test and lint usually are, serve and start are not)',
+                choices: scripts,
+                /**
+                 * limit is missing from the interface but it limits the amount of options shown
+                 */
+                limit: process.stdout.rows - 4, // 4 leaves room for the header above, the prompt and some whitespace
+            },
+        ])).cacheableOperations;
+        for (const scriptName of cacheableOperations) {
+            scriptOutputs[scriptName] = (await (0, enquirer_1.prompt)([
+                {
+                    type: 'input',
+                    name: scriptName,
+                    message: `Does the "${scriptName}" script create any outputs? If not, leave blank, otherwise provide a path relative to a project root (e.g. dist, lib, build, coverage)`,
+                },
+            ]))[scriptName];
+        }
+        useNxCloud =
+            options.nxCloud ?? (await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)());
+    }
+    else {
+        targetDefaults = [];
+        cacheableOperations = options.cacheable ?? [];
+        useNxCloud =
+            options.nxCloud ??
+                (options.interactive
+                    ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)()
+                    : false);
+    }
+    (0, utils_1.createNxJsonFile)(repoRoot, targetDefaults, cacheableOperations, scriptOutputs);
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    (0, utils_1.addDepsToPackageJson)(repoRoot);
+    output_1.output.log({ title: '📦 Installing dependencies' });
+    (0, utils_1.runInstall)(repoRoot);
+    if (useNxCloud) {
+        output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
+        await (0, utils_1.initCloud)('nx-init-monorepo');
+    }
+}
+// scanning package.json files
+function allProjectPackageJsonFiles(repoRoot) {
+    const packageJsonFiles = allPackageJsonFiles(repoRoot, repoRoot);
+    return packageJsonFiles.filter((c) => c != 'package.json');
+}
+function allPackageJsonFiles(repoRoot, dirName) {
+    const ignoredGlobs = getIgnoredGlobs(repoRoot);
+    const relDirName = (0, path_1.relative)(repoRoot, dirName);
+    if (relDirName &&
+        (ignoredGlobs.ignores(relDirName) ||
+            relDirName.indexOf(`node_modules`) > -1)) {
+        return [];
+    }
+    let res = [];
+    try {
+        (0, fs_1.readdirSync)(dirName).forEach((c) => {
+            const child = (0, path_1.join)(dirName, c);
+            if (ignoredGlobs.ignores((0, path_1.relative)(repoRoot, child))) {
+                return;
+            }
+            try {
+                const s = (0, fs_1.statSync)(child);
+                if (s.isFile() && c == 'package.json') {
+                    res.push((0, path_1.relative)(repoRoot, child));
+                }
+                else if (s.isDirectory()) {
+                    res = [...res, ...allPackageJsonFiles(repoRoot, child)];
+                }
+            }
+            catch { }
+        });
+    }
+    catch { }
+    return res;
+}
+function getIgnoredGlobs(repoRoot) {
+    const ig = ignore();
+    try {
+        ig.add((0, fs_1.readFileSync)(`${repoRoot}/.gitignore`, 'utf-8'));
+    }
+    catch { }
+    return ig;
+}
+function combineAllScriptNames(repoRoot, packageJsonFiles) {
+    const res = new Set();
+    packageJsonFiles.forEach((p) => {
+        const packageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(repoRoot, p));
+        Object.keys(packageJson.scripts || {}).forEach((scriptName) => res.add(scriptName));
+    });
+    return [...res];
+}

package/src/command-line/init/implementation/add-nx-to-nest.d.ts

@@ -0,0 +1,6 @@
+import { InitArgs } from '../init-v1';
+import { PackageJson } from '../../../utils/package-json';
+type Options = Pick<InitArgs, 'nxCloud' | 'interactive' | 'cacheable'>;
+export declare function addNxToNest(options: Options, packageJson: PackageJson): Promise<void>;
+export {};
+//# sourceMappingURL=add-nx-to-nest.d.ts.map

package/src/command-line/init/implementation/add-nx-to-nest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-nx-to-nest.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/init/implementation/add-nx-to-nest.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAStC,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAa1D,KAAK,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,CAAC,CAAC;AAGvE,wBAAsB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,iBAoH3E"}