Deployed the page to Github Pages.

2024-11-03 21:30:09 -05:00 · 2024-11-03 21:30:09 -05:00 · 2c89899458
commit 2c89899458
parent 1d79754e93
62797 changed files with 6551425 additions and 15279 deletions
--- a/node_modules/@angular/cli/src/commands/add/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/add/cli.d.ts
@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModuleImplementation, Options, OtherOptions } from '../../command-builder/command-module';
+import { SchematicsCommandArgs, SchematicsCommandModule } from '../../command-builder/schematics-command-module';
+interface AddCommandArgs extends SchematicsCommandArgs {
+    collection: string;
+    verbose?: boolean;
+    registry?: string;
+    'skip-confirmation'?: boolean;
+}
+export default class AddCommandModule extends SchematicsCommandModule implements CommandModuleImplementation<AddCommandArgs> {
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    protected allowPrivateSchematics: boolean;
+    private readonly schematicName;
+    private rootRequire;
+    builder(argv: Argv): Promise<Argv<AddCommandArgs>>;
+    run(options: Options<AddCommandArgs> & OtherOptions): Promise<number | void>;
+    private isProjectVersionValid;
+    private getCollectionName;
+    private isPackageInstalled;
+    private executeSchematic;
+    private findProjectVersion;
+    private hasMismatchedPeer;
+}
+export {};
--- a/node_modules/@angular/cli/src/commands/add/cli.js
+++ b/node_modules/@angular/cli/src/commands/add/cli.js
@ -0,0 +1,442 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tools_1 = require("@angular-devkit/schematics/tools");
+const listr2_1 = require("listr2");
+const module_1 = require("module");
+const node_assert_1 = __importDefault(require("node:assert"));
+const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
+const path_1 = require("path");
+const semver_1 = require("semver");
+const workspace_schema_1 = require("../../../lib/config/workspace-schema");
+const schematics_command_module_1 = require("../../command-builder/schematics-command-module");
+const error_1 = require("../../utilities/error");
+const package_metadata_1 = require("../../utilities/package-metadata");
+const tty_1 = require("../../utilities/tty");
+const version_1 = require("../../utilities/version");
+class CommandError extends Error {
+}
+/**
+ * The set of packages that should have certain versions excluded from consideration
+ * when attempting to find a compatible version for a package.
+ * The key is a package name and the value is a SemVer range of versions to exclude.
+ */
+const packageVersionExclusions = {
+    // @angular/localize@9.x and earlier versions as well as @angular/localize@10.0 prereleases do not have peer dependencies setup.
+    '@angular/localize': '<10.0.0',
+    // @angular/material@7.x versions have unbounded peer dependency ranges (>=7.0.0).
+    '@angular/material': '7.x',
+};
+class AddCommandModule extends schematics_command_module_1.SchematicsCommandModule {
+    command = 'add <collection>';
+    describe = 'Adds support for an external library to your project.';
+    longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    allowPrivateSchematics = true;
+    schematicName = 'ng-add';
+    rootRequire = (0, module_1.createRequire)(this.context.root + '/');
+    async builder(argv) {
+        const localYargs = (await super.builder(argv))
+            .positional('collection', {
+            description: 'The package to be added.',
+            type: 'string',
+            demandOption: true,
+        })
+            .option('registry', { description: 'The NPM registry to use.', type: 'string' })
+            .option('verbose', {
+            description: 'Display additional details about internal operations during execution.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('skip-confirmation', {
+            description: 'Skip asking a confirmation prompt before installing and executing the package. ' +
+                'Ensure package name is correct prior to using this option.',
+            type: 'boolean',
+            default: false,
+        })
+            // Prior to downloading we don't know the full schema and therefore we cannot be strict on the options.
+            // Possibly in the future update the logic to use the following syntax:
+            // `ng add @angular/localize -- --package-options`.
+            .strict(false);
+        const collectionName = await this.getCollectionName();
+        const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
+        try {
+            const collection = workflow.engine.createCollection(collectionName);
+            const options = await this.getSchematicOptions(collection, this.schematicName, workflow);
+            return this.addSchemaOptionsToCommand(localYargs, options);
+        }
+        catch (error) {
+            // During `ng add` prior to the downloading of the package
+            // we are not able to resolve and create a collection.
+            // Or when the collection value is a path to a tarball.
+        }
+        return localYargs;
+    }
+    // eslint-disable-next-line max-lines-per-function
+    async run(options) {
+        const { logger, packageManager } = this.context;
+        const { verbose, registry, collection, skipConfirmation } = options;
+        let packageIdentifier;
+        try {
+            packageIdentifier = (0, npm_package_arg_1.default)(collection);
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            logger.error(e.message);
+            return 1;
+        }
+        if (packageIdentifier.name &&
+            packageIdentifier.registry &&
+            this.isPackageInstalled(packageIdentifier.name)) {
+            const validVersion = await this.isProjectVersionValid(packageIdentifier);
+            if (validVersion) {
+                // Already installed so just run schematic
+                logger.info('Skipping installation: Package already installed');
+                return this.executeSchematic({ ...options, collection: packageIdentifier.name });
+            }
+        }
+        const taskContext = {
+            packageIdentifier,
+            executeSchematic: this.executeSchematic.bind(this),
+            hasMismatchedPeer: this.hasMismatchedPeer.bind(this),
+        };
+        const tasks = new listr2_1.Listr([
+            {
+                title: 'Determining Package Manager',
+                task(context, task) {
+                    context.usingYarn = packageManager.name === workspace_schema_1.PackageManager.Yarn;
+                    task.output = `Using package manager: ${listr2_1.color.dim(packageManager.name)}`;
+                },
+                rendererOptions: { persistentOutput: true },
+            },
+            {
+                title: 'Searching for compatible package version',
+                enabled: packageIdentifier.type === 'range' && packageIdentifier.rawSpec === '*',
+                async task(context, task) {
+                    (0, node_assert_1.default)(context.packageIdentifier.name, 'Registry package identifiers should always have a name.');
+                    // only package name provided; search for viable version
+                    // plus special cases for packages that did not have peer deps setup
+                    let packageMetadata;
+                    try {
+                        packageMetadata = await (0, package_metadata_1.fetchPackageMetadata)(context.packageIdentifier.name, logger, {
+                            registry,
+                            usingYarn: context.usingYarn,
+                            verbose,
+                        });
+                    }
+                    catch (e) {
+                        (0, error_1.assertIsError)(e);
+                        throw new CommandError(`Unable to load package information from registry: ${e.message}`);
+                    }
+                    // Start with the version tagged as `latest` if it exists
+                    const latestManifest = packageMetadata.tags['latest'];
+                    if (latestManifest) {
+                        context.packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
+                    }
+                    // Adjust the version based on name and peer dependencies
+                    if (latestManifest?.peerDependencies &&
+                        Object.keys(latestManifest.peerDependencies).length === 0) {
+                        task.output = `Found compatible package version: ${listr2_1.color.blue(latestManifest.version)}.`;
+                    }
+                    else if (!latestManifest || (await context.hasMismatchedPeer(latestManifest))) {
+                        // 'latest' is invalid so search for most recent matching package
+                        // Allow prelease versions if the CLI itself is a prerelease
+                        const allowPrereleases = (0, semver_1.prerelease)(version_1.VERSION.full);
+                        const versionExclusions = packageVersionExclusions[packageMetadata.name];
+                        const versionManifests = Object.values(packageMetadata.versions).filter((value) => {
+                            // Prerelease versions are not stable and should not be considered by default
+                            if (!allowPrereleases && (0, semver_1.prerelease)(value.version)) {
+                                return false;
+                            }
+                            // Deprecated versions should not be used or considered
+                            if (value.deprecated) {
+                                return false;
+                            }
+                            // Excluded package versions should not be considered
+                            if (versionExclusions &&
+                                (0, semver_1.satisfies)(value.version, versionExclusions, { includePrerelease: true })) {
+                                return false;
+                            }
+                            return true;
+                        });
+                        // Sort in reverse SemVer order so that the newest compatible version is chosen
+                        versionManifests.sort((a, b) => (0, semver_1.compare)(b.version, a.version, true));
+                        let found = false;
+                        for (const versionManifest of versionManifests) {
+                            const mismatch = await context.hasMismatchedPeer(versionManifest);
+                            if (mismatch) {
+                                continue;
+                            }
+                            context.packageIdentifier = npm_package_arg_1.default.resolve(versionManifest.name, versionManifest.version);
+                            found = true;
+                        }
+                        if (!found) {
+                            task.output = "Unable to find compatible package. Using 'latest' tag.";
+                        }
+                        else {
+                            task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
+                        }
+                    }
+                    else {
+                        task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
+                    }
+                },
+                rendererOptions: { persistentOutput: true },
+            },
+            {
+                title: 'Loading package information from registry',
+                async task(context, task) {
+                    let manifest;
+                    try {
+                        manifest = await (0, package_metadata_1.fetchPackageManifest)(context.packageIdentifier.toString(), logger, {
+                            registry,
+                            verbose,
+                            usingYarn: context.usingYarn,
+                        });
+                    }
+                    catch (e) {
+                        (0, error_1.assertIsError)(e);
+                        throw new CommandError(`Unable to fetch package information for '${context.packageIdentifier}': ${e.message}`);
+                    }
+                    context.savePackage = manifest['ng-add']?.save;
+                    context.collectionName = manifest.name;
+                    if (await context.hasMismatchedPeer(manifest)) {
+                        task.output = listr2_1.color.yellow(listr2_1.figures.warning +
+                            ' Package has unmet peer dependencies. Adding the package may not succeed.');
+                    }
+                },
+                rendererOptions: { persistentOutput: true },
+            },
+            {
+                title: 'Confirming installation',
+                enabled: !skipConfirmation,
+                async task(context, task) {
+                    if (!(0, tty_1.isTTY)()) {
+                        task.output =
+                            `'--skip-confirmation' can be used to bypass installation confirmation. ` +
+                                `Ensure package name is correct prior to '--skip-confirmation' option usage.`;
+                        throw new CommandError('No terminal detected');
+                    }
+                    const { ListrInquirerPromptAdapter } = await Promise.resolve().then(() => __importStar(require('@listr2/prompt-adapter-inquirer')));
+                    const { confirm } = await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
+                    const shouldProceed = await task.prompt(ListrInquirerPromptAdapter).run(confirm, {
+                        message: `The package ${listr2_1.color.blue(context.packageIdentifier.toString())} will be installed and executed.\n` +
+                            'Would you like to proceed?',
+                        default: true,
+                        theme: { prefix: '' },
+                    });
+                    if (!shouldProceed) {
+                        throw new CommandError('Command aborted');
+                    }
+                },
+                rendererOptions: { persistentOutput: true },
+            },
+            {
+                async task(context, task) {
+                    // Only show if installation will actually occur
+                    task.title = 'Installing package';
+                    if (context.savePackage === false) {
+                        task.title += ' in temporary location';
+                        // Temporary packages are located in a different directory
+                        // Hence we need to resolve them using the temp path
+                        const { success, tempNodeModules } = await packageManager.installTemp(context.packageIdentifier.toString(), registry ? [`--registry="${registry}"`] : undefined);
+                        const tempRequire = (0, module_1.createRequire)(tempNodeModules + '/');
+                        (0, node_assert_1.default)(context.collectionName, 'Collection name should always be available');
+                        const resolvedCollectionPath = tempRequire.resolve((0, path_1.join)(context.collectionName, 'package.json'));
+                        if (!success) {
+                            throw new CommandError('Unable to install package');
+                        }
+                        context.collectionName = (0, path_1.dirname)(resolvedCollectionPath);
+                    }
+                    else {
+                        const success = await packageManager.install(context.packageIdentifier.toString(), context.savePackage, registry ? [`--registry="${registry}"`] : undefined, undefined);
+                        if (!success) {
+                            throw new CommandError('Unable to install package');
+                        }
+                    }
+                },
+                rendererOptions: { bottomBar: Infinity },
+            },
+            // TODO: Rework schematic execution as a task and insert here
+        ]);
+        try {
+            const result = await tasks.run(taskContext);
+            (0, node_assert_1.default)(result.collectionName, 'Collection name should always be available');
+            return this.executeSchematic({ ...options, collection: result.collectionName });
+        }
+        catch (e) {
+            if (e instanceof CommandError) {
+                return 1;
+            }
+            throw e;
+        }
+    }
+    async isProjectVersionValid(packageIdentifier) {
+        if (!packageIdentifier.name) {
+            return false;
+        }
+        const installedVersion = await this.findProjectVersion(packageIdentifier.name);
+        if (!installedVersion) {
+            return false;
+        }
+        if (packageIdentifier.rawSpec === '*') {
+            return true;
+        }
+        if (packageIdentifier.type === 'range' &&
+            packageIdentifier.fetchSpec &&
+            packageIdentifier.fetchSpec !== '*') {
+            return (0, semver_1.satisfies)(installedVersion, packageIdentifier.fetchSpec);
+        }
+        if (packageIdentifier.type === 'version') {
+            const v1 = (0, semver_1.valid)(packageIdentifier.fetchSpec);
+            const v2 = (0, semver_1.valid)(installedVersion);
+            return v1 !== null && v1 === v2;
+        }
+        return false;
+    }
+    async getCollectionName() {
+        let [, collectionName] = this.context.args.positional;
+        // The CLI argument may specify also a version, like `ng add @my/lib@13.0.0`,
+        // but here we need only the name of the package, like `@my/lib`
+        try {
+            const packageIdentifier = (0, npm_package_arg_1.default)(collectionName);
+            collectionName = packageIdentifier.name ?? collectionName;
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            this.context.logger.error(e.message);
+        }
+        return collectionName;
+    }
+    isPackageInstalled(name) {
+        try {
+            this.rootRequire.resolve((0, path_1.join)(name, 'package.json'));
+            return true;
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            if (e.code !== 'MODULE_NOT_FOUND') {
+                throw e;
+            }
+        }
+        return false;
+    }
+    async executeSchematic(options) {
+        try {
+            const { verbose, skipConfirmation, interactive, force, dryRun, registry, defaults, collection: collectionName, ...schematicOptions } = options;
+            return await this.runSchematic({
+                schematicOptions,
+                schematicName: this.schematicName,
+                collectionName,
+                executionOptions: {
+                    interactive,
+                    force,
+                    dryRun,
+                    defaults,
+                    packageRegistry: registry,
+                },
+            });
+        }
+        catch (e) {
+            if (e instanceof tools_1.NodePackageDoesNotSupportSchematics) {
+                this.context.logger.error('The package that you are trying to add does not support schematics.' +
+                    'You can try using a different version of the package or contact the package author to add ng-add support.');
+                return 1;
+            }
+            throw e;
+        }
+    }
+    async findProjectVersion(name) {
+        const { logger, root } = this.context;
+        let installedPackage;
+        try {
+            installedPackage = this.rootRequire.resolve((0, path_1.join)(name, 'package.json'));
+        }
+        catch { }
+        if (installedPackage) {
+            try {
+                const installed = await (0, package_metadata_1.fetchPackageManifest)((0, path_1.dirname)(installedPackage), logger);
+                return installed.version;
+            }
+            catch { }
+        }
+        let projectManifest;
+        try {
+            projectManifest = await (0, package_metadata_1.fetchPackageManifest)(root, logger);
+        }
+        catch { }
+        if (projectManifest) {
+            const version = projectManifest.dependencies?.[name] || projectManifest.devDependencies?.[name];
+            if (version) {
+                return version;
+            }
+        }
+        return null;
+    }
+    async hasMismatchedPeer(manifest) {
+        for (const peer in manifest.peerDependencies) {
+            let peerIdentifier;
+            try {
+                peerIdentifier = npm_package_arg_1.default.resolve(peer, manifest.peerDependencies[peer]);
+            }
+            catch {
+                this.context.logger.warn(`Invalid peer dependency ${peer} found in package.`);
+                continue;
+            }
+            if (peerIdentifier.type === 'version' || peerIdentifier.type === 'range') {
+                try {
+                    const version = await this.findProjectVersion(peer);
+                    if (!version) {
+                        continue;
+                    }
+                    const options = { includePrerelease: true };
+                    if (!(0, semver_1.intersects)(version, peerIdentifier.rawSpec, options) &&
+                        !(0, semver_1.satisfies)(version, peerIdentifier.rawSpec, options)) {
+                        return true;
+                    }
+                }
+                catch {
+                    // Not found or invalid so ignore
+                    continue;
+                }
+            }
+            else {
+                // type === 'tag' | 'file' | 'directory' | 'remote' | 'git'
+                // Cannot accurately compare these as the tag/location may have changed since install
+            }
+        }
+        return false;
+    }
+}
+exports.default = AddCommandModule;
--- a/node_modules/@angular/cli/src/commands/add/long-description.md
+++ b/node_modules/@angular/cli/src/commands/add/long-description.md
@ -0,0 +1,7 @@
+Adds the npm package for a published library to your workspace, and configures
+the project in the current working directory to use that library, as specified by the library's schematic.
+For example, adding `@angular/pwa` configures your project for PWA support:
+
+```bash
+ng add @angular/pwa
+```
--- a/node_modules/@angular/cli/src/commands/analytics/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/analytics/cli.d.ts
@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation, Options } from '../../command-builder/command-module';
+export default class AnalyticsCommandModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    builder(localYargs: Argv): Argv;
+    run(_options: Options<{}>): void;
+}
--- a/node_modules/@angular/cli/src/commands/analytics/cli.js
+++ b/node_modules/@angular/cli/src/commands/analytics/cli.js
@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const command_module_1 = require("../../command-builder/command-module");
+const command_1 = require("../../command-builder/utilities/command");
+const cli_1 = require("./info/cli");
+const cli_2 = require("./settings/cli");
+class AnalyticsCommandModule extends command_module_1.CommandModule {
+    command = 'analytics';
+    describe = 'Configures the gathering of Angular CLI usage metrics.';
+    longDescriptionPath = (0, node_path_1.join)(__dirname, 'long-description.md');
+    builder(localYargs) {
+        const subcommands = [
+            cli_1.AnalyticsInfoCommandModule,
+            cli_2.AnalyticsDisableModule,
+            cli_2.AnalyticsEnableModule,
+            cli_2.AnalyticsPromptModule,
+        ].sort(); // sort by class name.
+        for (const module of subcommands) {
+            localYargs = (0, command_1.addCommandModuleToYargs)(localYargs, module, this.context);
+        }
+        return localYargs.demandCommand(1, command_1.demandCommandFailureMessage).strict();
+    }
+    run(_options) { }
+}
+exports.default = AnalyticsCommandModule;
--- a/node_modules/@angular/cli/src/commands/analytics/info/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/analytics/info/cli.d.ts
@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation, Options } from '../../../command-builder/command-module';
+export declare class AnalyticsInfoCommandModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    describe: string;
+    longDescriptionPath?: string;
+    builder(localYargs: Argv): Argv;
+    run(_options: Options<{}>): Promise<void>;
+}
--- a/node_modules/@angular/cli/src/commands/analytics/info/cli.js
+++ b/node_modules/@angular/cli/src/commands/analytics/info/cli.js
@ -0,0 +1,24 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsInfoCommandModule = void 0;
+const analytics_1 = require("../../../analytics/analytics");
+const command_module_1 = require("../../../command-builder/command-module");
+class AnalyticsInfoCommandModule extends command_module_1.CommandModule {
+    command = 'info';
+    describe = 'Prints analytics gathering and reporting configuration in the console.';
+    longDescriptionPath;
+    builder(localYargs) {
+        return localYargs.strict();
+    }
+    async run(_options) {
+        this.context.logger.info(await (0, analytics_1.getAnalyticsInfoString)(this.context));
+    }
+}
+exports.AnalyticsInfoCommandModule = AnalyticsInfoCommandModule;
--- a/node_modules/@angular/cli/src/commands/analytics/long-description.md
+++ b/node_modules/@angular/cli/src/commands/analytics/long-description.md
@ -0,0 +1,20 @@
+You can help the Angular Team to prioritize features and improvements by permitting the Angular team to send command-line command usage statistics to Google.
+The Angular Team does not collect usage statistics unless you explicitly opt in. When installing the Angular CLI you are prompted to allow global collection of usage statistics.
+If you say no or skip the prompt, no data is collected.
+
+### What is collected?
+
+Usage analytics include the commands and selected flags for each execution.
+Usage analytics may include the following information:
+
+- Your operating system \(macOS, Linux distribution, Windows\) and its version.
+- Package manager name and version \(local version only\).
+- Node.js version \(local version only\).
+- Angular CLI version \(local version only\).
+- Command name that was run.
+- Workspace information, the number of application and library projects.
+- For schematics commands \(add, generate and new\), the schematic collection and name and a list of selected flags.
+- For build commands \(build, serve\), the builder name, the number and size of bundles \(initial and lazy\), compilation units, the time it took to build and rebuild, and basic Angular-specific API usage.
+
+Only Angular owned and developed schematics and builders are reported.
+Third-party schematics and builders do not send data to the Angular Team.
--- a/node_modules/@angular/cli/src/commands/analytics/settings/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/analytics/settings/cli.d.ts
@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation, Options } from '../../../command-builder/command-module';
+interface AnalyticsCommandArgs {
+    global: boolean;
+}
+declare abstract class AnalyticsSettingModule extends CommandModule<AnalyticsCommandArgs> implements CommandModuleImplementation<AnalyticsCommandArgs> {
+    longDescriptionPath?: string;
+    builder(localYargs: Argv): Argv<AnalyticsCommandArgs>;
+    abstract run({ global }: Options<AnalyticsCommandArgs>): Promise<void>;
+}
+export declare class AnalyticsDisableModule extends AnalyticsSettingModule implements CommandModuleImplementation<AnalyticsCommandArgs> {
+    command: string;
+    aliases: string;
+    describe: string;
+    run({ global }: Options<AnalyticsCommandArgs>): Promise<void>;
+}
+export declare class AnalyticsEnableModule extends AnalyticsSettingModule implements CommandModuleImplementation<AnalyticsCommandArgs> {
+    command: string;
+    aliases: string;
+    describe: string;
+    run({ global }: Options<AnalyticsCommandArgs>): Promise<void>;
+}
+export declare class AnalyticsPromptModule extends AnalyticsSettingModule implements CommandModuleImplementation<AnalyticsCommandArgs> {
+    command: string;
+    describe: string;
+    run({ global }: Options<AnalyticsCommandArgs>): Promise<void>;
+}
+export {};
--- a/node_modules/@angular/cli/src/commands/analytics/settings/cli.js
+++ b/node_modules/@angular/cli/src/commands/analytics/settings/cli.js
@ -0,0 +1,53 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsPromptModule = exports.AnalyticsEnableModule = exports.AnalyticsDisableModule = void 0;
+const analytics_1 = require("../../../analytics/analytics");
+const command_module_1 = require("../../../command-builder/command-module");
+class AnalyticsSettingModule extends command_module_1.CommandModule {
+    longDescriptionPath;
+    builder(localYargs) {
+        return localYargs
+            .option('global', {
+            description: `Configure analytics gathering and reporting globally in the caller's home directory.`,
+            alias: ['g'],
+            type: 'boolean',
+            default: false,
+        })
+            .strict();
+    }
+}
+class AnalyticsDisableModule extends AnalyticsSettingModule {
+    command = 'disable';
+    aliases = 'off';
+    describe = 'Disables analytics gathering and reporting for the user.';
+    async run({ global }) {
+        await (0, analytics_1.setAnalyticsConfig)(global, false);
+        process.stderr.write(await (0, analytics_1.getAnalyticsInfoString)(this.context));
+    }
+}
+exports.AnalyticsDisableModule = AnalyticsDisableModule;
+class AnalyticsEnableModule extends AnalyticsSettingModule {
+    command = 'enable';
+    aliases = 'on';
+    describe = 'Enables analytics gathering and reporting for the user.';
+    async run({ global }) {
+        await (0, analytics_1.setAnalyticsConfig)(global, true);
+        process.stderr.write(await (0, analytics_1.getAnalyticsInfoString)(this.context));
+    }
+}
+exports.AnalyticsEnableModule = AnalyticsEnableModule;
+class AnalyticsPromptModule extends AnalyticsSettingModule {
+    command = 'prompt';
+    describe = 'Prompts the user to set the analytics gathering status interactively.';
+    async run({ global }) {
+        await (0, analytics_1.promptAnalytics)(this.context, global, true);
+    }
+}
+exports.AnalyticsPromptModule = AnalyticsPromptModule;
--- a/node_modules/@angular/cli/src/commands/build/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/build/cli.d.ts
@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export default class BuildCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    multiTarget: boolean;
+    command: string;
+    aliases: string[] | undefined;
+    describe: string;
+    longDescriptionPath: string;
+}
--- a/node_modules/@angular/cli/src/commands/build/cli.js
+++ b/node_modules/@angular/cli/src/commands/build/cli.js
@ -0,0 +1,20 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+const command_config_1 = require("../command-config");
+class BuildCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    multiTarget = false;
+    command = 'build [project]';
+    aliases = command_config_1.RootCommands['build'].aliases;
+    describe = 'Compiles an Angular application or library into an output directory named dist/ at the given output path.';
+    longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+}
+exports.default = BuildCommandModule;
--- a/node_modules/@angular/cli/src/commands/build/long-description.md
+++ b/node_modules/@angular/cli/src/commands/build/long-description.md
@ -0,0 +1,18 @@
+The command can be used to build a project of type "application" or "library".
+When used to build a library, a different builder is invoked, and only the `ts-config`, `configuration`, `poll` and `watch` options are applied.
+All other options apply only to building applications.
+
+The application builder uses the [esbuild](https://esbuild.github.io/) build tool, with default configuration options specified in the workspace configuration file (`angular.json`) or with a named alternative configuration.
+A "development" configuration is created by default when you use the CLI to create the project, and you can use that configuration by specifying the `--configuration development`.
+
+The configuration options generally correspond to the command options.
+You can override individual configuration defaults by specifying the corresponding options on the command line.
+The command can accept option names given in dash-case.
+Note that in the configuration file, you must specify names in camelCase.
+
+Some additional options can only be set through the configuration file,
+either by direct editing or with the `ng config` command.
+These include `assets`, `styles`, and `scripts` objects that provide runtime-global resources to include in the project.
+Resources in CSS, such as images and fonts, are automatically written and fingerprinted at the root of the output folder.
+
+For further details, see [Workspace Configuration](reference/configs/workspace-config).
--- a/node_modules/@angular/cli/src/commands/cache/clean/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/cache/clean/cli.d.ts
@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation, CommandScope } from '../../../command-builder/command-module';
+export declare class CacheCleanModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    describe: string;
+    longDescriptionPath: string | undefined;
+    scope: CommandScope;
+    builder(localYargs: Argv): Argv;
+    run(): Promise<void>;
+}
--- a/node_modules/@angular/cli/src/commands/cache/clean/cli.js
+++ b/node_modules/@angular/cli/src/commands/cache/clean/cli.js
@ -0,0 +1,31 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheCleanModule = void 0;
+const fs_1 = require("fs");
+const command_module_1 = require("../../../command-builder/command-module");
+const utilities_1 = require("../utilities");
+class CacheCleanModule extends command_module_1.CommandModule {
+    command = 'clean';
+    describe = 'Deletes persistent disk cache from disk.';
+    longDescriptionPath;
+    scope = command_module_1.CommandScope.In;
+    builder(localYargs) {
+        return localYargs.strict();
+    }
+    run() {
+        const { path } = (0, utilities_1.getCacheConfig)(this.context.workspace);
+        return fs_1.promises.rm(path, {
+            force: true,
+            recursive: true,
+            maxRetries: 3,
+        });
+    }
+}
+exports.CacheCleanModule = CacheCleanModule;
--- a/node_modules/@angular/cli/src/commands/cache/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/cache/cli.d.ts
@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation, CommandScope, Options } from '../../command-builder/command-module';
+export default class CacheCommandModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    scope: CommandScope;
+    builder(localYargs: Argv): Argv;
+    run(_options: Options<{}>): void;
+}
--- a/node_modules/@angular/cli/src/commands/cache/cli.js
+++ b/node_modules/@angular/cli/src/commands/cache/cli.js
@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const command_module_1 = require("../../command-builder/command-module");
+const command_1 = require("../../command-builder/utilities/command");
+const cli_1 = require("./clean/cli");
+const cli_2 = require("./info/cli");
+const cli_3 = require("./settings/cli");
+class CacheCommandModule extends command_module_1.CommandModule {
+    command = 'cache';
+    describe = 'Configure persistent disk cache and retrieve cache statistics.';
+    longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    scope = command_module_1.CommandScope.In;
+    builder(localYargs) {
+        const subcommands = [
+            cli_3.CacheEnableModule,
+            cli_3.CacheDisableModule,
+            cli_1.CacheCleanModule,
+            cli_2.CacheInfoCommandModule,
+        ].sort();
+        for (const module of subcommands) {
+            localYargs = (0, command_1.addCommandModuleToYargs)(localYargs, module, this.context);
+        }
+        return localYargs.demandCommand(1, command_1.demandCommandFailureMessage).strict();
+    }
+    run(_options) { }
+}
+exports.default = CacheCommandModule;
--- a/node_modules/@angular/cli/src/commands/cache/info/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/cache/info/cli.d.ts
@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation, CommandScope } from '../../../command-builder/command-module';
+export declare class CacheInfoCommandModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    describe: string;
+    longDescriptionPath?: string | undefined;
+    scope: CommandScope;
+    builder(localYargs: Argv): Argv;
+    run(): Promise<void>;
+    private getSizeOfDirectory;
+    private formatSize;
+    private effectiveEnabledStatus;
+}
--- a/node_modules/@angular/cli/src/commands/cache/info/cli.js
+++ b/node_modules/@angular/cli/src/commands/cache/info/cli.js
@ -0,0 +1,81 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheInfoCommandModule = void 0;
+const core_1 = require("@angular-devkit/core");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const command_module_1 = require("../../../command-builder/command-module");
+const environment_options_1 = require("../../../utilities/environment-options");
+const utilities_1 = require("../utilities");
+class CacheInfoCommandModule extends command_module_1.CommandModule {
+    command = 'info';
+    describe = 'Prints persistent disk cache configuration and statistics in the console.';
+    longDescriptionPath;
+    scope = command_module_1.CommandScope.In;
+    builder(localYargs) {
+        return localYargs.strict();
+    }
+    async run() {
+        const { path, environment, enabled } = (0, utilities_1.getCacheConfig)(this.context.workspace);
+        this.context.logger.info(core_1.tags.stripIndents `
+      Enabled: ${enabled ? 'yes' : 'no'}
+      Environment: ${environment}
+      Path: ${path}
+      Size on disk: ${await this.getSizeOfDirectory(path)}
+      Effective status on current machine: ${this.effectiveEnabledStatus() ? 'enabled' : 'disabled'}
+    `);
+    }
+    async getSizeOfDirectory(path) {
+        const directoriesStack = [path];
+        let size = 0;
+        while (directoriesStack.length) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const dirPath = directoriesStack.pop();
+            let entries = [];
+            try {
+                entries = await fs_1.promises.readdir(dirPath);
+            }
+            catch { }
+            for (const entry of entries) {
+                const entryPath = (0, path_1.join)(dirPath, entry);
+                const stats = await fs_1.promises.stat(entryPath);
+                if (stats.isDirectory()) {
+                    directoriesStack.push(entryPath);
+                }
+                size += stats.size;
+            }
+        }
+        return this.formatSize(size);
+    }
+    formatSize(size) {
+        if (size <= 0) {
+            return '0 bytes';
+        }
+        const abbreviations = ['bytes', 'kB', 'MB', 'GB'];
+        const index = Math.floor(Math.log(size) / Math.log(1024));
+        const roundedSize = size / Math.pow(1024, index);
+        // bytes don't have a fraction
+        const fractionDigits = index === 0 ? 0 : 2;
+        return `${roundedSize.toFixed(fractionDigits)} ${abbreviations[index]}`;
+    }
+    effectiveEnabledStatus() {
+        const { enabled, environment } = (0, utilities_1.getCacheConfig)(this.context.workspace);
+        if (enabled) {
+            switch (environment) {
+                case 'ci':
+                    return environment_options_1.isCI;
+                case 'local':
+                    return !environment_options_1.isCI;
+            }
+        }
+        return enabled;
+    }
+}
+exports.CacheInfoCommandModule = CacheInfoCommandModule;
--- a/node_modules/@angular/cli/src/commands/cache/long-description.md
+++ b/node_modules/@angular/cli/src/commands/cache/long-description.md
@ -0,0 +1,53 @@
+Angular CLI saves a number of cachable operations on disk by default.
+
+When you re-run the same build, the build system restores the state of the previous build and re-uses previously performed operations, which decreases the time taken to build and test your applications and libraries.
+
+To amend the default cache settings, add the `cli.cache` object to your [Workspace Configuration](reference/configs/workspace-config).
+The object goes under `cli.cache` at the top level of the file, outside the `projects` sections.
+
+```jsonc
+{
+  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
+  "version": 1,
+  "cli": {
+    "cache": {
+      // ...
+    },
+  },
+  "projects": {},
+}
+```
+
+For more information, see [cache options](reference/configs/workspace-config#cache-options).
+
+### Cache environments
+
+By default, disk cache is only enabled for local environments. The value of environment can be one of the following:
+
+- `all` - allows disk cache on all machines.
+- `local` - allows disk cache only on development machines.
+- `ci` - allows disk cache only on continuous integration (CI) systems.
+
+To change the environment setting to `all`, run the following command:
+
+```bash
+ng config cli.cache.environment all
+```
+
+For more information, see `environment` in [cache options](reference/configs/workspace-config#cache-options).
+
+<div class="alert is-helpful">
+
+The Angular CLI checks for the presence and value of the `CI` environment variable to determine in which environment it is running.
+
+</div>
+
+### Cache path
+
+By default, `.angular/cache` is used as a base directory to store cache results.
+
+To change this path to `.cache/ng`, run the following command:
+
+```bash
+ng config cli.cache.path ".cache/ng"
+```
--- a/node_modules/@angular/cli/src/commands/cache/settings/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/cache/settings/cli.d.ts
@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation, CommandScope } from '../../../command-builder/command-module';
+export declare class CacheDisableModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    aliases: string;
+    describe: string;
+    longDescriptionPath: string | undefined;
+    scope: CommandScope;
+    builder(localYargs: Argv): Argv;
+    run(): Promise<void>;
+}
+export declare class CacheEnableModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    aliases: string;
+    describe: string;
+    longDescriptionPath: string | undefined;
+    scope: CommandScope;
+    builder(localYargs: Argv): Argv;
+    run(): Promise<void>;
+}
--- a/node_modules/@angular/cli/src/commands/cache/settings/cli.js
+++ b/node_modules/@angular/cli/src/commands/cache/settings/cli.js
@ -0,0 +1,40 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheEnableModule = exports.CacheDisableModule = void 0;
+const command_module_1 = require("../../../command-builder/command-module");
+const utilities_1 = require("../utilities");
+class CacheDisableModule extends command_module_1.CommandModule {
+    command = 'disable';
+    aliases = 'off';
+    describe = 'Disables persistent disk cache for all projects in the workspace.';
+    longDescriptionPath;
+    scope = command_module_1.CommandScope.In;
+    builder(localYargs) {
+        return localYargs;
+    }
+    run() {
+        return (0, utilities_1.updateCacheConfig)(this.getWorkspaceOrThrow(), 'enabled', false);
+    }
+}
+exports.CacheDisableModule = CacheDisableModule;
+class CacheEnableModule extends command_module_1.CommandModule {
+    command = 'enable';
+    aliases = 'on';
+    describe = 'Enables disk cache for all projects in the workspace.';
+    longDescriptionPath;
+    scope = command_module_1.CommandScope.In;
+    builder(localYargs) {
+        return localYargs;
+    }
+    run() {
+        return (0, utilities_1.updateCacheConfig)(this.getWorkspaceOrThrow(), 'enabled', true);
+    }
+}
+exports.CacheEnableModule = CacheEnableModule;
--- a/node_modules/@angular/cli/src/commands/cache/utilities.d.ts
+++ b/node_modules/@angular/cli/src/commands/cache/utilities.d.ts
@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Cache } from '../../../lib/config/workspace-schema';
+import { AngularWorkspace } from '../../utilities/config';
+export declare function updateCacheConfig<K extends keyof Cache>(workspace: AngularWorkspace, key: K, value: Cache[K]): Promise<void>;
+export declare function getCacheConfig(workspace: AngularWorkspace | undefined): Required<Cache>;
--- a/node_modules/@angular/cli/src/commands/cache/utilities.js
+++ b/node_modules/@angular/cli/src/commands/cache/utilities.js
@ -0,0 +1,46 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCacheConfig = updateCacheConfig;
+exports.getCacheConfig = getCacheConfig;
+const core_1 = require("@angular-devkit/core");
+const path_1 = require("path");
+const workspace_schema_1 = require("../../../lib/config/workspace-schema");
+function updateCacheConfig(workspace, key, value) {
+    const cli = (workspace.extensions['cli'] ??= {});
+    const cache = (cli['cache'] ??= {});
+    cache[key] = value;
+    return workspace.save();
+}
+function getCacheConfig(workspace) {
+    if (!workspace) {
+        throw new Error(`Cannot retrieve cache configuration as workspace is not defined.`);
+    }
+    const defaultSettings = {
+        path: (0, path_1.resolve)(workspace.basePath, '.angular/cache'),
+        environment: workspace_schema_1.Environment.Local,
+        enabled: true,
+    };
+    const cliSetting = workspace.extensions['cli'];
+    if (!cliSetting || !(0, core_1.isJsonObject)(cliSetting)) {
+        return defaultSettings;
+    }
+    const cacheSettings = cliSetting['cache'];
+    if (!(0, core_1.isJsonObject)(cacheSettings)) {
+        return defaultSettings;
+    }
+    const { path = defaultSettings.path, environment = defaultSettings.environment, enabled = defaultSettings.enabled,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+     } = cacheSettings;
+    return {
+        path: (0, path_1.resolve)(workspace.basePath, path),
+        environment,
+        enabled,
+    };
+}
--- a/node_modules/@angular/cli/src/commands/command-config.d.ts
+++ b/node_modules/@angular/cli/src/commands/command-config.d.ts
@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { CommandModuleConstructor } from '../command-builder/utilities/command';
+export type CommandNames = 'add' | 'analytics' | 'build' | 'cache' | 'completion' | 'config' | 'deploy' | 'e2e' | 'extract-i18n' | 'generate' | 'lint' | 'make-this-awesome' | 'new' | 'run' | 'serve' | 'test' | 'update' | 'version';
+export interface CommandConfig {
+    aliases?: string[];
+    factory: () => Promise<{
+        default: CommandModuleConstructor;
+    }>;
+}
+export declare const RootCommands: Record<CommandNames & string, CommandConfig>;
+export declare const RootCommandsAliases: Record<string, CommandConfig>;
--- a/node_modules/@angular/cli/src/commands/command-config.js
+++ b/node_modules/@angular/cli/src/commands/command-config.js
@ -0,0 +1,102 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootCommandsAliases = exports.RootCommands = void 0;
+exports.RootCommands = {
+    'add': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./add/cli'))),
+    },
+    'analytics': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./analytics/cli'))),
+    },
+    'build': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./build/cli'))),
+        aliases: ['b'],
+    },
+    'cache': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./cache/cli'))),
+    },
+    'completion': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./completion/cli'))),
+    },
+    'config': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./config/cli'))),
+    },
+    'deploy': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./deploy/cli'))),
+    },
+    'e2e': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./e2e/cli'))),
+        aliases: ['e'],
+    },
+    'extract-i18n': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./extract-i18n/cli'))),
+    },
+    'generate': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./generate/cli'))),
+        aliases: ['g'],
+    },
+    'lint': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./lint/cli'))),
+    },
+    'make-this-awesome': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./make-this-awesome/cli'))),
+    },
+    'new': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./new/cli'))),
+        aliases: ['n'],
+    },
+    'run': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./run/cli'))),
+    },
+    'serve': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./serve/cli'))),
+        aliases: ['dev', 's'],
+    },
+    'test': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./test/cli'))),
+        aliases: ['t'],
+    },
+    'update': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./update/cli'))),
+    },
+    'version': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./version/cli'))),
+        aliases: ['v'],
+    },
+};
+exports.RootCommandsAliases = Object.values(exports.RootCommands).reduce((prev, current) => {
+    current.aliases?.forEach((alias) => {
+        prev[alias] = current;
+    });
+    return prev;
+}, {});
--- a/node_modules/@angular/cli/src/commands/completion/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/completion/cli.d.ts
@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation } from '../../command-builder/command-module';
+export default class CompletionCommandModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    builder(localYargs: Argv): Argv;
+    run(): Promise<number>;
+}
--- a/node_modules/@angular/cli/src/commands/completion/cli.js
+++ b/node_modules/@angular/cli/src/commands/completion/cli.js
@ -0,0 +1,63 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const yargs_1 = __importDefault(require("yargs"));
+const command_module_1 = require("../../command-builder/command-module");
+const command_1 = require("../../command-builder/utilities/command");
+const color_1 = require("../../utilities/color");
+const completion_1 = require("../../utilities/completion");
+const error_1 = require("../../utilities/error");
+class CompletionCommandModule extends command_module_1.CommandModule {
+    command = 'completion';
+    describe = 'Set up Angular CLI autocompletion for your terminal.';
+    longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    builder(localYargs) {
+        return (0, command_1.addCommandModuleToYargs)(localYargs, CompletionScriptCommandModule, this.context);
+    }
+    async run() {
+        let rcFile;
+        try {
+            rcFile = await (0, completion_1.initializeAutocomplete)();
+        }
+        catch (err) {
+            (0, error_1.assertIsError)(err);
+            this.context.logger.error(err.message);
+            return 1;
+        }
+        this.context.logger.info(`
+Appended \`source <(ng completion script)\` to \`${rcFile}\`. Restart your terminal or run the following to autocomplete \`ng\` commands:
+
+    ${color_1.colors.yellow('source <(ng completion script)')}
+      `.trim());
+        if ((await (0, completion_1.hasGlobalCliInstall)()) === false) {
+            this.context.logger.warn('Setup completed successfully, but there does not seem to be a global install of the' +
+                ' Angular CLI. For autocompletion to work, the CLI will need to be on your `$PATH`, which' +
+                ' is typically done with the `-g` flag in `npm install -g @angular/cli`.' +
+                '\n\n' +
+                'For more information, see https://angular.dev/cli/completion#global-install');
+        }
+        return 0;
+    }
+}
+exports.default = CompletionCommandModule;
+class CompletionScriptCommandModule extends command_module_1.CommandModule {
+    command = 'script';
+    describe = 'Generate a bash and zsh real-time type-ahead autocompletion script.';
+    longDescriptionPath = undefined;
+    builder(localYargs) {
+        return localYargs;
+    }
+    run() {
+        yargs_1.default.showCompletionScript();
+    }
+}
--- a/node_modules/@angular/cli/src/commands/completion/long-description.md
+++ b/node_modules/@angular/cli/src/commands/completion/long-description.md
@ -0,0 +1,67 @@
+Setting up autocompletion configures your terminal, so pressing the `<TAB>` key while in the middle
+of typing will display various commands and options available to you. This makes it very easy to
+discover and use CLI commands without lots of memorization.
+
+![A demo of Angular CLI autocompletion in a terminal. The user types several partial `ng` commands,
+using autocompletion to finish several arguments and list contextual options.
+](assets/images/guide/cli/completion.gif)
+
+## Automated setup
+
+The CLI should prompt and ask to set up autocompletion for you the first time you use it (v14+).
+Simply answer "Yes" and the CLI will take care of the rest.
+
+```
+$ ng serve
+? Would you like to enable autocompletion? This will set up your terminal so pressing TAB while typing Angular CLI commands will show possible options and autocomplete arguments. (Enabling autocompletion will modify configuration files in your home directory.) Yes
+Appended `source <(ng completion script)` to `/home/my-username/.bashrc`. Restart your terminal or run:
+
+source <(ng completion script)
+
+to autocomplete `ng` commands.
+
+# Serve output...
+```
+
+If you already refused the prompt, it won't ask again. But you can run `ng completion` to
+do the same thing automatically.
+
+This modifies your terminal environment to load Angular CLI autocompletion, but can't update your
+current terminal session. Either restart it or run `source <(ng completion script)` directly to
+enable autocompletion in your current session.
+
+Test it out by typing `ng ser<TAB>` and it should autocomplete to `ng serve`. Ambiguous arguments
+will show all possible options and their documentation, such as `ng generate <TAB>`.
+
+## Manual setup
+
+Some users may have highly customized terminal setups, possibly with configuration files checked
+into source control with an opinionated structure. `ng completion` only ever appends Angular's setup
+to an existing configuration file for your current shell, or creates one if none exists. If you want
+more control over exactly where this configuration lives, you can manually set it up by having your
+shell run at startup:
+
+```bash
+source <(ng completion script)
+```
+
+This is equivalent to what `ng completion` will automatically set up, and gives power users more
+flexibility in their environments when desired.
+
+## Platform support
+
+Angular CLI supports autocompletion for the Bash and Zsh shells on MacOS and Linux operating
+systems. On Windows, Git Bash and [Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/)
+using Bash or Zsh are supported.
+
+## Global install
+
+Autocompletion works by configuring your terminal to invoke the Angular CLI on startup to load the
+setup script. This means the terminal must be able to find and execute the Angular CLI, typically
+through a global install that places the binary on the user's `$PATH`. If you get
+`command not found: ng`, make sure the CLI is installed globally which you can do with the `-g`
+flag:
+
+```bash
+npm install -g @angular/cli
+```
--- a/node_modules/@angular/cli/src/commands/config/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/config/cli.d.ts
@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation, Options } from '../../command-builder/command-module';
+interface ConfigCommandArgs {
+    'json-path'?: string;
+    value?: string;
+    global?: boolean;
+}
+export default class ConfigCommandModule extends CommandModule<ConfigCommandArgs> implements CommandModuleImplementation<ConfigCommandArgs> {
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    builder(localYargs: Argv): Argv<ConfigCommandArgs>;
+    run(options: Options<ConfigCommandArgs>): Promise<number | void>;
+    private get;
+    private set;
+}
+export {};
--- a/node_modules/@angular/cli/src/commands/config/cli.js
+++ b/node_modules/@angular/cli/src/commands/config/cli.js
@ -0,0 +1,149 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const path_1 = require("path");
+const command_module_1 = require("../../command-builder/command-module");
+const config_1 = require("../../utilities/config");
+const json_file_1 = require("../../utilities/json-file");
+class ConfigCommandModule extends command_module_1.CommandModule {
+    command = 'config [json-path] [value]';
+    describe = 'Retrieves or sets Angular configuration values in the angular.json file for the workspace.';
+    longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    builder(localYargs) {
+        return localYargs
+            .positional('json-path', {
+            description: `The configuration key to set or query, in JSON path format. ` +
+                `For example: "a[3].foo.bar[2]". If no new value is provided, returns the current value of this key.`,
+            type: 'string',
+        })
+            .positional('value', {
+            description: 'If provided, a new value for the given configuration key.',
+            type: 'string',
+        })
+            .option('global', {
+            description: `Access the global configuration in the caller's home directory.`,
+            alias: ['g'],
+            type: 'boolean',
+            default: false,
+        })
+            .strict();
+    }
+    async run(options) {
+        const level = options.global ? 'global' : 'local';
+        const [config] = await (0, config_1.getWorkspaceRaw)(level);
+        if (options.value == undefined) {
+            if (!config) {
+                this.context.logger.error('No config found.');
+                return 1;
+            }
+            return this.get(config, options);
+        }
+        else {
+            return this.set(options);
+        }
+    }
+    get(jsonFile, options) {
+        const { logger } = this.context;
+        const value = options.jsonPath
+            ? jsonFile.get(parseJsonPath(options.jsonPath))
+            : jsonFile.content;
+        if (value === undefined) {
+            logger.error('Value cannot be found.');
+            return 1;
+        }
+        else if (typeof value === 'string') {
+            logger.info(value);
+        }
+        else {
+            logger.info(JSON.stringify(value, null, 2));
+        }
+        return 0;
+    }
+    async set(options) {
+        if (!options.jsonPath?.trim()) {
+            throw new command_module_1.CommandModuleError('Invalid Path.');
+        }
+        const [config, configPath] = await (0, config_1.getWorkspaceRaw)(options.global ? 'global' : 'local');
+        const { logger } = this.context;
+        if (!config || !configPath) {
+            throw new command_module_1.CommandModuleError('Confguration file cannot be found.');
+        }
+        const normalizeUUIDValue = (v) => (v === '' ? (0, crypto_1.randomUUID)() : `${v}`);
+        const value = options.jsonPath === 'cli.analyticsSharing.uuid'
+            ? normalizeUUIDValue(options.value)
+            : options.value;
+        const modified = config.modify(parseJsonPath(options.jsonPath), normalizeValue(value));
+        if (!modified) {
+            logger.error('Value cannot be found.');
+            return 1;
+        }
+        await (0, config_1.validateWorkspace)((0, json_file_1.parseJson)(config.content), options.global ?? false);
+        config.save();
+        return 0;
+    }
+}
+exports.default = ConfigCommandModule;
+/**
+ * Splits a JSON path string into fragments. Fragments can be used to get the value referenced
+ * by the path. For example, a path of "a[3].foo.bar[2]" would give you a fragment array of
+ * ["a", 3, "foo", "bar", 2].
+ * @param path The JSON string to parse.
+ * @returns {(string|number)[]} The fragments for the string.
+ * @private
+ */
+function parseJsonPath(path) {
+    const fragments = (path || '').split(/\./g);
+    const result = [];
+    while (fragments.length > 0) {
+        const fragment = fragments.shift();
+        if (fragment == undefined) {
+            break;
+        }
+        const match = fragment.match(/([^[]+)((\[.*\])*)/);
+        if (!match) {
+            throw new command_module_1.CommandModuleError('Invalid JSON path.');
+        }
+        result.push(match[1]);
+        if (match[2]) {
+            const indices = match[2]
+                .slice(1, -1)
+                .split('][')
+                .map((x) => (/^\d$/.test(x) ? +x : x.replace(/"|'/g, '')));
+            result.push(...indices);
+        }
+    }
+    return result.filter((fragment) => fragment != null);
+}
+function normalizeValue(value) {
+    const valueString = `${value}`.trim();
+    switch (valueString) {
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        case 'null':
+            return null;
+        case 'undefined':
+            return undefined;
+    }
+    if (isFinite(+valueString)) {
+        return +valueString;
+    }
+    try {
+        // We use `JSON.parse` instead of `parseJson` because the latter will parse UUIDs
+        // and convert them into a numberic entities.
+        // Example: 73b61974-182c-48e4-b4c6-30ddf08c5c98 -> 73.
+        // These values should never contain comments, therefore using `JSON.parse` is safe.
+        return JSON.parse(valueString);
+    }
+    catch {
+        return value;
+    }
+}
--- a/node_modules/@angular/cli/src/commands/config/long-description.md
+++ b/node_modules/@angular/cli/src/commands/config/long-description.md
@ -0,0 +1,13 @@
+A workspace has a single CLI configuration file, `angular.json`, at the top level.
+The `projects` object contains a configuration object for each project in the workspace.
+
+You can edit the configuration directly in a code editor,
+or indirectly on the command line using this command.
+
+The configurable property names match command option names,
+except that in the configuration file, all names must use camelCase,
+while on the command line options can be given dash-case.
+
+For further details, see [Workspace Configuration](reference/configs/workspace-config).
+
+For configuration of CLI usage analytics, see [ng analytics](cli/analytics).
--- a/node_modules/@angular/cli/src/commands/deploy/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/deploy/cli.d.ts
@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { MissingTargetChoice } from '../../command-builder/architect-base-command-module';
+import { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export default class DeployCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    missingTargetChoices: MissingTargetChoice[];
+    multiTarget: boolean;
+    command: string;
+    longDescriptionPath: string;
+    describe: string;
+}
--- a/node_modules/@angular/cli/src/commands/deploy/cli.js
+++ b/node_modules/@angular/cli/src/commands/deploy/cli.js
@ -0,0 +1,37 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+class DeployCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    // The below choices should be kept in sync with the list in https://angular.dev/tools/cli/deployment
+    missingTargetChoices = [
+        {
+            name: 'Amazon S3',
+            value: '@jefiozie/ngx-aws-deploy',
+        },
+        {
+            name: 'Firebase',
+            value: '@angular/fire',
+        },
+        {
+            name: 'Netlify',
+            value: '@netlify-builder/deploy',
+        },
+        {
+            name: 'GitHub Pages',
+            value: 'angular-cli-ghpages',
+        },
+    ];
+    multiTarget = false;
+    command = 'deploy [project]';
+    longDescriptionPath = (0, node_path_1.join)(__dirname, 'long-description.md');
+    describe = 'Invokes the deploy builder for a specified project or for the default project in the workspace.';
+}
+exports.default = DeployCommandModule;
--- a/node_modules/@angular/cli/src/commands/deploy/long-description.md
+++ b/node_modules/@angular/cli/src/commands/deploy/long-description.md
@ -0,0 +1,22 @@
+The command takes an optional project name, as specified in the `projects` section of the `angular.json` workspace configuration file.
+When a project name is not supplied, executes the `deploy` builder for the default project.
+
+To use the `ng deploy` command, use `ng add` to add a package that implements deployment capabilities to your favorite platform.
+Adding the package automatically updates your workspace configuration, adding a deployment
+[CLI builder](tools/cli/cli-builder).
+For example:
+
+```json
+"projects": {
+  "my-project": {
+    ...
+    "architect": {
+      ...
+      "deploy": {
+        "builder": "@angular/fire:deploy",
+        "options": {}
+      }
+    }
+  }
+}
+```
--- a/node_modules/@angular/cli/src/commands/e2e/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/e2e/cli.d.ts
@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { MissingTargetChoice } from '../../command-builder/architect-base-command-module';
+import { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export default class E2eCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    missingTargetChoices: MissingTargetChoice[];
+    multiTarget: boolean;
+    command: string;
+    aliases: string[] | undefined;
+    describe: string;
+    longDescriptionPath?: string;
+}
--- a/node_modules/@angular/cli/src/commands/e2e/cli.js
+++ b/node_modules/@angular/cli/src/commands/e2e/cli.js
@ -0,0 +1,41 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+const command_config_1 = require("../command-config");
+class E2eCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    missingTargetChoices = [
+        {
+            name: 'Playwright',
+            value: 'playwright-ng-schematics',
+        },
+        {
+            name: 'Cypress',
+            value: '@cypress/schematic',
+        },
+        {
+            name: 'Nightwatch',
+            value: '@nightwatch/schematics',
+        },
+        {
+            name: 'WebdriverIO',
+            value: '@wdio/schematics',
+        },
+        {
+            name: 'Puppeteer',
+            value: '@puppeteer/ng-schematics',
+        },
+    ];
+    multiTarget = true;
+    command = 'e2e [project]';
+    aliases = command_config_1.RootCommands['e2e'].aliases;
+    describe = 'Builds and serves an Angular application, then runs end-to-end tests.';
+    longDescriptionPath;
+}
+exports.default = E2eCommandModule;
--- a/node_modules/@angular/cli/src/commands/extract-i18n/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/extract-i18n/cli.d.ts
@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { workspaces } from '@angular-devkit/core';
+import { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export default class ExtractI18nCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    multiTarget: boolean;
+    command: string;
+    describe: string;
+    longDescriptionPath?: string | undefined;
+    findDefaultBuilderName(project: workspaces.ProjectDefinition): Promise<string | undefined>;
+}
--- a/node_modules/@angular/cli/src/commands/extract-i18n/cli.js
+++ b/node_modules/@angular/cli/src/commands/extract-i18n/cli.js
@ -0,0 +1,47 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+class ExtractI18nCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    multiTarget = false;
+    command = 'extract-i18n [project]';
+    describe = 'Extracts i18n messages from source code.';
+    longDescriptionPath;
+    async findDefaultBuilderName(project) {
+        // Only application type projects have a default i18n extraction target
+        if (project.extensions['projectType'] !== 'application') {
+            return;
+        }
+        const buildTarget = project.targets.get('build');
+        if (!buildTarget) {
+            // No default if there is no build target
+            return;
+        }
+        // Provide a default based on the defined builder for the 'build' target
+        switch (buildTarget.builder) {
+            case '@angular-devkit/build-angular:application':
+            case '@angular-devkit/build-angular:browser-esbuild':
+            case '@angular-devkit/build-angular:browser':
+                return '@angular-devkit/build-angular:extract-i18n';
+            case '@angular/build:application':
+                return '@angular/build:extract-i18n';
+        }
+        // For other builders, check for `@angular-devkit/build-angular` and use if found.
+        // This package is safer to use since it supports both application builder types.
+        try {
+            const projectRequire = (0, node_module_1.createRequire)((0, node_path_1.join)(this.context.root, project.root) + '/');
+            projectRequire.resolve('@angular-devkit/build-angular');
+            return '@angular-devkit/build-angular:extract-i18n';
+        }
+        catch { }
+    }
+}
+exports.default = ExtractI18nCommandModule;
--- a/node_modules/@angular/cli/src/commands/generate/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/generate/cli.d.ts
@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModuleImplementation, Options, OtherOptions } from '../../command-builder/command-module';
+import { SchematicsCommandArgs, SchematicsCommandModule } from '../../command-builder/schematics-command-module';
+interface GenerateCommandArgs extends SchematicsCommandArgs {
+    schematic?: string;
+}
+export default class GenerateCommandModule extends SchematicsCommandModule implements CommandModuleImplementation<GenerateCommandArgs> {
+    command: string;
+    aliases: string[] | undefined;
+    describe: string;
+    longDescriptionPath?: string | undefined;
+    builder(argv: Argv): Promise<Argv<GenerateCommandArgs>>;
+    run(options: Options<GenerateCommandArgs> & OtherOptions): Promise<number | void>;
+    private getCollectionNames;
+    private shouldAddCollectionNameAsPartOfCommand;
+    /**
+     * Generate an aliases string array to be passed to the command builder.
+     *
+     * @example `[component]` or `[@schematics/angular:component]`.
+     */
+    private generateCommandAliasesStrings;
+    /**
+     * Generate a command string to be passed to the command builder.
+     *
+     * @example `component [name]` or `@schematics/angular:component [name]`.
+     */
+    private generateCommandString;
+    /**
+     * Get schematics that can to be registered as subcommands.
+     */
+    private getSchematics;
+    private listSchematicAliases;
+    /**
+     * Get schematics that should to be registered as subcommands.
+     *
+     * @returns a sorted list of schematic that needs to be registered as subcommands.
+     */
+    private getSchematicsToRegister;
+}
+export {};
--- a/node_modules/@angular/cli/src/commands/generate/cli.js
+++ b/node_modules/@angular/cli/src/commands/generate/cli.js
@ -0,0 +1,188 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@angular-devkit/core");
+const command_module_1 = require("../../command-builder/command-module");
+const schematics_command_module_1 = require("../../command-builder/schematics-command-module");
+const command_1 = require("../../command-builder/utilities/command");
+const command_config_1 = require("../command-config");
+class GenerateCommandModule extends schematics_command_module_1.SchematicsCommandModule {
+    command = 'generate';
+    aliases = command_config_1.RootCommands['generate'].aliases;
+    describe = 'Generates and/or modifies files based on a schematic.';
+    longDescriptionPath;
+    async builder(argv) {
+        let localYargs = (await super.builder(argv)).command({
+            command: '$0 <schematic>',
+            describe: 'Run the provided schematic.',
+            builder: (localYargs) => localYargs
+                .positional('schematic', {
+                describe: 'The [collection:schematic] to run.',
+                type: 'string',
+                demandOption: true,
+            })
+                .strict(),
+            handler: (options) => this.handler(options),
+        });
+        for (const [schematicName, collectionName] of await this.getSchematicsToRegister()) {
+            const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
+            const collection = workflow.engine.createCollection(collectionName);
+            const { description: { schemaJson, aliases: schematicAliases, hidden: schematicHidden, description: schematicDescription, }, } = collection.createSchematic(schematicName, true);
+            if (!schemaJson) {
+                continue;
+            }
+            const { 'x-deprecated': xDeprecated, description = schematicDescription, hidden = schematicHidden, } = schemaJson;
+            const options = await this.getSchematicOptions(collection, schematicName, workflow);
+            localYargs = localYargs.command({
+                command: await this.generateCommandString(collectionName, schematicName, options),
+                // When 'describe' is set to false, it results in a hidden command.
+                describe: hidden === true ? false : typeof description === 'string' ? description : '',
+                deprecated: xDeprecated === true || typeof xDeprecated === 'string' ? xDeprecated : false,
+                aliases: Array.isArray(schematicAliases)
+                    ? await this.generateCommandAliasesStrings(collectionName, schematicAliases)
+                    : undefined,
+                builder: (localYargs) => this.addSchemaOptionsToCommand(localYargs, options).strict(),
+                handler: (options) => this.handler({
+                    ...options,
+                    schematic: `${collectionName}:${schematicName}`,
+                }),
+            });
+        }
+        return localYargs.demandCommand(1, command_1.demandCommandFailureMessage);
+    }
+    async run(options) {
+        const { dryRun, schematic, defaults, force, interactive, ...schematicOptions } = options;
+        const [collectionName, schematicName] = this.parseSchematicInfo(schematic);
+        if (!collectionName || !schematicName) {
+            throw new command_module_1.CommandModuleError('A collection and schematic is required during execution.');
+        }
+        return this.runSchematic({
+            collectionName,
+            schematicName,
+            schematicOptions,
+            executionOptions: {
+                dryRun,
+                defaults,
+                force,
+                interactive,
+            },
+        });
+    }
+    async getCollectionNames() {
+        const [collectionName] = this.parseSchematicInfo(
+        // positional = [generate, component] or [generate]
+        this.context.args.positional[1]);
+        return collectionName ? [collectionName] : [...(await this.getSchematicCollections())];
+    }
+    async shouldAddCollectionNameAsPartOfCommand() {
+        const [collectionNameFromArgs] = this.parseSchematicInfo(
+        // positional = [generate, component] or [generate]
+        this.context.args.positional[1]);
+        const schematicCollectionsFromConfig = await this.getSchematicCollections();
+        const collectionNames = await this.getCollectionNames();
+        // Only add the collection name as part of the command when it's not a known
+        // schematics collection or when it has been provided via the CLI.
+        // Ex:`ng generate @schematics/angular:c`
+        return (!!collectionNameFromArgs ||
+            !collectionNames.some((c) => schematicCollectionsFromConfig.has(c)));
+    }
+    /**
+     * Generate an aliases string array to be passed to the command builder.
+     *
+     * @example `[component]` or `[@schematics/angular:component]`.
+     */
+    async generateCommandAliasesStrings(collectionName, schematicAliases) {
+        // Only add the collection name as part of the command when it's not a known
+        // schematics collection or when it has been provided via the CLI.
+        // Ex:`ng generate @schematics/angular:c`
+        return (await this.shouldAddCollectionNameAsPartOfCommand())
+            ? schematicAliases.map((alias) => `${collectionName}:${alias}`)
+            : schematicAliases;
+    }
+    /**
+     * Generate a command string to be passed to the command builder.
+     *
+     * @example `component [name]` or `@schematics/angular:component [name]`.
+     */
+    async generateCommandString(collectionName, schematicName, options) {
+        const dasherizedSchematicName = core_1.strings.dasherize(schematicName);
+        // Only add the collection name as part of the command when it's not a known
+        // schematics collection or when it has been provided via the CLI.
+        // Ex:`ng generate @schematics/angular:component`
+        const commandName = (await this.shouldAddCollectionNameAsPartOfCommand())
+            ? collectionName + ':' + dasherizedSchematicName
+            : dasherizedSchematicName;
+        const positionalArgs = options
+            .filter((o) => o.positional !== undefined)
+            .map((o) => {
+            const label = `${core_1.strings.dasherize(o.name)}${o.type === 'array' ? ' ..' : ''}`;
+            return o.required ? `<${label}>` : `[${label}]`;
+        })
+            .join(' ');
+        return `${commandName}${positionalArgs ? ' ' + positionalArgs : ''}`;
+    }
+    /**
+     * Get schematics that can to be registered as subcommands.
+     */
+    async *getSchematics() {
+        const seenNames = new Set();
+        for (const collectionName of await this.getCollectionNames()) {
+            const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
+            const collection = workflow.engine.createCollection(collectionName);
+            for (const schematicName of collection.listSchematicNames(true /** includeHidden */)) {
+                // If a schematic with this same name is already registered skip.
+                if (!seenNames.has(schematicName)) {
+                    seenNames.add(schematicName);
+                    yield {
+                        schematicName,
+                        collectionName,
+                        schematicAliases: this.listSchematicAliases(collection, schematicName),
+                    };
+                }
+            }
+        }
+    }
+    listSchematicAliases(collection, schematicName) {
+        const description = collection.description.schematics[schematicName];
+        if (description) {
+            return description.aliases && new Set(description.aliases);
+        }
+        // Extended collections
+        if (collection.baseDescriptions) {
+            for (const base of collection.baseDescriptions) {
+                const description = base.schematics[schematicName];
+                if (description) {
+                    return description.aliases && new Set(description.aliases);
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get schematics that should to be registered as subcommands.
+     *
+     * @returns a sorted list of schematic that needs to be registered as subcommands.
+     */
+    async getSchematicsToRegister() {
+        const schematicsToRegister = [];
+        const [, schematicNameFromArgs] = this.parseSchematicInfo(
+        // positional = [generate, component] or [generate]
+        this.context.args.positional[1]);
+        for await (const { schematicName, collectionName, schematicAliases } of this.getSchematics()) {
+            if (schematicNameFromArgs &&
+                (schematicName === schematicNameFromArgs || schematicAliases?.has(schematicNameFromArgs))) {
+                return [[schematicName, collectionName]];
+            }
+            schematicsToRegister.push([schematicName, collectionName]);
+        }
+        // Didn't find the schematic or no schematic name was provided Ex: `ng generate --help`.
+        return schematicsToRegister.sort(([nameA], [nameB]) => nameA.localeCompare(nameB, undefined, { sensitivity: 'accent' }));
+    }
+}
+exports.default = GenerateCommandModule;
--- a/node_modules/@angular/cli/src/commands/lint/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/lint/cli.d.ts
@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { MissingTargetChoice } from '../../command-builder/architect-base-command-module';
+import { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export default class LintCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    missingTargetChoices: MissingTargetChoice[];
+    multiTarget: boolean;
+    command: string;
+    longDescriptionPath: string;
+    describe: string;
+}
--- a/node_modules/@angular/cli/src/commands/lint/cli.js
+++ b/node_modules/@angular/cli/src/commands/lint/cli.js
@ -0,0 +1,24 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+class LintCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    missingTargetChoices = [
+        {
+            name: 'ESLint',
+            value: '@angular-eslint/schematics',
+        },
+    ];
+    multiTarget = true;
+    command = 'lint [project]';
+    longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    describe = 'Runs linting tools on Angular application code in a given project folder.';
+}
+exports.default = LintCommandModule;
--- a/node_modules/@angular/cli/src/commands/lint/long-description.md
+++ b/node_modules/@angular/cli/src/commands/lint/long-description.md
@ -0,0 +1,20 @@
+The command takes an optional project name, as specified in the `projects` section of the `angular.json` workspace configuration file.
+When a project name is not supplied, executes the `lint` builder for all projects.
+
+To use the `ng lint` command, use `ng add` to add a package that implements linting capabilities. Adding the package automatically updates your workspace configuration, adding a lint [CLI builder](tools/cli/cli-builder).
+For example:
+
+```json
+"projects": {
+  "my-project": {
+    ...
+    "architect": {
+      ...
+      "lint": {
+        "builder": "@angular-eslint/builder:lint",
+        "options": {}
+      }
+    }
+  }
+}
+```
--- a/node_modules/@angular/cli/src/commands/make-this-awesome/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/make-this-awesome/cli.d.ts
@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation } from '../../command-builder/command-module';
+export default class AwesomeCommandModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    describe: false;
+    deprecated: boolean;
+    longDescriptionPath?: string | undefined;
+    builder(localYargs: Argv): Argv;
+    run(): void;
+}
--- a/node_modules/@angular/cli/src/commands/make-this-awesome/cli.js
+++ b/node_modules/@angular/cli/src/commands/make-this-awesome/cli.js
@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_module_1 = require("../../command-builder/command-module");
+const color_1 = require("../../utilities/color");
+class AwesomeCommandModule extends command_module_1.CommandModule {
+    command = 'make-this-awesome';
+    describe = false;
+    deprecated = false;
+    longDescriptionPath;
+    builder(localYargs) {
+        return localYargs;
+    }
+    run() {
+        const pickOne = (of) => of[Math.floor(Math.random() * of.length)];
+        const phrase = pickOne([
+            `You're on it, there's nothing for me to do!`,
+            `Let's take a look... nope, it's all good!`,
+            `You're doing fine.`,
+            `You're already doing great.`,
+            `Nothing to do; already awesome. Exiting.`,
+            `Error 418: As Awesome As Can Get.`,
+            `I spy with my little eye a great developer!`,
+            `Noop... already awesome.`,
+        ]);
+        this.context.logger.info(color_1.colors.green(phrase));
+    }
+}
+exports.default = AwesomeCommandModule;
--- a/node_modules/@angular/cli/src/commands/new/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/new/cli.d.ts
@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModuleImplementation, CommandScope, Options, OtherOptions } from '../../command-builder/command-module';
+import { SchematicsCommandArgs, SchematicsCommandModule } from '../../command-builder/schematics-command-module';
+interface NewCommandArgs extends SchematicsCommandArgs {
+    collection?: string;
+}
+export default class NewCommandModule extends SchematicsCommandModule implements CommandModuleImplementation<NewCommandArgs> {
+    private readonly schematicName;
+    scope: CommandScope;
+    protected allowPrivateSchematics: boolean;
+    command: string;
+    aliases: string[] | undefined;
+    describe: string;
+    longDescriptionPath: string;
+    builder(argv: Argv): Promise<Argv<NewCommandArgs>>;
+    run(options: Options<NewCommandArgs> & OtherOptions): Promise<number | void>;
+    /** Find a collection from config that has an `ng-new` schematic. */
+    private getCollectionFromConfig;
+}
+export {};
--- a/node_modules/@angular/cli/src/commands/new/cli.js
+++ b/node_modules/@angular/cli/src/commands/new/cli.js
@ -0,0 +1,74 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const command_module_1 = require("../../command-builder/command-module");
+const schematics_command_module_1 = require("../../command-builder/schematics-command-module");
+const version_1 = require("../../utilities/version");
+const command_config_1 = require("../command-config");
+class NewCommandModule extends schematics_command_module_1.SchematicsCommandModule {
+    schematicName = 'ng-new';
+    scope = command_module_1.CommandScope.Out;
+    allowPrivateSchematics = true;
+    command = 'new [name]';
+    aliases = command_config_1.RootCommands['new'].aliases;
+    describe = 'Creates a new Angular workspace.';
+    longDescriptionPath = (0, node_path_1.join)(__dirname, 'long-description.md');
+    async builder(argv) {
+        const localYargs = (await super.builder(argv)).option('collection', {
+            alias: 'c',
+            describe: 'A collection of schematics to use in generating the initial application.',
+            type: 'string',
+        });
+        const { options: { collection: collectionNameFromArgs }, } = this.context.args;
+        const collectionName = typeof collectionNameFromArgs === 'string'
+            ? collectionNameFromArgs
+            : await this.getCollectionFromConfig();
+        const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
+        const collection = workflow.engine.createCollection(collectionName);
+        const options = await this.getSchematicOptions(collection, this.schematicName, workflow);
+        return this.addSchemaOptionsToCommand(localYargs, options);
+    }
+    async run(options) {
+        // Register the version of the CLI in the registry.
+        const collectionName = options.collection ?? (await this.getCollectionFromConfig());
+        const { dryRun, force, interactive, defaults, collection, ...schematicOptions } = options;
+        const workflow = await this.getOrCreateWorkflowForExecution(collectionName, {
+            dryRun,
+            force,
+            interactive,
+            defaults,
+        });
+        workflow.registry.addSmartDefaultProvider('ng-cli-version', () => version_1.VERSION.full);
+        return this.runSchematic({
+            collectionName,
+            schematicName: this.schematicName,
+            schematicOptions,
+            executionOptions: {
+                dryRun,
+                force,
+                interactive,
+                defaults,
+            },
+        });
+    }
+    /** Find a collection from config that has an `ng-new` schematic. */
+    async getCollectionFromConfig() {
+        for (const collectionName of await this.getSchematicCollections()) {
+            const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
+            const collection = workflow.engine.createCollection(collectionName);
+            const schematicsInCollection = collection.description.schematics;
+            if (Object.keys(schematicsInCollection).includes(this.schematicName)) {
+                return collectionName;
+            }
+        }
+        return schematics_command_module_1.DEFAULT_SCHEMATICS_COLLECTION;
+    }
+}
+exports.default = NewCommandModule;
--- a/node_modules/@angular/cli/src/commands/new/long-description.md
+++ b/node_modules/@angular/cli/src/commands/new/long-description.md
@ -0,0 +1,15 @@
+Creates and initializes a new Angular application that is the default project for a new workspace.
+
+Provides interactive prompts for optional configuration, such as adding routing support.
+All prompts can safely be allowed to default.
+
+- The new workspace folder is given the specified project name, and contains configuration files at the top level.
+
+- By default, the files for a new initial application (with the same name as the workspace) are placed in the `src/` subfolder.
+- The new application's configuration appears in the `projects` section of the `angular.json` workspace configuration file, under its project name.
+
+- Subsequent applications that you generate in the workspace reside in the `projects/` subfolder.
+
+If you plan to have multiple applications in the workspace, you can create an empty workspace by using the `--no-create-application` option.
+You can then use `ng generate application` to create an initial application.
+This allows a workspace name different from the initial app name, and ensures that all applications reside in the `/projects` subfolder, matching the structure of the configuration file.
--- a/node_modules/@angular/cli/src/commands/run/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/run/cli.d.ts
@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Target } from '@angular-devkit/architect';
+import { Argv } from 'yargs';
+import { ArchitectBaseCommandModule } from '../../command-builder/architect-base-command-module';
+import { CommandModuleImplementation, CommandScope, Options, OtherOptions } from '../../command-builder/command-module';
+export interface RunCommandArgs {
+    target: string;
+}
+export default class RunCommandModule extends ArchitectBaseCommandModule<RunCommandArgs> implements CommandModuleImplementation<RunCommandArgs> {
+    scope: CommandScope;
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    builder(argv: Argv): Promise<Argv<RunCommandArgs>>;
+    run(options: Options<RunCommandArgs> & OtherOptions): Promise<number>;
+    protected makeTargetSpecifier(options?: Options<RunCommandArgs>): Target | undefined;
+    /** @returns a sorted list of target specifiers to be used for auto completion. */
+    private getTargetChoices;
+}
--- a/node_modules/@angular/cli/src/commands/run/cli.js
+++ b/node_modules/@angular/cli/src/commands/run/cli.js
@ -0,0 +1,88 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const architect_base_command_module_1 = require("../../command-builder/architect-base-command-module");
+const command_module_1 = require("../../command-builder/command-module");
+class RunCommandModule extends architect_base_command_module_1.ArchitectBaseCommandModule {
+    scope = command_module_1.CommandScope.In;
+    command = 'run <target>';
+    describe = 'Runs an Architect target with an optional custom builder configuration defined in your project.';
+    longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    async builder(argv) {
+        const { jsonHelp, getYargsCompletions, help } = this.context.args.options;
+        const localYargs = argv
+            .positional('target', {
+            describe: 'The Architect target to run provided in the following format `project:target[:configuration]`.',
+            type: 'string',
+            demandOption: true,
+            // Show only in when using --help and auto completion because otherwise comma seperated configuration values will be invalid.
+            // Also, hide choices from JSON help so that we don't display them in AIO.
+            choices: (getYargsCompletions || help) && !jsonHelp ? this.getTargetChoices() : undefined,
+        })
+            .middleware((args) => {
+            // TODO: remove in version 15.
+            const { configuration, target } = args;
+            if (typeof configuration === 'string' && target) {
+                const targetWithConfig = target.split(':', 2);
+                targetWithConfig.push(configuration);
+                throw new command_module_1.CommandModuleError('Unknown argument: configuration.\n' +
+                    `Provide the configuration as part of the target 'ng run ${targetWithConfig.join(':')}'.`);
+            }
+        }, true)
+            .strict();
+        const target = this.makeTargetSpecifier();
+        if (!target) {
+            return localYargs;
+        }
+        const schemaOptions = await this.getArchitectTargetOptions(target);
+        return this.addSchemaOptionsToCommand(localYargs, schemaOptions);
+    }
+    async run(options) {
+        const target = this.makeTargetSpecifier(options);
+        const { target: _target, ...extraOptions } = options;
+        if (!target) {
+            throw new command_module_1.CommandModuleError('Cannot determine project or target.');
+        }
+        return this.runSingleTarget(target, extraOptions);
+    }
+    makeTargetSpecifier(options) {
+        const architectTarget = options?.target ?? this.context.args.positional[1];
+        if (!architectTarget) {
+            return undefined;
+        }
+        const [project = '', target = '', configuration] = architectTarget.split(':');
+        return {
+            project,
+            target,
+            configuration,
+        };
+    }
+    /** @returns a sorted list of target specifiers to be used for auto completion. */
+    getTargetChoices() {
+        if (!this.context.workspace) {
+            return;
+        }
+        const targets = [];
+        for (const [projectName, project] of this.context.workspace.projects) {
+            for (const [targetName, target] of project.targets) {
+                const currentTarget = `${projectName}:${targetName}`;
+                targets.push(currentTarget);
+                if (!target.configurations) {
+                    continue;
+                }
+                for (const configName of Object.keys(target.configurations)) {
+                    targets.push(`${currentTarget}:${configName}`);
+                }
+            }
+        }
+        return targets.sort();
+    }
+}
+exports.default = RunCommandModule;
--- a/node_modules/@angular/cli/src/commands/run/long-description.md
+++ b/node_modules/@angular/cli/src/commands/run/long-description.md
@ -0,0 +1,10 @@
+Architect is the tool that the CLI uses to perform complex tasks such as compilation, according to provided configurations.
+The CLI commands run Architect targets such as `build`, `serve`, `test`, and `lint`.
+Each named target has a default configuration, specified by an `options` object,
+and an optional set of named alternate configurations in the `configurations` object.
+
+For example, the `serve` target for a newly generated app has a predefined
+alternate configuration named `production`.
+
+You can define new targets and their configuration options in the `architect` section
+of the `angular.json` file which you can run them from the command line using the `ng run` command.
--- a/node_modules/@angular/cli/src/commands/serve/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/serve/cli.d.ts
@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export default class ServeCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    multiTarget: boolean;
+    command: string;
+    aliases: string[] | undefined;
+    describe: string;
+    longDescriptionPath?: string | undefined;
+}
--- a/node_modules/@angular/cli/src/commands/serve/cli.js
+++ b/node_modules/@angular/cli/src/commands/serve/cli.js
@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+const command_config_1 = require("../command-config");
+class ServeCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    multiTarget = false;
+    command = 'serve [project]';
+    aliases = command_config_1.RootCommands['serve'].aliases;
+    describe = 'Builds and serves your application, rebuilding on file changes.';
+    longDescriptionPath;
+}
+exports.default = ServeCommandModule;
--- a/node_modules/@angular/cli/src/commands/test/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/test/cli.d.ts
@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export default class TestCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    multiTarget: boolean;
+    command: string;
+    aliases: string[] | undefined;
+    describe: string;
+    longDescriptionPath: string;
+}
--- a/node_modules/@angular/cli/src/commands/test/cli.js
+++ b/node_modules/@angular/cli/src/commands/test/cli.js
@ -0,0 +1,20 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+const command_config_1 = require("../command-config");
+class TestCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    multiTarget = true;
+    command = 'test [project]';
+    aliases = command_config_1.RootCommands['test'].aliases;
+    describe = 'Runs unit tests in a project.';
+    longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+}
+exports.default = TestCommandModule;
--- a/node_modules/@angular/cli/src/commands/test/long-description.md
+++ b/node_modules/@angular/cli/src/commands/test/long-description.md
@ -0,0 +1,2 @@
+Takes the name of the project, as specified in the `projects` section of the `angular.json` workspace configuration file.
+When a project name is not supplied, it will execute for all projects.
--- a/node_modules/@angular/cli/src/commands/update/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/update/cli.d.ts
@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandScope, Options } from '../../command-builder/command-module';
+interface UpdateCommandArgs {
+    packages?: string[];
+    force: boolean;
+    next: boolean;
+    'migrate-only'?: boolean;
+    name?: string;
+    from?: string;
+    to?: string;
+    'allow-dirty': boolean;
+    verbose: boolean;
+    'create-commits': boolean;
+}
+export default class UpdateCommandModule extends CommandModule<UpdateCommandArgs> {
+    scope: CommandScope;
+    protected shouldReportAnalytics: boolean;
+    private readonly resolvePaths;
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    builder(localYargs: Argv): Argv<UpdateCommandArgs>;
+    run(options: Options<UpdateCommandArgs>): Promise<number | void>;
+    private executeSchematic;
+    /**
+     * @return Whether or not the migration was performed successfully.
+     */
+    private executeMigration;
+    /**
+     * @return Whether or not the migrations were performed successfully.
+     */
+    private executeMigrations;
+    private executePackageMigrations;
+    private migrateOnly;
+    private updatePackagesAndMigrate;
+    /**
+     * @return Whether or not the commit was successful.
+     */
+    private commit;
+    private checkCleanGit;
+    /**
+     * Checks if the current installed CLI version is older or newer than a compatible version.
+     * @returns the version to install or null when there is no update to install.
+     */
+    private checkCLIVersion;
+    private getCLIUpdateRunnerVersion;
+    private runTempBinary;
+    private packageManagerForce;
+    private getOptionalMigrationsToRun;
+}
+export {};
--- a/node_modules/@angular/cli/src/commands/update/cli.js
+++ b/node_modules/@angular/cli/src/commands/update/cli.js
@ -0,0 +1,906 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematics_1 = require("@angular-devkit/schematics");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const listr2_1 = require("listr2");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
+const npm_pick_manifest_1 = __importDefault(require("npm-pick-manifest"));
+const path = __importStar(require("path"));
+const path_1 = require("path");
+const semver = __importStar(require("semver"));
+const workspace_schema_1 = require("../../../lib/config/workspace-schema");
+const command_module_1 = require("../../command-builder/command-module");
+const schematic_engine_host_1 = require("../../command-builder/utilities/schematic-engine-host");
+const schematic_workflow_1 = require("../../command-builder/utilities/schematic-workflow");
+const color_1 = require("../../utilities/color");
+const environment_options_1 = require("../../utilities/environment-options");
+const error_1 = require("../../utilities/error");
+const log_file_1 = require("../../utilities/log-file");
+const package_metadata_1 = require("../../utilities/package-metadata");
+const package_tree_1 = require("../../utilities/package-tree");
+const prompt_1 = require("../../utilities/prompt");
+const tty_1 = require("../../utilities/tty");
+const version_1 = require("../../utilities/version");
+class CommandError extends Error {
+}
+const ANGULAR_PACKAGES_REGEXP = /^@(?:angular|nguniversal)\//;
+const UPDATE_SCHEMATIC_COLLECTION = path.join(__dirname, 'schematic/collection.json');
+class UpdateCommandModule extends command_module_1.CommandModule {
+    scope = command_module_1.CommandScope.In;
+    shouldReportAnalytics = false;
+    resolvePaths = [__dirname, this.context.root];
+    command = 'update [packages..]';
+    describe = 'Updates your workspace and its dependencies. See https://update.angular.dev/.';
+    longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    builder(localYargs) {
+        return localYargs
+            .positional('packages', {
+            description: 'The names of package(s) to update.',
+            type: 'string',
+            array: true,
+        })
+            .option('force', {
+            description: 'Ignore peer dependency version mismatches.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('next', {
+            description: 'Use the prerelease version, including beta and RCs.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('migrate-only', {
+            description: 'Only perform a migration, do not update the installed version.',
+            type: 'boolean',
+        })
+            .option('name', {
+            description: 'The name of the migration to run. Only available when a single package is updated.',
+            type: 'string',
+            conflicts: ['to', 'from'],
+        })
+            .option('from', {
+            description: 'Version from which to migrate from. ' +
+                `Only available when a single package is updated, and only with 'migrate-only'.`,
+            type: 'string',
+            implies: ['migrate-only'],
+            conflicts: ['name'],
+        })
+            .option('to', {
+            describe: 'Version up to which to apply migrations. Only available when a single package is updated, ' +
+                `and only with 'migrate-only' option. Requires 'from' to be specified. Default to the installed version detected.`,
+            type: 'string',
+            implies: ['from', 'migrate-only'],
+            conflicts: ['name'],
+        })
+            .option('allow-dirty', {
+            describe: 'Whether to allow updating when the repository contains modified or untracked files.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('verbose', {
+            describe: 'Display additional details about internal operations during execution.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('create-commits', {
+            describe: 'Create source control commits for updates and migrations.',
+            type: 'boolean',
+            alias: ['C'],
+            default: false,
+        })
+            .middleware((argv) => {
+            if (argv.name) {
+                argv['migrate-only'] = true;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return argv;
+        })
+            .check(({ packages, 'allow-dirty': allowDirty, 'migrate-only': migrateOnly }) => {
+            const { logger } = this.context;
+            // This allows the user to easily reset any changes from the update.
+            if (packages?.length && !this.checkCleanGit()) {
+                if (allowDirty) {
+                    logger.warn('Repository is not clean. Update changes will be mixed with pre-existing changes.');
+                }
+                else {
+                    throw new command_module_1.CommandModuleError('Repository is not clean. Please commit or stash any changes before updating.');
+                }
+            }
+            if (migrateOnly) {
+                if (packages?.length !== 1) {
+                    throw new command_module_1.CommandModuleError(`A single package must be specified when using the 'migrate-only' option.`);
+                }
+            }
+            return true;
+        })
+            .strict();
+    }
+    async run(options) {
+        const { logger, packageManager } = this.context;
+        // Check if the current installed CLI version is older than the latest compatible version.
+        // Skip when running `ng update` without a package name as this will not trigger an actual update.
+        if (!environment_options_1.disableVersionCheck && options.packages?.length) {
+            const cliVersionToInstall = await this.checkCLIVersion(options.packages, options.verbose, options.next);
+            if (cliVersionToInstall) {
+                logger.warn('The installed Angular CLI version is outdated.\n' +
+                    `Installing a temporary Angular CLI versioned ${cliVersionToInstall} to perform the update.`);
+                return this.runTempBinary(`@angular/cli@${cliVersionToInstall}`, process.argv.slice(2));
+            }
+        }
+        const packages = [];
+        for (const request of options.packages ?? []) {
+            try {
+                const packageIdentifier = (0, npm_package_arg_1.default)(request);
+                // only registry identifiers are supported
+                if (!packageIdentifier.registry) {
+                    logger.error(`Package '${request}' is not a registry package identifer.`);
+                    return 1;
+                }
+                if (packages.some((v) => v.name === packageIdentifier.name)) {
+                    logger.error(`Duplicate package '${packageIdentifier.name}' specified.`);
+                    return 1;
+                }
+                if (options.migrateOnly && packageIdentifier.rawSpec !== '*') {
+                    logger.warn('Package specifier has no effect when using "migrate-only" option.');
+                }
+                // If next option is used and no specifier supplied, use next tag
+                if (options.next && packageIdentifier.rawSpec === '*') {
+                    packageIdentifier.fetchSpec = 'next';
+                }
+                packages.push(packageIdentifier);
+            }
+            catch (e) {
+                (0, error_1.assertIsError)(e);
+                logger.error(e.message);
+                return 1;
+            }
+        }
+        logger.info(`Using package manager: ${color_1.colors.gray(packageManager.name)}`);
+        logger.info('Collecting installed dependencies...');
+        const rootDependencies = await (0, package_tree_1.getProjectDependencies)(this.context.root);
+        logger.info(`Found ${rootDependencies.size} dependencies.`);
+        const workflow = new tools_1.NodeWorkflow(this.context.root, {
+            packageManager: packageManager.name,
+            packageManagerForce: this.packageManagerForce(options.verbose),
+            // __dirname -> favor @schematics/update from this package
+            // Otherwise, use packages from the active workspace (migrations)
+            resolvePaths: this.resolvePaths,
+            schemaValidation: true,
+            engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
+        });
+        if (packages.length === 0) {
+            // Show status
+            const { success } = await this.executeSchematic(workflow, UPDATE_SCHEMATIC_COLLECTION, 'update', {
+                force: options.force,
+                next: options.next,
+                verbose: options.verbose,
+                packageManager: packageManager.name,
+                packages: [],
+            });
+            return success ? 0 : 1;
+        }
+        return options.migrateOnly
+            ? this.migrateOnly(workflow, (options.packages ?? [])[0], rootDependencies, options)
+            : this.updatePackagesAndMigrate(workflow, rootDependencies, options, packages);
+    }
+    async executeSchematic(workflow, collection, schematic, options = {}) {
+        const { logger } = this.context;
+        const workflowSubscription = (0, schematic_workflow_1.subscribeToWorkflow)(workflow, logger);
+        // TODO: Allow passing a schematic instance directly
+        try {
+            await workflow
+                .execute({
+                collection,
+                schematic,
+                options,
+                logger,
+            })
+                .toPromise();
+            return { success: !workflowSubscription.error, files: workflowSubscription.files };
+        }
+        catch (e) {
+            if (e instanceof schematics_1.UnsuccessfulWorkflowExecution) {
+                logger.error(`${color_1.figures.cross} Migration failed. See above for further details.\n`);
+            }
+            else {
+                (0, error_1.assertIsError)(e);
+                const logPath = (0, log_file_1.writeErrorToLogFile)(e);
+                logger.fatal(`${color_1.figures.cross} Migration failed: ${e.message}\n` +
+                    `  See "${logPath}" for further details.\n`);
+            }
+            return { success: false, files: workflowSubscription.files };
+        }
+        finally {
+            workflowSubscription.unsubscribe();
+        }
+    }
+    /**
+     * @return Whether or not the migration was performed successfully.
+     */
+    async executeMigration(workflow, packageName, collectionPath, migrationName, commit) {
+        const { logger } = this.context;
+        const collection = workflow.engine.createCollection(collectionPath);
+        const name = collection.listSchematicNames().find((name) => name === migrationName);
+        if (!name) {
+            logger.error(`Cannot find migration '${migrationName}' in '${packageName}'.`);
+            return 1;
+        }
+        logger.info(color_1.colors.cyan(`** Executing '${migrationName}' of package '${packageName}' **\n`));
+        const schematic = workflow.engine.createSchematic(name, collection);
+        return this.executePackageMigrations(workflow, [schematic.description], packageName, commit);
+    }
+    /**
+     * @return Whether or not the migrations were performed successfully.
+     */
+    async executeMigrations(workflow, packageName, collectionPath, from, to, commit) {
+        const collection = workflow.engine.createCollection(collectionPath);
+        const migrationRange = new semver.Range('>' + (semver.prerelease(from) ? from.split('-')[0] + '-0' : from) + ' <=' + to.split('-')[0]);
+        const requiredMigrations = [];
+        const optionalMigrations = [];
+        for (const name of collection.listSchematicNames()) {
+            const schematic = workflow.engine.createSchematic(name, collection);
+            const description = schematic.description;
+            description.version = coerceVersionNumber(description.version);
+            if (!description.version) {
+                continue;
+            }
+            if (semver.satisfies(description.version, migrationRange, { includePrerelease: true })) {
+                (description.optional ? optionalMigrations : requiredMigrations).push(description);
+            }
+        }
+        if (requiredMigrations.length === 0 && optionalMigrations.length === 0) {
+            return 0;
+        }
+        // Required migrations
+        if (requiredMigrations.length) {
+            this.context.logger.info(color_1.colors.cyan(`** Executing migrations of package '${packageName}' **\n`));
+            requiredMigrations.sort((a, b) => semver.compare(a.version, b.version) || a.name.localeCompare(b.name));
+            const result = await this.executePackageMigrations(workflow, requiredMigrations, packageName, commit);
+            if (result === 1) {
+                return 1;
+            }
+        }
+        // Optional migrations
+        if (optionalMigrations.length) {
+            this.context.logger.info(color_1.colors.magenta(`** Optional migrations of package '${packageName}' **\n`));
+            optionalMigrations.sort((a, b) => semver.compare(a.version, b.version) || a.name.localeCompare(b.name));
+            const migrationsToRun = await this.getOptionalMigrationsToRun(optionalMigrations, packageName);
+            if (migrationsToRun?.length) {
+                return this.executePackageMigrations(workflow, migrationsToRun, packageName, commit);
+            }
+        }
+        return 0;
+    }
+    async executePackageMigrations(workflow, migrations, packageName, commit = false) {
+        const { logger } = this.context;
+        for (const migration of migrations) {
+            const { title, description } = getMigrationTitleAndDescription(migration);
+            logger.info(color_1.colors.cyan(color_1.figures.pointer) + ' ' + color_1.colors.bold(title));
+            if (description) {
+                logger.info('  ' + description);
+            }
+            const { success, files } = await this.executeSchematic(workflow, migration.collection.name, migration.name);
+            if (!success) {
+                return 1;
+            }
+            let modifiedFilesText;
+            switch (files.size) {
+                case 0:
+                    modifiedFilesText = 'No changes made';
+                    break;
+                case 1:
+                    modifiedFilesText = '1 file modified';
+                    break;
+                default:
+                    modifiedFilesText = `${files.size} files modified`;
+                    break;
+            }
+            logger.info(`  Migration completed (${modifiedFilesText}).`);
+            // Commit migration
+            if (commit) {
+                const commitPrefix = `${packageName} migration - ${migration.name}`;
+                const commitMessage = migration.description
+                    ? `${commitPrefix}\n\n${migration.description}`
+                    : commitPrefix;
+                const committed = this.commit(commitMessage);
+                if (!committed) {
+                    // Failed to commit, something went wrong. Abort the update.
+                    return 1;
+                }
+            }
+            logger.info(''); // Extra trailing newline.
+        }
+        return 0;
+    }
+    async migrateOnly(workflow, packageName, rootDependencies, options) {
+        const { logger } = this.context;
+        const packageDependency = rootDependencies.get(packageName);
+        let packagePath = packageDependency?.path;
+        let packageNode = packageDependency?.package;
+        if (packageDependency && !packageNode) {
+            logger.error('Package found in package.json but is not installed.');
+            return 1;
+        }
+        else if (!packageDependency) {
+            // Allow running migrations on transitively installed dependencies
+            // There can technically be nested multiple versions
+            // TODO: If multiple, this should find all versions and ask which one to use
+            const packageJson = (0, package_tree_1.findPackageJson)(this.context.root, packageName);
+            if (packageJson) {
+                packagePath = path.dirname(packageJson);
+                packageNode = await (0, package_tree_1.readPackageJson)(packageJson);
+            }
+        }
+        if (!packageNode || !packagePath) {
+            logger.error('Package is not installed.');
+            return 1;
+        }
+        const updateMetadata = packageNode['ng-update'];
+        let migrations = updateMetadata?.migrations;
+        if (migrations === undefined) {
+            logger.error('Package does not provide migrations.');
+            return 1;
+        }
+        else if (typeof migrations !== 'string') {
+            logger.error('Package contains a malformed migrations field.');
+            return 1;
+        }
+        else if (path.posix.isAbsolute(migrations) || path.win32.isAbsolute(migrations)) {
+            logger.error('Package contains an invalid migrations field. Absolute paths are not permitted.');
+            return 1;
+        }
+        // Normalize slashes
+        migrations = migrations.replace(/\\/g, '/');
+        if (migrations.startsWith('../')) {
+            logger.error('Package contains an invalid migrations field. Paths outside the package root are not permitted.');
+            return 1;
+        }
+        // Check if it is a package-local location
+        const localMigrations = path.join(packagePath, migrations);
+        if ((0, node_fs_1.existsSync)(localMigrations)) {
+            migrations = localMigrations;
+        }
+        else {
+            // Try to resolve from package location.
+            // This avoids issues with package hoisting.
+            try {
+                const packageRequire = (0, node_module_1.createRequire)(packagePath + '/');
+                migrations = packageRequire.resolve(migrations, { paths: this.resolvePaths });
+            }
+            catch (e) {
+                (0, error_1.assertIsError)(e);
+                if (e.code === 'MODULE_NOT_FOUND') {
+                    logger.error('Migrations for package were not found.');
+                }
+                else {
+                    logger.error(`Unable to resolve migrations for package.  [${e.message}]`);
+                }
+                return 1;
+            }
+        }
+        if (options.name) {
+            return this.executeMigration(workflow, packageName, migrations, options.name, options.createCommits);
+        }
+        const from = coerceVersionNumber(options.from);
+        if (!from) {
+            logger.error(`"from" value [${options.from}] is not a valid version.`);
+            return 1;
+        }
+        return this.executeMigrations(workflow, packageName, migrations, from, options.to || packageNode.version, options.createCommits);
+    }
+    // eslint-disable-next-line max-lines-per-function
+    async updatePackagesAndMigrate(workflow, rootDependencies, options, packages) {
+        const { logger } = this.context;
+        const logVerbose = (message) => {
+            if (options.verbose) {
+                logger.info(message);
+            }
+        };
+        const requests = [];
+        // Validate packages actually are part of the workspace
+        for (const pkg of packages) {
+            const node = rootDependencies.get(pkg.name);
+            if (!node?.package) {
+                logger.error(`Package '${pkg.name}' is not a dependency.`);
+                return 1;
+            }
+            // If a specific version is requested and matches the installed version, skip.
+            if (pkg.type === 'version' && node.package.version === pkg.fetchSpec) {
+                logger.info(`Package '${pkg.name}' is already at '${pkg.fetchSpec}'.`);
+                continue;
+            }
+            requests.push({ identifier: pkg, node });
+        }
+        if (requests.length === 0) {
+            return 0;
+        }
+        logger.info('Fetching dependency metadata from registry...');
+        const packagesToUpdate = [];
+        for (const { identifier: requestIdentifier, node } of requests) {
+            const packageName = requestIdentifier.name;
+            let metadata;
+            try {
+                // Metadata requests are internally cached; multiple requests for same name
+                // does not result in additional network traffic
+                metadata = await (0, package_metadata_1.fetchPackageMetadata)(packageName, logger, {
+                    verbose: options.verbose,
+                });
+            }
+            catch (e) {
+                (0, error_1.assertIsError)(e);
+                logger.error(`Error fetching metadata for '${packageName}': ` + e.message);
+                return 1;
+            }
+            // Try to find a package version based on the user requested package specifier
+            // registry specifier types are either version, range, or tag
+            let manifest;
+            if (requestIdentifier.type === 'version' ||
+                requestIdentifier.type === 'range' ||
+                requestIdentifier.type === 'tag') {
+                try {
+                    manifest = (0, npm_pick_manifest_1.default)(metadata, requestIdentifier.fetchSpec);
+                }
+                catch (e) {
+                    (0, error_1.assertIsError)(e);
+                    if (e.code === 'ETARGET') {
+                        // If not found and next was used and user did not provide a specifier, try latest.
+                        // Package may not have a next tag.
+                        if (requestIdentifier.type === 'tag' &&
+                            requestIdentifier.fetchSpec === 'next' &&
+                            !requestIdentifier.rawSpec) {
+                            try {
+                                manifest = (0, npm_pick_manifest_1.default)(metadata, 'latest');
+                            }
+                            catch (e) {
+                                (0, error_1.assertIsError)(e);
+                                if (e.code !== 'ETARGET' && e.code !== 'ENOVERSIONS') {
+                                    throw e;
+                                }
+                            }
+                        }
+                    }
+                    else if (e.code !== 'ENOVERSIONS') {
+                        throw e;
+                    }
+                }
+            }
+            if (!manifest) {
+                logger.error(`Package specified by '${requestIdentifier.raw}' does not exist within the registry.`);
+                return 1;
+            }
+            if (manifest.version === node.package?.version) {
+                logger.info(`Package '${packageName}' is already up to date.`);
+                continue;
+            }
+            if (node.package && ANGULAR_PACKAGES_REGEXP.test(node.package.name)) {
+                const { name, version } = node.package;
+                const toBeInstalledMajorVersion = +manifest.version.split('.')[0];
+                const currentMajorVersion = +version.split('.')[0];
+                if (toBeInstalledMajorVersion - currentMajorVersion > 1) {
+                    // Only allow updating a single version at a time.
+                    if (currentMajorVersion < 6) {
+                        // Before version 6, the major versions were not always sequential.
+                        // Example @angular/core skipped version 3, @angular/cli skipped versions 2-5.
+                        logger.error(`Updating multiple major versions of '${name}' at once is not supported. Please migrate each major version individually.\n` +
+                            `For more information about the update process, see https://update.angular.dev/.`);
+                    }
+                    else {
+                        const nextMajorVersionFromCurrent = currentMajorVersion + 1;
+                        logger.error(`Updating multiple major versions of '${name}' at once is not supported. Please migrate each major version individually.\n` +
+                            `Run 'ng update ${name}@${nextMajorVersionFromCurrent}' in your workspace directory ` +
+                            `to update to latest '${nextMajorVersionFromCurrent}.x' version of '${name}'.\n\n` +
+                            `For more information about the update process, see https://update.angular.dev/?v=${currentMajorVersion}.0-${nextMajorVersionFromCurrent}.0`);
+                    }
+                    return 1;
+                }
+            }
+            packagesToUpdate.push(requestIdentifier.toString());
+        }
+        if (packagesToUpdate.length === 0) {
+            return 0;
+        }
+        const { success } = await this.executeSchematic(workflow, UPDATE_SCHEMATIC_COLLECTION, 'update', {
+            verbose: options.verbose,
+            force: options.force,
+            next: options.next,
+            packageManager: this.context.packageManager.name,
+            packages: packagesToUpdate,
+        });
+        if (success) {
+            const { root: commandRoot, packageManager } = this.context;
+            const installArgs = this.packageManagerForce(options.verbose) ? ['--force'] : [];
+            const tasks = new listr2_1.Listr([
+                {
+                    title: 'Cleaning node modules directory',
+                    async task(_, task) {
+                        try {
+                            await node_fs_1.promises.rm(path.join(commandRoot, 'node_modules'), {
+                                force: true,
+                                recursive: true,
+                                maxRetries: 3,
+                            });
+                        }
+                        catch (e) {
+                            (0, error_1.assertIsError)(e);
+                            if (e.code === 'ENOENT') {
+                                task.skip('Cleaning not required. Node modules directory not found.');
+                            }
+                        }
+                    },
+                },
+                {
+                    title: 'Installing packages',
+                    async task() {
+                        const installationSuccess = await packageManager.installAll(installArgs, commandRoot);
+                        if (!installationSuccess) {
+                            throw new CommandError('Unable to install packages');
+                        }
+                    },
+                },
+            ]);
+            try {
+                await tasks.run();
+            }
+            catch (e) {
+                if (e instanceof CommandError) {
+                    return 1;
+                }
+                throw e;
+            }
+        }
+        if (success && options.createCommits) {
+            if (!this.commit(`Angular CLI update for packages - ${packagesToUpdate.join(', ')}`)) {
+                return 1;
+            }
+        }
+        // This is a temporary workaround to allow data to be passed back from the update schematic
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const migrations = global.externalMigrations;
+        if (success && migrations) {
+            const rootRequire = (0, node_module_1.createRequire)(this.context.root + '/');
+            for (const migration of migrations) {
+                // Resolve the package from the workspace root, as otherwise it will be resolved from the temp
+                // installed CLI version.
+                let packagePath;
+                logVerbose(`Resolving migration package '${migration.package}' from '${this.context.root}'...`);
+                try {
+                    try {
+                        packagePath = path.dirname(
+                        // This may fail if the `package.json` is not exported as an entry point
+                        rootRequire.resolve(path.join(migration.package, 'package.json')));
+                    }
+                    catch (e) {
+                        (0, error_1.assertIsError)(e);
+                        if (e.code === 'MODULE_NOT_FOUND') {
+                            // Fallback to trying to resolve the package's main entry point
+                            packagePath = rootRequire.resolve(migration.package);
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+                catch (e) {
+                    (0, error_1.assertIsError)(e);
+                    if (e.code === 'MODULE_NOT_FOUND') {
+                        logVerbose(e.toString());
+                        logger.error(`Migrations for package (${migration.package}) were not found.` +
+                            ' The package could not be found in the workspace.');
+                    }
+                    else {
+                        logger.error(`Unable to resolve migrations for package (${migration.package}).  [${e.message}]`);
+                    }
+                    return 1;
+                }
+                let migrations;
+                // Check if it is a package-local location
+                const localMigrations = path.join(packagePath, migration.collection);
+                if ((0, node_fs_1.existsSync)(localMigrations)) {
+                    migrations = localMigrations;
+                }
+                else {
+                    // Try to resolve from package location.
+                    // This avoids issues with package hoisting.
+                    try {
+                        const packageRequire = (0, node_module_1.createRequire)(packagePath + '/');
+                        migrations = packageRequire.resolve(migration.collection);
+                    }
+                    catch (e) {
+                        (0, error_1.assertIsError)(e);
+                        if (e.code === 'MODULE_NOT_FOUND') {
+                            logger.error(`Migrations for package (${migration.package}) were not found.`);
+                        }
+                        else {
+                            logger.error(`Unable to resolve migrations for package (${migration.package}).  [${e.message}]`);
+                        }
+                        return 1;
+                    }
+                }
+                const result = await this.executeMigrations(workflow, migration.package, migrations, migration.from, migration.to, options.createCommits);
+                // A non-zero value is a failure for the package's migrations
+                if (result !== 0) {
+                    return result;
+                }
+            }
+        }
+        return success ? 0 : 1;
+    }
+    /**
+     * @return Whether or not the commit was successful.
+     */
+    commit(message) {
+        const { logger } = this.context;
+        // Check if a commit is needed.
+        let commitNeeded;
+        try {
+            commitNeeded = hasChangesToCommit();
+        }
+        catch (err) {
+            logger.error(`  Failed to read Git tree:\n${err.stderr}`);
+            return false;
+        }
+        if (!commitNeeded) {
+            logger.info('  No changes to commit after migration.');
+            return true;
+        }
+        // Commit changes and abort on error.
+        try {
+            createCommit(message);
+        }
+        catch (err) {
+            logger.error(`Failed to commit update (${message}):\n${err.stderr}`);
+            return false;
+        }
+        // Notify user of the commit.
+        const hash = findCurrentGitSha();
+        const shortMessage = message.split('\n')[0];
+        if (hash) {
+            logger.info(`  Committed migration step (${getShortHash(hash)}): ${shortMessage}.`);
+        }
+        else {
+            // Commit was successful, but reading the hash was not. Something weird happened,
+            // but nothing that would stop the update. Just log the weirdness and continue.
+            logger.info(`  Committed migration step: ${shortMessage}.`);
+            logger.warn('  Failed to look up hash of most recent commit, continuing anyways.');
+        }
+        return true;
+    }
+    checkCleanGit() {
+        try {
+            const topLevel = (0, node_child_process_1.execSync)('git rev-parse --show-toplevel', {
+                encoding: 'utf8',
+                stdio: 'pipe',
+            });
+            const result = (0, node_child_process_1.execSync)('git status --porcelain', { encoding: 'utf8', stdio: 'pipe' });
+            if (result.trim().length === 0) {
+                return true;
+            }
+            // Only files inside the workspace root are relevant
+            for (const entry of result.split('\n')) {
+                const relativeEntry = path.relative(path.resolve(this.context.root), path.resolve(topLevel.trim(), entry.slice(3).trim()));
+                if (!relativeEntry.startsWith('..') && !path.isAbsolute(relativeEntry)) {
+                    return false;
+                }
+            }
+        }
+        catch { }
+        return true;
+    }
+    /**
+     * Checks if the current installed CLI version is older or newer than a compatible version.
+     * @returns the version to install or null when there is no update to install.
+     */
+    async checkCLIVersion(packagesToUpdate, verbose = false, next = false) {
+        const { version } = await (0, package_metadata_1.fetchPackageManifest)(`@angular/cli@${this.getCLIUpdateRunnerVersion(packagesToUpdate, next)}`, this.context.logger, {
+            verbose,
+            usingYarn: this.context.packageManager.name === workspace_schema_1.PackageManager.Yarn,
+        });
+        return version_1.VERSION.full === version ? null : version;
+    }
+    getCLIUpdateRunnerVersion(packagesToUpdate, next) {
+        if (next) {
+            return 'next';
+        }
+        const updatingAngularPackage = packagesToUpdate?.find((r) => ANGULAR_PACKAGES_REGEXP.test(r));
+        if (updatingAngularPackage) {
+            // If we are updating any Angular package we can update the CLI to the target version because
+            // migrations for @angular/core@13 can be executed using Angular/cli@13.
+            // This is same behaviour as `npx @angular/cli@13 update @angular/core@13`.
+            // `@angular/cli@13` -> ['', 'angular/cli', '13']
+            // `@angular/cli` -> ['', 'angular/cli']
+            const tempVersion = coerceVersionNumber(updatingAngularPackage.split('@')[2]);
+            return semver.parse(tempVersion)?.major ?? 'latest';
+        }
+        // When not updating an Angular package we cannot determine which schematic runtime the migration should to be executed in.
+        // Typically, we can assume that the `@angular/cli` was updated previously.
+        // Example: Angular official packages are typically updated prior to NGRX etc...
+        // Therefore, we only update to the latest patch version of the installed major version of the Angular CLI.
+        // This is important because we might end up in a scenario where locally Angular v12 is installed, updating NGRX from 11 to 12.
+        // We end up using Angular ClI v13 to run the migrations if we run the migrations using the CLI installed major version + 1 logic.
+        return version_1.VERSION.major;
+    }
+    async runTempBinary(packageName, args = []) {
+        const { success, tempNodeModules } = await this.context.packageManager.installTemp(packageName);
+        if (!success) {
+            return 1;
+        }
+        // Remove version/tag etc... from package name
+        // Ex: @angular/cli@latest -> @angular/cli
+        const packageNameNoVersion = packageName.substring(0, packageName.lastIndexOf('@'));
+        const pkgLocation = (0, path_1.join)(tempNodeModules, packageNameNoVersion);
+        const packageJsonPath = (0, path_1.join)(pkgLocation, 'package.json');
+        // Get a binary location for this package
+        let binPath;
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            const content = await node_fs_1.promises.readFile(packageJsonPath, 'utf-8');
+            if (content) {
+                const { bin = {} } = JSON.parse(content);
+                const binKeys = Object.keys(bin);
+                if (binKeys.length) {
+                    binPath = (0, path_1.resolve)(pkgLocation, bin[binKeys[0]]);
+                }
+            }
+        }
+        if (!binPath) {
+            throw new Error(`Cannot locate bin for temporary package: ${packageNameNoVersion}.`);
+        }
+        const { status, error } = (0, node_child_process_1.spawnSync)(process.execPath, [binPath, ...args], {
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                NG_DISABLE_VERSION_CHECK: 'true',
+                NG_CLI_ANALYTICS: 'false',
+            },
+        });
+        if (status === null && error) {
+            throw error;
+        }
+        return status ?? 0;
+    }
+    packageManagerForce(verbose) {
+        // npm 7+ can fail due to it incorrectly resolving peer dependencies that have valid SemVer
+        // ranges during an update. Update will set correct versions of dependencies within the
+        // package.json file. The force option is set to workaround these errors.
+        // Example error:
+        // npm ERR! Conflicting peer dependency: @angular/compiler-cli@14.0.0-rc.0
+        // npm ERR! node_modules/@angular/compiler-cli
+        // npm ERR!   peer @angular/compiler-cli@"^14.0.0 || ^14.0.0-rc" from @angular-devkit/build-angular@14.0.0-rc.0
+        // npm ERR!   node_modules/@angular-devkit/build-angular
+        // npm ERR!     dev @angular-devkit/build-angular@"~14.0.0-rc.0" from the root project
+        if (this.context.packageManager.name === workspace_schema_1.PackageManager.Npm &&
+            this.context.packageManager.version &&
+            semver.gte(this.context.packageManager.version, '7.0.0')) {
+            if (verbose) {
+                this.context.logger.info('NPM 7+ detected -- enabling force option for package installation');
+            }
+            return true;
+        }
+        return false;
+    }
+    async getOptionalMigrationsToRun(optionalMigrations, packageName) {
+        const { logger } = this.context;
+        const numberOfMigrations = optionalMigrations.length;
+        logger.info(`This package has ${numberOfMigrations} optional migration${numberOfMigrations > 1 ? 's' : ''} that can be executed.`);
+        if (!(0, tty_1.isTTY)()) {
+            for (const migration of optionalMigrations) {
+                const { title } = getMigrationTitleAndDescription(migration);
+                logger.info(color_1.colors.cyan(color_1.figures.pointer) + ' ' + color_1.colors.bold(title));
+                logger.info(color_1.colors.gray(`  ng update ${packageName} --name ${migration.name}`));
+                logger.info(''); // Extra trailing newline.
+            }
+            return undefined;
+        }
+        logger.info('Optional migrations may be skipped and executed after the update process, if preferred.');
+        logger.info(''); // Extra trailing newline.
+        const answer = await (0, prompt_1.askChoices)(`Select the migrations that you'd like to run`, optionalMigrations.map((migration) => {
+            const { title, documentation } = getMigrationTitleAndDescription(migration);
+            return {
+                name: `[${color_1.colors.white(migration.name)}] ${title}${documentation ? ` (${documentation})` : ''}`,
+                value: migration.name,
+            };
+        }), null);
+        logger.info(''); // Extra trailing newline.
+        return optionalMigrations.filter(({ name }) => answer?.includes(name));
+    }
+}
+exports.default = UpdateCommandModule;
+/**
+ * @return Whether or not the working directory has Git changes to commit.
+ */
+function hasChangesToCommit() {
+    // List all modified files not covered by .gitignore.
+    // If any files are returned, then there must be something to commit.
+    return (0, node_child_process_1.execSync)('git ls-files -m -d -o --exclude-standard').toString() !== '';
+}
+/**
+ * Precondition: Must have pending changes to commit, they do not need to be staged.
+ * Postcondition: The Git working tree is committed and the repo is clean.
+ * @param message The commit message to use.
+ */
+function createCommit(message) {
+    // Stage entire working tree for commit.
+    (0, node_child_process_1.execSync)('git add -A', { encoding: 'utf8', stdio: 'pipe' });
+    // Commit with the message passed via stdin to avoid bash escaping issues.
+    (0, node_child_process_1.execSync)('git commit --no-verify -F -', { encoding: 'utf8', stdio: 'pipe', input: message });
+}
+/**
+ * @return The Git SHA hash of the HEAD commit. Returns null if unable to retrieve the hash.
+ */
+function findCurrentGitSha() {
+    try {
+        return (0, node_child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf8', stdio: 'pipe' }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function getShortHash(commitHash) {
+    return commitHash.slice(0, 9);
+}
+function coerceVersionNumber(version) {
+    if (!version) {
+        return undefined;
+    }
+    if (!/^\d{1,30}\.\d{1,30}\.\d{1,30}/.test(version)) {
+        const match = version.match(/^\d{1,30}(\.\d{1,30})*/);
+        if (!match) {
+            return undefined;
+        }
+        if (!match[1]) {
+            version = version.substring(0, match[0].length) + '.0.0' + version.substring(match[0].length);
+        }
+        else if (!match[2]) {
+            version = version.substring(0, match[0].length) + '.0' + version.substring(match[0].length);
+        }
+        else {
+            return undefined;
+        }
+    }
+    return semver.valid(version) ?? undefined;
+}
+function getMigrationTitleAndDescription(migration) {
+    const [title, ...description] = migration.description.split('. ');
+    return {
+        title: title.endsWith('.') ? title : title + '.',
+        description: description.join('.\n  '),
+        documentation: migration.documentation
+            ? new URL(migration.documentation, 'https://angular.dev').href
+            : undefined,
+    };
+}
--- a/node_modules/@angular/cli/src/commands/update/long-description.md
+++ b/node_modules/@angular/cli/src/commands/update/long-description.md
@ -0,0 +1,22 @@
+Perform a basic update to the current stable release of the core framework and CLI by running the following command.
+
+```
+ng update @angular/cli @angular/core
+```
+
+To update to the next beta or pre-release version, use the `--next` option.
+
+To update from one major version to another, use the format
+
+```
+ng update @angular/cli@^<major_version> @angular/core@^<major_version>
+```
+
+We recommend that you always update to the latest patch version, as it contains fixes we released since the initial major release.
+For example, use the following command to take the latest 10.x.x version and use that to update.
+
+```
+ng update @angular/cli@^10 @angular/core@^10
+```
+
+For detailed information and guidance on updating your application, see the interactive [Angular Update Guide](https://update.angular.dev/).
--- a/node_modules/@angular/cli/src/commands/update/schematic/collection.json
+++ b/node_modules/@angular/cli/src/commands/update/schematic/collection.json
@ -0,0 +1,9 @@
+{
+  "schematics": {
+    "update": {
+      "factory": "./index",
+      "schema": "./schema.json",
+      "description": "Update one or multiple packages to versions, updating peer dependencies along the way."
+    }
+  }
+}
--- a/node_modules/@angular/cli/src/commands/update/schematic/index.d.ts
+++ b/node_modules/@angular/cli/src/commands/update/schematic/index.d.ts
@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Rule } from '@angular-devkit/schematics';
+import { Schema as UpdateSchema } from './schema';
+export declare function angularMajorCompatGuarantee(range: string): string;
+export default function (options: UpdateSchema): Rule;
--- a/node_modules/@angular/cli/src/commands/update/schematic/index.js
+++ b/node_modules/@angular/cli/src/commands/update/schematic/index.js
@ -0,0 +1,707 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angularMajorCompatGuarantee = angularMajorCompatGuarantee;
+exports.default = default_1;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const npa = __importStar(require("npm-package-arg"));
+const semver = __importStar(require("semver"));
+const package_metadata_1 = require("../../../utilities/package-metadata");
+// Angular guarantees that a major is compatible with its following major (so packages that depend
+// on Angular 5 are also compatible with Angular 6). This is, in code, represented by verifying
+// that all other packages that have a peer dependency of `"@angular/core": "^5.0.0"` actually
+// supports 6.0, by adding that compatibility to the range, so it is `^5.0.0 || ^6.0.0`.
+// We export it to allow for testing.
+function angularMajorCompatGuarantee(range) {
+    let newRange = semver.validRange(range);
+    if (!newRange) {
+        return range;
+    }
+    let major = 1;
+    while (!semver.gtr(major + '.0.0', newRange)) {
+        major++;
+        if (major >= 99) {
+            // Use original range if it supports a major this high
+            // Range is most likely unbounded (e.g., >=5.0.0)
+            return newRange;
+        }
+    }
+    // Add the major version as compatible with the angular compatible, with all minors. This is
+    // already one major above the greatest supported, because we increment `major` before checking.
+    // We add minors like this because a minor beta is still compatible with a minor non-beta.
+    newRange = range;
+    for (let minor = 0; minor < 20; minor++) {
+        newRange += ` || ^${major}.${minor}.0-alpha.0 `;
+    }
+    return semver.validRange(newRange) || range;
+}
+// This is a map of packageGroupName to range extending function. If it isn't found, the range is
+// kept the same.
+const knownPeerCompatibleList = {
+    '@angular/core': angularMajorCompatGuarantee,
+};
+function _updatePeerVersion(infoMap, name, range) {
+    // Resolve packageGroupName.
+    const maybePackageInfo = infoMap.get(name);
+    if (!maybePackageInfo) {
+        return range;
+    }
+    if (maybePackageInfo.target) {
+        name = maybePackageInfo.target.updateMetadata.packageGroupName || name;
+    }
+    else {
+        name = maybePackageInfo.installed.updateMetadata.packageGroupName || name;
+    }
+    const maybeTransform = knownPeerCompatibleList[name];
+    if (maybeTransform) {
+        if (typeof maybeTransform == 'function') {
+            return maybeTransform(range);
+        }
+        else {
+            return maybeTransform;
+        }
+    }
+    return range;
+}
+function _validateForwardPeerDependencies(name, infoMap, peers, peersMeta, logger, next) {
+    let validationFailed = false;
+    for (const [peer, range] of Object.entries(peers)) {
+        logger.debug(`Checking forward peer ${peer}...`);
+        const maybePeerInfo = infoMap.get(peer);
+        const isOptional = peersMeta[peer] && !!peersMeta[peer].optional;
+        if (!maybePeerInfo) {
+            if (!isOptional) {
+                logger.warn([
+                    `Package ${JSON.stringify(name)} has a missing peer dependency of`,
+                    `${JSON.stringify(peer)} @ ${JSON.stringify(range)}.`,
+                ].join(' '));
+            }
+            continue;
+        }
+        const peerVersion = maybePeerInfo.target && maybePeerInfo.target.packageJson.version
+            ? maybePeerInfo.target.packageJson.version
+            : maybePeerInfo.installed.version;
+        logger.debug(`  Range intersects(${range}, ${peerVersion})...`);
+        if (!semver.satisfies(peerVersion, range, { includePrerelease: next || undefined })) {
+            logger.error([
+                `Package ${JSON.stringify(name)} has an incompatible peer dependency to`,
+                `${JSON.stringify(peer)} (requires ${JSON.stringify(range)},`,
+                `would install ${JSON.stringify(peerVersion)})`,
+            ].join(' '));
+            validationFailed = true;
+            continue;
+        }
+    }
+    return validationFailed;
+}
+function _validateReversePeerDependencies(name, version, infoMap, logger, next) {
+    for (const [installed, installedInfo] of infoMap.entries()) {
+        const installedLogger = logger.createChild(installed);
+        installedLogger.debug(`${installed}...`);
+        const peers = (installedInfo.target || installedInfo.installed).packageJson.peerDependencies;
+        for (const [peer, range] of Object.entries(peers || {})) {
+            if (peer != name) {
+                // Only check peers to the packages we're updating. We don't care about peers
+                // that are unmet but we have no effect on.
+                continue;
+            }
+            // Ignore peerDependency mismatches for these packages.
+            // They are deprecated and removed via a migration.
+            const ignoredPackages = [
+                'codelyzer',
+                '@schematics/update',
+                '@angular-devkit/build-ng-packagr',
+                'tsickle',
+                '@nguniversal/builders',
+            ];
+            if (ignoredPackages.includes(installed)) {
+                continue;
+            }
+            // Override the peer version range if it's known as a compatible.
+            const extendedRange = _updatePeerVersion(infoMap, peer, range);
+            if (!semver.satisfies(version, extendedRange, { includePrerelease: next || undefined })) {
+                logger.error([
+                    `Package ${JSON.stringify(installed)} has an incompatible peer dependency to`,
+                    `${JSON.stringify(name)} (requires`,
+                    `${JSON.stringify(range)}${extendedRange == range ? '' : ' (extended)'},`,
+                    `would install ${JSON.stringify(version)}).`,
+                ].join(' '));
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function _validateUpdatePackages(infoMap, force, next, logger) {
+    logger.debug('Updating the following packages:');
+    infoMap.forEach((info) => {
+        if (info.target) {
+            logger.debug(`  ${info.name} => ${info.target.version}`);
+        }
+    });
+    let peerErrors = false;
+    infoMap.forEach((info) => {
+        const { name, target } = info;
+        if (!target) {
+            return;
+        }
+        const pkgLogger = logger.createChild(name);
+        logger.debug(`${name}...`);
+        const { peerDependencies = {}, peerDependenciesMeta = {} } = target.packageJson;
+        peerErrors =
+            _validateForwardPeerDependencies(name, infoMap, peerDependencies, peerDependenciesMeta, pkgLogger, next) || peerErrors;
+        peerErrors =
+            _validateReversePeerDependencies(name, target.version, infoMap, pkgLogger, next) ||
+                peerErrors;
+    });
+    if (!force && peerErrors) {
+        throw new schematics_1.SchematicsException('Incompatible peer dependencies found.\n' +
+            'Peer dependency warnings when installing dependencies means that those dependencies might not work correctly together.\n' +
+            `You can use the '--force' option to ignore incompatible peer dependencies and instead address these warnings later.`);
+    }
+}
+function _performUpdate(tree, context, infoMap, logger, migrateOnly) {
+    const packageJsonContent = tree.read('/package.json')?.toString();
+    if (!packageJsonContent) {
+        throw new schematics_1.SchematicsException('Could not find a package.json. Are you in a Node project?');
+    }
+    const packageJson = tree.readJson('/package.json');
+    const updateDependency = (deps, name, newVersion) => {
+        const oldVersion = deps[name];
+        // We only respect caret and tilde ranges on update.
+        const execResult = /^[\^~]/.exec(oldVersion);
+        deps[name] = `${execResult ? execResult[0] : ''}${newVersion}`;
+    };
+    const toInstall = [...infoMap.values()]
+        .map((x) => [x.name, x.target, x.installed])
+        .filter(([name, target, installed]) => {
+        return !!name && !!target && !!installed;
+    });
+    toInstall.forEach(([name, target, installed]) => {
+        logger.info(`Updating package.json with dependency ${name} ` +
+            `@ ${JSON.stringify(target.version)} (was ${JSON.stringify(installed.version)})...`);
+        if (packageJson.dependencies && packageJson.dependencies[name]) {
+            updateDependency(packageJson.dependencies, name, target.version);
+            if (packageJson.devDependencies && packageJson.devDependencies[name]) {
+                delete packageJson.devDependencies[name];
+            }
+            if (packageJson.peerDependencies && packageJson.peerDependencies[name]) {
+                delete packageJson.peerDependencies[name];
+            }
+        }
+        else if (packageJson.devDependencies && packageJson.devDependencies[name]) {
+            updateDependency(packageJson.devDependencies, name, target.version);
+            if (packageJson.peerDependencies && packageJson.peerDependencies[name]) {
+                delete packageJson.peerDependencies[name];
+            }
+        }
+        else if (packageJson.peerDependencies && packageJson.peerDependencies[name]) {
+            updateDependency(packageJson.peerDependencies, name, target.version);
+        }
+        else {
+            logger.warn(`Package ${name} was not found in dependencies.`);
+        }
+    });
+    const eofMatches = packageJsonContent.match(/\r?\n$/);
+    const eof = eofMatches?.[0] ?? '';
+    const newContent = JSON.stringify(packageJson, null, 2) + eof;
+    if (packageJsonContent != newContent || migrateOnly) {
+        if (!migrateOnly) {
+            tree.overwrite('/package.json', newContent);
+        }
+        const externalMigrations = [];
+        // Run the migrate schematics with the list of packages to use. The collection contains
+        // version information and we need to do this post installation. Please note that the
+        // migration COULD fail and leave side effects on disk.
+        // Run the schematics task of those packages.
+        toInstall.forEach(([name, target, installed]) => {
+            if (!target.updateMetadata.migrations) {
+                return;
+            }
+            externalMigrations.push({
+                package: name,
+                collection: target.updateMetadata.migrations,
+                from: installed.version,
+                to: target.version,
+            });
+            return;
+        });
+        if (externalMigrations.length > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            global.externalMigrations = externalMigrations;
+        }
+    }
+}
+function _getUpdateMetadata(packageJson, logger) {
+    const metadata = packageJson['ng-update'];
+    const result = {
+        packageGroup: {},
+        requirements: {},
+    };
+    if (!metadata || typeof metadata != 'object' || Array.isArray(metadata)) {
+        return result;
+    }
+    if (metadata['packageGroup']) {
+        const packageGroup = metadata['packageGroup'];
+        // Verify that packageGroup is an array of strings or an map of versions. This is not an error
+        // but we still warn the user and ignore the packageGroup keys.
+        if (Array.isArray(packageGroup) && packageGroup.every((x) => typeof x == 'string')) {
+            result.packageGroup = packageGroup.reduce((group, name) => {
+                group[name] = packageJson.version;
+                return group;
+            }, result.packageGroup);
+        }
+        else if (typeof packageGroup == 'object' &&
+            packageGroup &&
+            !Array.isArray(packageGroup) &&
+            Object.values(packageGroup).every((x) => typeof x == 'string')) {
+            result.packageGroup = packageGroup;
+        }
+        else {
+            logger.warn(`packageGroup metadata of package ${packageJson.name} is malformed. Ignoring.`);
+        }
+        result.packageGroupName = Object.keys(result.packageGroup)[0];
+    }
+    if (typeof metadata['packageGroupName'] == 'string') {
+        result.packageGroupName = metadata['packageGroupName'];
+    }
+    if (metadata['requirements']) {
+        const requirements = metadata['requirements'];
+        // Verify that requirements are
+        if (typeof requirements != 'object' ||
+            Array.isArray(requirements) ||
+            Object.keys(requirements).some((name) => typeof requirements[name] != 'string')) {
+            logger.warn(`requirements metadata of package ${packageJson.name} is malformed. Ignoring.`);
+        }
+        else {
+            result.requirements = requirements;
+        }
+    }
+    if (metadata['migrations']) {
+        const migrations = metadata['migrations'];
+        if (typeof migrations != 'string') {
+            logger.warn(`migrations metadata of package ${packageJson.name} is malformed. Ignoring.`);
+        }
+        else {
+            result.migrations = migrations;
+        }
+    }
+    return result;
+}
+function _usageMessage(options, infoMap, logger) {
+    const packageGroups = new Map();
+    const packagesToUpdate = [...infoMap.entries()]
+        .map(([name, info]) => {
+        let tag = options.next
+            ? info.npmPackageJson['dist-tags']['next']
+                ? 'next'
+                : 'latest'
+            : 'latest';
+        let version = info.npmPackageJson['dist-tags'][tag];
+        let target = info.npmPackageJson.versions[version];
+        const versionDiff = semver.diff(info.installed.version, version);
+        if (versionDiff !== 'patch' &&
+            versionDiff !== 'minor' &&
+            /^@(?:angular|nguniversal)\//.test(name)) {
+            const installedMajorVersion = semver.parse(info.installed.version)?.major;
+            const toInstallMajorVersion = semver.parse(version)?.major;
+            if (installedMajorVersion !== undefined &&
+                toInstallMajorVersion !== undefined &&
+                installedMajorVersion < toInstallMajorVersion - 1) {
+                const nextMajorVersion = `${installedMajorVersion + 1}.`;
+                const nextMajorVersions = Object.keys(info.npmPackageJson.versions)
+                    .filter((v) => v.startsWith(nextMajorVersion))
+                    .sort((a, b) => (a > b ? -1 : 1));
+                if (nextMajorVersions.length) {
+                    version = nextMajorVersions[0];
+                    target = info.npmPackageJson.versions[version];
+                    tag = '';
+                }
+            }
+        }
+        return {
+            name,
+            info,
+            version,
+            tag,
+            target,
+        };
+    })
+        .filter(({ info, version, target }) => target?.['ng-update'] && semver.compare(info.installed.version, version) < 0)
+        .map(({ name, info, version, tag, target }) => {
+        // Look for packageGroup.
+        const packageGroup = target['ng-update']?.['packageGroup'];
+        if (packageGroup) {
+            const packageGroupNames = Array.isArray(packageGroup)
+                ? packageGroup
+                : Object.keys(packageGroup);
+            const packageGroupName = target['ng-update']?.['packageGroupName'] || packageGroupNames[0];
+            if (packageGroupName) {
+                if (packageGroups.has(name)) {
+                    return null;
+                }
+                packageGroupNames.forEach((x) => packageGroups.set(x, packageGroupName));
+                packageGroups.set(packageGroupName, packageGroupName);
+                name = packageGroupName;
+            }
+        }
+        let command = `ng update ${name}`;
+        if (!tag) {
+            command += `@${semver.parse(version)?.major || version}`;
+        }
+        else if (tag == 'next') {
+            command += ' --next';
+        }
+        return [name, `${info.installed.version} -> ${version} `, command];
+    })
+        .filter((x) => x !== null)
+        .sort((a, b) => (a && b ? a[0].localeCompare(b[0]) : 0));
+    if (packagesToUpdate.length == 0) {
+        logger.info('We analyzed your package.json and everything seems to be in order. Good work!');
+        return;
+    }
+    logger.info('We analyzed your package.json, there are some packages to update:\n');
+    // Find the largest name to know the padding needed.
+    let namePad = Math.max(...[...infoMap.keys()].map((x) => x.length)) + 2;
+    if (!Number.isFinite(namePad)) {
+        namePad = 30;
+    }
+    const pads = [namePad, 25, 0];
+    logger.info('  ' + ['Name', 'Version', 'Command to update'].map((x, i) => x.padEnd(pads[i])).join(''));
+    logger.info(' ' + '-'.repeat(pads.reduce((s, x) => (s += x), 0) + 20));
+    packagesToUpdate.forEach((fields) => {
+        if (!fields) {
+            return;
+        }
+        logger.info('  ' + fields.map((x, i) => x.padEnd(pads[i])).join(''));
+    });
+    logger.info(`\nThere might be additional packages which don't provide 'ng update' capabilities that are outdated.\n` +
+        `You can update the additional packages by running the update command of your package manager.`);
+    return;
+}
+function _buildPackageInfo(tree, packages, allDependencies, npmPackageJson, logger) {
+    const name = npmPackageJson.name;
+    const packageJsonRange = allDependencies.get(name);
+    if (!packageJsonRange) {
+        throw new schematics_1.SchematicsException(`Package ${JSON.stringify(name)} was not found in package.json.`);
+    }
+    // Find out the currently installed version. Either from the package.json or the node_modules/
+    // TODO: figure out a way to read package-lock.json and/or yarn.lock.
+    const pkgJsonPath = `/node_modules/${name}/package.json`;
+    const pkgJsonExists = tree.exists(pkgJsonPath);
+    let installedVersion;
+    if (pkgJsonExists) {
+        const { version } = tree.readJson(pkgJsonPath);
+        installedVersion = version;
+    }
+    const packageVersionsNonDeprecated = [];
+    const packageVersionsDeprecated = [];
+    for (const [version, { deprecated }] of Object.entries(npmPackageJson.versions)) {
+        if (deprecated) {
+            packageVersionsDeprecated.push(version);
+        }
+        else {
+            packageVersionsNonDeprecated.push(version);
+        }
+    }
+    const findSatisfyingVersion = (targetVersion) => (semver.maxSatisfying(packageVersionsNonDeprecated, targetVersion) ??
+        semver.maxSatisfying(packageVersionsDeprecated, targetVersion)) ??
+        undefined;
+    if (!installedVersion) {
+        // Find the version from NPM that fits the range to max.
+        installedVersion = findSatisfyingVersion(packageJsonRange);
+    }
+    if (!installedVersion) {
+        throw new schematics_1.SchematicsException(`An unexpected error happened; could not determine version for package ${name}.`);
+    }
+    const installedPackageJson = npmPackageJson.versions[installedVersion] || pkgJsonExists;
+    if (!installedPackageJson) {
+        throw new schematics_1.SchematicsException(`An unexpected error happened; package ${name} has no version ${installedVersion}.`);
+    }
+    let targetVersion = packages.get(name);
+    if (targetVersion) {
+        if (npmPackageJson['dist-tags'][targetVersion]) {
+            targetVersion = npmPackageJson['dist-tags'][targetVersion];
+        }
+        else if (targetVersion == 'next') {
+            targetVersion = npmPackageJson['dist-tags']['latest'];
+        }
+        else {
+            targetVersion = findSatisfyingVersion(targetVersion);
+        }
+    }
+    if (targetVersion && semver.lte(targetVersion, installedVersion)) {
+        logger.debug(`Package ${name} already satisfied by package.json (${packageJsonRange}).`);
+        targetVersion = undefined;
+    }
+    const target = targetVersion
+        ? {
+            version: targetVersion,
+            packageJson: npmPackageJson.versions[targetVersion],
+            updateMetadata: _getUpdateMetadata(npmPackageJson.versions[targetVersion], logger),
+        }
+        : undefined;
+    // Check if there's an installed version.
+    return {
+        name,
+        npmPackageJson,
+        installed: {
+            version: installedVersion,
+            packageJson: installedPackageJson,
+            updateMetadata: _getUpdateMetadata(installedPackageJson, logger),
+        },
+        target,
+        packageJsonRange,
+    };
+}
+function _buildPackageList(options, projectDeps, logger) {
+    // Parse the packages options to set the targeted version.
+    const packages = new Map();
+    const commandLinePackages = options.packages && options.packages.length > 0 ? options.packages : [];
+    for (const pkg of commandLinePackages) {
+        // Split the version asked on command line.
+        const m = pkg.match(/^((?:@[^/]{1,100}\/)?[^@]{1,100})(?:@(.{1,100}))?$/);
+        if (!m) {
+            logger.warn(`Invalid package argument: ${JSON.stringify(pkg)}. Skipping.`);
+            continue;
+        }
+        const [, npmName, maybeVersion] = m;
+        const version = projectDeps.get(npmName);
+        if (!version) {
+            logger.warn(`Package not installed: ${JSON.stringify(npmName)}. Skipping.`);
+            continue;
+        }
+        packages.set(npmName, (maybeVersion || (options.next ? 'next' : 'latest')));
+    }
+    return packages;
+}
+function _addPackageGroup(tree, packages, allDependencies, npmPackageJson, logger) {
+    const maybePackage = packages.get(npmPackageJson.name);
+    if (!maybePackage) {
+        return;
+    }
+    const info = _buildPackageInfo(tree, packages, allDependencies, npmPackageJson, logger);
+    const version = (info.target && info.target.version) ||
+        npmPackageJson['dist-tags'][maybePackage] ||
+        maybePackage;
+    if (!npmPackageJson.versions[version]) {
+        return;
+    }
+    const ngUpdateMetadata = npmPackageJson.versions[version]['ng-update'];
+    if (!ngUpdateMetadata) {
+        return;
+    }
+    const packageGroup = ngUpdateMetadata['packageGroup'];
+    if (!packageGroup) {
+        return;
+    }
+    let packageGroupNormalized = {};
+    if (Array.isArray(packageGroup) && !packageGroup.some((x) => typeof x != 'string')) {
+        packageGroupNormalized = packageGroup.reduce((acc, curr) => {
+            acc[curr] = maybePackage;
+            return acc;
+        }, {});
+    }
+    else if (typeof packageGroup == 'object' &&
+        packageGroup &&
+        !Array.isArray(packageGroup) &&
+        Object.values(packageGroup).every((x) => typeof x == 'string')) {
+        packageGroupNormalized = packageGroup;
+    }
+    else {
+        logger.warn(`packageGroup metadata of package ${npmPackageJson.name} is malformed. Ignoring.`);
+        return;
+    }
+    for (const [name, value] of Object.entries(packageGroupNormalized)) {
+        // Don't override names from the command line.
+        // Remove packages that aren't installed.
+        if (!packages.has(name) && allDependencies.has(name)) {
+            packages.set(name, value);
+        }
+    }
+}
+/**
+ * Add peer dependencies of packages on the command line to the list of packages to update.
+ * We don't do verification of the versions here as this will be done by a later step (and can
+ * be ignored by the --force flag).
+ * @private
+ */
+function _addPeerDependencies(tree, packages, allDependencies, npmPackageJson, npmPackageJsonMap, logger) {
+    const maybePackage = packages.get(npmPackageJson.name);
+    if (!maybePackage) {
+        return;
+    }
+    const info = _buildPackageInfo(tree, packages, allDependencies, npmPackageJson, logger);
+    const version = (info.target && info.target.version) ||
+        npmPackageJson['dist-tags'][maybePackage] ||
+        maybePackage;
+    if (!npmPackageJson.versions[version]) {
+        return;
+    }
+    const packageJson = npmPackageJson.versions[version];
+    const error = false;
+    for (const [peer, range] of Object.entries(packageJson.peerDependencies || {})) {
+        if (packages.has(peer)) {
+            continue;
+        }
+        const peerPackageJson = npmPackageJsonMap.get(peer);
+        if (peerPackageJson) {
+            const peerInfo = _buildPackageInfo(tree, packages, allDependencies, peerPackageJson, logger);
+            if (semver.satisfies(peerInfo.installed.version, range)) {
+                continue;
+            }
+        }
+        packages.set(peer, range);
+    }
+    if (error) {
+        throw new schematics_1.SchematicsException('An error occured, see above.');
+    }
+}
+function _getAllDependencies(tree) {
+    const { dependencies, devDependencies, peerDependencies } = tree.readJson('/package.json');
+    return [
+        ...Object.entries(peerDependencies || {}),
+        ...Object.entries(devDependencies || {}),
+        ...Object.entries(dependencies || {}),
+    ];
+}
+function _formatVersion(version) {
+    if (version === undefined) {
+        return undefined;
+    }
+    if (!version.match(/^\d{1,30}\.\d{1,30}\.\d{1,30}/)) {
+        version += '.0';
+    }
+    if (!version.match(/^\d{1,30}\.\d{1,30}\.\d{1,30}/)) {
+        version += '.0';
+    }
+    if (!semver.valid(version)) {
+        throw new schematics_1.SchematicsException(`Invalid migration version: ${JSON.stringify(version)}`);
+    }
+    return version;
+}
+/**
+ * Returns whether or not the given package specifier (the value string in a
+ * `package.json` dependency) is hosted in the NPM registry.
+ * @throws When the specifier cannot be parsed.
+ */
+function isPkgFromRegistry(name, specifier) {
+    const result = npa.resolve(name, specifier);
+    return !!result.registry;
+}
+function default_1(options) {
+    if (!options.packages) {
+        // We cannot just return this because we need to fetch the packages from NPM still for the
+        // help/guide to show.
+        options.packages = [];
+    }
+    else {
+        // We split every packages by commas to allow people to pass in multiple and make it an array.
+        options.packages = options.packages.reduce((acc, curr) => {
+            return acc.concat(curr.split(','));
+        }, []);
+    }
+    if (options.migrateOnly && options.from) {
+        if (options.packages.length !== 1) {
+            throw new schematics_1.SchematicsException('--from requires that only a single package be passed.');
+        }
+    }
+    options.from = _formatVersion(options.from);
+    options.to = _formatVersion(options.to);
+    const usingYarn = options.packageManager === 'yarn';
+    return async (tree, context) => {
+        const logger = context.logger;
+        const npmDeps = new Map(_getAllDependencies(tree).filter(([name, specifier]) => {
+            try {
+                return isPkgFromRegistry(name, specifier);
+            }
+            catch {
+                logger.warn(`Package ${name} was not found on the registry. Skipping.`);
+                return false;
+            }
+        }));
+        const packages = _buildPackageList(options, npmDeps, logger);
+        // Grab all package.json from the npm repository. This requires a lot of HTTP calls so we
+        // try to parallelize as many as possible.
+        const allPackageMetadata = await Promise.all(Array.from(npmDeps.keys()).map((depName) => (0, package_metadata_1.getNpmPackageJson)(depName, logger, {
+            registry: options.registry,
+            usingYarn,
+            verbose: options.verbose,
+        })));
+        // Build a map of all dependencies and their packageJson.
+        const npmPackageJsonMap = allPackageMetadata.reduce((acc, npmPackageJson) => {
+            // If the package was not found on the registry. It could be private, so we will just
+            // ignore. If the package was part of the list, we will error out, but will simply ignore
+            // if it's either not requested (so just part of package.json. silently).
+            if (!npmPackageJson.name) {
+                if (npmPackageJson.requestedName && packages.has(npmPackageJson.requestedName)) {
+                    throw new schematics_1.SchematicsException(`Package ${JSON.stringify(npmPackageJson.requestedName)} was not found on the ` +
+                        'registry. Cannot continue as this may be an error.');
+                }
+            }
+            else {
+                // If a name is present, it is assumed to be fully populated
+                acc.set(npmPackageJson.name, npmPackageJson);
+            }
+            return acc;
+        }, new Map());
+        // Augment the command line package list with packageGroups and forward peer dependencies.
+        // Each added package may uncover new package groups and peer dependencies, so we must
+        // repeat this process until the package list stabilizes.
+        let lastPackagesSize;
+        do {
+            lastPackagesSize = packages.size;
+            npmPackageJsonMap.forEach((npmPackageJson) => {
+                _addPackageGroup(tree, packages, npmDeps, npmPackageJson, logger);
+                _addPeerDependencies(tree, packages, npmDeps, npmPackageJson, npmPackageJsonMap, logger);
+            });
+        } while (packages.size > lastPackagesSize);
+        // Build the PackageInfo for each module.
+        const packageInfoMap = new Map();
+        npmPackageJsonMap.forEach((npmPackageJson) => {
+            packageInfoMap.set(npmPackageJson.name, _buildPackageInfo(tree, packages, npmDeps, npmPackageJson, logger));
+        });
+        // Now that we have all the information, check the flags.
+        if (packages.size > 0) {
+            if (options.migrateOnly && options.from && options.packages) {
+                return;
+            }
+            const sublog = new core_1.logging.LevelCapLogger('validation', logger.createChild(''), 'warn');
+            _validateUpdatePackages(packageInfoMap, !!options.force, !!options.next, sublog);
+            _performUpdate(tree, context, packageInfoMap, logger, !!options.migrateOnly);
+        }
+        else {
+            _usageMessage(options, packageInfoMap, logger);
+        }
+    };
+}
--- a/node_modules/@angular/cli/src/commands/update/schematic/schema.d.ts
+++ b/node_modules/@angular/cli/src/commands/update/schematic/schema.d.ts
@ -0,0 +1,52 @@
+export interface Schema {
+    /**
+     * When false (the default), reports an error if installed packages are incompatible with
+     * the update.
+     */
+    force?: boolean;
+    /**
+     * When using `--migrateOnly` for a single package, the version of that package from which
+     * to migrate.
+     */
+    from?: string;
+    /**
+     * Perform a migration, but do not update the installed version.
+     */
+    migrateOnly?: boolean;
+    /**
+     * Update to the latest version, including beta and RCs.
+     */
+    next?: boolean;
+    /**
+     * The preferred package manager configuration files to use for registry settings.
+     */
+    packageManager?: PackageManager;
+    /**
+     * The package or packages to update.
+     */
+    packages?: string[];
+    /**
+     * The npm registry to use.
+     */
+    registry?: string;
+    /**
+     * When using `--migrateOnly` for a single package, the version of that package to which to
+     * migrate.
+     */
+    to?: string;
+    /**
+     * Display additional details during the update process.
+     */
+    verbose?: boolean;
+    [property: string]: any;
+}
+/**
+ * The preferred package manager configuration files to use for registry settings.
+ */
+export declare enum PackageManager {
+    Bun = "bun",
+    Cnpm = "cnpm",
+    Npm = "npm",
+    Pnpm = "pnpm",
+    Yarn = "yarn"
+}
--- a/node_modules/@angular/cli/src/commands/update/schematic/schema.js
+++ b/node_modules/@angular/cli/src/commands/update/schematic/schema.js
@ -0,0 +1,16 @@
+"use strict";
+// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE
+// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageManager = void 0;
+/**
+ * The preferred package manager configuration files to use for registry settings.
+ */
+var PackageManager;
+(function (PackageManager) {
+    PackageManager["Bun"] = "bun";
+    PackageManager["Cnpm"] = "cnpm";
+    PackageManager["Npm"] = "npm";
+    PackageManager["Pnpm"] = "pnpm";
+    PackageManager["Yarn"] = "yarn";
+})(PackageManager || (exports.PackageManager = PackageManager = {}));
--- a/node_modules/@angular/cli/src/commands/update/schematic/schema.json
+++ b/node_modules/@angular/cli/src/commands/update/schematic/schema.json
@ -0,0 +1,64 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "SchematicsUpdateSchema",
+  "title": "Schematic Options Schema",
+  "type": "object",
+  "properties": {
+    "packages": {
+      "description": "The package or packages to update.",
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "$default": {
+        "$source": "argv"
+      }
+    },
+    "force": {
+      "description": "When false (the default), reports an error if installed packages are incompatible with the update.",
+      "default": false,
+      "type": "boolean"
+    },
+    "next": {
+      "description": "Update to the latest version, including beta and RCs.",
+      "default": false,
+      "type": "boolean"
+    },
+    "migrateOnly": {
+      "description": "Perform a migration, but do not update the installed version.",
+      "default": false,
+      "type": "boolean"
+    },
+    "from": {
+      "description": "When using `--migrateOnly` for a single package, the version of that package from which to migrate.",
+      "type": "string"
+    },
+    "to": {
+      "description": "When using `--migrateOnly` for a single package, the version of that package to which to migrate.",
+      "type": "string"
+    },
+    "registry": {
+      "description": "The npm registry to use.",
+      "type": "string",
+      "oneOf": [
+        {
+          "format": "uri"
+        },
+        {
+          "format": "hostname"
+        }
+      ]
+    },
+    "verbose": {
+      "description": "Display additional details during the update process.",
+      "type": "boolean"
+    },
+    "packageManager": {
+      "description": "The preferred package manager configuration files to use for registry settings.",
+      "type": "string",
+      "default": "npm",
+      "enum": ["npm", "yarn", "cnpm", "pnpm", "bun"]
+    }
+  },
+  "required": []
+}
--- a/node_modules/@angular/cli/src/commands/version/cli.d.ts
+++ b/node_modules/@angular/cli/src/commands/version/cli.d.ts
@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation } from '../../command-builder/command-module';
+export default class VersionCommandModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    aliases: string[] | undefined;
+    describe: string;
+    longDescriptionPath?: string | undefined;
+    builder(localYargs: Argv): Argv;
+    run(): Promise<void>;
+    private getVersion;
+}
--- a/node_modules/@angular/cli/src/commands/version/cli.js
+++ b/node_modules/@angular/cli/src/commands/version/cli.js
@ -0,0 +1,157 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_module_1 = __importDefault(require("node:module"));
+const node_path_1 = require("node:path");
+const command_module_1 = require("../../command-builder/command-module");
+const color_1 = require("../../utilities/color");
+const command_config_1 = require("../command-config");
+/**
+ * Major versions of Node.js that are officially supported by Angular.
+ */
+const SUPPORTED_NODE_MAJORS = [18, 20, 22];
+const PACKAGE_PATTERNS = [
+    /^@angular\/.*/,
+    /^@angular-devkit\/.*/,
+    /^@ngtools\/.*/,
+    /^@schematics\/.*/,
+    /^rxjs$/,
+    /^typescript$/,
+    /^ng-packagr$/,
+    /^webpack$/,
+    /^zone\.js$/,
+];
+class VersionCommandModule extends command_module_1.CommandModule {
+    command = 'version';
+    aliases = command_config_1.RootCommands['version'].aliases;
+    describe = 'Outputs Angular CLI version.';
+    longDescriptionPath;
+    builder(localYargs) {
+        return localYargs;
+    }
+    async run() {
+        const { packageManager, logger, root } = this.context;
+        const localRequire = node_module_1.default.createRequire((0, node_path_1.resolve)(__filename, '../../../'));
+        // Trailing slash is used to allow the path to be treated as a directory
+        const workspaceRequire = node_module_1.default.createRequire(root + '/');
+        const cliPackage = localRequire('./package.json');
+        let workspacePackage;
+        try {
+            workspacePackage = workspaceRequire('./package.json');
+        }
+        catch { }
+        const [nodeMajor] = process.versions.node.split('.').map((part) => Number(part));
+        const unsupportedNodeVersion = !SUPPORTED_NODE_MAJORS.includes(nodeMajor);
+        const packageNames = new Set(Object.keys({
+            ...cliPackage.dependencies,
+            ...cliPackage.devDependencies,
+            ...workspacePackage?.dependencies,
+            ...workspacePackage?.devDependencies,
+        }));
+        const versions = {};
+        for (const name of packageNames) {
+            if (PACKAGE_PATTERNS.some((p) => p.test(name))) {
+                versions[name] = this.getVersion(name, workspaceRequire, localRequire);
+            }
+        }
+        const ngCliVersion = cliPackage.version;
+        let angularCoreVersion = '';
+        const angularSameAsCore = [];
+        if (workspacePackage) {
+            // Filter all angular versions that are the same as core.
+            angularCoreVersion = versions['@angular/core'];
+            if (angularCoreVersion) {
+                for (const [name, version] of Object.entries(versions)) {
+                    if (version === angularCoreVersion && name.startsWith('@angular/')) {
+                        angularSameAsCore.push(name.replace(/^@angular\//, ''));
+                        delete versions[name];
+                    }
+                }
+                // Make sure we list them in alphabetical order.
+                angularSameAsCore.sort();
+            }
+        }
+        const namePad = ' '.repeat(Object.keys(versions).sort((a, b) => b.length - a.length)[0].length + 3);
+        const asciiArt = `
+     _                      _                 ____ _     ___
+    / \\   _ __   __ _ _   _| | __ _ _ __     / ___| |   |_ _|
+   / △ \\ | '_ \\ / _\` | | | | |/ _\` | '__|   | |   | |    | |
+  / ___ \\| | | | (_| | |_| | | (_| | |      | |___| |___ | |
+ /_/   \\_\\_| |_|\\__, |\\__,_|_|\\__,_|_|       \\____|_____|___|
+                |___/
+    `
+            .split('\n')
+            .map((x) => color_1.colors.red(x))
+            .join('\n');
+        logger.info(asciiArt);
+        logger.info(`
+      Angular CLI: ${ngCliVersion}
+      Node: ${process.versions.node}${unsupportedNodeVersion ? ' (Unsupported)' : ''}
+      Package Manager: ${packageManager.name} ${packageManager.version ?? '<error>'}
+      OS: ${process.platform} ${process.arch}
+
+      Angular: ${angularCoreVersion}
+      ... ${angularSameAsCore
+            .reduce((acc, name) => {
+            // Perform a simple word wrap around 60.
+            if (acc.length == 0) {
+                return [name];
+            }
+            const line = acc[acc.length - 1] + ', ' + name;
+            if (line.length > 60) {
+                acc.push(name);
+            }
+            else {
+                acc[acc.length - 1] = line;
+            }
+            return acc;
+        }, [])
+            .join('\n... ')}
+
+      Package${namePad.slice(7)}Version
+      -------${namePad.replace(/ /g, '-')}------------------
+      ${Object.keys(versions)
+            .map((module) => `${module}${namePad.slice(module.length)}${versions[module]}`)
+            .sort()
+            .join('\n')}
+    `.replace(/^ {6}/gm, ''));
+        if (unsupportedNodeVersion) {
+            logger.warn(`Warning: The current version of Node (${process.versions.node}) is not supported by Angular.`);
+        }
+    }
+    getVersion(moduleName, workspaceRequire, localRequire) {
+        let packageInfo;
+        let cliOnly = false;
+        // Try to find the package in the workspace
+        try {
+            packageInfo = workspaceRequire(`${moduleName}/package.json`);
+        }
+        catch { }
+        // If not found, try to find within the CLI
+        if (!packageInfo) {
+            try {
+                packageInfo = localRequire(`${moduleName}/package.json`);
+                cliOnly = true;
+            }
+            catch { }
+        }
+        // If found, attempt to get the version
+        if (packageInfo) {
+            try {
+                return packageInfo.version + (cliOnly ? ' (cli-only)' : '');
+            }
+            catch { }
+        }
+        return '<error>';
+    }
+}
+exports.default = VersionCommandModule;