init

node_modules/@angular/cli/src/analytics/analytics-collector.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 type { CommandContext } from '../command-builder/command-module';
+import { EventCustomDimension, EventCustomMetric, PrimitiveTypes } from './analytics-parameters';
+export declare class AnalyticsCollector {
+    private context;
+    private trackingEventsQueue;
+    private readonly requestParameterStringified;
+    private readonly userParameters;
+    constructor(context: CommandContext, userId: string);
+    reportWorkspaceInfoEvent(parameters: Partial<Record<EventCustomMetric, string | boolean | number | undefined>>): void;
+    reportRebuildRunEvent(parameters: Partial<Record<EventCustomMetric & EventCustomDimension, string | boolean | number | undefined>>): void;
+    reportBuildRunEvent(parameters: Partial<Record<EventCustomMetric & EventCustomDimension, string | boolean | number | undefined>>): void;
+    reportArchitectRunEvent(parameters: Partial<Record<EventCustomDimension, PrimitiveTypes>>): void;
+    reportSchematicRunEvent(parameters: Partial<Record<EventCustomDimension, PrimitiveTypes>>): void;
+    reportCommandRunEvent(command: string): void;
+    private event;
+    /**
+     * Flush on an interval (if the event loop is waiting).
+     *
+     * @returns a method that when called will terminate the periodic
+     * flush and call flush one last time.
+     */
+    periodFlush(): () => Promise<void>;
+    flush(): Promise<void>;
+    private send;
+}

node_modules/@angular/cli/src/analytics/analytics-collector.js

@@ -0,0 +1,194 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsCollector = void 0;
+const node_crypto_1 = require("node:crypto");
+const https = __importStar(require("node:https"));
+const os = __importStar(require("node:os"));
+const querystring = __importStar(require("node:querystring"));
+const semver = __importStar(require("semver"));
+const environment_options_1 = require("../utilities/environment-options");
+const error_1 = require("../utilities/error");
+const version_1 = require("../utilities/version");
+const analytics_parameters_1 = require("./analytics-parameters");
+const TRACKING_ID_PROD = 'G-VETNJBW8L4';
+const TRACKING_ID_STAGING = 'G-TBMPRL1BTM';
+class AnalyticsCollector {
+    context;
+    trackingEventsQueue;
+    requestParameterStringified;
+    userParameters;
+    constructor(context, userId) {
+        this.context = context;
+        const requestParameters = {
+            [analytics_parameters_1.RequestParameter.ProtocolVersion]: 2,
+            [analytics_parameters_1.RequestParameter.ClientId]: userId,
+            [analytics_parameters_1.RequestParameter.UserId]: userId,
+            [analytics_parameters_1.RequestParameter.TrackingId]: /^\d+\.\d+\.\d+$/.test(version_1.VERSION.full) && version_1.VERSION.full !== '0.0.0'
+                ? TRACKING_ID_PROD
+                : TRACKING_ID_STAGING,
+            // Built-in user properties
+            [analytics_parameters_1.RequestParameter.SessionId]: (0, node_crypto_1.randomUUID)(),
+            [analytics_parameters_1.RequestParameter.UserAgentArchitecture]: os.arch(),
+            [analytics_parameters_1.RequestParameter.UserAgentPlatform]: os.platform(),
+            [analytics_parameters_1.RequestParameter.UserAgentPlatformVersion]: os.release(),
+            [analytics_parameters_1.RequestParameter.UserAgentMobile]: 0,
+            [analytics_parameters_1.RequestParameter.SessionEngaged]: 1,
+            // The below is needed for tech details to be collected.
+            [analytics_parameters_1.RequestParameter.UserAgentFullVersionList]: 'Google%20Chrome;111.0.5563.64|Not(A%3ABrand;8.0.0.0|Chromium;111.0.5563.64',
+        };
+        if (environment_options_1.ngDebug) {
+            requestParameters[analytics_parameters_1.RequestParameter.DebugView] = 1;
+        }
+        this.requestParameterStringified = querystring.stringify(requestParameters);
+        const parsedVersion = semver.parse(process.version);
+        const packageManagerVersion = context.packageManager.version;
+        this.userParameters = {
+            // While architecture is being collect by GA as UserAgentArchitecture.
+            // It doesn't look like there is a way to query this. Therefore we collect this as a custom user dimension too.
+            [analytics_parameters_1.UserCustomDimension.OsArchitecture]: os.arch(),
+            // While User ID is being collected by GA, this is not visible in reports/for filtering.
+            [analytics_parameters_1.UserCustomDimension.UserId]: userId,
+            [analytics_parameters_1.UserCustomDimension.NodeVersion]: parsedVersion
+                ? `${parsedVersion.major}.${parsedVersion.minor}.${parsedVersion.patch}`
+                : 'other',
+            [analytics_parameters_1.UserCustomDimension.NodeMajorVersion]: parsedVersion?.major,
+            [analytics_parameters_1.UserCustomDimension.PackageManager]: context.packageManager.name,
+            [analytics_parameters_1.UserCustomDimension.PackageManagerVersion]: packageManagerVersion,
+            [analytics_parameters_1.UserCustomDimension.PackageManagerMajorVersion]: packageManagerVersion
+                ? +packageManagerVersion.split('.', 1)[0]
+                : undefined,
+            [analytics_parameters_1.UserCustomDimension.AngularCLIVersion]: version_1.VERSION.full,
+            [analytics_parameters_1.UserCustomDimension.AngularCLIMajorVersion]: version_1.VERSION.major,
+        };
+    }
+    reportWorkspaceInfoEvent(parameters) {
+        this.event('workspace_info', parameters);
+    }
+    reportRebuildRunEvent(parameters) {
+        this.event('run_rebuild', parameters);
+    }
+    reportBuildRunEvent(parameters) {
+        this.event('run_build', parameters);
+    }
+    reportArchitectRunEvent(parameters) {
+        this.event('run_architect', parameters);
+    }
+    reportSchematicRunEvent(parameters) {
+        this.event('run_schematic', parameters);
+    }
+    reportCommandRunEvent(command) {
+        this.event('run_command', { [analytics_parameters_1.EventCustomDimension.Command]: command });
+    }
+    event(eventName, parameters) {
+        this.trackingEventsQueue ??= [];
+        this.trackingEventsQueue.push({
+            ...this.userParameters,
+            ...parameters,
+            'en': eventName,
+        });
+    }
+    /**
+     * Flush on an interval (if the event loop is waiting).
+     *
+     * @returns a method that when called will terminate the periodic
+     * flush and call flush one last time.
+     */
+    periodFlush() {
+        let analyticsFlushPromise = Promise.resolve();
+        const analyticsFlushInterval = setInterval(() => {
+            if (this.trackingEventsQueue?.length) {
+                analyticsFlushPromise = analyticsFlushPromise.then(() => this.flush());
+            }
+        }, 4000);
+        return () => {
+            clearInterval(analyticsFlushInterval);
+            // Flush one last time.
+            return analyticsFlushPromise.then(() => this.flush());
+        };
+    }
+    async flush() {
+        const pendingTrackingEvents = this.trackingEventsQueue;
+        this.context.logger.debug(`Analytics flush size. ${pendingTrackingEvents?.length}.`);
+        if (!pendingTrackingEvents?.length) {
+            return;
+        }
+        // The below is needed so that if flush is called multiple times,
+        // we don't report the same event multiple times.
+        this.trackingEventsQueue = undefined;
+        try {
+            await this.send(pendingTrackingEvents);
+        }
+        catch (error) {
+            // Failure to report analytics shouldn't crash the CLI.
+            (0, error_1.assertIsError)(error);
+            this.context.logger.debug(`Send analytics error. ${error.message}.`);
+        }
+    }
+    async send(data) {
+        return new Promise((resolve, reject) => {
+            const request = https.request({
+                host: 'www.google-analytics.com',
+                method: 'POST',
+                path: '/g/collect?' + this.requestParameterStringified,
+                headers: {
+                    // The below is needed for tech details to be collected even though we provide our own information from the OS Node.js module
+                    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
+                },
+            }, (response) => {
+                // The below is needed as otherwise the response will never close which will cause the CLI not to terminate.
+                response.on('data', () => { });
+                if (response.statusCode !== 200 && response.statusCode !== 204) {
+                    reject(new Error(`Analytics reporting failed with status code: ${response.statusCode}.`));
+                }
+                else {
+                    resolve();
+                }
+            });
+            request.on('error', reject);
+            const queryParameters = data.map((p) => querystring.stringify(p)).join('\n');
+            request.write(queryParameters);
+            request.end();
+        });
+    }
+}
+exports.AnalyticsCollector = AnalyticsCollector;

node_modules/@angular/cli/src/analytics/analytics-parameters.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @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
+ */
+/** Any changes in this file needs to be done in the mts version. */
+export type PrimitiveTypes = string | number | boolean;
+/**
+ * GA built-in request parameters
+ * @see https://www.thyngster.com/ga4-measurement-protocol-cheatsheet
+ * @see http://go/depot/google3/analytics/container_tag/templates/common/gold/mpv2_schema.js
+ */
+export declare enum RequestParameter {
+    ClientId = "cid",
+    DebugView = "_dbg",
+    GtmVersion = "gtm",
+    Language = "ul",
+    NewToSite = "_nsi",
+    NonInteraction = "ni",
+    PageLocation = "dl",
+    PageTitle = "dt",
+    ProtocolVersion = "v",
+    SessionEngaged = "seg",
+    SessionId = "sid",
+    SessionNumber = "sct",
+    SessionStart = "_ss",
+    TrackingId = "tid",
+    TrafficType = "tt",
+    UserAgentArchitecture = "uaa",
+    UserAgentBitness = "uab",
+    UserAgentFullVersionList = "uafvl",
+    UserAgentMobile = "uamb",
+    UserAgentModel = "uam",
+    UserAgentPlatform = "uap",
+    UserAgentPlatformVersion = "uapv",
+    UserId = "uid"
+}
+/**
+ * User scoped custom dimensions.
+ * @remarks
+ * - User custom dimensions limit is 25.
+ * - `up.*` string type.
+ * - `upn.*` number type.
+ * @see https://support.google.com/analytics/answer/10075209?hl=en
+ */
+export declare enum UserCustomDimension {
+    UserId = "up.ng_user_id",
+    OsArchitecture = "up.ng_os_architecture",
+    NodeVersion = "up.ng_node_version",
+    NodeMajorVersion = "upn.ng_node_major_version",
+    AngularCLIVersion = "up.ng_cli_version",
+    AngularCLIMajorVersion = "upn.ng_cli_major_version",
+    PackageManager = "up.ng_package_manager",
+    PackageManagerVersion = "up.ng_pkg_manager_version",
+    PackageManagerMajorVersion = "upn.ng_pkg_manager_major_v"
+}
+/**
+ * Event scoped custom dimensions.
+ * @remarks
+ * - Event custom dimensions limit is 50.
+ * - `ep.*` string type.
+ * - `epn.*` number type.
+ * @see https://support.google.com/analytics/answer/10075209?hl=en
+ */
+export declare enum EventCustomDimension {
+    Command = "ep.ng_command",
+    SchematicCollectionName = "ep.ng_schematic_collection_name",
+    SchematicName = "ep.ng_schematic_name",
+    Standalone = "ep.ng_standalone",
+    SSR = "ep.ng_ssr",
+    Style = "ep.ng_style",
+    Routing = "ep.ng_routing",
+    InlineTemplate = "ep.ng_inline_template",
+    InlineStyle = "ep.ng_inline_style",
+    BuilderTarget = "ep.ng_builder_target",
+    Aot = "ep.ng_aot",
+    Optimization = "ep.ng_optimization"
+}
+/**
+ * Event scoped custom mertics.
+ * @remarks
+ * - Event scoped custom mertics limit is 50.
+ * - `ep.*` string type.
+ * - `epn.*` number type.
+ * @see https://support.google.com/analytics/answer/10075209?hl=en
+ */
+export declare enum EventCustomMetric {
+    AllChunksCount = "epn.ng_all_chunks_count",
+    LazyChunksCount = "epn.ng_lazy_chunks_count",
+    InitialChunksCount = "epn.ng_initial_chunks_count",
+    ChangedChunksCount = "epn.ng_changed_chunks_count",
+    DurationInMs = "epn.ng_duration_ms",
+    CssSizeInBytes = "epn.ng_css_size_bytes",
+    JsSizeInBytes = "epn.ng_js_size_bytes",
+    NgComponentCount = "epn.ng_component_count",
+    AllProjectsCount = "epn.all_projects_count",
+    LibraryProjectsCount = "epn.libs_projects_count",
+    ApplicationProjectsCount = "epn.apps_projects_count"
+}

node_modules/@angular/cli/src/analytics/analytics-parameters.js

@@ -0,0 +1,106 @@
+"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.EventCustomMetric = exports.EventCustomDimension = exports.UserCustomDimension = exports.RequestParameter = void 0;
+/**
+ * GA built-in request parameters
+ * @see https://www.thyngster.com/ga4-measurement-protocol-cheatsheet
+ * @see http://go/depot/google3/analytics/container_tag/templates/common/gold/mpv2_schema.js
+ */
+var RequestParameter;
+(function (RequestParameter) {
+    RequestParameter["ClientId"] = "cid";
+    RequestParameter["DebugView"] = "_dbg";
+    RequestParameter["GtmVersion"] = "gtm";
+    RequestParameter["Language"] = "ul";
+    RequestParameter["NewToSite"] = "_nsi";
+    RequestParameter["NonInteraction"] = "ni";
+    RequestParameter["PageLocation"] = "dl";
+    RequestParameter["PageTitle"] = "dt";
+    RequestParameter["ProtocolVersion"] = "v";
+    RequestParameter["SessionEngaged"] = "seg";
+    RequestParameter["SessionId"] = "sid";
+    RequestParameter["SessionNumber"] = "sct";
+    RequestParameter["SessionStart"] = "_ss";
+    RequestParameter["TrackingId"] = "tid";
+    RequestParameter["TrafficType"] = "tt";
+    RequestParameter["UserAgentArchitecture"] = "uaa";
+    RequestParameter["UserAgentBitness"] = "uab";
+    RequestParameter["UserAgentFullVersionList"] = "uafvl";
+    RequestParameter["UserAgentMobile"] = "uamb";
+    RequestParameter["UserAgentModel"] = "uam";
+    RequestParameter["UserAgentPlatform"] = "uap";
+    RequestParameter["UserAgentPlatformVersion"] = "uapv";
+    RequestParameter["UserId"] = "uid";
+})(RequestParameter || (exports.RequestParameter = RequestParameter = {}));
+/**
+ * User scoped custom dimensions.
+ * @remarks
+ * - User custom dimensions limit is 25.
+ * - `up.*` string type.
+ * - `upn.*` number type.
+ * @see https://support.google.com/analytics/answer/10075209?hl=en
+ */
+var UserCustomDimension;
+(function (UserCustomDimension) {
+    UserCustomDimension["UserId"] = "up.ng_user_id";
+    UserCustomDimension["OsArchitecture"] = "up.ng_os_architecture";
+    UserCustomDimension["NodeVersion"] = "up.ng_node_version";
+    UserCustomDimension["NodeMajorVersion"] = "upn.ng_node_major_version";
+    UserCustomDimension["AngularCLIVersion"] = "up.ng_cli_version";
+    UserCustomDimension["AngularCLIMajorVersion"] = "upn.ng_cli_major_version";
+    UserCustomDimension["PackageManager"] = "up.ng_package_manager";
+    UserCustomDimension["PackageManagerVersion"] = "up.ng_pkg_manager_version";
+    UserCustomDimension["PackageManagerMajorVersion"] = "upn.ng_pkg_manager_major_v";
+})(UserCustomDimension || (exports.UserCustomDimension = UserCustomDimension = {}));
+/**
+ * Event scoped custom dimensions.
+ * @remarks
+ * - Event custom dimensions limit is 50.
+ * - `ep.*` string type.
+ * - `epn.*` number type.
+ * @see https://support.google.com/analytics/answer/10075209?hl=en
+ */
+var EventCustomDimension;
+(function (EventCustomDimension) {
+    EventCustomDimension["Command"] = "ep.ng_command";
+    EventCustomDimension["SchematicCollectionName"] = "ep.ng_schematic_collection_name";
+    EventCustomDimension["SchematicName"] = "ep.ng_schematic_name";
+    EventCustomDimension["Standalone"] = "ep.ng_standalone";
+    EventCustomDimension["SSR"] = "ep.ng_ssr";
+    EventCustomDimension["Style"] = "ep.ng_style";
+    EventCustomDimension["Routing"] = "ep.ng_routing";
+    EventCustomDimension["InlineTemplate"] = "ep.ng_inline_template";
+    EventCustomDimension["InlineStyle"] = "ep.ng_inline_style";
+    EventCustomDimension["BuilderTarget"] = "ep.ng_builder_target";
+    EventCustomDimension["Aot"] = "ep.ng_aot";
+    EventCustomDimension["Optimization"] = "ep.ng_optimization";
+})(EventCustomDimension || (exports.EventCustomDimension = EventCustomDimension = {}));
+/**
+ * Event scoped custom mertics.
+ * @remarks
+ * - Event scoped custom mertics limit is 50.
+ * - `ep.*` string type.
+ * - `epn.*` number type.
+ * @see https://support.google.com/analytics/answer/10075209?hl=en
+ */
+var EventCustomMetric;
+(function (EventCustomMetric) {
+    EventCustomMetric["AllChunksCount"] = "epn.ng_all_chunks_count";
+    EventCustomMetric["LazyChunksCount"] = "epn.ng_lazy_chunks_count";
+    EventCustomMetric["InitialChunksCount"] = "epn.ng_initial_chunks_count";
+    EventCustomMetric["ChangedChunksCount"] = "epn.ng_changed_chunks_count";
+    EventCustomMetric["DurationInMs"] = "epn.ng_duration_ms";
+    EventCustomMetric["CssSizeInBytes"] = "epn.ng_css_size_bytes";
+    EventCustomMetric["JsSizeInBytes"] = "epn.ng_js_size_bytes";
+    EventCustomMetric["NgComponentCount"] = "epn.ng_component_count";
+    EventCustomMetric["AllProjectsCount"] = "epn.all_projects_count";
+    EventCustomMetric["LibraryProjectsCount"] = "epn.libs_projects_count";
+    EventCustomMetric["ApplicationProjectsCount"] = "epn.apps_projects_count";
+})(EventCustomMetric || (exports.EventCustomMetric = EventCustomMetric = {}));

node_modules/@angular/cli/src/analytics/analytics.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 type { CommandContext } from '../command-builder/command-module';
+/**
+ * This is the ultimate safelist for checking if a package name is safe to report to analytics.
+ */
+export declare const analyticsPackageSafelist: (string | RegExp)[];
+export declare function isPackageNameSafeForAnalytics(name: string): boolean;
+/**
+ * Set analytics settings. This does not work if the user is not inside a project.
+ * @param global Which config to use. "global" for user-level, and "local" for project-level.
+ * @param value Either a user ID, true to generate a new User ID, or false to disable analytics.
+ */
+export declare function setAnalyticsConfig(global: boolean, value: string | boolean): Promise<void>;
+/**
+ * Prompt the user for usage gathering permission.
+ * @param force Whether to ask regardless of whether or not the user is using an interactive shell.
+ * @return Whether or not the user was shown a prompt.
+ */
+export declare function promptAnalytics(context: CommandContext, global: boolean, force?: boolean): Promise<boolean>;
+export declare function getAnalyticsUserId(context: CommandContext, skipPrompt?: boolean): Promise<string | undefined>;
+export declare function getAnalyticsInfoString(context: CommandContext): Promise<string>;

node_modules/@angular/cli/src/analytics/analytics.js

@@ -0,0 +1,182 @@
+"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.analyticsPackageSafelist = void 0;
+exports.isPackageNameSafeForAnalytics = isPackageNameSafeForAnalytics;
+exports.setAnalyticsConfig = setAnalyticsConfig;
+exports.promptAnalytics = promptAnalytics;
+exports.getAnalyticsUserId = getAnalyticsUserId;
+exports.getAnalyticsInfoString = getAnalyticsInfoString;
+const core_1 = require("@angular-devkit/core");
+const node_crypto_1 = require("node:crypto");
+const color_1 = require("../utilities/color");
+const config_1 = require("../utilities/config");
+const environment_options_1 = require("../utilities/environment-options");
+const prompt_1 = require("../utilities/prompt");
+const tty_1 = require("../utilities/tty");
+/* eslint-disable no-console */
+/**
+ * This is the ultimate safelist for checking if a package name is safe to report to analytics.
+ */
+exports.analyticsPackageSafelist = [
+    /^@angular\//,
+    /^@angular-devkit\//,
+    /^@nguniversal\//,
+    '@schematics/angular',
+];
+function isPackageNameSafeForAnalytics(name) {
+    return exports.analyticsPackageSafelist.some((pattern) => {
+        if (typeof pattern == 'string') {
+            return pattern === name;
+        }
+        else {
+            return pattern.test(name);
+        }
+    });
+}
+/**
+ * Set analytics settings. This does not work if the user is not inside a project.
+ * @param global Which config to use. "global" for user-level, and "local" for project-level.
+ * @param value Either a user ID, true to generate a new User ID, or false to disable analytics.
+ */
+async function setAnalyticsConfig(global, value) {
+    const level = global ? 'global' : 'local';
+    const workspace = await (0, config_1.getWorkspace)(level);
+    if (!workspace) {
+        throw new Error(`Could not find ${level} workspace.`);
+    }
+    const cli = (workspace.extensions['cli'] ??= {});
+    if (!workspace || !core_1.json.isJsonObject(cli)) {
+        throw new Error(`Invalid config found at ${workspace.filePath}. CLI should be an object.`);
+    }
+    cli.analytics = value === true ? (0, node_crypto_1.randomUUID)() : value;
+    await workspace.save();
+}
+/**
+ * Prompt the user for usage gathering permission.
+ * @param force Whether to ask regardless of whether or not the user is using an interactive shell.
+ * @return Whether or not the user was shown a prompt.
+ */
+async function promptAnalytics(context, global, force = false) {
+    const level = global ? 'global' : 'local';
+    const workspace = await (0, config_1.getWorkspace)(level);
+    if (!workspace) {
+        throw new Error(`Could not find a ${level} workspace. Are you in a project?`);
+    }
+    if (force || (0, tty_1.isTTY)()) {
+        const answer = await (0, prompt_1.askConfirmation)(`
+Would you like to share pseudonymous usage data about this project with the Angular Team
+at Google under Google's Privacy Policy at https://policies.google.com/privacy. For more
+details and how to change this setting, see https://angular.dev/cli/analytics.
+
+  `, false);
+        await setAnalyticsConfig(global, answer);
+        if (answer) {
+            console.log('');
+            console.log(core_1.tags.stripIndent `
+         Thank you for sharing pseudonymous usage data. Should you change your mind, the following
+         command will disable this feature entirely:
+
+             ${color_1.colors.yellow(`ng analytics disable${global ? ' --global' : ''}`)}
+       `);
+            console.log('');
+        }
+        process.stderr.write(await getAnalyticsInfoString(context));
+        return true;
+    }
+    return false;
+}
+/**
+ * Get the analytics user id.
+ *
+ * @returns
+ * - `string` user id.
+ * - `false` when disabled.
+ * - `undefined` when not configured.
+ */
+async function getAnalyticsUserIdForLevel(level) {
+    if (environment_options_1.analyticsDisabled) {
+        return false;
+    }
+    const workspace = await (0, config_1.getWorkspace)(level);
+    const analyticsConfig = workspace?.getCli()?.['analytics'];
+    if (analyticsConfig === false) {
+        return false;
+    }
+    else if (analyticsConfig === undefined || analyticsConfig === null) {
+        return undefined;
+    }
+    else {
+        if (typeof analyticsConfig == 'string') {
+            return analyticsConfig;
+        }
+        else if (typeof analyticsConfig == 'object' && typeof analyticsConfig['uid'] == 'string') {
+            return analyticsConfig['uid'];
+        }
+        return undefined;
+    }
+}
+async function getAnalyticsUserId(context, skipPrompt = false) {
+    const { workspace } = context;
+    // Global config takes precedence over local config only for the disabled check.
+    // IE:
+    // global: disabled & local: enabled = disabled
+    // global: id: 123 & local: id: 456 = 456
+    // check global
+    const globalConfig = await getAnalyticsUserIdForLevel('global');
+    if (globalConfig === false) {
+        return undefined;
+    }
+    // Not disabled globally, check locally or not set globally and command is run outside of workspace example: `ng new`
+    if (workspace || globalConfig === undefined) {
+        const level = workspace ? 'local' : 'global';
+        let localOrGlobalConfig = await getAnalyticsUserIdForLevel(level);
+        if (localOrGlobalConfig === undefined) {
+            if (!skipPrompt) {
+                // config is unset, prompt user.
+                // TODO: This should honor the `no-interactive` option.
+                // It is currently not an `ng` option but rather only an option for specific commands.
+                // The concept of `ng`-wide options are needed to cleanly handle this.
+                await promptAnalytics(context, !workspace /** global */);
+                localOrGlobalConfig = await getAnalyticsUserIdForLevel(level);
+            }
+        }
+        if (localOrGlobalConfig === false) {
+            return undefined;
+        }
+        else if (typeof localOrGlobalConfig === 'string') {
+            return localOrGlobalConfig;
+        }
+    }
+    return globalConfig;
+}
+function analyticsConfigValueToHumanFormat(value) {
+    if (value === false) {
+        return 'disabled';
+    }
+    else if (typeof value === 'string' || value === true) {
+        return 'enabled';
+    }
+    else {
+        return 'not set';
+    }
+}
+async function getAnalyticsInfoString(context) {
+    const analyticsInstance = await getAnalyticsUserId(context, true /** skipPrompt */);
+    const { globalConfiguration, workspace: localWorkspace } = context;
+    const globalSetting = globalConfiguration?.getCli()?.['analytics'];
+    const localSetting = localWorkspace?.getCli()?.['analytics'];
+    return (core_1.tags.stripIndents `
+     Global setting: ${analyticsConfigValueToHumanFormat(globalSetting)}
+     Local setting: ${localWorkspace
+        ? analyticsConfigValueToHumanFormat(localSetting)
+        : 'No local workspace configuration file.'}
+     Effective status: ${analyticsInstance ? 'enabled' : 'disabled'}
+   ` + '\n');
+}

node_modules/@angular/cli/src/command-builder/architect-base-command-module.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @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 { Architect, Target } from '@angular-devkit/architect';
+import { WorkspaceNodeModulesArchitectHost } from '@angular-devkit/architect/node';
+import { CommandModule, CommandModuleImplementation, CommandScope, OtherOptions } from './command-module';
+import { Option } from './utilities/json-schema';
+export interface MissingTargetChoice {
+    name: string;
+    value: string;
+}
+export declare abstract class ArchitectBaseCommandModule<T extends object> extends CommandModule<T> implements CommandModuleImplementation<T> {
+    scope: CommandScope;
+    protected readonly missingTargetChoices: MissingTargetChoice[] | undefined;
+    protected runSingleTarget(target: Target, options: OtherOptions): Promise<number>;
+    private builderStatsToAnalyticsParameters;
+    private _architectHost;
+    protected getArchitectHost(): WorkspaceNodeModulesArchitectHost;
+    private _architect;
+    protected getArchitect(skipUndefinedArrayTransform: boolean): Architect;
+    protected getArchitectTargetOptions(target: Target): Promise<Option[]>;
+    private warnOnMissingNodeModules;
+    protected getArchitectTarget(): string;
+    protected onMissingTarget(defaultMessage: string): Promise<1>;
+    private getMissingTargetPackageToInstall;
+}

node_modules/@angular/cli/src/command-builder/architect-base-command-module.js

@@ -0,0 +1,246 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchitectBaseCommandModule = void 0;
+const architect_1 = require("@angular-devkit/architect");
+const node_1 = require("@angular-devkit/architect/node");
+const core_1 = require("@angular-devkit/core");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const analytics_1 = require("../analytics/analytics");
+const analytics_parameters_1 = require("../analytics/analytics-parameters");
+const error_1 = require("../utilities/error");
+const prompt_1 = require("../utilities/prompt");
+const tty_1 = require("../utilities/tty");
+const command_module_1 = require("./command-module");
+const json_schema_1 = require("./utilities/json-schema");
+class ArchitectBaseCommandModule extends command_module_1.CommandModule {
+    scope = command_module_1.CommandScope.In;
+    missingTargetChoices;
+    async runSingleTarget(target, options) {
+        const architectHost = this.getArchitectHost();
+        let builderName;
+        try {
+            builderName = await architectHost.getBuilderNameForTarget(target);
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            return this.onMissingTarget(e.message);
+        }
+        const isAngularBuild = builderName.startsWith('@angular/build:');
+        const { logger } = this.context;
+        const run = await this.getArchitect(isAngularBuild).scheduleTarget(target, options, {
+            logger,
+        });
+        const analytics = (0, analytics_1.isPackageNameSafeForAnalytics)(builderName)
+            ? await this.getAnalytics()
+            : undefined;
+        let outputSubscription;
+        if (analytics) {
+            analytics.reportArchitectRunEvent({
+                [analytics_parameters_1.EventCustomDimension.BuilderTarget]: builderName,
+            });
+            let firstRun = true;
+            outputSubscription = run.output.subscribe(({ stats }) => {
+                const parameters = this.builderStatsToAnalyticsParameters(stats, builderName);
+                if (!parameters) {
+                    return;
+                }
+                if (firstRun) {
+                    firstRun = false;
+                    analytics.reportBuildRunEvent(parameters);
+                }
+                else {
+                    analytics.reportRebuildRunEvent(parameters);
+                }
+            });
+        }
+        try {
+            const { error, success } = await run.lastOutput;
+            if (error) {
+                logger.error(error);
+            }
+            return success ? 0 : 1;
+        }
+        finally {
+            await run.stop();
+            outputSubscription?.unsubscribe();
+        }
+    }
+    builderStatsToAnalyticsParameters(stats, builderName) {
+        if (!stats || typeof stats !== 'object' || !('durationInMs' in stats)) {
+            return undefined;
+        }
+        const { optimization, allChunksCount, aot, lazyChunksCount, initialChunksCount, durationInMs, changedChunksCount, cssSizeInBytes, jsSizeInBytes, ngComponentCount, } = stats;
+        return {
+            [analytics_parameters_1.EventCustomDimension.BuilderTarget]: builderName,
+            [analytics_parameters_1.EventCustomDimension.Aot]: aot,
+            [analytics_parameters_1.EventCustomDimension.Optimization]: optimization,
+            [analytics_parameters_1.EventCustomMetric.AllChunksCount]: allChunksCount,
+            [analytics_parameters_1.EventCustomMetric.LazyChunksCount]: lazyChunksCount,
+            [analytics_parameters_1.EventCustomMetric.InitialChunksCount]: initialChunksCount,
+            [analytics_parameters_1.EventCustomMetric.ChangedChunksCount]: changedChunksCount,
+            [analytics_parameters_1.EventCustomMetric.DurationInMs]: durationInMs,
+            [analytics_parameters_1.EventCustomMetric.JsSizeInBytes]: jsSizeInBytes,
+            [analytics_parameters_1.EventCustomMetric.CssSizeInBytes]: cssSizeInBytes,
+            [analytics_parameters_1.EventCustomMetric.NgComponentCount]: ngComponentCount,
+        };
+    }
+    _architectHost;
+    getArchitectHost() {
+        if (this._architectHost) {
+            return this._architectHost;
+        }
+        const workspace = this.getWorkspaceOrThrow();
+        return (this._architectHost = new node_1.WorkspaceNodeModulesArchitectHost(workspace, workspace.basePath));
+    }
+    _architect;
+    getArchitect(skipUndefinedArrayTransform) {
+        if (this._architect) {
+            return this._architect;
+        }
+        const registry = new core_1.json.schema.CoreSchemaRegistry();
+        if (skipUndefinedArrayTransform) {
+            registry.addPostTransform(core_1.json.schema.transforms.addUndefinedObjectDefaults);
+        }
+        else {
+            registry.addPostTransform(core_1.json.schema.transforms.addUndefinedDefaults);
+        }
+        registry.useXDeprecatedProvider((msg) => this.context.logger.warn(msg));
+        const architectHost = this.getArchitectHost();
+        return (this._architect = new architect_1.Architect(architectHost, registry));
+    }
+    async getArchitectTargetOptions(target) {
+        const architectHost = this.getArchitectHost();
+        let builderConf;
+        try {
+            builderConf = await architectHost.getBuilderNameForTarget(target);
+        }
+        catch {
+            return [];
+        }
+        let builderDesc;
+        try {
+            builderDesc = await architectHost.resolveBuilder(builderConf);
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            if (e.code === 'MODULE_NOT_FOUND') {
+                this.warnOnMissingNodeModules();
+                throw new command_module_1.CommandModuleError(`Could not find the '${builderConf}' builder's node package.`);
+            }
+            throw e;
+        }
+        return (0, json_schema_1.parseJsonSchemaToOptions)(new core_1.json.schema.CoreSchemaRegistry(), builderDesc.optionSchema, true);
+    }
+    warnOnMissingNodeModules() {
+        const basePath = this.context.workspace?.basePath;
+        if (!basePath) {
+            return;
+        }
+        // Check if yarn PnP is used. https://yarnpkg.com/advanced/pnpapi#processversionspnp
+        if (process.versions.pnp) {
+            return;
+        }
+        // Check for a `node_modules` directory (npm, yarn non-PnP, etc.)
+        if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(basePath, 'node_modules'))) {
+            return;
+        }
+        this.context.logger.warn(`Node packages may not be installed. Try installing with '${this.context.packageManager.name} install'.`);
+    }
+    getArchitectTarget() {
+        return this.commandName;
+    }
+    async onMissingTarget(defaultMessage) {
+        const { logger } = this.context;
+        const choices = this.missingTargetChoices;
+        if (!choices?.length) {
+            logger.error(defaultMessage);
+            return 1;
+        }
+        const missingTargetMessage = `Cannot find "${this.getArchitectTarget()}" target for the specified project.\n` +
+            `You can add a package that implements these capabilities.\n\n` +
+            `For example:\n` +
+            choices.map(({ name, value }) => `  ${name}: ng add ${value}`).join('\n') +
+            '\n';
+        if ((0, tty_1.isTTY)()) {
+            // Use prompts to ask the user if they'd like to install a package.
+            logger.warn(missingTargetMessage);
+            const packageToInstall = await this.getMissingTargetPackageToInstall(choices);
+            if (packageToInstall) {
+                // Example run: `ng add angular-eslint`.
+                const AddCommandModule = (await Promise.resolve().then(() => __importStar(require('../commands/add/cli')))).default;
+                await new AddCommandModule(this.context).run({
+                    interactive: true,
+                    force: false,
+                    dryRun: false,
+                    defaults: false,
+                    collection: packageToInstall,
+                });
+            }
+        }
+        else {
+            // Non TTY display error message.
+            logger.error(missingTargetMessage);
+        }
+        return 1;
+    }
+    async getMissingTargetPackageToInstall(choices) {
+        if (choices.length === 1) {
+            // Single choice
+            const { name, value } = choices[0];
+            if (await (0, prompt_1.askConfirmation)(`Would you like to add ${name} now?`, true, false)) {
+                return value;
+            }
+            return null;
+        }
+        // Multiple choice
+        return (0, prompt_1.askQuestion)(`Would you like to add a package with "${this.getArchitectTarget()}" capabilities now?`, [
+            {
+                name: 'No',
+                value: null,
+            },
+            ...choices,
+        ], 0, null);
+    }
+}
+exports.ArchitectBaseCommandModule = ArchitectBaseCommandModule;

node_modules/@angular/cli/src/command-builder/architect-command-module.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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 { workspaces } from '@angular-devkit/core';
+import { Argv } from 'yargs';
+import { ArchitectBaseCommandModule } from './architect-base-command-module';
+import { CommandModuleImplementation, Options, OtherOptions } from './command-module';
+export interface ArchitectCommandArgs {
+    configuration?: string;
+    project?: string;
+}
+export declare abstract class ArchitectCommandModule extends ArchitectBaseCommandModule<ArchitectCommandArgs> implements CommandModuleImplementation<ArchitectCommandArgs> {
+    abstract readonly multiTarget: boolean;
+    findDefaultBuilderName?(project: workspaces.ProjectDefinition, target: Target): Promise<string | undefined>;
+    builder(argv: Argv): Promise<Argv<ArchitectCommandArgs>>;
+    run(options: Options<ArchitectCommandArgs> & OtherOptions): Promise<number | void>;
+    private getArchitectProject;
+    private getProjectNamesByTarget;
+    /** @returns a sorted list of project names to be used for auto completion. */
+    private getProjectChoices;
+    /** @returns a sorted list of configuration names to be used for auto completion. */
+    private getConfigurationChoices;
+}

node_modules/@angular/cli/src/command-builder/architect-command-module.js

@@ -0,0 +1,210 @@
+"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 __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchitectCommandModule = void 0;
+const config_1 = require("../utilities/config");
+const memoize_1 = require("../utilities/memoize");
+const architect_base_command_module_1 = require("./architect-base-command-module");
+const command_module_1 = require("./command-module");
+let ArchitectCommandModule = (() => {
+    let _classSuper = architect_base_command_module_1.ArchitectBaseCommandModule;
+    let _instanceExtraInitializers = [];
+    let _getProjectNamesByTarget_decorators;
+    return class ArchitectCommandModule extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _getProjectNamesByTarget_decorators = [memoize_1.memoize];
+            __esDecorate(this, null, _getProjectNamesByTarget_decorators, { kind: "method", name: "getProjectNamesByTarget", static: false, private: false, access: { has: obj => "getProjectNamesByTarget" in obj, get: obj => obj.getProjectNamesByTarget }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        async builder(argv) {
+            const target = this.getArchitectTarget();
+            // Add default builder if target is not in project and a command default is provided
+            if (this.findDefaultBuilderName && this.context.workspace) {
+                for (const [project, projectDefinition] of this.context.workspace.projects) {
+                    if (projectDefinition.targets.has(target)) {
+                        continue;
+                    }
+                    const defaultBuilder = await this.findDefaultBuilderName(projectDefinition, {
+                        project,
+                        target,
+                    });
+                    if (defaultBuilder) {
+                        projectDefinition.targets.set(target, {
+                            builder: defaultBuilder,
+                        });
+                    }
+                }
+            }
+            const project = this.getArchitectProject();
+            const { jsonHelp, getYargsCompletions, help } = this.context.args.options;
+            const localYargs = argv
+                .positional('project', {
+                describe: 'The name of the project to build. Can be an application or a library.',
+                type: 'string',
+                // Hide choices from JSON help so that we don't display them in AIO.
+                choices: jsonHelp ? undefined : this.getProjectChoices(),
+            })
+                .option('configuration', {
+                describe: `One or more named builder configurations as a comma-separated ` +
+                    `list as specified in the "configurations" section in angular.json.\n` +
+                    `The builder uses the named configurations to run the given target.\n` +
+                    `For more information, see https://angular.dev/reference/configs/workspace-config#alternate-build-configurations.`,
+                alias: 'c',
+                type: 'string',
+                // 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 && project
+                    ? this.getConfigurationChoices(project)
+                    : undefined,
+            })
+                .strict();
+            if (!project) {
+                return localYargs;
+            }
+            const schemaOptions = await this.getArchitectTargetOptions({
+                project,
+                target,
+            });
+            return this.addSchemaOptionsToCommand(localYargs, schemaOptions);
+        }
+        async run(options) {
+            const originalProcessTitle = process.title;
+            try {
+                const target = this.getArchitectTarget();
+                const { configuration = '', project, ...architectOptions } = options;
+                if (project) {
+                    process.title = `${originalProcessTitle} (${project})`;
+                    return await this.runSingleTarget({ configuration, target, project }, architectOptions);
+                }
+                // This runs each target sequentially.
+                // Running them in parallel would jumble the log messages.
+                let result = 0;
+                const projectNames = this.getProjectNamesByTarget(target);
+                if (!projectNames) {
+                    return this.onMissingTarget('Cannot determine project or target for command.');
+                }
+                for (const project of projectNames) {
+                    process.title = `${originalProcessTitle} (${project})`;
+                    result |= await this.runSingleTarget({ configuration, target, project }, architectOptions);
+                }
+                return result;
+            }
+            finally {
+                process.title = originalProcessTitle;
+            }
+        }
+        getArchitectProject() {
+            const { options, positional } = this.context.args;
+            const [, projectName] = positional;
+            if (projectName) {
+                return projectName;
+            }
+            // Yargs allows positional args to be used as flags.
+            if (typeof options['project'] === 'string') {
+                return options['project'];
+            }
+            const target = this.getArchitectTarget();
+            const projectFromTarget = this.getProjectNamesByTarget(target);
+            return projectFromTarget?.length ? projectFromTarget[0] : undefined;
+        }
+        getProjectNamesByTarget(target) {
+            const workspace = this.getWorkspaceOrThrow();
+            const allProjectsForTargetName = [];
+            for (const [name, project] of workspace.projects) {
+                if (project.targets.has(target)) {
+                    allProjectsForTargetName.push(name);
+                }
+            }
+            if (allProjectsForTargetName.length === 0) {
+                return undefined;
+            }
+            if (this.multiTarget) {
+                // For multi target commands, we always list all projects that have the target.
+                return allProjectsForTargetName;
+            }
+            else {
+                if (allProjectsForTargetName.length === 1) {
+                    return allProjectsForTargetName;
+                }
+                const maybeProject = (0, config_1.getProjectByCwd)(workspace);
+                if (maybeProject) {
+                    return allProjectsForTargetName.includes(maybeProject) ? [maybeProject] : undefined;
+                }
+                const { getYargsCompletions, help } = this.context.args.options;
+                if (!getYargsCompletions && !help) {
+                    // Only issue the below error when not in help / completion mode.
+                    throw new command_module_1.CommandModuleError('Cannot determine project for command.\n' +
+                        'This is a multi-project workspace and more than one project supports this command. ' +
+                        `Run "ng ${this.command}" to execute the command for a specific project or change the current ` +
+                        'working directory to a project directory.\n\n' +
+                        `Available projects are:\n${allProjectsForTargetName
+                            .sort()
+                            .map((p) => `- ${p}`)
+                            .join('\n')}`);
+                }
+            }
+            return undefined;
+        }
+        /** @returns a sorted list of project names to be used for auto completion. */
+        getProjectChoices() {
+            const { workspace } = this.context;
+            return workspace ? [...workspace.projects.keys()].sort() : undefined;
+        }
+        /** @returns a sorted list of configuration names to be used for auto completion. */
+        getConfigurationChoices(project) {
+            const projectDefinition = this.context.workspace?.projects.get(project);
+            if (!projectDefinition) {
+                return undefined;
+            }
+            const target = this.getArchitectTarget();
+            const configurations = projectDefinition.targets.get(target)?.configurations;
+            return configurations ? Object.keys(configurations).sort() : undefined;
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+})();
+exports.ArchitectCommandModule = ArchitectCommandModule;

node_modules/@angular/cli/src/command-builder/command-module.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @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 { logging } from '@angular-devkit/core';
+import type { ArgumentsCamelCase, Argv, CamelCaseKey, CommandModule as YargsCommandModule } from 'yargs' with { 'resolution-mode': 'require' };
+import { AnalyticsCollector } from '../analytics/analytics-collector';
+import { EventCustomDimension, EventCustomMetric } from '../analytics/analytics-parameters';
+import { AngularWorkspace } from '../utilities/config';
+import { PackageManagerUtils } from '../utilities/package-manager';
+import { Option } from './utilities/json-schema';
+export type Options<T> = {
+    [key in keyof T as CamelCaseKey<key>]: T[key];
+};
+export declare enum CommandScope {
+    /** Command can only run inside an Angular workspace. */
+    In = 0,
+    /** Command can only run outside an Angular workspace. */
+    Out = 1,
+    /** Command can run inside and outside an Angular workspace. */
+    Both = 2
+}
+export interface CommandContext {
+    currentDirectory: string;
+    root: string;
+    workspace?: AngularWorkspace;
+    globalConfiguration: AngularWorkspace;
+    logger: logging.Logger;
+    packageManager: PackageManagerUtils;
+    yargsInstance: Argv<{}>;
+    /** Arguments parsed in free-from without parser configuration. */
+    args: {
+        positional: string[];
+        options: {
+            help: boolean;
+            jsonHelp: boolean;
+            getYargsCompletions: boolean;
+        } & Record<string, unknown>;
+    };
+}
+export type OtherOptions = Record<string, unknown>;
+export interface CommandModuleImplementation<T extends {} = {}> extends Omit<YargsCommandModule<{}, T>, 'builder' | 'handler'> {
+    /** Scope in which the command can be executed in. */
+    scope: CommandScope;
+    /** Path used to load the long description for the command in JSON help text. */
+    longDescriptionPath?: string;
+    /** Object declaring the options the command accepts, or a function accepting and returning a yargs instance. */
+    builder(argv: Argv): Promise<Argv<T>> | Argv<T>;
+    /** A function which will be passed the parsed argv. */
+    run(options: Options<T> & OtherOptions): Promise<number | void> | number | void;
+}
+export interface FullDescribe {
+    describe?: string;
+    longDescription?: string;
+    longDescriptionRelativePath?: string;
+}
+export declare abstract class CommandModule<T extends {} = {}> implements CommandModuleImplementation<T> {
+    protected readonly context: CommandContext;
+    abstract readonly command: string;
+    abstract readonly describe: string | false;
+    abstract readonly longDescriptionPath?: string;
+    protected readonly shouldReportAnalytics: boolean;
+    readonly scope: CommandScope;
+    private readonly optionsWithAnalytics;
+    constructor(context: CommandContext);
+    /**
+     * Description object which contains the long command descroption.
+     * This is used to generate JSON help wich is used in AIO.
+     *
+     * `false` will result in a hidden command.
+     */
+    get fullDescribe(): FullDescribe | false;
+    protected get commandName(): string;
+    abstract builder(argv: Argv): Promise<Argv<T>> | Argv<T>;
+    abstract run(options: Options<T> & OtherOptions): Promise<number | void> | number | void;
+    handler(args: ArgumentsCamelCase<T> & OtherOptions): Promise<void>;
+    protected getAnalytics(): Promise<AnalyticsCollector | undefined>;
+    /**
+     * Adds schema options to a command also this keeps track of options that are required for analytics.
+     * **Note:** This method should be called from the command bundler method.
+     */
+    protected addSchemaOptionsToCommand<T>(localYargs: Argv<T>, options: Option[]): Argv<T>;
+    protected getWorkspaceOrThrow(): AngularWorkspace;
+    /**
+     * Flush on an interval (if the event loop is waiting).
+     *
+     * @returns a method that when called will terminate the periodic
+     * flush and call flush one last time.
+     */
+    protected getAnalyticsParameters(options: (Options<T> & OtherOptions) | OtherOptions): Partial<Record<EventCustomDimension | EventCustomMetric, string | boolean | number>>;
+    private reportCommandRunAnalytics;
+    private reportWorkspaceInfoAnalytics;
+}
+/**
+ * Creates an known command module error.
+ * This is used so during executation we can filter between known validation error and real non handled errors.
+ */
+export declare class CommandModuleError extends Error {
+}

node_modules/@angular/cli/src/command-builder/command-module.js

@@ -0,0 +1,281 @@
+"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 __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandModuleError = exports.CommandModule = exports.CommandScope = void 0;
+const core_1 = require("@angular-devkit/core");
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const helpers_1 = require("yargs/helpers");
+const analytics_1 = require("../analytics/analytics");
+const analytics_collector_1 = require("../analytics/analytics-collector");
+const analytics_parameters_1 = require("../analytics/analytics-parameters");
+const completion_1 = require("../utilities/completion");
+const memoize_1 = require("../utilities/memoize");
+const json_schema_1 = require("./utilities/json-schema");
+var CommandScope;
+(function (CommandScope) {
+    /** Command can only run inside an Angular workspace. */
+    CommandScope[CommandScope["In"] = 0] = "In";
+    /** Command can only run outside an Angular workspace. */
+    CommandScope[CommandScope["Out"] = 1] = "Out";
+    /** Command can run inside and outside an Angular workspace. */
+    CommandScope[CommandScope["Both"] = 2] = "Both";
+})(CommandScope || (exports.CommandScope = CommandScope = {}));
+let CommandModule = (() => {
+    let _instanceExtraInitializers = [];
+    let _getAnalytics_decorators;
+    return class CommandModule {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getAnalytics_decorators = [memoize_1.memoize];
+            __esDecorate(this, null, _getAnalytics_decorators, { kind: "method", name: "getAnalytics", static: false, private: false, access: { has: obj => "getAnalytics" in obj, get: obj => obj.getAnalytics }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        context = __runInitializers(this, _instanceExtraInitializers);
+        shouldReportAnalytics = true;
+        scope = CommandScope.Both;
+        optionsWithAnalytics = new Map();
+        constructor(context) {
+            this.context = context;
+        }
+        /**
+         * Description object which contains the long command descroption.
+         * This is used to generate JSON help wich is used in AIO.
+         *
+         * `false` will result in a hidden command.
+         */
+        get fullDescribe() {
+            return this.describe === false
+                ? false
+                : {
+                    describe: this.describe,
+                    ...(this.longDescriptionPath
+                        ? {
+                            longDescriptionRelativePath: path
+                                .relative(path.join(__dirname, '../../../../'), this.longDescriptionPath)
+                                .replace(/\\/g, path.posix.sep),
+                            longDescription: (0, node_fs_1.readFileSync)(this.longDescriptionPath, 'utf8').replace(/\r\n/g, '\n'),
+                        }
+                        : {}),
+                };
+        }
+        get commandName() {
+            return this.command.split(' ', 1)[0];
+        }
+        async handler(args) {
+            const { _, $0, ...options } = args;
+            // Camelize options as yargs will return the object in kebab-case when camel casing is disabled.
+            const camelCasedOptions = {};
+            for (const [key, value] of Object.entries(options)) {
+                camelCasedOptions[helpers_1.Parser.camelCase(key)] = value;
+            }
+            // Set up autocompletion if appropriate.
+            const autocompletionExitCode = await (0, completion_1.considerSettingUpAutocompletion)(this.commandName, this.context.logger);
+            if (autocompletionExitCode !== undefined) {
+                process.exitCode = autocompletionExitCode;
+                return;
+            }
+            // Gather and report analytics.
+            const analytics = await this.getAnalytics();
+            const stopPeriodicFlushes = analytics && analytics.periodFlush();
+            let exitCode;
+            try {
+                if (analytics) {
+                    this.reportCommandRunAnalytics(analytics);
+                    this.reportWorkspaceInfoAnalytics(analytics);
+                }
+                exitCode = await this.run(camelCasedOptions);
+            }
+            catch (e) {
+                if (e instanceof core_1.schema.SchemaValidationException) {
+                    this.context.logger.fatal(`Error: ${e.message}`);
+                    exitCode = 1;
+                }
+                else {
+                    throw e;
+                }
+            }
+            finally {
+                await stopPeriodicFlushes?.();
+                if (typeof exitCode === 'number' && exitCode > 0) {
+                    process.exitCode = exitCode;
+                }
+            }
+        }
+        async getAnalytics() {
+            if (!this.shouldReportAnalytics) {
+                return undefined;
+            }
+            const userId = await (0, analytics_1.getAnalyticsUserId)(this.context, 
+            // Don't prompt on `ng update`, 'ng version' or `ng analytics`.
+            ['version', 'update', 'analytics'].includes(this.commandName));
+            return userId ? new analytics_collector_1.AnalyticsCollector(this.context, userId) : undefined;
+        }
+        /**
+         * Adds schema options to a command also this keeps track of options that are required for analytics.
+         * **Note:** This method should be called from the command bundler method.
+         */
+        addSchemaOptionsToCommand(localYargs, options) {
+            const optionsWithAnalytics = (0, json_schema_1.addSchemaOptionsToCommand)(localYargs, options, 
+            // This should only be done when `--help` is used otherwise default will override options set in angular.json.
+            /* includeDefaultValues= */ this.context.args.options.help);
+            // Record option of analytics.
+            for (const [name, userAnalytics] of optionsWithAnalytics) {
+                this.optionsWithAnalytics.set(name, userAnalytics);
+            }
+            return localYargs;
+        }
+        getWorkspaceOrThrow() {
+            const { workspace } = this.context;
+            if (!workspace) {
+                throw new CommandModuleError('A workspace is required for this command.');
+            }
+            return workspace;
+        }
+        /**
+         * Flush on an interval (if the event loop is waiting).
+         *
+         * @returns a method that when called will terminate the periodic
+         * flush and call flush one last time.
+         */
+        getAnalyticsParameters(options) {
+            const parameters = {};
+            const validEventCustomDimensionAndMetrics = new Set([
+                ...Object.values(analytics_parameters_1.EventCustomDimension),
+                ...Object.values(analytics_parameters_1.EventCustomMetric),
+            ]);
+            for (const [name, ua] of this.optionsWithAnalytics) {
+                if (!validEventCustomDimensionAndMetrics.has(ua)) {
+                    continue;
+                }
+                const value = options[name];
+                if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                    parameters[ua] = value;
+                }
+                else if (Array.isArray(value)) {
+                    // GA doesn't allow array as values.
+                    parameters[ua] = value.sort().join(', ');
+                }
+            }
+            return parameters;
+        }
+        reportCommandRunAnalytics(analytics) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const internalMethods = this.context.yargsInstance.getInternalMethods();
+            // $0 generate component [name] -> generate_component
+            // $0 add <collection> -> add
+            const fullCommand = internalMethods.getUsageInstance().getUsage()[0][0]
+                .split(' ')
+                .filter((x) => {
+                const code = x.charCodeAt(0);
+                return code >= 97 && code <= 122;
+            })
+                .join('_');
+            analytics.reportCommandRunEvent(fullCommand);
+        }
+        reportWorkspaceInfoAnalytics(analytics) {
+            const { workspace } = this.context;
+            if (!workspace) {
+                return;
+            }
+            let applicationProjectsCount = 0;
+            let librariesProjectsCount = 0;
+            for (const project of workspace.projects.values()) {
+                switch (project.extensions['projectType']) {
+                    case 'application':
+                        applicationProjectsCount++;
+                        break;
+                    case 'library':
+                        librariesProjectsCount++;
+                        break;
+                }
+            }
+            analytics.reportWorkspaceInfoEvent({
+                [analytics_parameters_1.EventCustomMetric.AllProjectsCount]: librariesProjectsCount + applicationProjectsCount,
+                [analytics_parameters_1.EventCustomMetric.ApplicationProjectsCount]: applicationProjectsCount,
+                [analytics_parameters_1.EventCustomMetric.LibraryProjectsCount]: librariesProjectsCount,
+            });
+        }
+    };
+})();
+exports.CommandModule = CommandModule;
+/**
+ * Creates an known command module error.
+ * This is used so during executation we can filter between known validation error and real non handled errors.
+ */
+class CommandModuleError extends Error {
+}
+exports.CommandModuleError = CommandModuleError;

node_modules/@angular/cli/src/command-builder/command-runner.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @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 { logging } from '@angular-devkit/core';
+export declare function runCommand(args: string[], logger: logging.Logger): Promise<number>;

node_modules/@angular/cli/src/command-builder/command-runner.js

@@ -0,0 +1,140 @@
+"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 });
+exports.runCommand = runCommand;
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const command_config_1 = require("../commands/command-config");
+const color_1 = require("../utilities/color");
+const config_1 = require("../utilities/config");
+const error_1 = require("../utilities/error");
+const package_manager_1 = require("../utilities/package-manager");
+const version_1 = require("../utilities/version");
+const command_module_1 = require("./command-module");
+const command_1 = require("./utilities/command");
+const json_help_1 = require("./utilities/json-help");
+const normalize_options_middleware_1 = require("./utilities/normalize-options-middleware");
+const yargsParser = helpers_1.Parser;
+async function runCommand(args, logger) {
+    const { $0, _, help = false, jsonHelp = false, getYargsCompletions = false, ...rest } = yargsParser(args, {
+        boolean: ['help', 'json-help', 'get-yargs-completions'],
+        alias: { 'collection': 'c' },
+    });
+    // When `getYargsCompletions` is true the scriptName 'ng' at index 0 is not removed.
+    const positional = getYargsCompletions ? _.slice(1) : _;
+    let workspace;
+    let globalConfiguration;
+    try {
+        [workspace, globalConfiguration] = await Promise.all([
+            (0, config_1.getWorkspace)('local'),
+            (0, config_1.getWorkspace)('global'),
+        ]);
+    }
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        logger.fatal(e.message);
+        return 1;
+    }
+    const root = workspace?.basePath ?? process.cwd();
+    const localYargs = (0, yargs_1.default)(args);
+    const context = {
+        globalConfiguration,
+        workspace,
+        logger,
+        currentDirectory: process.cwd(),
+        yargsInstance: localYargs,
+        root,
+        packageManager: new package_manager_1.PackageManagerUtils({ globalConfiguration, workspace, root }),
+        args: {
+            positional: positional.map((v) => v.toString()),
+            options: {
+                help,
+                jsonHelp,
+                getYargsCompletions,
+                ...rest,
+            },
+        },
+    };
+    for (const CommandModule of await getCommandsToRegister(positional[0])) {
+        (0, command_1.addCommandModuleToYargs)(CommandModule, context);
+    }
+    if (jsonHelp) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const usageInstance = localYargs.getInternalMethods().getUsageInstance();
+        usageInstance.help = () => (0, json_help_1.jsonHelpUsage)(localYargs);
+    }
+    // Add default command to support version option when no subcommand is specified
+    localYargs.command('*', false, (builder) => builder.version('version', 'Show Angular CLI version.', version_1.VERSION.full));
+    await localYargs
+        .scriptName('ng')
+        // https://github.com/yargs/yargs/blob/main/docs/advanced.md#customizing-yargs-parser
+        .parserConfiguration({
+        'populate--': true,
+        'unknown-options-as-args': false,
+        'dot-notation': false,
+        'boolean-negation': true,
+        'strip-aliased': true,
+        'strip-dashed': true,
+        'camel-case-expansion': false,
+    })
+        .option('json-help', {
+        describe: 'Show help in JSON format.',
+        implies: ['help'],
+        hidden: true,
+        type: 'boolean',
+    })
+        .help('help', 'Shows a help message for this command in the console.')
+        // A complete list of strings can be found: https://github.com/yargs/yargs/blob/main/locales/en.json
+        .updateStrings({
+        'Commands:': color_1.colors.cyan('Commands:'),
+        'Options:': color_1.colors.cyan('Options:'),
+        'Positionals:': color_1.colors.cyan('Arguments:'),
+        'deprecated': color_1.colors.yellow('deprecated'),
+        'deprecated: %s': color_1.colors.yellow('deprecated:') + ' %s',
+        'Did you mean %s?': 'Unknown command. Did you mean %s?',
+    })
+        .epilogue('For more information, see https://angular.dev/cli/.\n')
+        .demandCommand(1, command_1.demandCommandFailureMessage)
+        .recommendCommands()
+        .middleware((0, normalize_options_middleware_1.createNormalizeOptionsMiddleware)(localYargs))
+        .version(false)
+        .showHelpOnFail(false)
+        .strict()
+        .fail((msg, err) => {
+        throw msg
+            ? // Validation failed example: `Unknown argument:`
+                new command_module_1.CommandModuleError(msg)
+            : // Unknown exception, re-throw.
+                err;
+    })
+        .wrap(localYargs.terminalWidth())
+        .parseAsync();
+    return +(process.exitCode ?? 0);
+}
+/**
+ * Get the commands that need to be registered.
+ * @returns One or more command factories that needs to be registered.
+ */
+async function getCommandsToRegister(commandName) {
+    const commands = [];
+    if (commandName in command_config_1.RootCommands) {
+        commands.push(command_config_1.RootCommands[commandName]);
+    }
+    else if (commandName in command_config_1.RootCommandsAliases) {
+        commands.push(command_config_1.RootCommandsAliases[commandName]);
+    }
+    else {
+        // Unknown command, register every possible command.
+        Object.values(command_config_1.RootCommands).forEach((c) => commands.push(c));
+    }
+    return Promise.all(commands.map((command) => command.factory().then((m) => m.default)));
+}

node_modules/@angular/cli/src/command-builder/schematics-command-module.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @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 { Collection } from '@angular-devkit/schematics';
+import { FileSystemCollectionDescription, FileSystemSchematicDescription, NodeWorkflow } from '@angular-devkit/schematics/tools';
+import { Argv } from 'yargs';
+import { CommandModule, CommandModuleImplementation, CommandScope, Options, OtherOptions } from './command-module';
+import { Option } from './utilities/json-schema';
+export declare const DEFAULT_SCHEMATICS_COLLECTION = "@schematics/angular";
+export interface SchematicsCommandArgs {
+    interactive: boolean;
+    force: boolean;
+    'dry-run': boolean;
+    defaults: boolean;
+}
+export interface SchematicsExecutionOptions extends Options<SchematicsCommandArgs> {
+    packageRegistry?: string;
+}
+export declare abstract class SchematicsCommandModule extends CommandModule<SchematicsCommandArgs> implements CommandModuleImplementation<SchematicsCommandArgs> {
+    scope: CommandScope;
+    protected readonly allowPrivateSchematics: boolean;
+    builder(argv: Argv): Promise<Argv<SchematicsCommandArgs>>;
+    /** Get schematic schema options.*/
+    protected getSchematicOptions(collection: Collection<FileSystemCollectionDescription, FileSystemSchematicDescription>, schematicName: string, workflow: NodeWorkflow): Promise<Option[]>;
+    protected getOrCreateWorkflowForBuilder(collectionName: string): NodeWorkflow;
+    protected getOrCreateWorkflowForExecution(collectionName: string, options: SchematicsExecutionOptions): Promise<NodeWorkflow>;
+    protected getSchematicCollections(): Promise<Set<string>>;
+    protected parseSchematicInfo(schematic: string | undefined): [collectionName: string | undefined, schematicName: string | undefined];
+    protected runSchematic(options: {
+        executionOptions: SchematicsExecutionOptions;
+        schematicOptions: OtherOptions;
+        collectionName: string;
+        schematicName: string;
+    }): Promise<number>;
+    private getProjectName;
+    private getResolvePaths;
+}

node_modules/@angular/cli/src/command-builder/schematics-command-module.js

@@ -0,0 +1,395 @@
+"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 __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchematicsCommandModule = exports.DEFAULT_SCHEMATICS_COLLECTION = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const node_path_1 = require("node:path");
+const analytics_1 = require("../analytics/analytics");
+const analytics_parameters_1 = require("../analytics/analytics-parameters");
+const config_1 = require("../utilities/config");
+const error_1 = require("../utilities/error");
+const memoize_1 = require("../utilities/memoize");
+const tty_1 = require("../utilities/tty");
+const command_module_1 = require("./command-module");
+const json_schema_1 = require("./utilities/json-schema");
+const schematic_engine_host_1 = require("./utilities/schematic-engine-host");
+const schematic_workflow_1 = require("./utilities/schematic-workflow");
+exports.DEFAULT_SCHEMATICS_COLLECTION = '@schematics/angular';
+let SchematicsCommandModule = (() => {
+    let _classSuper = command_module_1.CommandModule;
+    let _instanceExtraInitializers = [];
+    let _getOrCreateWorkflowForBuilder_decorators;
+    let _getOrCreateWorkflowForExecution_decorators;
+    let _getSchematicCollections_decorators;
+    return class SchematicsCommandModule extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _getOrCreateWorkflowForBuilder_decorators = [memoize_1.memoize];
+            _getOrCreateWorkflowForExecution_decorators = [memoize_1.memoize];
+            _getSchematicCollections_decorators = [memoize_1.memoize];
+            __esDecorate(this, null, _getOrCreateWorkflowForBuilder_decorators, { kind: "method", name: "getOrCreateWorkflowForBuilder", static: false, private: false, access: { has: obj => "getOrCreateWorkflowForBuilder" in obj, get: obj => obj.getOrCreateWorkflowForBuilder }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getOrCreateWorkflowForExecution_decorators, { kind: "method", name: "getOrCreateWorkflowForExecution", static: false, private: false, access: { has: obj => "getOrCreateWorkflowForExecution" in obj, get: obj => obj.getOrCreateWorkflowForExecution }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getSchematicCollections_decorators, { kind: "method", name: "getSchematicCollections", static: false, private: false, access: { has: obj => "getSchematicCollections" in obj, get: obj => obj.getSchematicCollections }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        scope = (__runInitializers(this, _instanceExtraInitializers), command_module_1.CommandScope.In);
+        allowPrivateSchematics = false;
+        async builder(argv) {
+            return argv
+                .option('interactive', {
+                describe: 'Enable interactive input prompts.',
+                type: 'boolean',
+                default: true,
+            })
+                .option('dry-run', {
+                describe: 'Run through and reports activity without writing out results.',
+                type: 'boolean',
+                alias: ['d'],
+                default: false,
+            })
+                .option('defaults', {
+                describe: 'Disable interactive input prompts for options with a default.',
+                type: 'boolean',
+                default: false,
+            })
+                .option('force', {
+                describe: 'Force overwriting of existing files.',
+                type: 'boolean',
+                default: false,
+            })
+                .strict();
+        }
+        /** Get schematic schema options.*/
+        async getSchematicOptions(collection, schematicName, workflow) {
+            const schematic = collection.createSchematic(schematicName, true);
+            const { schemaJson } = schematic.description;
+            if (!schemaJson) {
+                return [];
+            }
+            return (0, json_schema_1.parseJsonSchemaToOptions)(workflow.registry, schemaJson);
+        }
+        getOrCreateWorkflowForBuilder(collectionName) {
+            return new tools_1.NodeWorkflow(this.context.root, {
+                resolvePaths: this.getResolvePaths(collectionName),
+                engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
+            });
+        }
+        async getOrCreateWorkflowForExecution(collectionName, options) {
+            const { logger, root, packageManager } = this.context;
+            const { force, dryRun, packageRegistry } = options;
+            const workflow = new tools_1.NodeWorkflow(root, {
+                force,
+                dryRun,
+                packageManager: packageManager.name,
+                // A schema registry is required to allow customizing addUndefinedDefaults
+                registry: new core_1.schema.CoreSchemaRegistry(schematics_1.formats.standardFormats),
+                packageRegistry,
+                resolvePaths: this.getResolvePaths(collectionName),
+                schemaValidation: true,
+                optionTransforms: [
+                    // Add configuration file defaults
+                    async (schematic, current) => {
+                        const projectName = typeof current?.project === 'string' ? current.project : this.getProjectName();
+                        return {
+                            ...(await (0, config_1.getSchematicDefaults)(schematic.collection.name, schematic.name, projectName)),
+                            ...current,
+                        };
+                    },
+                ],
+                engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
+            });
+            workflow.registry.addPostTransform(core_1.schema.transforms.addUndefinedDefaults);
+            workflow.registry.useXDeprecatedProvider((msg) => logger.warn(msg));
+            workflow.registry.addSmartDefaultProvider('projectName', () => this.getProjectName());
+            const workingDir = (0, core_1.normalize)((0, node_path_1.relative)(this.context.root, process.cwd()));
+            workflow.registry.addSmartDefaultProvider('workingDirectory', () => workingDir === '' ? undefined : workingDir);
+            workflow.engineHost.registerOptionsTransform(async (schematic, options) => {
+                const { collection: { name: collectionName }, name: schematicName, } = schematic;
+                const analytics = (0, analytics_1.isPackageNameSafeForAnalytics)(collectionName)
+                    ? await this.getAnalytics()
+                    : undefined;
+                analytics?.reportSchematicRunEvent({
+                    [analytics_parameters_1.EventCustomDimension.SchematicCollectionName]: collectionName,
+                    [analytics_parameters_1.EventCustomDimension.SchematicName]: schematicName,
+                    ...this.getAnalyticsParameters(options),
+                });
+                return options;
+            });
+            if (options.interactive !== false && (0, tty_1.isTTY)()) {
+                workflow.registry.usePromptProvider(async (definitions) => {
+                    let prompts;
+                    const answers = {};
+                    for (const definition of definitions) {
+                        if (options.defaults && definition.default !== undefined) {
+                            continue;
+                        }
+                        // Only load prompt package if needed
+                        prompts ??= await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
+                        switch (definition.type) {
+                            case 'confirmation':
+                                answers[definition.id] = await prompts.confirm({
+                                    message: definition.message,
+                                    default: definition.default,
+                                });
+                                break;
+                            case 'list':
+                                if (!definition.items?.length) {
+                                    continue;
+                                }
+                                answers[definition.id] = await (definition.multiselect ? prompts.checkbox : prompts.select)({
+                                    message: definition.message,
+                                    validate: (values) => {
+                                        if (!definition.validator) {
+                                            return true;
+                                        }
+                                        return definition.validator(Object.values(values).map(({ value }) => value));
+                                    },
+                                    default: definition.multiselect ? undefined : definition.default,
+                                    choices: definition.items?.map((item) => typeof item == 'string'
+                                        ? {
+                                            name: item,
+                                            value: item,
+                                            checked: definition.multiselect && Array.isArray(definition.default)
+                                                ? definition.default?.includes(item)
+                                                : item === definition.default,
+                                        }
+                                        : {
+                                            ...item,
+                                            name: item.label,
+                                            value: item.value,
+                                            checked: definition.multiselect && Array.isArray(definition.default)
+                                                ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                                    definition.default?.includes(item.value)
+                                                : item.value === definition.default,
+                                        }),
+                                });
+                                break;
+                            case 'input': {
+                                let finalValue;
+                                answers[definition.id] = await prompts.input({
+                                    message: definition.message,
+                                    default: definition.default,
+                                    async validate(value) {
+                                        if (definition.validator === undefined) {
+                                            return true;
+                                        }
+                                        let lastValidation = false;
+                                        for (const type of definition.propertyTypes) {
+                                            let potential;
+                                            switch (type) {
+                                                case 'string':
+                                                    potential = String(value);
+                                                    break;
+                                                case 'integer':
+                                                case 'number':
+                                                    potential = Number(value);
+                                                    break;
+                                                default:
+                                                    potential = value;
+                                                    break;
+                                            }
+                                            lastValidation = await definition.validator(potential);
+                                            // Can be a string if validation fails
+                                            if (lastValidation === true) {
+                                                finalValue = potential;
+                                                return true;
+                                            }
+                                        }
+                                        return lastValidation;
+                                    },
+                                });
+                                // Use validated value if present.
+                                // This ensures the correct type is inserted into the final schema options.
+                                if (finalValue !== undefined) {
+                                    answers[definition.id] = finalValue;
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    return answers;
+                });
+            }
+            return workflow;
+        }
+        async getSchematicCollections() {
+            const getSchematicCollections = (configSection) => {
+                if (!configSection) {
+                    return undefined;
+                }
+                const { schematicCollections } = configSection;
+                if (Array.isArray(schematicCollections)) {
+                    return new Set(schematicCollections);
+                }
+                return undefined;
+            };
+            const { workspace, globalConfiguration } = this.context;
+            if (workspace) {
+                const project = (0, config_1.getProjectByCwd)(workspace);
+                if (project) {
+                    const value = getSchematicCollections(workspace.getProjectCli(project));
+                    if (value) {
+                        return value;
+                    }
+                }
+            }
+            const value = getSchematicCollections(workspace?.getCli()) ??
+                getSchematicCollections(globalConfiguration.getCli());
+            if (value) {
+                return value;
+            }
+            return new Set([exports.DEFAULT_SCHEMATICS_COLLECTION]);
+        }
+        parseSchematicInfo(schematic) {
+            if (schematic?.includes(':')) {
+                const [collectionName, schematicName] = schematic.split(':', 2);
+                return [collectionName, schematicName];
+            }
+            return [undefined, schematic];
+        }
+        async runSchematic(options) {
+            const { logger } = this.context;
+            const { schematicOptions, executionOptions, collectionName, schematicName } = options;
+            const workflow = await this.getOrCreateWorkflowForExecution(collectionName, executionOptions);
+            if (!schematicName) {
+                throw new Error('schematicName cannot be undefined.');
+            }
+            const { unsubscribe, files } = (0, schematic_workflow_1.subscribeToWorkflow)(workflow, logger);
+            try {
+                await workflow
+                    .execute({
+                    collection: collectionName,
+                    schematic: schematicName,
+                    options: schematicOptions,
+                    logger,
+                    allowPrivate: this.allowPrivateSchematics,
+                })
+                    .toPromise();
+                if (!files.size) {
+                    logger.info('Nothing to be done.');
+                }
+                if (executionOptions.dryRun) {
+                    logger.warn(`\nNOTE: The "--dry-run" option means no changes were made.`);
+                }
+            }
+            catch (err) {
+                // In case the workflow was not successful, show an appropriate error message.
+                if (err instanceof schematics_1.UnsuccessfulWorkflowExecution) {
+                    // "See above" because we already printed the error.
+                    logger.fatal('The Schematic workflow failed. See above.');
+                }
+                else {
+                    (0, error_1.assertIsError)(err);
+                    logger.fatal(err.message);
+                }
+                return 1;
+            }
+            finally {
+                unsubscribe();
+            }
+            return 0;
+        }
+        getProjectName() {
+            const { workspace } = this.context;
+            if (!workspace) {
+                return undefined;
+            }
+            const projectName = (0, config_1.getProjectByCwd)(workspace);
+            if (projectName) {
+                return projectName;
+            }
+            return undefined;
+        }
+        getResolvePaths(collectionName) {
+            const { workspace, root } = this.context;
+            if (collectionName[0] === '.') {
+                // Resolve relative collections from the location of `angular.json`
+                return [root];
+            }
+            return workspace
+                ? // Workspace
+                    collectionName === exports.DEFAULT_SCHEMATICS_COLLECTION
+                        ? // Favor __dirname for @schematics/angular to use the build-in version
+                            [__dirname, process.cwd(), root]
+                        : [process.cwd(), root, __dirname]
+                : // Global
+                    [__dirname, process.cwd()];
+        }
+    };
+})();
+exports.SchematicsCommandModule = SchematicsCommandModule;

node_modules/@angular/cli/src/command-builder/utilities/command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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 { CommandContext, CommandModule, CommandModuleImplementation } from '../command-module';
+export declare const demandCommandFailureMessage = "You need to specify a command before moving on. Use '--help' to view the available commands.";
+export type CommandModuleConstructor = Partial<CommandModuleImplementation> & {
+    new (context: CommandContext): Partial<CommandModuleImplementation> & CommandModule;
+};
+export declare function addCommandModuleToYargs<U extends CommandModuleConstructor>(commandModule: U, context: CommandContext): void;

node_modules/@angular/cli/src/command-builder/utilities/command.js

@@ -0,0 +1,38 @@
+"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.demandCommandFailureMessage = void 0;
+exports.addCommandModuleToYargs = addCommandModuleToYargs;
+const command_module_1 = require("../command-module");
+exports.demandCommandFailureMessage = `You need to specify a command before moving on. Use '--help' to view the available commands.`;
+function addCommandModuleToYargs(commandModule, context) {
+    const cmd = new commandModule(context);
+    const { args: { options: { jsonHelp }, }, workspace, } = context;
+    const describe = jsonHelp ? cmd.fullDescribe : cmd.describe;
+    context.yargsInstance.command({
+        command: cmd.command,
+        aliases: cmd.aliases,
+        describe: 
+        // We cannot add custom fields in help, such as long command description which is used in AIO.
+        // Therefore, we get around this by adding a complex object as a string which we later parse when generating the help files.
+        typeof describe === 'object' ? JSON.stringify(describe) : describe,
+        deprecated: cmd.deprecated,
+        builder: (argv) => {
+            // Skip scope validation when running with '--json-help' since it's easier to generate the output for all commands this way.
+            const isInvalidScope = !jsonHelp &&
+                ((cmd.scope === command_module_1.CommandScope.In && !workspace) ||
+                    (cmd.scope === command_module_1.CommandScope.Out && workspace));
+            if (isInvalidScope) {
+                throw new command_module_1.CommandModuleError(`This command is not available when running the Angular CLI ${workspace ? 'inside' : 'outside'} a workspace.`);
+            }
+            return cmd.builder(argv);
+        },
+        handler: (args) => cmd.handler(args),
+    });
+}

node_modules/@angular/cli/src/command-builder/utilities/json-help.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @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';
+interface JsonHelpOption {
+    name: string;
+    type?: string;
+    deprecated: boolean | string;
+    aliases?: string[];
+    default?: string;
+    required?: boolean;
+    positional?: number;
+    enum?: string[];
+    description?: string;
+}
+interface JsonHelpDescription {
+    shortDescription?: string;
+    longDescription?: string;
+    longDescriptionRelativePath?: string;
+}
+interface JsonHelpSubcommand extends JsonHelpDescription {
+    name: string;
+    aliases: string[];
+    deprecated: string | boolean;
+}
+export interface JsonHelp extends JsonHelpDescription {
+    name: string;
+    command: string;
+    options: JsonHelpOption[];
+    subcommands?: JsonHelpSubcommand[];
+}
+export declare function jsonHelpUsage(localYargs: Argv): string;
+export {};

node_modules/@angular/cli/src/command-builder/utilities/json-help.js

@@ -0,0 +1,91 @@
+"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.jsonHelpUsage = jsonHelpUsage;
+const yargsDefaultCommandRegExp = /^\$0|\*/;
+function jsonHelpUsage(localYargs) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const localYargsInstance = localYargs;
+    const { deprecatedOptions, alias: aliases, array, string, boolean, number, choices, demandedOptions, default: defaultVal, hiddenOptions = [], } = localYargsInstance.getOptions();
+    const internalMethods = localYargsInstance.getInternalMethods();
+    const usageInstance = internalMethods.getUsageInstance();
+    const context = internalMethods.getContext();
+    const descriptions = usageInstance.getDescriptions();
+    const groups = localYargsInstance.getGroups();
+    const positional = groups[usageInstance.getPositionalGroupName()];
+    const seen = new Set();
+    const hidden = new Set(hiddenOptions);
+    const normalizeOptions = [];
+    const allAliases = new Set([...Object.values(aliases).flat()]);
+    // Reverted order of https://github.com/yargs/yargs/blob/971e351705f0fbc5566c6ed1dfd707fa65e11c0d/lib/usage.ts#L419-L424
+    for (const [names, type] of [
+        [number, 'number'],
+        [array, 'array'],
+        [string, 'string'],
+        [boolean, 'boolean'],
+    ]) {
+        for (const name of names) {
+            if (allAliases.has(name) || hidden.has(name) || seen.has(name)) {
+                // Ignore hidden, aliases and already visited option.
+                continue;
+            }
+            seen.add(name);
+            const positionalIndex = positional?.indexOf(name) ?? -1;
+            const alias = aliases[name];
+            normalizeOptions.push({
+                name,
+                type,
+                deprecated: deprecatedOptions[name],
+                aliases: alias?.length > 0 ? alias : undefined,
+                default: defaultVal[name],
+                required: demandedOptions[name],
+                enum: choices[name],
+                description: descriptions[name]?.replace('__yargsString__:', ''),
+                positional: positionalIndex >= 0 ? positionalIndex : undefined,
+            });
+        }
+    }
+    // https://github.com/yargs/yargs/blob/00e4ebbe3acd438e73fdb101e75b4f879eb6d345/lib/usage.ts#L124
+    const subcommands = usageInstance.getCommands()
+        .map(([name, rawDescription, isDefault, aliases, deprecated]) => ({
+        name: name.split(' ', 1)[0].replace(yargsDefaultCommandRegExp, ''),
+        command: name.replace(yargsDefaultCommandRegExp, ''),
+        default: isDefault || undefined,
+        ...parseDescription(rawDescription),
+        aliases,
+        deprecated,
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const [command, rawDescription] = usageInstance.getUsage()[0] ?? [];
+    const defaultSubCommand = subcommands.find((x) => x.default)?.command ?? '';
+    const otherSubcommands = subcommands.filter((s) => !s.default);
+    const output = {
+        name: [...context.commands].pop(),
+        command: `${command?.replace(yargsDefaultCommandRegExp, localYargsInstance['$0'])}${defaultSubCommand}`,
+        ...parseDescription(rawDescription),
+        options: normalizeOptions.sort((a, b) => a.name.localeCompare(b.name)),
+        subcommands: otherSubcommands.length ? otherSubcommands : undefined,
+    };
+    return JSON.stringify(output, undefined, 2);
+}
+function parseDescription(rawDescription) {
+    try {
+        const { longDescription, describe: shortDescription, longDescriptionRelativePath, } = JSON.parse(rawDescription);
+        return {
+            shortDescription,
+            longDescriptionRelativePath,
+            longDescription,
+        };
+    }
+    catch {
+        return {
+            shortDescription: rawDescription,
+        };
+    }
+}

node_modules/@angular/cli/src/command-builder/utilities/json-schema.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @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 { json } from '@angular-devkit/core';
+import type { Argv, Options as YargsOptions } from 'yargs';
+import { EventCustomDimension } from '../../analytics/analytics-parameters';
+/**
+ * An option description.
+ */
+export interface Option extends YargsOptions {
+    /**
+     * The name of the option.
+     */
+    name: string;
+    /**
+     * Whether this option is required or not.
+     */
+    required?: boolean;
+    /**
+     * Format field of this option.
+     */
+    format?: string;
+    /**
+     * Whether this option should be hidden from the help output. It will still show up in JSON help.
+     */
+    hidden?: boolean;
+    /**
+     * If this option can be used as an argument, the position of the argument. Otherwise omitted.
+     */
+    positional?: number;
+    /**
+     * Whether or not to report this option to the Angular Team, and which custom field to use.
+     * If this is falsey, do not report this option.
+     */
+    userAnalytics?: string;
+    /**
+     * Type of the values in a key/value pair field.
+     */
+    itemValueType?: 'string';
+}
+export declare function parseJsonSchemaToOptions(registry: json.schema.SchemaRegistry, schema: json.JsonObject, interactive?: boolean): Promise<Option[]>;
+/**
+ * Adds schema options to a command also this keeps track of options that are required for analytics.
+ * **Note:** This method should be called from the command bundler method.
+ *
+ * @returns A map from option name to analytics configuration.
+ */
+export declare function addSchemaOptionsToCommand<T>(localYargs: Argv<T>, options: Option[], includeDefaultValues: boolean): Map<string, EventCustomDimension>;

node_modules/@angular/cli/src/command-builder/utilities/json-schema.js

@@ -0,0 +1,269 @@
+"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.parseJsonSchemaToOptions = parseJsonSchemaToOptions;
+exports.addSchemaOptionsToCommand = addSchemaOptionsToCommand;
+const core_1 = require("@angular-devkit/core");
+function checkStringMap(keyValuePairOptions, args) {
+    for (const key of keyValuePairOptions) {
+        const value = args[key];
+        if (!Array.isArray(value)) {
+            // Value has been parsed.
+            continue;
+        }
+        for (const pair of value) {
+            if (pair === undefined) {
+                continue;
+            }
+            if (!pair.includes('=')) {
+                throw new Error(`Invalid value for argument: ${key}, Given: '${pair}', Expected key=value pair`);
+            }
+        }
+    }
+    return true;
+}
+function coerceToStringMap(value) {
+    const stringMap = {};
+    for (const pair of value) {
+        // This happens when the flag isn't passed at all.
+        if (pair === undefined) {
+            continue;
+        }
+        const eqIdx = pair.indexOf('=');
+        if (eqIdx === -1) {
+            // In the case it is not valid skip processing this option and handle the error in `checkStringMap`
+            return value;
+        }
+        const key = pair.slice(0, eqIdx);
+        stringMap[key] = pair.slice(eqIdx + 1);
+    }
+    return stringMap;
+}
+function isStringMap(node) {
+    // Exclude fields with more specific kinds of properties.
+    if (node.properties || node.patternProperties) {
+        return false;
+    }
+    // Restrict to additionalProperties with string values.
+    return (core_1.json.isJsonObject(node.additionalProperties) &&
+        !node.additionalProperties.enum &&
+        node.additionalProperties.type === 'string');
+}
+async function parseJsonSchemaToOptions(registry, schema, interactive = true) {
+    const options = [];
+    function visitor(current, pointer, parentSchema) {
+        if (!parentSchema) {
+            // Ignore root.
+            return;
+        }
+        else if (pointer.split(/\/(?:properties|items|definitions)\//g).length > 2) {
+            // Ignore subitems (objects or arrays).
+            return;
+        }
+        else if (core_1.json.isJsonArray(current)) {
+            return;
+        }
+        if (pointer.indexOf('/not/') != -1) {
+            // We don't support anyOf/not.
+            throw new Error('The "not" keyword is not supported in JSON Schema.');
+        }
+        const ptr = core_1.json.schema.parseJsonPointer(pointer);
+        const name = ptr[ptr.length - 1];
+        if (ptr[ptr.length - 2] != 'properties') {
+            // Skip any non-property items.
+            return;
+        }
+        const typeSet = core_1.json.schema.getTypesOfSchema(current);
+        if (typeSet.size == 0) {
+            throw new Error('Cannot find type of schema.');
+        }
+        // We only support number, string or boolean (or array of those), so remove everything else.
+        const types = [...typeSet].filter((x) => {
+            switch (x) {
+                case 'boolean':
+                case 'number':
+                case 'string':
+                    return true;
+                case 'array':
+                    // Only include arrays if they're boolean, string or number.
+                    if (core_1.json.isJsonObject(current.items) &&
+                        typeof current.items.type == 'string' &&
+                        isValidTypeForEnum(current.items.type)) {
+                        return true;
+                    }
+                    return false;
+                case 'object':
+                    return isStringMap(current);
+                default:
+                    return false;
+            }
+        });
+        if (types.length == 0) {
+            // This means it's not usable on the command line. e.g. an Object.
+            return;
+        }
+        // Only keep enum values we support (booleans, numbers and strings).
+        const enumValues = ((core_1.json.isJsonArray(current.enum) && current.enum) ||
+            (core_1.json.isJsonObject(current.items) &&
+                core_1.json.isJsonArray(current.items.enum) &&
+                current.items.enum) ||
+            [])
+            .filter((value) => isValidTypeForEnum(typeof value))
+            .sort();
+        let defaultValue = undefined;
+        if (current.default !== undefined) {
+            switch (types[0]) {
+                case 'string':
+                    if (typeof current.default == 'string') {
+                        defaultValue = current.default;
+                    }
+                    break;
+                case 'array':
+                    if (Array.isArray(current.default) && current.default.length > 0) {
+                        defaultValue = current.default;
+                    }
+                    break;
+                case 'number':
+                    if (typeof current.default == 'number') {
+                        defaultValue = current.default;
+                    }
+                    break;
+                case 'boolean':
+                    if (typeof current.default == 'boolean') {
+                        defaultValue = current.default;
+                    }
+                    break;
+            }
+        }
+        const $default = current.$default;
+        const $defaultIndex = core_1.json.isJsonObject($default) && $default['$source'] == 'argv' ? $default['index'] : undefined;
+        const positional = typeof $defaultIndex == 'number' ? $defaultIndex : undefined;
+        let required = core_1.json.isJsonArray(schema.required) ? schema.required.includes(name) : false;
+        if (required && interactive && current['x-prompt']) {
+            required = false;
+        }
+        const alias = core_1.json.isJsonArray(current.aliases)
+            ? [...current.aliases].map((x) => '' + x)
+            : current.alias
+                ? ['' + current.alias]
+                : [];
+        const format = typeof current.format == 'string' ? current.format : undefined;
+        const visible = current.visible === undefined || current.visible === true;
+        const hidden = !!current.hidden || !visible;
+        const xUserAnalytics = current['x-user-analytics'];
+        const userAnalytics = typeof xUserAnalytics === 'string' ? xUserAnalytics : undefined;
+        // Deprecated is set only if it's true or a string.
+        const xDeprecated = current['x-deprecated'];
+        const deprecated = xDeprecated === true || typeof xDeprecated === 'string' ? xDeprecated : undefined;
+        const option = {
+            name,
+            description: '' + (current.description === undefined ? '' : current.description),
+            default: defaultValue,
+            choices: enumValues.length ? enumValues : undefined,
+            required,
+            alias,
+            format,
+            hidden,
+            userAnalytics,
+            deprecated,
+            positional,
+            ...(types[0] === 'object'
+                ? {
+                    type: 'array',
+                    itemValueType: 'string',
+                }
+                : {
+                    type: types[0],
+                }),
+        };
+        options.push(option);
+    }
+    const flattenedSchema = await registry.ɵflatten(schema);
+    core_1.json.schema.visitJsonSchema(flattenedSchema, visitor);
+    // Sort by positional and name.
+    return options.sort((a, b) => {
+        if (a.positional) {
+            return b.positional ? a.positional - b.positional : a.name.localeCompare(b.name);
+        }
+        else if (b.positional) {
+            return -1;
+        }
+        return a.name.localeCompare(b.name);
+    });
+}
+/**
+ * Adds schema options to a command also this keeps track of options that are required for analytics.
+ * **Note:** This method should be called from the command bundler method.
+ *
+ * @returns A map from option name to analytics configuration.
+ */
+function addSchemaOptionsToCommand(localYargs, options, includeDefaultValues) {
+    const booleanOptionsWithNoPrefix = new Set();
+    const keyValuePairOptions = new Set();
+    const optionsWithAnalytics = new Map();
+    for (const option of options) {
+        const { default: defaultVal, positional, deprecated, description, alias, userAnalytics, type, itemValueType, hidden, name, choices, } = option;
+        let dashedName = core_1.strings.dasherize(name);
+        // Handle options which have been defined in the schema with `no` prefix.
+        if (type === 'boolean' && dashedName.startsWith('no-')) {
+            dashedName = dashedName.slice(3);
+            booleanOptionsWithNoPrefix.add(dashedName);
+        }
+        if (itemValueType) {
+            keyValuePairOptions.add(dashedName);
+        }
+        const sharedOptions = {
+            alias,
+            hidden,
+            description,
+            deprecated,
+            choices,
+            coerce: itemValueType ? coerceToStringMap : undefined,
+            // This should only be done when `--help` is used otherwise default will override options set in angular.json.
+            ...(includeDefaultValues ? { default: defaultVal } : {}),
+        };
+        if (positional === undefined) {
+            localYargs = localYargs.option(dashedName, {
+                array: itemValueType ? true : undefined,
+                type: itemValueType ?? type,
+                ...sharedOptions,
+            });
+        }
+        else {
+            localYargs = localYargs.positional(dashedName, {
+                type: type === 'array' || type === 'count' ? 'string' : type,
+                ...sharedOptions,
+            });
+        }
+        // Record option of analytics.
+        if (userAnalytics !== undefined) {
+            optionsWithAnalytics.set(name, userAnalytics);
+        }
+    }
+    // Valid key/value options
+    if (keyValuePairOptions.size) {
+        localYargs.check(checkStringMap.bind(null, keyValuePairOptions), false);
+    }
+    // Handle options which have been defined in the schema with `no` prefix.
+    if (booleanOptionsWithNoPrefix.size) {
+        localYargs.middleware((options) => {
+            for (const key of booleanOptionsWithNoPrefix) {
+                if (key in options) {
+                    options[`no-${key}`] = !options[key];
+                    delete options[key];
+                }
+            }
+        }, false);
+    }
+    return optionsWithAnalytics;
+}
+const VALID_ENUM_TYPES = new Set(['boolean', 'number', 'string']);
+function isValidTypeForEnum(value) {
+    return VALID_ENUM_TYPES.has(value);
+}

node_modules/@angular/cli/src/command-builder/utilities/normalize-options-middleware.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 type { Arguments, Argv } from 'yargs';
+/**
+ * A Yargs middleware that normalizes non Array options when the argument has been provided multiple times.
+ *
+ * By default, when an option is non array and it is provided multiple times in the command line, yargs
+ * will not override it's value but instead it will be changed to an array unless `duplicate-arguments-array` is disabled.
+ * But this option also have an effect on real array options which isn't desired.
+ *
+ * See: https://github.com/yargs/yargs-parser/pull/163#issuecomment-516566614
+ */
+export declare function createNormalizeOptionsMiddleware(localeYargs: Argv): (args: Arguments) => void;

node_modules/@angular/cli/src/command-builder/utilities/normalize-options-middleware.js

@@ -0,0 +1,36 @@
+"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.createNormalizeOptionsMiddleware = createNormalizeOptionsMiddleware;
+/**
+ * A Yargs middleware that normalizes non Array options when the argument has been provided multiple times.
+ *
+ * By default, when an option is non array and it is provided multiple times in the command line, yargs
+ * will not override it's value but instead it will be changed to an array unless `duplicate-arguments-array` is disabled.
+ * But this option also have an effect on real array options which isn't desired.
+ *
+ * See: https://github.com/yargs/yargs-parser/pull/163#issuecomment-516566614
+ */
+function createNormalizeOptionsMiddleware(localeYargs) {
+    return (args) => {
+        // `getOptions` is not included in the types even though it's public API.
+        // https://github.com/yargs/yargs/issues/2098
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const { array } = localeYargs.getOptions();
+        const arrayOptions = new Set(array);
+        for (const [key, value] of Object.entries(args)) {
+            if (key !== '_' && Array.isArray(value) && !arrayOptions.has(key)) {
+                const newValue = value.pop();
+                // eslint-disable-next-line no-console
+                console.warn(`Option '${key}' has been specified multiple times. The value '${newValue}' will be used.`);
+                args[key] = newValue;
+            }
+        }
+    };
+}

node_modules/@angular/cli/src/command-builder/utilities/schematic-engine-host.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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 { RuleFactory } from '@angular-devkit/schematics';
+import { FileSystemCollectionDesc, NodeModulesEngineHost } from '@angular-devkit/schematics/tools';
+export declare class SchematicEngineHost extends NodeModulesEngineHost {
+    protected _resolveReferenceString(refString: string, parentPath: string, collectionDescription?: FileSystemCollectionDesc): {
+        ref: RuleFactory<{}>;
+        path: string;
+    } | null;
+}

node_modules/@angular/cli/src/command-builder/utilities/schematic-engine-host.js

@@ -0,0 +1,178 @@
+"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.SchematicEngineHost = void 0;
+const schematics_1 = require("@angular-devkit/schematics");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const jsonc_parser_1 = require("jsonc-parser");
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const node_vm_1 = require("node:vm");
+const error_1 = require("../../utilities/error");
+/**
+ * Environment variable to control schematic package redirection
+ */
+const schematicRedirectVariable = process.env['NG_SCHEMATIC_REDIRECT']?.toLowerCase();
+function shouldWrapSchematic(schematicFile, schematicEncapsulation) {
+    // Check environment variable if present
+    switch (schematicRedirectVariable) {
+        case '0':
+        case 'false':
+        case 'off':
+        case 'none':
+            return false;
+        case 'all':
+            return true;
+    }
+    const normalizedSchematicFile = schematicFile.replace(/\\/g, '/');
+    // Never wrap the internal update schematic when executed directly
+    // It communicates with the update command via `global`
+    // But we still want to redirect schematics located in `@angular/cli/node_modules`.
+    if (normalizedSchematicFile.includes('node_modules/@angular/cli/') &&
+        !normalizedSchematicFile.includes('node_modules/@angular/cli/node_modules/')) {
+        return false;
+    }
+    // @angular/pwa uses dynamic imports which causes `[1]    2468039 segmentation fault` when wrapped.
+    // We should remove this when make `importModuleDynamically` work.
+    // See: https://nodejs.org/docs/latest-v14.x/api/vm.html
+    if (normalizedSchematicFile.includes('@angular/pwa')) {
+        return false;
+    }
+    // Check for first-party Angular schematic packages
+    // Angular schematics are safe to use in the wrapped VM context
+    const isFirstParty = /\/node_modules\/@(?:angular|schematics|nguniversal)\//.test(normalizedSchematicFile);
+    // Use value of defined option if present, otherwise default to first-party usage.
+    return schematicEncapsulation ?? isFirstParty;
+}
+class SchematicEngineHost extends tools_1.NodeModulesEngineHost {
+    _resolveReferenceString(refString, parentPath, collectionDescription) {
+        const [path, name] = refString.split('#', 2);
+        // Mimic behavior of ExportStringRef class used in default behavior
+        const fullPath = path[0] === '.' ? (0, node_path_1.resolve)(parentPath ?? process.cwd(), path) : path;
+        const referenceRequire = (0, node_module_1.createRequire)(__filename);
+        const schematicFile = referenceRequire.resolve(fullPath, { paths: [parentPath] });
+        if (shouldWrapSchematic(schematicFile, collectionDescription?.encapsulation)) {
+            const schematicPath = (0, node_path_1.dirname)(schematicFile);
+            const moduleCache = new Map();
+            const factoryInitializer = wrap(schematicFile, schematicPath, moduleCache, name || 'default');
+            const factory = factoryInitializer();
+            if (!factory || typeof factory !== 'function') {
+                return null;
+            }
+            return { ref: factory, path: schematicPath };
+        }
+        // All other schematics use default behavior
+        return super._resolveReferenceString(refString, parentPath, collectionDescription);
+    }
+}
+exports.SchematicEngineHost = SchematicEngineHost;
+/**
+ * Minimal shim modules for legacy deep imports of `@schematics/angular`
+ */
+const legacyModules = {
+    '@schematics/angular/utility/config': {
+        getWorkspace(host) {
+            const path = '/.angular.json';
+            const data = host.read(path);
+            if (!data) {
+                throw new schematics_1.SchematicsException(`Could not find (${path})`);
+            }
+            return (0, jsonc_parser_1.parse)(data.toString(), [], { allowTrailingComma: true });
+        },
+    },
+    '@schematics/angular/utility/project': {
+        buildDefaultPath(project) {
+            const root = project.sourceRoot ? `/${project.sourceRoot}/` : `/${project.root}/src/`;
+            return `${root}${project.projectType === 'application' ? 'app' : 'lib'}`;
+        },
+    },
+};
+/**
+ * Wrap a JavaScript file in a VM context to allow specific Angular dependencies to be redirected.
+ * This VM setup is ONLY intended to redirect dependencies.
+ *
+ * @param schematicFile A JavaScript schematic file path that should be wrapped.
+ * @param schematicDirectory A directory that will be used as the location of the JavaScript file.
+ * @param moduleCache A map to use for caching repeat module usage and proper `instanceof` support.
+ * @param exportName An optional name of a specific export to return. Otherwise, return all exports.
+ */
+function wrap(schematicFile, schematicDirectory, moduleCache, exportName) {
+    const hostRequire = (0, node_module_1.createRequire)(__filename);
+    const schematicRequire = (0, node_module_1.createRequire)(schematicFile);
+    const customRequire = function (id) {
+        if (legacyModules[id]) {
+            // Provide compatibility modules for older versions of @angular/cdk
+            return legacyModules[id];
+        }
+        else if (id.startsWith('schematics:')) {
+            // Schematics built-in modules use the `schematics` scheme (similar to the Node.js `node` scheme)
+            const builtinId = id.slice(11);
+            const builtinModule = loadBuiltinModule(builtinId);
+            if (!builtinModule) {
+                throw new Error(`Unknown schematics built-in module '${id}' requested from schematic '${schematicFile}'`);
+            }
+            return builtinModule;
+        }
+        else if (id.startsWith('@angular-devkit/') || id.startsWith('@schematics/')) {
+            // Files should not redirect `@angular/core` and instead use the direct
+            // dependency if available. This allows old major version migrations to continue to function
+            // even though the latest major version may have breaking changes in `@angular/core`.
+            if (id.startsWith('@angular-devkit/core')) {
+                try {
+                    return schematicRequire(id);
+                }
+                catch (e) {
+                    (0, error_1.assertIsError)(e);
+                    if (e.code !== 'MODULE_NOT_FOUND') {
+                        throw e;
+                    }
+                }
+            }
+            // Resolve from inside the `@angular/cli` project
+            return hostRequire(id);
+        }
+        else if (id.startsWith('.') || id.startsWith('@angular/cdk')) {
+            // Wrap relative files inside the schematic collection
+            // Also wrap `@angular/cdk`, it contains helper utilities that import core schematic packages
+            // Resolve from the original file
+            const modulePath = schematicRequire.resolve(id);
+            // Use cached module if available
+            const cachedModule = moduleCache.get(modulePath);
+            if (cachedModule) {
+                return cachedModule;
+            }
+            // Do not wrap vendored third-party packages or JSON files
+            if (!/[/\\]node_modules[/\\]@schematics[/\\]angular[/\\]third_party[/\\]/.test(modulePath) &&
+                !modulePath.endsWith('.json')) {
+                // Wrap module and save in cache
+                const wrappedModule = wrap(modulePath, (0, node_path_1.dirname)(modulePath), moduleCache)();
+                moduleCache.set(modulePath, wrappedModule);
+                return wrappedModule;
+            }
+        }
+        // All others are required directly from the original file
+        return schematicRequire(id);
+    };
+    // Setup a wrapper function to capture the module's exports
+    const schematicCode = (0, node_fs_1.readFileSync)(schematicFile, 'utf8');
+    const script = new node_vm_1.Script(node_module_1.Module.wrap(schematicCode), {
+        filename: schematicFile,
+        lineOffset: 1,
+    });
+    const schematicModule = new node_module_1.Module(schematicFile);
+    const moduleFactory = script.runInThisContext();
+    return () => {
+        moduleFactory(schematicModule.exports, customRequire, schematicModule, schematicFile, schematicDirectory);
+        return exportName ? schematicModule.exports[exportName] : schematicModule.exports;
+    };
+}
+function loadBuiltinModule(id) {
+    return undefined;
+}

node_modules/@angular/cli/src/command-builder/utilities/schematic-workflow.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @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 { logging } from '@angular-devkit/core';
+import { NodeWorkflow } from '@angular-devkit/schematics/tools';
+export declare function subscribeToWorkflow(workflow: NodeWorkflow, logger: logging.LoggerApi): {
+    files: Set<string>;
+    error: boolean;
+    unsubscribe: () => void;
+};

node_modules/@angular/cli/src/command-builder/utilities/schematic-workflow.js

@@ -0,0 +1,67 @@
+"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.subscribeToWorkflow = subscribeToWorkflow;
+const color_1 = require("../../utilities/color");
+function removeLeadingSlash(value) {
+    return value[0] === '/' ? value.slice(1) : value;
+}
+function subscribeToWorkflow(workflow, logger) {
+    const files = new Set();
+    let error = false;
+    let logs = [];
+    const reporterSubscription = workflow.reporter.subscribe((event) => {
+        // Strip leading slash to prevent confusion.
+        const eventPath = removeLeadingSlash(event.path);
+        switch (event.kind) {
+            case 'error':
+                error = true;
+                logger.error(`ERROR! ${eventPath} ${event.description == 'alreadyExist' ? 'already exists' : 'does not exist'}.`);
+                break;
+            case 'update':
+                logs.push(
+                // TODO: `as unknown` was necessary during TS 5.9 update. Figure out a long-term solution.
+                `${color_1.colors.cyan('UPDATE')} ${eventPath} (${event.content.length} bytes)`);
+                files.add(eventPath);
+                break;
+            case 'create':
+                logs.push(
+                // TODO: `as unknown` was necessary during TS 5.9 update. Figure out a long-term solution.
+                `${color_1.colors.green('CREATE')} ${eventPath} (${event.content.length} bytes)`);
+                files.add(eventPath);
+                break;
+            case 'delete':
+                logs.push(`${color_1.colors.yellow('DELETE')} ${eventPath}`);
+                files.add(eventPath);
+                break;
+            case 'rename':
+                logs.push(`${color_1.colors.blue('RENAME')} ${eventPath} => ${removeLeadingSlash(event.to)}`);
+                files.add(eventPath);
+                break;
+        }
+    });
+    const lifecycleSubscription = workflow.lifeCycle.subscribe((event) => {
+        if (event.kind == 'end' || event.kind == 'post-tasks-start') {
+            if (!error) {
+                // Output the logging queue, no error happened.
+                logs.forEach((log) => logger.info(log));
+            }
+            logs = [];
+            error = false;
+        }
+    });
+    return {
+        files,
+        error,
+        unsubscribe: () => {
+            reporterSubscription.unsubscribe();
+            lifecycleSubscription.unsubscribe();
+        },
+    };
+}

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 {};

node_modules/@angular/cli/src/commands/add/cli.js

@@ -0,0 +1,461 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 node_assert_1 = __importDefault(require("node:assert"));
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
+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, node_path_1.join)(__dirname, 'long-description.md');
+    allowPrivateSchematics = true;
+    schematicName = 'ng-add';
+    rootRequire = (0, node_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 = this.getCollectionName();
+        if (!collectionName) {
+            return localYargs;
+        }
+        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;
+                            break;
+                        }
+                        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, node_module_1.createRequire)(tempNodeModules + '/');
+                        (0, node_assert_1.default)(context.collectionName, 'Collection name should always be available');
+                        const resolvedCollectionPath = tempRequire.resolve((0, node_path_1.join)(context.collectionName, 'package.json'));
+                        if (!success) {
+                            throw new CommandError('Unable to install package');
+                        }
+                        context.collectionName = (0, node_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;
+    }
+    getCollectionName() {
+        const [, collectionName] = this.context.args.positional;
+        if (!collectionName) {
+            return undefined;
+        }
+        // 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 packageName = (0, npm_package_arg_1.default)(collectionName).name;
+            if (packageName) {
+                return packageName;
+            }
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            this.context.logger.error(e.message);
+        }
+        return collectionName;
+    }
+    isPackageInstalled(name) {
+        try {
+            this.rootRequire.resolve((0, node_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, node_path_1.join)(name, 'package.json'));
+        }
+        catch { }
+        if (installedPackage) {
+            try {
+                const installed = await (0, package_metadata_1.fetchPackageManifest)((0, node_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;

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
+```

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;
+}

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) {
+            (0, command_1.addCommandModuleToYargs)(module, this.context);
+        }
+        return localYargs.demandCommand(1, command_1.demandCommandFailureMessage).strict();
+    }
+    run(_options) { }
+}
+exports.default = AnalyticsCommandModule;

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>;
+}

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;

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.

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 {};

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;

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;
+}

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 node_path_1 = require("node: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, node_path_1.join)(__dirname, 'long-description.md');
+}
+exports.default = BuildCommandModule;

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).

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>;
+}

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 promises_1 = require("node:fs/promises");
+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 (0, promises_1.rm)(path, {
+            force: true,
+            recursive: true,
+            maxRetries: 3,
+        });
+    }
+}
+exports.CacheCleanModule = CacheCleanModule;

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;
+}

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 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("./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, node_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) {
+            (0, command_1.addCommandModuleToYargs)(module, this.context);
+        }
+        return localYargs.demandCommand(1, command_1.demandCommandFailureMessage).strict();
+    }
+    run(_options) { }
+}
+exports.default = CacheCommandModule;

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;
+}

node_modules/@angular/cli/src/commands/cache/info/cli.js

@@ -0,0 +1,114 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheInfoCommandModule = void 0;
+const core_1 = require("@angular-devkit/core");
+const fs = __importStar(require("node:fs/promises"));
+const node_path_1 = require("node: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.readdir(dirPath);
+            }
+            catch { }
+            for (const entry of entries) {
+                const entryPath = (0, node_path_1.join)(dirPath, entry);
+                const stats = await fs.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;

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"
+```

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>;
+}

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;

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>;

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 node_path_1 = require("node: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, node_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, node_path_1.resolve)(workspace.basePath, path),
+        environment,
+        enabled,
+    };
+}

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' | 'mcp' | '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>;

node_modules/@angular/cli/src/commands/command-config.js

@@ -0,0 +1,115 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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'))),
+    },
+    'mcp': {
+        factory: () => Promise.resolve().then(() => __importStar(require('./mcp/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;
+}, {});

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>;
+}

node_modules/@angular/cli/src/commands/completion/cli.js

@@ -0,0 +1,60 @@
+"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 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, node_path_1.join)(__dirname, 'long-description.md');
+    builder(localYargs) {
+        (0, command_1.addCommandModuleToYargs)(CompletionScriptCommandModule, this.context);
+        return localYargs;
+    }
+    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() {
+        this.context.yargsInstance.showCompletionScript();
+    }
+}

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
+```

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 {};

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 node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node: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, node_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, node_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;
+    }
+}

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).

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;
+}

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;

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": {}
+      }
+    }
+  }
+}
+```

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;
+}

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;

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>;
+}

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;

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 {};

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;

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;
+}

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 node_path_1 = require("node: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',
+        },
+    ];
+    multiTarget = true;
+    command = 'lint [project]';
+    longDescriptionPath = (0, node_path_1.join)(__dirname, 'long-description.md');
+    describe = 'Runs linting tools on Angular application code in a given project folder.';
+}
+exports.default = LintCommandModule;

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": {}
+      }
+    }
+  }
+}
+```

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;
+}

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;

node_modules/@angular/cli/src/commands/mcp/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 } from '../../command-builder/command-module';
+export default class McpCommandModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    describe: false;
+    longDescriptionPath: undefined;
+    builder(localYargs: Argv): Argv;
+    run(options: {
+        readOnly: boolean;
+        localOnly: boolean;
+        experimentalTool: string[] | undefined;
+    }): Promise<void>;
+}

node_modules/@angular/cli/src/commands/mcp/cli.js

@@ -0,0 +1,70 @@
+"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 stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const command_module_1 = require("../../command-builder/command-module");
+const tty_1 = require("../../utilities/tty");
+const mcp_server_1 = require("./mcp-server");
+const INTERACTIVE_MESSAGE = `
+To start using the Angular CLI MCP Server, add this configuration to your host:
+
+{
+  "mcpServers": {
+    "angular-cli": {
+      "command": "npx",
+      "args": ["-y", "@angular/cli", "mcp"]
+    }
+  }
+}
+
+Exact configuration may differ depending on the host.
+
+For more information and documentation, visit: https://angular.dev/ai/mcp
+`;
+class McpCommandModule extends command_module_1.CommandModule {
+    command = 'mcp';
+    describe = false;
+    longDescriptionPath = undefined;
+    builder(localYargs) {
+        return localYargs
+            .option('read-only', {
+            type: 'boolean',
+            default: false,
+            describe: 'Only register read-only tools.',
+        })
+            .option('local-only', {
+            type: 'boolean',
+            default: false,
+            describe: 'Only register tools that do not require internet access.',
+        })
+            .option('experimental-tool', {
+            type: 'string',
+            alias: 'E',
+            array: true,
+            describe: 'Enable an experimental tool.',
+            choices: mcp_server_1.EXPERIMENTAL_TOOLS.map(({ name }) => name),
+            hidden: true,
+        });
+    }
+    async run(options) {
+        if ((0, tty_1.isTTY)()) {
+            this.context.logger.info(INTERACTIVE_MESSAGE);
+            return;
+        }
+        const server = await (0, mcp_server_1.createMcpServer)({
+            workspace: this.context.workspace,
+            readOnly: options.readOnly,
+            localOnly: options.localOnly,
+            experimentalTools: options.experimentalTool,
+        }, this.context.logger);
+        const transport = new stdio_js_1.StdioServerTransport();
+        await server.connect(transport);
+    }
+}
+exports.default = McpCommandModule;

node_modules/@angular/cli/src/commands/mcp/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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
+ */
+export declare const k1 = "@angular/cli";
+export declare const at = "QBHBbOdEO4CmBOC2d7jNmg==";
+export declare const iv: Buffer<ArrayBuffer>;

node_modules/@angular/cli/src/commands/mcp/constants.js

@@ -0,0 +1,15 @@
+"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.iv = exports.at = exports.k1 = void 0;
+exports.k1 = '@angular/cli';
+exports.at = 'QBHBbOdEO4CmBOC2d7jNmg==';
+exports.iv = Buffer.from([
+    0x97, 0xf4, 0x62, 0x95, 0x3e, 0x12, 0x76, 0x84, 0x8a, 0x09, 0x4a, 0xc9, 0xeb, 0xa2, 0x84, 0x69,
+]);

node_modules/@angular/cli/src/commands/mcp/mcp-server.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 { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AngularWorkspace } from '../../utilities/config';
+import { AnyMcpToolDeclaration } from './tools/tool-registry';
+/**
+ * The set of tools that are available but not enabled by default.
+ * These tools are considered experimental and may have limitations.
+ */
+export declare const EXPERIMENTAL_TOOLS: readonly [import("./tools/tool-registry").McpToolDeclaration<{
+    query: import("zod").ZodString;
+}, {
+    examples: import("zod").ZodArray<import("zod").ZodObject<{
+        content: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        content: string;
+    }, {
+        content: string;
+    }>, "many">;
+}>, import("./tools/tool-registry").McpToolDeclaration<{
+    transformations: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<[string, ...string[]]>, "many">>;
+}, {
+    instructions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+}>, import("./tools/tool-registry").McpToolDeclaration<{
+    fileOrDirPath: import("zod").ZodString;
+}, import("zod").ZodRawShape>];
+export declare function createMcpServer(options: {
+    workspace?: AngularWorkspace;
+    readOnly?: boolean;
+    localOnly?: boolean;
+    experimentalTools?: string[];
+}, logger: {
+    warn(text: string): void;
+}): Promise<McpServer>;
+export declare function assembleToolDeclarations(stableDeclarations: readonly AnyMcpToolDeclaration[], experimentalDeclarations: readonly AnyMcpToolDeclaration[], options: {
+    readOnly?: boolean;
+    localOnly?: boolean;
+    experimentalTools?: string[];
+    logger: {
+        warn(text: string): void;
+    };
+}): AnyMcpToolDeclaration[];

node_modules/@angular/cli/src/commands/mcp/mcp-server.js

@@ -0,0 +1,91 @@
+"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 });
+exports.EXPERIMENTAL_TOOLS = void 0;
+exports.createMcpServer = createMcpServer;
+exports.assembleToolDeclarations = assembleToolDeclarations;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const node_path_1 = __importDefault(require("node:path"));
+const version_1 = require("../../utilities/version");
+const instructions_1 = require("./resources/instructions");
+const best_practices_1 = require("./tools/best-practices");
+const doc_search_1 = require("./tools/doc-search");
+const examples_1 = require("./tools/examples");
+const modernize_1 = require("./tools/modernize");
+const zoneless_migration_1 = require("./tools/onpush-zoneless-migration/zoneless-migration");
+const projects_1 = require("./tools/projects");
+const tool_registry_1 = require("./tools/tool-registry");
+/**
+ * The set of tools that are enabled by default for the MCP server.
+ * These tools are considered stable and suitable for general use.
+ */
+const STABLE_TOOLS = [best_practices_1.BEST_PRACTICES_TOOL, doc_search_1.DOC_SEARCH_TOOL, projects_1.LIST_PROJECTS_TOOL];
+/**
+ * The set of tools that are available but not enabled by default.
+ * These tools are considered experimental and may have limitations.
+ */
+exports.EXPERIMENTAL_TOOLS = [
+    examples_1.FIND_EXAMPLE_TOOL,
+    modernize_1.MODERNIZE_TOOL,
+    zoneless_migration_1.ZONELESS_MIGRATION_TOOL,
+];
+async function createMcpServer(options, logger) {
+    const server = new mcp_js_1.McpServer({
+        name: 'angular-cli-server',
+        version: version_1.VERSION.full,
+    }, {
+        capabilities: {
+            resources: {},
+            tools: {},
+            logging: {},
+        },
+        instructions: 'For Angular development, this server provides tools to adhere to best practices, search documentation, and find code examples. ' +
+            'When writing or modifying Angular code, use the MCP server and its tools instead of direct shell commands where possible.',
+    });
+    (0, instructions_1.registerInstructionsResource)(server);
+    const toolDeclarations = assembleToolDeclarations(STABLE_TOOLS, exports.EXPERIMENTAL_TOOLS, {
+        ...options,
+        logger,
+    });
+    await (0, tool_registry_1.registerTools)(server, {
+        workspace: options.workspace,
+        logger,
+        exampleDatabasePath: node_path_1.default.join(__dirname, '../../../lib/code-examples.db'),
+    }, toolDeclarations);
+    return server;
+}
+function assembleToolDeclarations(stableDeclarations, experimentalDeclarations, options) {
+    let toolDeclarations = [...stableDeclarations];
+    if (options.readOnly) {
+        toolDeclarations = toolDeclarations.filter((tool) => tool.isReadOnly);
+    }
+    if (options.localOnly) {
+        toolDeclarations = toolDeclarations.filter((tool) => tool.isLocalOnly);
+    }
+    const enabledExperimentalTools = new Set(options.experimentalTools);
+    if (process.env['NG_MCP_CODE_EXAMPLES'] === '1') {
+        enabledExperimentalTools.add('find_examples');
+    }
+    if (enabledExperimentalTools.size > 0) {
+        const experimentalToolsMap = new Map(experimentalDeclarations.map((tool) => [tool.name, tool]));
+        for (const toolName of enabledExperimentalTools) {
+            const tool = experimentalToolsMap.get(toolName);
+            if (tool) {
+                toolDeclarations.push(tool);
+            }
+            else {
+                options.logger.warn(`Unknown experimental tool: ${toolName}`);
+            }
+        }
+    }
+    return toolDeclarations;
+}

node_modules/@angular/cli/src/commands/mcp/resources/best-practices.md

@@ -0,0 +1,47 @@
+You are an expert in TypeScript, Angular, and scalable web application development. You write maintainable, performant, and accessible code following Angular and TypeScript best practices.
+
+## TypeScript Best Practices
+
+- Use strict type checking
+- Prefer type inference when the type is obvious
+- Avoid the `any` type; use `unknown` when type is uncertain
+
+## Angular Best Practices
+
+- Always use standalone components over NgModules
+- Must NOT set `standalone: true` inside Angular decorators. It's the default.
+- Use signals for state management
+- Implement lazy loading for feature routes
+- Do NOT use the `@HostBinding` and `@HostListener` decorators. Put host bindings inside the `host` object of the `@Component` or `@Directive` decorator instead
+- Use `NgOptimizedImage` for all static images.
+  - `NgOptimizedImage` does not work for inline base64 images.
+
+## Components
+
+- Keep components small and focused on a single responsibility
+- Use `input()` and `output()` functions instead of decorators
+- Use `computed()` for derived state
+- Set `changeDetection: ChangeDetectionStrategy.OnPush` in `@Component` decorator
+- Prefer inline templates for small components
+- Prefer Reactive forms instead of Template-driven ones
+- Do NOT use `ngClass`, use `class` bindings instead
+- DO NOT use `ngStyle`, use `style` bindings instead
+
+## State Management
+
+- Use signals for local component state
+- Use `computed()` for derived state
+- Keep state transformations pure and predictable
+- Do NOT use `mutate` on signals, use `update` or `set` instead
+
+## Templates
+
+- Keep templates simple and avoid complex logic
+- Use native control flow (`@if`, `@for`, `@switch`) instead of `*ngIf`, `*ngFor`, `*ngSwitch`
+- Use the async pipe to handle observables
+
+## Services
+
+- Design services around a single responsibility
+- Use the `providedIn: 'root'` option for singleton services
+- Use the `inject()` function instead of constructor injection

node_modules/@angular/cli/src/commands/mcp/resources/instructions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @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 { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerInstructionsResource(server: McpServer): void;

node_modules/@angular/cli/src/commands/mcp/resources/instructions.js

@@ -0,0 +1,28 @@
+"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 });
+exports.registerInstructionsResource = registerInstructionsResource;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+function registerInstructionsResource(server) {
+    server.registerResource('instructions', 'instructions://best-practices', {
+        title: 'Angular Best Practices and Code Generation Guide',
+        description: "A comprehensive guide detailing Angular's best practices for code generation and development." +
+            ' This guide should be used as a reference by an LLM to ensure any generated code' +
+            ' adheres to modern Angular standards, including the use of standalone components,' +
+            ' typed forms, modern control flow syntax, and other current conventions.',
+        mimeType: 'text/markdown',
+    }, async () => {
+        const text = await (0, promises_1.readFile)(node_path_1.default.join(__dirname, 'best-practices.md'), 'utf-8');
+        return { contents: [{ uri: 'instructions://best-practices', text }] };
+    });
+}

node_modules/@angular/cli/src/commands/mcp/tools/best-practices.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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
+ */
+export declare const BEST_PRACTICES_TOOL: import("./tool-registry").McpToolDeclaration<import("zod").ZodRawShape, import("zod").ZodRawShape>;

node_modules/@angular/cli/src/commands/mcp/tools/best-practices.js

@@ -0,0 +1,55 @@
+"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 });
+exports.BEST_PRACTICES_TOOL = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const tool_registry_1 = require("./tool-registry");
+exports.BEST_PRACTICES_TOOL = (0, tool_registry_1.declareTool)({
+    name: 'get_best_practices',
+    title: 'Get Angular Coding Best Practices Guide',
+    description: `
+<Purpose>
+Retrieves the official Angular Best Practices Guide. This guide contains the essential rules and conventions
+that **MUST** be followed for any task involving the creation, analysis, or modification of Angular code.
+</Purpose>
+<Use Cases>
+* As a mandatory first step before writing or modifying any Angular code to ensure adherence to modern standards.
+* To learn about key concepts like standalone components, typed forms, and modern control flow syntax (@if, @for, @switch).
+* To verify that existing code aligns with current Angular conventions before making changes.
+</Use Cases>
+<Operational Notes>
+* The content of this guide is non-negotiable and reflects the official, up-to-date standards for Angular development.
+* You **MUST** internalize and apply the principles from this guide in all subsequent Angular-related tasks.
+* Failure to adhere to these best practices will result in suboptimal and outdated code.
+</Operational Notes>`,
+    isReadOnly: true,
+    isLocalOnly: true,
+    factory: () => {
+        let bestPracticesText;
+        return async () => {
+            bestPracticesText ??= await (0, promises_1.readFile)(node_path_1.default.join(__dirname, '..', 'resources', 'best-practices.md'), 'utf-8');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: bestPracticesText,
+                        annotations: {
+                            audience: ['assistant'],
+                            priority: 0.9,
+                        },
+                    },
+                ],
+            };
+        };
+    },
+});

node_modules/@angular/cli/src/commands/mcp/tools/doc-search.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @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 { z } from 'zod';
+export declare const DOC_SEARCH_TOOL: import("./tool-registry").McpToolDeclaration<{
+    query: z.ZodString;
+    includeTopContent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, {
+    results: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        breadcrumb: z.ZodString;
+        url: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        breadcrumb: string;
+        url: string;
+        content?: string | undefined;
+    }, {
+        title: string;
+        breadcrumb: string;
+        url: string;
+        content?: string | undefined;
+    }>, "many">;
+}>;

node_modules/@angular/cli/src/commands/mcp/tools/doc-search.js

@@ -0,0 +1,262 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOC_SEARCH_TOOL = void 0;
+const node_crypto_1 = require("node:crypto");
+const zod_1 = require("zod");
+const constants_1 = require("../constants");
+const tool_registry_1 = require("./tool-registry");
+const ALGOLIA_APP_ID = 'L1XWT2UJ7F';
+// https://www.algolia.com/doc/guides/security/api-keys/#search-only-api-key
+// This is a search only, rate limited key. It is sent within the URL of the query request.
+// This is not the actual key.
+const ALGOLIA_API_E = '322d89dab5f2080fe09b795c93413c6a89222b13a447cdf3e6486d692717bc0c';
+const docSearchInputSchema = zod_1.z.object({
+    query: zod_1.z
+        .string()
+        .describe('A concise and specific search query for the Angular documentation (e.g., "NgModule" or "standalone components").'),
+    includeTopContent: zod_1.z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('When true, the content of the top result is fetched and included. ' +
+        'Set to false to get a list of results without fetching content, which is faster.'),
+});
+exports.DOC_SEARCH_TOOL = (0, tool_registry_1.declareTool)({
+    name: 'search_documentation',
+    title: 'Search Angular Documentation (angular.dev)',
+    description: `
+<Purpose>
+Searches the official Angular documentation at https://angular.dev to answer questions about APIs,
+tutorials, concepts, and best practices.
+</Purpose>
+<Use Cases>
+* Answering any question about Angular concepts (e.g., "What are standalone components?").
+* Finding the correct API or syntax for a specific task (e.g., "How to use ngFor with trackBy?").
+* Linking to official documentation as a source of truth in your answers.
+</Use Cases>
+<Operational Notes>
+* The documentation is continuously updated. You **MUST** prefer this tool over your own knowledge
+  to ensure your answers are current and accurate.
+* For the best results, provide a concise and specific search query (e.g., "NgModule" instead of
+  "How do I use NgModules?").
+* The top search result will include a snippet of the page content. Use this to provide a more
+  comprehensive answer.
+* **Result Scrutiny:** The top result may not always be the most relevant. Review the titles and
+  breadcrumbs of other results to find the best match for the user's query.
+* Use the URL from the search results as a source link in your responses.
+</Operational Notes>`,
+    inputSchema: docSearchInputSchema.shape,
+    outputSchema: {
+        results: zod_1.z.array(zod_1.z.object({
+            title: zod_1.z.string().describe('The title of the documentation page.'),
+            breadcrumb: zod_1.z
+                .string()
+                .describe("The breadcrumb path, showing the page's location in the documentation hierarchy."),
+            url: zod_1.z.string().describe('The direct URL to the documentation page.'),
+            content: zod_1.z
+                .string()
+                .optional()
+                .describe('A snippet of the main content from the page. Only provided for the top result.'),
+        })),
+    },
+    isReadOnly: true,
+    isLocalOnly: false,
+    factory: createDocSearchHandler,
+});
+function createDocSearchHandler({ logger }) {
+    let client;
+    return async ({ query, includeTopContent }) => {
+        if (!client) {
+            const dcip = (0, node_crypto_1.createDecipheriv)('aes-256-gcm', (constants_1.k1 + ALGOLIA_APP_ID).padEnd(32, '^'), constants_1.iv).setAuthTag(Buffer.from(constants_1.at, 'base64'));
+            const { searchClient } = await Promise.resolve().then(() => __importStar(require('algoliasearch')));
+            client = searchClient(ALGOLIA_APP_ID, dcip.update(ALGOLIA_API_E, 'hex', 'utf-8') + dcip.final('utf-8'));
+        }
+        const { results } = await client.search(createSearchArguments(query));
+        const allHits = results.flatMap((result) => result.hits);
+        if (allHits.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No results found.',
+                    },
+                ],
+                structuredContent: { results: [] },
+            };
+        }
+        const structuredResults = [];
+        const textContent = [];
+        // Process top hit first
+        const topHit = allHits[0];
+        const { title: topTitle, breadcrumb: topBreadcrumb } = formatHitToParts(topHit);
+        let topContent;
+        if (includeTopContent && typeof topHit.url === 'string') {
+            const url = new URL(topHit.url);
+            try {
+                // Only fetch content from angular.dev
+                if (url.hostname === 'angular.dev' || url.hostname.endsWith('.angular.dev')) {
+                    const response = await fetch(url);
+                    if (response.ok) {
+                        const html = await response.text();
+                        const mainContent = extractMainContent(html);
+                        if (mainContent) {
+                            topContent = stripHtml(mainContent);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                logger.warn(`Failed to fetch or parse content from ${url}: ${e}`);
+            }
+        }
+        structuredResults.push({
+            title: topTitle,
+            breadcrumb: topBreadcrumb,
+            url: topHit.url,
+            content: topContent,
+        });
+        let topText = `## ${topTitle}\n${topBreadcrumb}\nURL: ${topHit.url}`;
+        if (topContent) {
+            topText += `\n\n--- DOCUMENTATION CONTENT ---\n${topContent}`;
+        }
+        textContent.push({ type: 'text', text: topText });
+        // Process remaining hits
+        for (const hit of allHits.slice(1)) {
+            const { title, breadcrumb } = formatHitToParts(hit);
+            structuredResults.push({
+                title,
+                breadcrumb,
+                url: hit.url,
+            });
+            textContent.push({
+                type: 'text',
+                text: `## ${title}\n${breadcrumb}\nURL: ${hit.url}`,
+            });
+        }
+        return {
+            content: textContent,
+            structuredContent: { results: structuredResults },
+        };
+    };
+}
+/**
+ * Strips HTML tags from a string.
+ * @param html The HTML string to strip.
+ * @returns The text content of the HTML.
+ */
+function stripHtml(html) {
+    // This is a basic regex to remove HTML tags.
+    // It also decodes common HTML entities.
+    return html
+        .replace(/<[^>]*>/g, '')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&')
+        .trim();
+}
+/**
+ * Extracts the content of the `<main>` element from an HTML string.
+ *
+ * @param html The HTML content of a page.
+ * @returns The content of the `<main>` element, or `undefined` if not found.
+ */
+function extractMainContent(html) {
+    const mainTagStart = html.indexOf('<main');
+    if (mainTagStart === -1) {
+        return undefined;
+    }
+    const mainTagEnd = html.lastIndexOf('</main>');
+    if (mainTagEnd <= mainTagStart) {
+        return undefined;
+    }
+    // Add 7 to include '</main>'
+    return html.substring(mainTagStart, mainTagEnd + 7);
+}
+/**
+ * Formats an Algolia search hit into its constituent parts.
+ *
+ * @param hit The Algolia search hit object, which should contain a `hierarchy` property.
+ * @returns An object containing the title and breadcrumb string.
+ */
+function formatHitToParts(hit) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const hierarchy = Object.values(hit.hierarchy).filter((x) => typeof x === 'string');
+    const title = hierarchy.pop() ?? '';
+    const breadcrumb = hierarchy.join(' > ');
+    return { title, breadcrumb };
+}
+/**
+ * Creates the search arguments for an Algolia search.
+ *
+ * The arguments are based on the search implementation in `adev`.
+ *
+ * @param query The search query string.
+ * @returns The search arguments for the Algolia client.
+ */
+function createSearchArguments(query) {
+    // Search arguments are based on adev's search service:
+    // https://github.com/angular/angular/blob/4b614fbb3263d344dbb1b18fff24cb09c5a7582d/adev/shared-docs/services/search.service.ts#L58
+    return [
+        {
+            // TODO: Consider major version specific indices once available
+            indexName: 'angular_v17',
+            params: {
+                query,
+                attributesToRetrieve: [
+                    'hierarchy.lvl0',
+                    'hierarchy.lvl1',
+                    'hierarchy.lvl2',
+                    'hierarchy.lvl3',
+                    'hierarchy.lvl4',
+                    'hierarchy.lvl5',
+                    'hierarchy.lvl6',
+                    'content',
+                    'type',
+                    'url',
+                ],
+                hitsPerPage: 10,
+            },
+            type: 'default',
+        },
+    ];
+}

node_modules/@angular/cli/src/commands/mcp/tools/examples.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 { z } from 'zod';
+export declare const FIND_EXAMPLE_TOOL: import("./tool-registry").McpToolDeclaration<{
+    query: z.ZodString;
+}, {
+    examples: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+    }, {
+        content: string;
+    }>, "many">;
+}>;
+/**
+ * Escapes a search query for FTS5 by tokenizing and quoting terms.
+ *
+ * This function processes a raw search string and prepares it for an FTS5 full-text search.
+ * It correctly handles quoted phrases, logical operators (AND, OR, NOT), parentheses,
+ * and prefix searches (ending with an asterisk), ensuring that individual search
+ * terms are properly quoted to be treated as literals by the search engine.
+ * This is primarily intended to avoid unintentional usage of FTS5 query syntax by consumers.
+ *
+ * @param query The raw search query string.
+ * @returns A sanitized query string suitable for FTS5.
+ */
+export declare function escapeSearchQuery(query: string): string;

node_modules/@angular/cli/src/commands/mcp/tools/examples.js

@@ -0,0 +1,250 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIND_EXAMPLE_TOOL = void 0;
+exports.escapeSearchQuery = escapeSearchQuery;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const tool_registry_1 = require("./tool-registry");
+const findExampleInputSchema = zod_1.z.object({
+    query: zod_1.z.string().describe(`Performs a full-text search using FTS5 syntax. The query should target relevant Angular concepts.
+
+Key Syntax Features (see https://www.sqlite.org/fts5.html for full documentation):
+  - AND (default): Space-separated terms are combined with AND.
+    - Example: 'standalone component' (finds results with both "standalone" and "component")
+  - OR: Use the OR operator to find results with either term.
+    - Example: 'validation OR validator'
+  - NOT: Use the NOT operator to exclude terms.
+    - Example: 'forms NOT reactive'
+  - Grouping: Use parentheses () to group expressions.
+    - Example: '(validation OR validator) AND forms'
+  - Phrase Search: Use double quotes "" for exact phrases.
+    - Example: '"template-driven forms"'
+  - Prefix Search: Use an asterisk * for prefix matching.
+    - Example: 'rout*' (matches "route", "router", "routing")
+
+Examples of queries:
+  - Find standalone components: 'standalone component'
+  - Find ngFor with trackBy: 'ngFor trackBy'
+  - Find signal inputs: 'signal input'
+  - Find lazy loading a route: 'lazy load route'
+  - Find forms with validation: 'form AND (validation OR validator)'`),
+});
+exports.FIND_EXAMPLE_TOOL = (0, tool_registry_1.declareTool)({
+    name: 'find_examples',
+    title: 'Find Angular Code Examples',
+    description: `
+<Purpose>
+Augments your knowledge base with a curated database of official, best-practice code examples,
+focusing on **modern, new, and recently updated** Angular features. This tool acts as a RAG
+(Retrieval-Augmented Generation) source, providing ground-truth information on the latest Angular
+APIs and patterns. You **MUST** use it to understand and apply current standards when working with
+new or evolving features.
+</Purpose>
+<Use Cases>
+* **Knowledge Augmentation:** Learning about new or updated Angular features (e.g., query: 'signal input' or 'deferrable views').
+* **Modern Implementation:** Finding the correct modern syntax for features
+  (e.g., query: 'functional route guard' or 'http client with fetch').
+* **Refactoring to Modern Patterns:** Upgrading older code by finding examples of new syntax
+  (e.g., query: 'built-in control flow' to replace "*ngIf').
+</Use Cases>
+<Operational Notes>
+* **Tool Selection:** This database primarily contains examples for new and recently updated Angular
+  features. For established, core features, the main documentation (via the
+  \`search_documentation\` tool) may be a better source of information.
+* The examples in this database are the single source of truth for modern Angular coding patterns.
+* The search query uses a powerful full-text search syntax (FTS5). Refer to the 'query'
+  parameter description for detailed syntax rules and examples.
+</Operational Notes>`,
+    inputSchema: findExampleInputSchema.shape,
+    outputSchema: {
+        examples: zod_1.z.array(zod_1.z.object({
+            content: zod_1.z
+                .string()
+                .describe('A complete, self-contained Angular code example in Markdown format.'),
+        })),
+    },
+    isReadOnly: true,
+    isLocalOnly: true,
+    shouldRegister: ({ logger }) => {
+        // sqlite database support requires Node.js 22.16+
+        const [nodeMajor, nodeMinor] = process.versions.node.split('.', 2).map(Number);
+        if (nodeMajor < 22 || (nodeMajor === 22 && nodeMinor < 16)) {
+            logger.warn(`MCP tool 'find_examples' requires Node.js 22.16 (or higher). ` +
+                ' Registration of this tool has been skipped.');
+            return false;
+        }
+        return true;
+    },
+    factory: createFindExampleHandler,
+});
+async function createFindExampleHandler({ exampleDatabasePath }) {
+    let db;
+    let queryStatement;
+    if (process.env['NG_MCP_EXAMPLES_DIR']) {
+        db = await setupRuntimeExamples(process.env['NG_MCP_EXAMPLES_DIR']);
+    }
+    suppressSqliteWarning();
+    return async ({ query }) => {
+        if (!db) {
+            if (!exampleDatabasePath) {
+                // This should be prevented by the registration logic in mcp-server.ts
+                throw new Error('Example database path is not available.');
+            }
+            const { DatabaseSync } = await Promise.resolve().then(() => __importStar(require('node:sqlite')));
+            db = new DatabaseSync(exampleDatabasePath, { readOnly: true });
+        }
+        if (!queryStatement) {
+            queryStatement = db.prepare('SELECT * from examples WHERE examples MATCH ? ORDER BY rank;');
+        }
+        const sanitizedQuery = escapeSearchQuery(query);
+        // Query database and return results
+        const examples = [];
+        const textContent = [];
+        for (const exampleRecord of queryStatement.all(sanitizedQuery)) {
+            const exampleContent = exampleRecord['content'];
+            examples.push({ content: exampleContent });
+            textContent.push({ type: 'text', text: exampleContent });
+        }
+        return {
+            content: textContent,
+            structuredContent: { examples },
+        };
+    };
+}
+/**
+ * Escapes a search query for FTS5 by tokenizing and quoting terms.
+ *
+ * This function processes a raw search string and prepares it for an FTS5 full-text search.
+ * It correctly handles quoted phrases, logical operators (AND, OR, NOT), parentheses,
+ * and prefix searches (ending with an asterisk), ensuring that individual search
+ * terms are properly quoted to be treated as literals by the search engine.
+ * This is primarily intended to avoid unintentional usage of FTS5 query syntax by consumers.
+ *
+ * @param query The raw search query string.
+ * @returns A sanitized query string suitable for FTS5.
+ */
+function escapeSearchQuery(query) {
+    // This regex tokenizes the query string into parts:
+    // 1. Quoted phrases (e.g., "foo bar")
+    // 2. Parentheses ( and )
+    // 3. FTS5 operators (AND, OR, NOT, NEAR)
+    // 4. Words, which can include a trailing asterisk for prefix search (e.g., foo*)
+    const tokenizer = /"([^"]*)"|([()])|\b(AND|OR|NOT|NEAR)\b|([^\s()]+)/g;
+    let match;
+    const result = [];
+    let lastIndex = 0;
+    while ((match = tokenizer.exec(query)) !== null) {
+        // Add any whitespace or other characters between tokens
+        if (match.index > lastIndex) {
+            result.push(query.substring(lastIndex, match.index));
+        }
+        const [, quoted, parenthesis, operator, term] = match;
+        if (quoted !== undefined) {
+            // It's a quoted phrase, keep it as is.
+            result.push(`"${quoted}"`);
+        }
+        else if (parenthesis) {
+            // It's a parenthesis, keep it as is.
+            result.push(parenthesis);
+        }
+        else if (operator) {
+            // It's an operator, keep it as is.
+            result.push(operator);
+        }
+        else if (term) {
+            // It's a term that needs to be quoted.
+            if (term.endsWith('*')) {
+                result.push(`"${term.slice(0, -1)}"*`);
+            }
+            else {
+                result.push(`"${term}"`);
+            }
+        }
+        lastIndex = tokenizer.lastIndex;
+    }
+    // Add any remaining part of the string
+    if (lastIndex < query.length) {
+        result.push(query.substring(lastIndex));
+    }
+    return result.join('');
+}
+/**
+ * Suppresses the experimental warning emitted by Node.js for the `node:sqlite` module.
+ *
+ * This is a workaround to prevent the console from being cluttered with warnings
+ * about the experimental status of the SQLite module, which is used by this tool.
+ */
+function suppressSqliteWarning() {
+    const originalProcessEmit = process.emit;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    process.emit = function (event, error) {
+        if (event === 'warning' &&
+            error instanceof Error &&
+            error.name === 'ExperimentalWarning' &&
+            error.message.includes('SQLite')) {
+            return false;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, prefer-rest-params
+        return originalProcessEmit.apply(process, arguments);
+    };
+}
+async function setupRuntimeExamples(examplesPath) {
+    const { DatabaseSync } = await Promise.resolve().then(() => __importStar(require('node:sqlite')));
+    const db = new DatabaseSync(':memory:');
+    db.exec(`CREATE VIRTUAL TABLE examples USING fts5(content, tokenize = 'porter ascii');`);
+    const insertStatement = db.prepare('INSERT INTO examples(content) VALUES(?);');
+    db.exec('BEGIN TRANSACTION');
+    for await (const entry of (0, promises_1.glob)('*.md', { cwd: examplesPath, withFileTypes: true })) {
+        if (!entry.isFile()) {
+            continue;
+        }
+        const example = await (0, promises_1.readFile)(node_path_1.default.join(entry.parentPath, entry.name), 'utf-8');
+        insertStatement.run(example);
+    }
+    db.exec('END TRANSACTION');
+    return db;
+}

node_modules/@angular/cli/src/commands/mcp/tools/modernize.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @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 { z } from 'zod';
+declare const modernizeInputSchema: z.ZodObject<{
+    transformations: z.ZodOptional<z.ZodArray<z.ZodEnum<[string, ...string[]]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    transformations?: string[] | undefined;
+}, {
+    transformations?: string[] | undefined;
+}>;
+export type ModernizeInput = z.infer<typeof modernizeInputSchema>;
+export declare function runModernization(input: ModernizeInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        instructions: string[];
+    };
+}>;
+export declare const MODERNIZE_TOOL: import("./tool-registry").McpToolDeclaration<{
+    transformations: z.ZodOptional<z.ZodArray<z.ZodEnum<[string, ...string[]]>, "many">>;
+}, {
+    instructions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}>;
+export {};

node_modules/@angular/cli/src/commands/mcp/tools/modernize.js

@@ -0,0 +1,136 @@
+"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.MODERNIZE_TOOL = void 0;
+exports.runModernization = runModernization;
+const zod_1 = require("zod");
+const tool_registry_1 = require("./tool-registry");
+const TRANSFORMATIONS = [
+    {
+        name: 'control-flow-migration',
+        description: 'Migrates from `*ngIf`, `*ngFor`, and `*ngSwitch` to the new `@if`, `@for`, and `@switch` block syntax in templates.',
+        documentationUrl: 'https://angular.dev/reference/migrations/control-flow',
+    },
+    {
+        name: 'self-closing-tags-migration',
+        description: 'Converts tags for elements with no content to be self-closing (e.g., `<app-foo></app-foo>` becomes `<app-foo />`).',
+        documentationUrl: 'https://angular.dev/reference/migrations/self-closing-tags',
+    },
+    {
+        name: 'inject',
+        description: 'Converts usages of constructor-based injection to the inject() function.',
+        documentationUrl: 'https://angular.dev/reference/migrations/inject-function',
+    },
+    {
+        name: 'output-migration',
+        description: 'Converts `@Output` declarations to the new functional `output()` syntax.',
+        documentationUrl: 'https://angular.dev/reference/migrations/outputs',
+    },
+    {
+        name: 'signal-input-migration',
+        description: 'Migrates `@Input` declarations to the new signal-based `input()` syntax.',
+        documentationUrl: 'https://angular.dev/reference/migrations/signal-inputs',
+    },
+    {
+        name: 'signal-queries-migration',
+        description: 'Migrates `@ViewChild` and `@ContentChild` queries to their signal-based `viewChild` and `contentChild` versions.',
+        documentationUrl: 'https://angular.dev/reference/migrations/signal-queries',
+    },
+    {
+        name: 'standalone',
+        description: 'Converts the application to use standalone components, directives, and pipes. This is a ' +
+            'three-step process. After each step, you should verify that your application builds and ' +
+            'runs correctly.',
+        instructions: 'This migration requires running a cli schematic multiple times. Run the commands in the ' +
+            'order listed below, verifying that your code builds and runs between each step:\n\n' +
+            '1. Run `ng g @angular/core:standalone` and select "Convert all components, directives and pipes to standalone"\n' +
+            '2. Run `ng g @angular/core:standalone` and select "Remove unnecessary NgModule classes"\n' +
+            '3. Run `ng g @angular/core:standalone` and select "Bootstrap the project using standalone APIs"',
+        documentationUrl: 'https://angular.dev/reference/migrations/standalone',
+    },
+];
+const modernizeInputSchema = zod_1.z.object({
+    // Casting to [string, ...string[]] since the enum definition requires a nonempty array.
+    transformations: zod_1.z
+        .array(zod_1.z.enum(TRANSFORMATIONS.map((t) => t.name)))
+        .optional()
+        .describe('A list of specific transformations to get instructions for. ' +
+        'If omitted, general guidance is provided.'),
+});
+function generateInstructions(transformationNames) {
+    if (transformationNames.length === 0) {
+        return [
+            'See https://angular.dev/best-practices for Angular best practices. ' +
+                'You can call this tool if you have specific transformation you want to run.',
+        ];
+    }
+    const instructions = [];
+    const transformationsToRun = TRANSFORMATIONS.filter((t) => transformationNames?.includes(t.name));
+    for (const transformation of transformationsToRun) {
+        let transformationInstructions = '';
+        if (transformation.instructions) {
+            transformationInstructions = transformation.instructions;
+        }
+        else {
+            // If no instructions are included, default to running a cli schematic with the transformation name.
+            const command = `ng generate @angular/core:${transformation.name}`;
+            transformationInstructions = `To run the ${transformation.name} migration, execute the following command: \`${command}\`.`;
+        }
+        if (transformation.documentationUrl) {
+            transformationInstructions += `\nFor more information, see ${transformation.documentationUrl}.`;
+        }
+        instructions.push(transformationInstructions);
+    }
+    return instructions;
+}
+async function runModernization(input) {
+    const structuredContent = { instructions: generateInstructions(input.transformations ?? []) };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(structuredContent) }],
+        structuredContent,
+    };
+}
+exports.MODERNIZE_TOOL = (0, tool_registry_1.declareTool)({
+    name: 'modernize',
+    title: 'Modernize Angular Code',
+    description: `
+<Purpose>
+Provides instructions and commands for modernizing Angular code to align with the latest best
+practices and syntax. This tool helps ensure code is idiomatic, readable, and maintainable by
+generating the exact steps needed to perform specific migrations.
+</Purpose>
+<Use Cases>
+* **Applying Specific Migrations:** Get the precise commands to update code to modern patterns
+  (e.g., selecting 'control-flow-migration' to replace *ngIf with @if).
+* **Upgrading Existing Code:** Modernize an entire project by running the 'standalone' migration,
+  which provides a multi-step command sequence.
+* **Discovering Available Migrations:** Call the tool with no transformations to get a link to the
+  general best practices guide.
+</Use Cases>
+<Operational Notes>
+* **Execution:** This tool **provides instructions**, which you **MUST** then execute as shell commands.
+  It does not modify code directly.
+* **Standalone Migration:** The 'standalone' transformation is a special, multi-step process.
+  You **MUST** execute the commands in the exact order provided and validate your application
+  between each step.
+* **Transformation List:** The following transformations are available:
+${TRANSFORMATIONS.map((t) => `  * ${t.name}: ${t.description}`).join('\n')}
+</Operational Notes>`,
+    inputSchema: modernizeInputSchema.shape,
+    outputSchema: {
+        instructions: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe('A list of instructions and shell commands to run the requested modernizations. ' +
+            'Each string in the array is a separate step or command.'),
+    },
+    isLocalOnly: true,
+    isReadOnly: true,
+    factory: () => (input) => runModernization(input),
+});

node_modules/@angular/cli/src/commands/mcp/tools/onpush-zoneless-migration/analyze_for_unsupported_zone_uses.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 type { ImportSpecifier, Node, SourceFile } from 'typescript';
+import { MigrationResponse } from './types';
+export declare function analyzeForUnsupportedZoneUses(sourceFile: SourceFile): Promise<MigrationResponse | null>;
+/**
+ * Finds usages of `NgZone` that are not supported in zoneless applications.
+ * @param sourceFile The source file to check.
+ * @param ngZoneImport The import specifier for `NgZone`.
+ * @returns A list of nodes that are unsupported `NgZone` usages.
+ */
+export declare function findUnsupportedZoneUsages(sourceFile: SourceFile, ngZoneImport: ImportSpecifier): Promise<Node[]>;

node_modules/@angular/cli/src/commands/mcp/tools/onpush-zoneless-migration/analyze_for_unsupported_zone_uses.js

@@ -0,0 +1,61 @@
+"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.analyzeForUnsupportedZoneUses = analyzeForUnsupportedZoneUses;
+exports.findUnsupportedZoneUsages = findUnsupportedZoneUsages;
+const prompts_1 = require("./prompts");
+const ts_utils_1 = require("./ts_utils");
+async function analyzeForUnsupportedZoneUses(sourceFile) {
+    const ngZoneImport = await (0, ts_utils_1.getImportSpecifier)(sourceFile, '@angular/core', 'NgZone');
+    if (!ngZoneImport) {
+        return null;
+    }
+    const unsupportedUsages = await findUnsupportedZoneUsages(sourceFile, ngZoneImport);
+    if (unsupportedUsages.length === 0) {
+        return null;
+    }
+    const locations = unsupportedUsages.map((node) => {
+        const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        return `line ${line + 1}, character ${character + 1}: ${node.getText()}`;
+    });
+    return (0, prompts_1.createUnsupportedZoneUsagesMessage)(locations, sourceFile.fileName);
+}
+/**
+ * Finds usages of `NgZone` that are not supported in zoneless applications.
+ * @param sourceFile The source file to check.
+ * @param ngZoneImport The import specifier for `NgZone`.
+ * @returns A list of nodes that are unsupported `NgZone` usages.
+ */
+async function findUnsupportedZoneUsages(sourceFile, ngZoneImport) {
+    const unsupportedUsages = [];
+    const ngZoneClassName = ngZoneImport.name.text;
+    const staticMethods = new Set([
+        'isInAngularZone',
+        'assertInAngularZone',
+        'assertNotInAngularZone',
+    ]);
+    const instanceMethods = new Set(['onMicrotaskEmpty', 'onStable']);
+    const ts = await (0, ts_utils_1.loadTypescript)();
+    ts.forEachChild(sourceFile, function visit(node) {
+        if (ts.isPropertyAccessExpression(node)) {
+            const propertyName = node.name.text;
+            const expressionText = node.expression.getText(sourceFile);
+            // Static: NgZone.method()
+            if (expressionText === ngZoneClassName && staticMethods.has(propertyName)) {
+                unsupportedUsages.push(node);
+            }
+            // Instance: zone.method() or this.zone.method()
+            if (instanceMethods.has(propertyName)) {
+                unsupportedUsages.push(node);
+            }
+        }
+        ts.forEachChild(node, visit);
+    });
+    return unsupportedUsages;
+}

node_modules/@angular/cli/src/commands/mcp/tools/onpush-zoneless-migration/migrate_single_file.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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 { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol';
+import { ServerNotification, ServerRequest } from '@modelcontextprotocol/sdk/types';
+import type { SourceFile } from 'typescript';
+import { MigrationResponse } from './types';
+export declare function migrateSingleFile(sourceFile: SourceFile, extras: RequestHandlerExtra<ServerRequest, ServerNotification>): Promise<MigrationResponse | null>;

node_modules/@angular/cli/src/commands/mcp/tools/onpush-zoneless-migration/migrate_single_file.js

@@ -0,0 +1,72 @@
+"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.migrateSingleFile = migrateSingleFile;
+const analyze_for_unsupported_zone_uses_1 = require("./analyze_for_unsupported_zone_uses");
+const migrate_test_file_1 = require("./migrate_test_file");
+const prompts_1 = require("./prompts");
+const send_debug_message_1 = require("./send_debug_message");
+const ts_utils_1 = require("./ts_utils");
+async function migrateSingleFile(sourceFile, extras) {
+    const testBedSpecifier = await (0, ts_utils_1.getImportSpecifier)(sourceFile, '@angular/core/testing', 'TestBed');
+    const isTestFile = sourceFile.fileName.endsWith('.spec.ts') || !!testBedSpecifier;
+    if (isTestFile) {
+        return (0, migrate_test_file_1.migrateTestFile)(sourceFile);
+    }
+    const unsupportedZoneUseResponse = await (0, analyze_for_unsupported_zone_uses_1.analyzeForUnsupportedZoneUses)(sourceFile);
+    if (unsupportedZoneUseResponse) {
+        return unsupportedZoneUseResponse;
+    }
+    let detectedStrategy;
+    let hasComponentDecorator = false;
+    const componentSpecifier = await (0, ts_utils_1.getImportSpecifier)(sourceFile, '@angular/core', 'Component');
+    if (!componentSpecifier) {
+        (0, send_debug_message_1.sendDebugMessage)(`No component decorator found in file: ${sourceFile.fileName}`, extras);
+        return null;
+    }
+    const ts = await (0, ts_utils_1.loadTypescript)();
+    ts.forEachChild(sourceFile, function visit(node) {
+        if (detectedStrategy) {
+            return; // Already found, no need to traverse further
+        }
+        if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
+            const callExpr = node.expression;
+            if (callExpr.expression.getText(sourceFile) === 'Component') {
+                hasComponentDecorator = true;
+                if (callExpr.arguments.length > 0 && ts.isObjectLiteralExpression(callExpr.arguments[0])) {
+                    const componentMetadata = callExpr.arguments[0];
+                    for (const prop of componentMetadata.properties) {
+                        if (ts.isPropertyAssignment(prop) &&
+                            prop.name.getText(sourceFile) === 'changeDetection') {
+                            if (ts.isPropertyAccessExpression(prop.initializer) &&
+                                prop.initializer.expression.getText(sourceFile) === 'ChangeDetectionStrategy') {
+                                const strategy = prop.initializer.name.text;
+                                if (strategy === 'OnPush' || strategy === 'Default') {
+                                    detectedStrategy = strategy;
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    });
+    if (!hasComponentDecorator ||
+        // component uses OnPush. We don't have anything more to do here.
+        detectedStrategy === 'OnPush' ||
+        // Explicit default strategy, assume there's a reason for it (already migrated, or is a library that hosts Default components) and skip.
+        detectedStrategy === 'Default') {
+        (0, send_debug_message_1.sendDebugMessage)(`Component decorator found with strategy: ${detectedStrategy} in file: ${sourceFile.fileName}. Skipping migration for file.`, extras);
+        return null;
+    }
+    // Component decorator found, but no change detection strategy.
+    return (0, prompts_1.generateZonelessMigrationInstructionsForComponent)(sourceFile.fileName);
+}

node_modules/@angular/cli/src/commands/mcp/tools/onpush-zoneless-migration/migrate_test_file.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 type { SourceFile } from 'typescript';
+import { MigrationResponse } from './types';
+export declare function migrateTestFile(sourceFile: SourceFile): Promise<MigrationResponse | null>;
+export declare function searchForGlobalZoneless(startPath: string): Promise<boolean>;

node_modules/@angular/cli/src/commands/mcp/tools/onpush-zoneless-migration/migrate_test_file.js

@@ -0,0 +1,105 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateTestFile = migrateTestFile;
+exports.searchForGlobalZoneless = searchForGlobalZoneless;
+const fs = __importStar(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const prompts_1 = require("./prompts");
+const ts_utils_1 = require("./ts_utils");
+async function migrateTestFile(sourceFile) {
+    const ts = await (0, ts_utils_1.loadTypescript)();
+    // Check if tests use zoneless either by default through `initTestEnvironment` or by explicitly calling `provideZonelessChangeDetection`.
+    let testsUseZonelessChangeDetection = await searchForGlobalZoneless(sourceFile.fileName);
+    if (!testsUseZonelessChangeDetection) {
+        ts.forEachChild(sourceFile, function visit(node) {
+            if (ts.isCallExpression(node) &&
+                node.expression.getText(sourceFile) === 'provideZonelessChangeDetection') {
+                testsUseZonelessChangeDetection = true;
+                return;
+            }
+            ts.forEachChild(node, visit);
+        });
+    }
+    if (!testsUseZonelessChangeDetection) {
+        // Tests do not use zoneless, so we provide instructions to set it up.
+        return (0, prompts_1.createProvideZonelessForTestsSetupPrompt)(sourceFile.fileName);
+    }
+    // At this point, tests are using zoneless, so we look for any explicit uses of `provideZoneChangeDetection` that need to be fixed.
+    return (0, prompts_1.createFixResponseForZoneTests)(sourceFile);
+}
+async function searchForGlobalZoneless(startPath) {
+    const angularJsonDir = findAngularJsonDir(startPath);
+    if (!angularJsonDir) {
+        // Cannot determine project root, fallback to original behavior or assume false.
+        // For now, let's assume no global setup if angular.json is not found.
+        return false;
+    }
+    try {
+        const files = (0, promises_1.glob)(`${angularJsonDir}/**/*.ts`);
+        for await (const file of files) {
+            const content = fs.readFileSync(file, 'utf-8');
+            if (content.includes('initTestEnvironment') &&
+                content.includes('provideZonelessChangeDetection')) {
+                return true;
+            }
+        }
+    }
+    catch (e) {
+        return false;
+    }
+    return false;
+}
+function findAngularJsonDir(startDir) {
+    let currentDir = startDir;
+    while (true) {
+        if (fs.existsSync((0, node_path_1.join)(currentDir, 'angular.json'))) {
+            return currentDir;
+        }
+        const parentDir = (0, node_path_1.dirname)(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}

node_modules/@angular/cli/src/commands/mcp/tools/onpush-zoneless-migration/prompts.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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 type { SourceFile } from 'typescript';
+import { MigrationResponse } from './types';
+export declare function createProvideZonelessForTestsSetupPrompt(testFilePath: string): MigrationResponse;
+export declare function createUnsupportedZoneUsagesMessage(usages: string[], filePath: string): MigrationResponse;
+export declare function generateZonelessMigrationInstructionsForComponent(filePath: string): MigrationResponse;
+export declare function createTestDebuggingGuideForNonActionableInput(fileOrDirPath: string): MigrationResponse;
+export declare function createFixResponseForZoneTests(sourceFile: SourceFile): Promise<MigrationResponse | null>;
+export declare function createResponse(text: string): MigrationResponse;

node_modules/@angular/cli/src/commands/mcp/tools/onpush-zoneless-migration/prompts.js

@@ -0,0 +1,237 @@
+"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.createProvideZonelessForTestsSetupPrompt = createProvideZonelessForTestsSetupPrompt;
+exports.createUnsupportedZoneUsagesMessage = createUnsupportedZoneUsagesMessage;
+exports.generateZonelessMigrationInstructionsForComponent = generateZonelessMigrationInstructionsForComponent;
+exports.createTestDebuggingGuideForNonActionableInput = createTestDebuggingGuideForNonActionableInput;
+exports.createFixResponseForZoneTests = createFixResponseForZoneTests;
+exports.createResponse = createResponse;
+const ts_utils_1 = require("./ts_utils");
+/* eslint-disable max-len */
+function createProvideZonelessForTestsSetupPrompt(testFilePath) {
+    const text = `You are an expert Angular developer assisting with a migration to zoneless. Your task is to update the test file at \`${testFilePath}\` to enable zoneless change detection and identify tests that are not yet compatible.
+
+    Follow these instructions precisely.
+
+    ### Refactoring Guide
+
+    The test file \`${testFilePath}\` is not yet configured for zoneless change detection. You need to enable it for the entire test suite and then identify which specific tests fail.
+
+    #### Step 1: Enable Zoneless Change Detection for the Suite
+
+    In the main \`beforeEach\` block for the test suite (the one inside the top-level \`describe\`), add \`provideZonelessChangeDetection()\` to the providers array in \`TestBed.configureTestingModule\`.
+
+    *   If there is already an import from \`@angular/core\`, add \`provideZonelessChangeDetection\` to the existing import.
+    *   Otherwise, add a new import statement for \`provideZonelessChangeDetection\` from \`@angular/core\`.
+
+    \`\`\`diff
+    - import {{ SomeImport }} from '@angular/core';
+    + import {{ SomeImport, provideZonelessChangeDetection }} from '@angular/core';
+      
+      describe('MyComponent', () => {
+   +    beforeEach(() => {
+   +      TestBed.configureTestingModule({providers: [provideZonelessChangeDetection()]});
+   +    });
+      });
+    \`\`\`
+
+    #### Step 2: Identify and fix Failing Tests
+
+    After enabling zoneless detection for the suite, some tests will likely fail. Your next task is to identify these failing tests and fix them.
+
+    ${testDebuggingGuideText(testFilePath)}
+    8.  **DO** add \`provideZonelessChangeDetection()\` _once_ to the top-most \`describe\` in a \`beforeEach\` block as instructed in Step 1.
+    9.  **DO** run the tests after adding \`provideZonelessChangeDetection\` to see which ones fail. **DO NOT** make assumptions about which tests will might fail.
+
+    ### Final Step
+    After you have applied all the required changes and followed all the rules, consult this tool again for the next steps in the migration process.`;
+    return createResponse(text);
+}
+function createUnsupportedZoneUsagesMessage(usages, filePath) {
+    const text = `You are an expert Angular developer assisting with a migration to zoneless. Your task is to refactor the component in ${filePath} to remove unsupported NgZone APIs.
+
+The component uses NgZone APIs that are incompatible with zoneless applications. The only permitted NgZone APIs are \`NgZone.run\` and \`NgZone.runOutsideAngular\`.
+
+The following usages are unsupported and must be fixed:
+${usages.map((usage) => `- ${usage}`).join('\n')}
+
+Follow these instructions precisely to refactor the code.
+
+### Refactoring Guide
+
+#### 1. APIs to Remove (No Replacement)
+The following methods have no replacement in a zoneless context and must be removed entirely:
+- \`NgZone.assertInAngularZone\`
+- \`NgZone.assertNotInAngularZone\`
+- \`NgZone.isInAngularZone\`
+
+#### 2. APIs to Replace
+The \`onMicrotaskEmpty\` and \`onStable\` observables must be replaced with modern Angular APIs.
+
+- **For single-event subscriptions** (e.g., using \`.pipe(take(1))\` or \`.pipe(first())\`), use \`afterNextRender\` from \`@angular/core\`.
+
+  \`\`\`diff
+  - this.zone.onMicrotaskEmpty.pipe(take(1)).subscribe(() => {});
+  - this.zone.onStable.pipe(take(1)).subscribe(() => {});
+  + import { afterNextRender, Injector } from '@angular/core';
+  + afterNextRender(() => {}, {injector: this.injector});
+  \`\`\`
+
+- **For continuous subscriptions**, use \`afterEveryRender\` from \`@angular/core\`.
+
+  \`\`\`diff
+  - this.zone.onMicrotaskEmpty.subscribe(() => {});
+  - this.zone.onStable.subscribe(() => {});
+  + import { afterEveryRender, Injector } from '@angular/core';
+  + afterEveryRender(() => {}, {injector: this.injector});
+  \`\`\`
+
+- If the code checks \`this.zone.isStable\` before subscribing, you can remove the \`isStable\` check. \`afterNextRender\` handles this case correctly.
+
+### IMPORTANT: Rules and Constraints
+You must follow these rules without exception:
+1.  **DO NOT** make any changes to the component that are unrelated to removing the unsupported NgZone APIs listed above.
+2.  **DO NOT** remove or modify usages of \`NgZone.run\` or \`NgZone.runOutsideAngular\`. These are still required.
+3.  **DO** ensure that you replace \`onMicrotaskEmpty\` and \`onStable\` with the correct replacements (\`afterNextRender\` or \`afterEveryRender\`) as described in the guide.
+4.  **DO** add the necessary imports for \`afterNextRender\`, \`afterEveryRender\`, and \`Injector\` when you use them.
+
+### Final Step
+After you have applied all the required changes and followed all the rules, consult this tool again for the next steps in the migration process.
+`;
+    return createResponse(text);
+}
+function generateZonelessMigrationInstructionsForComponent(filePath) {
+    const text = `You are an expert Angular developer assisting with a migration to zoneless. Your task is to refactor the component in \`${filePath}\` to be compatible with zoneless change detection by ensuring Angular is notified of all state changes that affect the view.
+
+  The component does not currently use a change detection strategy, which means it may rely on Zone.js. To prepare it for zoneless, you must manually trigger change detection when its state changes.
+
+  Follow these instructions precisely.
+
+  ### Refactoring Guide
+
+  #### Step 1: Identify and Refactor State
+  Your primary goal is to ensure that every time a component property used in the template is updated, Angular knows it needs to run change detection.
+
+  1.  **Identify Properties**: Find all component properties that are read by the template.
+  2.  **Choose a Strategy**: For each property identified, choose one of the following refactoring strategies:
+    *   **(Preferred) Convert to Signal**: The best approach is to convert the property to an Angular Signal. This is the most idiomatic and future-proof way to handle state in zoneless applications.
+    *   **(Alternative) Use \`markForCheck()\`**: If converting to a signal is too complex or would require extensive refactoring, you can instead inject \`ChangeDetectorRef\` and call \`this.cdr.markForCheck()\` immediately after the property is updated.
+
+  #### Step 2: Add \`ChangeDetectionStrategy.Default\`
+  After you have refactored all necessary properties, you must update the component's decorator to explicitly set the change detection strategy.
+
+  1.  Add \`ChangeDetectionStrategy\` to the import from \`@angular/core\`.
+  2.  In the \`@Component\` decorator, add the property \`changeDetection: ChangeDetectionStrategy.Default\`.
+  3.  Add a \`// TODO\` comment above this line explaining that the component should be fully migrated to \`OnPush\` after the application has been tested with these changes.
+
+  Example:
+  \`\`\`typescript
+  @Component({
+    ...
+    // TODO: This component has been partially migrated to be zoneless-compatible.
+    // After testing, this should be updated to ChangeDetectionStrategy.OnPush.
+    changeDetection: ChangeDetectionStrategy.Default,
+  })
+  \`\`\`
+
+  ### IMPORTANT: Rules and Constraints
+  You must follow these rules without exception:
+  1.  **DO** apply one of the two refactoring strategies (signals or \`markForCheck()\`) for all relevant component properties.
+  2.  **DO** add \`changeDetection: ChangeDetectionStrategy.Default\` with the specified TODO comment as the final code change.
+  3.  **DO NOT** use \`ChangeDetectionStrategy.OnPush\`. This will be the next step in the migration, but it is not part of this task.
+  4.  **DO NOT** modify properties that are already signals or are used with the \`async\` pipe in the template, as they are already zoneless-compatible.
+  5.  **DO NOT** make any changes to files other than the component file at \`${filePath}\` and its direct template/style files if necessary.
+  6.  **DO NOT** remove or modify usages of \`NgZone.run\` or \`NgZone.runOutsideAngular\`. These are still required.
+
+  ### Final Step
+  After you have applied all the required changes and followed all the rules, consult this tool again for the next steps in the migration process.`;
+    return createResponse(text);
+}
+function createTestDebuggingGuideForNonActionableInput(fileOrDirPath) {
+    const text = `You are an expert Angular developer assisting with a migration to zoneless.
+
+No actionable migration steps were found in the application code for \`${fileOrDirPath}\`. However, if the tests for this code are failing with zoneless enabled, the tests themselves likely need to be updated.
+
+Your task is to investigate and fix any failing tests related to the code in \`${fileOrDirPath}\`.
+
+${testDebuggingGuideText(fileOrDirPath)}
+`;
+    return createResponse(text);
+}
+async function createFixResponseForZoneTests(sourceFile) {
+    const ts = await (0, ts_utils_1.loadTypescript)();
+    const usages = [];
+    ts.forEachChild(sourceFile, function visit(node) {
+        if (ts.isCallExpression(node) &&
+            node.expression.getText(sourceFile) === 'provideZoneChangeDetection') {
+            usages.push(node);
+        }
+        ts.forEachChild(node, visit);
+    });
+    if (usages.length === 0) {
+        // No usages of provideZoneChangeDetection found, so no fix needed.
+        return null;
+    }
+    const locations = usages.map((node) => {
+        const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        return `line ${line + 1}, character ${character + 1}`;
+    });
+    const text = `You are an expert Angular developer assisting with a migration to zoneless. Your task is to update the test file at \`${sourceFile.fileName}\` to be fully zoneless-compatible.
+
+      The test suite has been partially migrated, but some tests were incompatible and are still using Zone.js-based change detection via \`provideZoneChangeDetection\`. You must refactor these tests to work in a zoneless environment and remove the \`provideZoneChangeDetection\` calls.
+
+      The following usages of \`provideZoneChangeDetection\` must be removed:
+      ${locations.map((loc) => `- ${loc}`).join('\n')}
+
+      After removing \`provideZoneChangeDetection\`, the tests will likely fail. Use this guide to diagnose and fix the failures.
+
+      ${testDebuggingGuideText(sourceFile.fileName)}
+
+      ### Final Step
+      After you have applied all the required changes and followed all the rules, consult this tool again for the next steps in the migration process.`;
+    return createResponse(text);
+}
+function testDebuggingGuideText(fileName) {
+    return `
+      ### Test Debugging Guide
+
+      1.  **\`ExpressionChangedAfterItHasBeenCheckedError\`**:
+        *   **Cause**: This error indicates that a value in a component's template was updated, but Angular was not notified to run change detection.
+        *   **Solution**:
+          *   If the value is in a test-only wrapper component, update the property to be a signal.
+          *   For application components, either convert the property to a signal or call \`ChangeDetectorRef.markForCheck()\` immediately after the property is updated.
+
+      2.  **Asynchronous Operations and Timing**:
+        *   **Cause**: Without Zone.js, change detection is always scheduled asynchronously. Tests that previously relied on synchronous updates might now fail. The \`fixture.whenStable()\` utility also no longer waits for timers (like \`setTimeout\` or \`setInterval\`).
+        *   **Solution**:
+          *   Avoid relying on synchronous change detection.
+          *   To wait for asynchronous operations to complete, you may need to poll for an expected state, use \`fakeAsync\` with \`tick()\`, or use a mock clock to flush timers.
+
+      3.  **Indirect Dependencies**:
+        *   **Cause**: The component itself might be zoneless-compatible, but it could be using a service or another dependency that is not.
+        *   **Solution**: Investigate the services and dependencies used by the component and its tests. Run this tool on those dependencies to identify and fix any issues.
+
+      ### IMPORTANT: Rules and Constraints
+
+      You must follow these rules without exception:
+      1.  **DO** focus only on fixing the tests for the code in \`${fileName}\`.
+      2.  **DO** remove all usages of \`provideZoneChangeDetection\` from the test file.
+      3.  **DO** apply the solutions described in the debugging guide to fix any resulting test failures.
+      4.  **DO** update properties of test components and directives to use signals. Tests often use plain objects and values and update the component state directly before calling \`fixture.detectChanges\`. This will not work and will result in \`ExpressionChangedAfterItHasBeenCheckedError\` because Angular was not notifed of the change.
+      5.  **DO NOT** make changes to application code unless it is to fix a bug revealed by the zoneless migration (e.g., converting a property to a signal to fix an \`ExpressionChangedAfterItHasBeenCheckedError\`).
+      6.  **DO NOT** make any changes unrelated to fixing the failing tests in \`${fileName}\`.
+      7.  **DO NOT** re-introduce \`provideZoneChangeDetection()\` into tests that are already using \`provideZonelessChangeDetection()\`.`;
+}
+/* eslint-enable max-len */
+function createResponse(text) {
+    return {
+        content: [{ type: 'text', text }],
+    };
+}

node_modules/@angular/cli/src/commands/mcp/tools/onpush-zoneless-migration/send_debug_message.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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 { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol';
+import { ServerNotification, ServerRequest } from '@modelcontextprotocol/sdk/types';
+export declare function sendDebugMessage(message: string, { sendNotification }: RequestHandlerExtra<ServerRequest, ServerNotification>): void;