Deployed the page to Github Pages.

node_modules/@schematics/angular/utility/standalone/app_config.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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 { Tree } from '@angular-devkit/schematics';
+import ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';
+/** App config that was resolved to its source node. */
+export interface ResolvedAppConfig {
+    /** Tree-relative path of the file containing the app config. */
+    filePath: string;
+    /** Node defining the app config. */
+    node: ts.ObjectLiteralExpression;
+}
+/**
+ * Resolves the node that defines the app config from a bootstrap call.
+ * @param bootstrapCall Call for which to resolve the config.
+ * @param tree File tree of the project.
+ * @param filePath File path of the bootstrap call.
+ */
+export declare function findAppConfig(bootstrapCall: ts.CallExpression, tree: Tree, filePath: string): ResolvedAppConfig | null;

node_modules/@schematics/angular/utility/standalone/app_config.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.findAppConfig = findAppConfig;
+const path_1 = require("path");
+const typescript_1 = __importDefault(require("../../third_party/github.com/Microsoft/TypeScript/lib/typescript"));
+const util_1 = require("./util");
+/**
+ * Resolves the node that defines the app config from a bootstrap call.
+ * @param bootstrapCall Call for which to resolve the config.
+ * @param tree File tree of the project.
+ * @param filePath File path of the bootstrap call.
+ */
+function findAppConfig(bootstrapCall, tree, filePath) {
+    if (bootstrapCall.arguments.length > 1) {
+        const config = bootstrapCall.arguments[1];
+        if (typescript_1.default.isObjectLiteralExpression(config)) {
+            return { filePath, node: config };
+        }
+        if (typescript_1.default.isIdentifier(config)) {
+            return resolveAppConfigFromIdentifier(config, tree, filePath);
+        }
+    }
+    return null;
+}
+/**
+ * Resolves the app config from an identifier referring to it.
+ * @param identifier Identifier referring to the app config.
+ * @param tree File tree of the project.
+ * @param bootstapFilePath Path of the bootstrap call.
+ */
+function resolveAppConfigFromIdentifier(identifier, tree, bootstapFilePath) {
+    const sourceFile = identifier.getSourceFile();
+    for (const node of sourceFile.statements) {
+        // Only look at relative imports. This will break if the app uses a path
+        // mapping to refer to the import, but in order to resolve those, we would
+        // need knowledge about the entire program.
+        if (!typescript_1.default.isImportDeclaration(node) ||
+            !node.importClause?.namedBindings ||
+            !typescript_1.default.isNamedImports(node.importClause.namedBindings) ||
+            !typescript_1.default.isStringLiteralLike(node.moduleSpecifier) ||
+            !node.moduleSpecifier.text.startsWith('.')) {
+            continue;
+        }
+        for (const specifier of node.importClause.namedBindings.elements) {
+            if (specifier.name.text !== identifier.text) {
+                continue;
+            }
+            // Look for a variable with the imported name in the file. Note that ideally we would use
+            // the type checker to resolve this, but we can't because these utilities are set up to
+            // operate on individual files, not the entire program.
+            const filePath = (0, path_1.join)((0, path_1.dirname)(bootstapFilePath), node.moduleSpecifier.text + '.ts');
+            const importedSourceFile = (0, util_1.getSourceFile)(tree, filePath);
+            const resolvedVariable = findAppConfigFromVariableName(importedSourceFile, (specifier.propertyName || specifier.name).text);
+            if (resolvedVariable) {
+                return { filePath, node: resolvedVariable };
+            }
+        }
+    }
+    const variableInSameFile = findAppConfigFromVariableName(sourceFile, identifier.text);
+    return variableInSameFile ? { filePath: bootstapFilePath, node: variableInSameFile } : null;
+}
+/**
+ * Finds an app config within the top-level variables of a file.
+ * @param sourceFile File in which to search for the config.
+ * @param variableName Name of the variable containing the config.
+ */
+function findAppConfigFromVariableName(sourceFile, variableName) {
+    for (const node of sourceFile.statements) {
+        if (typescript_1.default.isVariableStatement(node)) {
+            for (const decl of node.declarationList.declarations) {
+                if (typescript_1.default.isIdentifier(decl.name) &&
+                    decl.name.text === variableName &&
+                    decl.initializer &&
+                    typescript_1.default.isObjectLiteralExpression(decl.initializer)) {
+                    return decl.initializer;
+                }
+            }
+        }
+    }
+    return null;
+}

node_modules/@schematics/angular/utility/standalone/code_block.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Rule } from '@angular-devkit/schematics';
+/** Generated code that hasn't been interpolated yet. */
+export interface PendingCode {
+    /** Code that will be inserted. */
+    expression: string;
+    /** Imports that need to be added to the file in which the code is inserted. */
+    imports: PendingImports;
+}
+/** Map keeping track of imports and aliases under which they're referred to in an expression. */
+type PendingImports = Map<string, Map<string, string>>;
+/**
+ * Callback invoked by a Rule that produces the code
+ * that needs to be inserted somewhere in the app.
+ */
+export type CodeBlockCallback = (block: CodeBlock) => PendingCode;
+/**
+ * Utility class used to generate blocks of code that
+ * can be inserted by the devkit into a user's app.
+ */
+export declare class CodeBlock {
+    private _imports;
+    /** Function used to tag a code block in order to produce a `PendingCode` object. */
+    code: (strings: TemplateStringsArray, ...params: unknown[]) => PendingCode;
+    /**
+     * Used inside of a code block to mark external symbols and which module they should be imported
+     * from. When the code is inserted, the required import statements will be produced automatically.
+     * @param symbolName Name of the external symbol.
+     * @param moduleName Module from which the symbol should be imported.
+     */
+    external: (symbolName: string, moduleName: string) => string;
+    /**
+     * Produces the necessary rules to transform a `PendingCode` object into valid code.
+     * @param initialCode Code pending transformed.
+     * @param filePath Path of the file in which the code will be inserted.
+     */
+    static transformPendingCode(initialCode: PendingCode, filePath: string): {
+        code: {
+            /** Code that will be inserted. */
+            expression: string;
+            /** Imports that need to be added to the file in which the code is inserted. */
+            imports: PendingImports;
+        };
+        rules: Rule[];
+    };
+}
+export {};

node_modules/@schematics/angular/utility/standalone/code_block.js

@@ -0,0 +1,80 @@
+"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.CodeBlock = void 0;
+const typescript_1 = __importDefault(require("../../third_party/github.com/Microsoft/TypeScript/lib/typescript"));
+const ast_utils_1 = require("../ast-utils");
+const change_1 = require("../change");
+/** Counter used to generate unique IDs. */
+let uniqueIdCounter = 0;
+/**
+ * Utility class used to generate blocks of code that
+ * can be inserted by the devkit into a user's app.
+ */
+class CodeBlock {
+    _imports = new Map();
+    // Note: the methods here are defined as arrow function so that they can be destructured by
+    // consumers without losing their context. This makes the API more concise.
+    /** Function used to tag a code block in order to produce a `PendingCode` object. */
+    code = (strings, ...params) => {
+        return {
+            expression: strings.map((part, index) => part + (params[index] || '')).join(''),
+            imports: this._imports,
+        };
+    };
+    /**
+     * Used inside of a code block to mark external symbols and which module they should be imported
+     * from. When the code is inserted, the required import statements will be produced automatically.
+     * @param symbolName Name of the external symbol.
+     * @param moduleName Module from which the symbol should be imported.
+     */
+    external = (symbolName, moduleName) => {
+        if (!this._imports.has(moduleName)) {
+            this._imports.set(moduleName, new Map());
+        }
+        const symbolsPerModule = this._imports.get(moduleName);
+        if (!symbolsPerModule.has(symbolName)) {
+            symbolsPerModule.set(symbolName, `@@__SCHEMATIC_PLACEHOLDER_${uniqueIdCounter++}__@@`);
+        }
+        return symbolsPerModule.get(symbolName);
+    };
+    /**
+     * Produces the necessary rules to transform a `PendingCode` object into valid code.
+     * @param initialCode Code pending transformed.
+     * @param filePath Path of the file in which the code will be inserted.
+     */
+    static transformPendingCode(initialCode, filePath) {
+        const code = { ...initialCode };
+        const rules = [];
+        code.imports.forEach((symbols, moduleName) => {
+            symbols.forEach((placeholder, symbolName) => {
+                rules.push((tree) => {
+                    const recorder = tree.beginUpdate(filePath);
+                    const sourceFile = typescript_1.default.createSourceFile(filePath, tree.readText(filePath), typescript_1.default.ScriptTarget.Latest, true);
+                    // Note that this could still technically clash if there's a top-level symbol called
+                    // `${symbolName}_alias`, however this is unlikely. We can revisit this if it becomes
+                    // a problem.
+                    const alias = (0, ast_utils_1.hasTopLevelIdentifier)(sourceFile, symbolName, moduleName)
+                        ? symbolName + '_alias'
+                        : undefined;
+                    code.expression = code.expression.replace(new RegExp(placeholder, 'g'), alias || symbolName);
+                    (0, change_1.applyToUpdateRecorder)(recorder, [
+                        (0, ast_utils_1.insertImport)(sourceFile, filePath, symbolName, moduleName, false, alias),
+                    ]);
+                    tree.commitUpdate(recorder);
+                });
+            });
+        });
+        return { code, rules };
+    }
+}
+exports.CodeBlock = CodeBlock;

node_modules/@schematics/angular/utility/standalone/index.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
+ */
+export { addRootImport, addRootProvider } from './rules';
+export type { PendingCode, CodeBlockCallback, CodeBlock } from './code_block';

node_modules/@schematics/angular/utility/standalone/index.js

@@ -0,0 +1,13 @@
+"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.addRootProvider = exports.addRootImport = void 0;
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "addRootImport", { enumerable: true, get: function () { return rules_1.addRootImport; } });
+Object.defineProperty(exports, "addRootProvider", { enumerable: true, get: function () { return rules_1.addRootProvider; } });

node_modules/@schematics/angular/utility/standalone/rules.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Rule } from '@angular-devkit/schematics';
+import { CodeBlockCallback } from './code_block';
+/**
+ * Adds an import to the root of the project.
+ * @param project Name of the project to which to add the import.
+ * @param callback Function that generates the code block which should be inserted.
+ * @example
+ *
+ * ```ts
+ * import { Rule } from '@angular-devkit/schematics';
+ * import { addRootImport } from '@schematics/angular/utility';
+ *
+ * export default function(): Rule {
+ *   return addRootImport('default', ({code, external}) => {
+ *     return code`${external('MyModule', '@my/module')}.forRoot({})`;
+ *   });
+ * }
+ * ```
+ */
+export declare function addRootImport(project: string, callback: CodeBlockCallback): Rule;
+/**
+ * Adds a provider to the root of the project.
+ * @param project Name of the project to which to add the import.
+ * @param callback Function that generates the code block which should be inserted.
+ * @example
+ *
+ * ```ts
+ * import { Rule } from '@angular-devkit/schematics';
+ * import { addRootProvider } from '@schematics/angular/utility';
+ *
+ * export default function(): Rule {
+ *   return addRootProvider('default', ({code, external}) => {
+ *     return code`${external('provideLibrary', '@my/library')}({})`;
+ *   });
+ * }
+ * ```
+ */
+export declare function addRootProvider(project: string, callback: CodeBlockCallback): Rule;

node_modules/@schematics/angular/utility/standalone/rules.js

@@ -0,0 +1,187 @@
+"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.addRootImport = addRootImport;
+exports.addRootProvider = addRootProvider;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const ast_utils_1 = require("../ast-utils");
+const change_1 = require("../change");
+const ng_ast_utils_1 = require("../ng-ast-utils");
+const app_config_1 = require("./app_config");
+const code_block_1 = require("./code_block");
+const util_1 = require("./util");
+/**
+ * Adds an import to the root of the project.
+ * @param project Name of the project to which to add the import.
+ * @param callback Function that generates the code block which should be inserted.
+ * @example
+ *
+ * ```ts
+ * import { Rule } from '@angular-devkit/schematics';
+ * import { addRootImport } from '@schematics/angular/utility';
+ *
+ * export default function(): Rule {
+ *   return addRootImport('default', ({code, external}) => {
+ *     return code`${external('MyModule', '@my/module')}.forRoot({})`;
+ *   });
+ * }
+ * ```
+ */
+function addRootImport(project, callback) {
+    return getRootInsertionRule(project, callback, 'imports', {
+        name: 'importProvidersFrom',
+        module: '@angular/core',
+    });
+}
+/**
+ * Adds a provider to the root of the project.
+ * @param project Name of the project to which to add the import.
+ * @param callback Function that generates the code block which should be inserted.
+ * @example
+ *
+ * ```ts
+ * import { Rule } from '@angular-devkit/schematics';
+ * import { addRootProvider } from '@schematics/angular/utility';
+ *
+ * export default function(): Rule {
+ *   return addRootProvider('default', ({code, external}) => {
+ *     return code`${external('provideLibrary', '@my/library')}({})`;
+ *   });
+ * }
+ * ```
+ */
+function addRootProvider(project, callback) {
+    return getRootInsertionRule(project, callback, 'providers');
+}
+/**
+ * Creates a rule that inserts code at the root of either a standalone or NgModule-based project.
+ * @param project Name of the project into which to inser tthe code.
+ * @param callback Function that generates the code block which should be inserted.
+ * @param ngModuleField Field of the root NgModule into which the code should be inserted, if the
+ * app is based on NgModule
+ * @param standaloneWrapperFunction Function with which to wrap the code if the app is standalone.
+ */
+function getRootInsertionRule(project, callback, ngModuleField, standaloneWrapperFunction) {
+    return async (host) => {
+        const mainFilePath = await (0, util_1.getMainFilePath)(host, project);
+        const codeBlock = new code_block_1.CodeBlock();
+        if ((0, ng_ast_utils_1.isStandaloneApp)(host, mainFilePath)) {
+            return (tree) => addProviderToStandaloneBootstrap(tree, callback(codeBlock), mainFilePath, standaloneWrapperFunction);
+        }
+        const modulePath = (0, ng_ast_utils_1.getAppModulePath)(host, mainFilePath);
+        const pendingCode = code_block_1.CodeBlock.transformPendingCode(callback(codeBlock), modulePath);
+        return (0, schematics_1.chain)([
+            ...pendingCode.rules,
+            (tree) => {
+                const changes = (0, ast_utils_1.addSymbolToNgModuleMetadata)((0, util_1.getSourceFile)(tree, modulePath), modulePath, ngModuleField, pendingCode.code.expression, 
+                // Explicitly set the import path to null since we deal with imports here separately.
+                null);
+                (0, util_1.applyChangesToFile)(tree, modulePath, changes);
+            },
+        ]);
+    };
+}
+/**
+ * Adds a provider to the root of a standalone project.
+ * @param host Tree of the root rule.
+ * @param pendingCode Code that should be inserted.
+ * @param mainFilePath Path to the project's main file.
+ * @param wrapperFunction Optional function with which to wrap the provider.
+ */
+function addProviderToStandaloneBootstrap(host, pendingCode, mainFilePath, wrapperFunction) {
+    const bootstrapCall = (0, util_1.findBootstrapApplicationCall)(host, mainFilePath);
+    const fileToEdit = (0, app_config_1.findAppConfig)(bootstrapCall, host, mainFilePath)?.filePath || mainFilePath;
+    const { code, rules } = code_block_1.CodeBlock.transformPendingCode(pendingCode, fileToEdit);
+    return (0, schematics_1.chain)([
+        ...rules,
+        () => {
+            let wrapped;
+            let additionalRules;
+            if (wrapperFunction) {
+                const block = new code_block_1.CodeBlock();
+                const result = code_block_1.CodeBlock.transformPendingCode(block.code `${block.external(wrapperFunction.name, wrapperFunction.module)}(${code.expression})`, fileToEdit);
+                wrapped = result.code;
+                additionalRules = result.rules;
+            }
+            else {
+                wrapped = code;
+                additionalRules = [];
+            }
+            return (0, schematics_1.chain)([
+                ...additionalRules,
+                (tree) => insertStandaloneRootProvider(tree, mainFilePath, wrapped.expression),
+            ]);
+        },
+    ]);
+}
+/**
+ * Inserts a string expression into the root of a standalone project.
+ * @param tree File tree used to modify the project.
+ * @param mainFilePath Path to the main file of the project.
+ * @param expression Code expression to be inserted.
+ */
+function insertStandaloneRootProvider(tree, mainFilePath, expression) {
+    const bootstrapCall = (0, util_1.findBootstrapApplicationCall)(tree, mainFilePath);
+    const appConfig = (0, app_config_1.findAppConfig)(bootstrapCall, tree, mainFilePath);
+    if (bootstrapCall.arguments.length === 0) {
+        throw new schematics_1.SchematicsException(`Cannot add provider to invalid bootstrapApplication call in ${bootstrapCall.getSourceFile().fileName}`);
+    }
+    if (appConfig) {
+        addProvidersExpressionToAppConfig(tree, appConfig, expression);
+        return;
+    }
+    const newAppConfig = `, {\n${core_1.tags.indentBy(2) `providers: [${expression}]`}\n}`;
+    let targetCall;
+    if (bootstrapCall.arguments.length === 1) {
+        targetCall = bootstrapCall;
+    }
+    else if ((0, util_1.isMergeAppConfigCall)(bootstrapCall.arguments[1])) {
+        targetCall = bootstrapCall.arguments[1];
+    }
+    else {
+        throw new schematics_1.SchematicsException(`Cannot statically analyze bootstrapApplication call in ${bootstrapCall.getSourceFile().fileName}`);
+    }
+    (0, util_1.applyChangesToFile)(tree, mainFilePath, [
+        (0, ast_utils_1.insertAfterLastOccurrence)(targetCall.arguments, newAppConfig, mainFilePath, targetCall.getEnd() - 1),
+    ]);
+}
+/**
+ * Adds a string expression to an app config object.
+ * @param tree File tree used to modify the project.
+ * @param appConfig Resolved configuration object of the project.
+ * @param expression Code expression to be inserted.
+ */
+function addProvidersExpressionToAppConfig(tree, appConfig, expression) {
+    const { node, filePath } = appConfig;
+    const configProps = node.properties;
+    const providersLiteral = (0, util_1.findProvidersLiteral)(node);
+    // If there's a `providers` property, we can add the provider
+    // to it, otherwise we need to declare it ourselves.
+    if (providersLiteral) {
+        (0, util_1.applyChangesToFile)(tree, filePath, [
+            (0, ast_utils_1.insertAfterLastOccurrence)(providersLiteral.elements, (providersLiteral.elements.length === 0 ? '' : ', ') + expression, filePath, providersLiteral.getStart() + 1),
+        ]);
+    }
+    else {
+        const prop = core_1.tags.indentBy(2) `providers: [${expression}]`;
+        let toInsert;
+        let insertPosition;
+        if (configProps.length === 0) {
+            toInsert = '\n' + prop + '\n';
+            insertPosition = node.getEnd() - 1;
+        }
+        else {
+            const hasTrailingComma = configProps.hasTrailingComma;
+            toInsert = (hasTrailingComma ? '' : ',') + '\n' + prop;
+            insertPosition = configProps[configProps.length - 1].getEnd() + (hasTrailingComma ? 1 : 0);
+        }
+        (0, util_1.applyChangesToFile)(tree, filePath, [new change_1.InsertChange(filePath, insertPosition, toInsert)]);
+    }
+}

node_modules/@schematics/angular/utility/standalone/util.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 { Tree } from '@angular-devkit/schematics';
+import ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';
+import { Change } from '../change';
+/**
+ * Finds the main file of a project.
+ * @param tree File tree for the project.
+ * @param projectName Name of the project in which to search.
+ */
+export declare function getMainFilePath(tree: Tree, projectName: string): Promise<string>;
+/**
+ * Gets a TypeScript source file at a specific path.
+ * @param tree File tree of a project.
+ * @param path Path to the file.
+ */
+export declare function getSourceFile(tree: Tree, path: string): ts.SourceFile;
+/** Finds the call to `bootstrapApplication` within a file. */
+export declare function findBootstrapApplicationCall(tree: Tree, mainFilePath: string): ts.CallExpression;
+/**
+ * Applies a set of changes to a file.
+ * @param tree File tree of the project.
+ * @param path Path to the file that is being changed.
+ * @param changes Changes that should be applied to the file.
+ */
+export declare function applyChangesToFile(tree: Tree, path: string, changes: Change[]): void;
+/** Checks whether a node is a call to `mergeApplicationConfig`. */
+export declare function isMergeAppConfigCall(node: ts.Node): node is ts.CallExpression;
+/** Finds the `providers` array literal within an application config. */
+export declare function findProvidersLiteral(config: ts.ObjectLiteralExpression): ts.ArrayLiteralExpression | null;

node_modules/@schematics/angular/utility/standalone/util.js

@@ -0,0 +1,137 @@
+"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.getMainFilePath = getMainFilePath;
+exports.getSourceFile = getSourceFile;
+exports.findBootstrapApplicationCall = findBootstrapApplicationCall;
+exports.applyChangesToFile = applyChangesToFile;
+exports.isMergeAppConfigCall = isMergeAppConfigCall;
+exports.findProvidersLiteral = findProvidersLiteral;
+const schematics_1 = require("@angular-devkit/schematics");
+const typescript_1 = __importDefault(require("../../third_party/github.com/Microsoft/TypeScript/lib/typescript"));
+const change_1 = require("../change");
+const project_targets_1 = require("../project-targets");
+const workspace_1 = require("../workspace");
+const workspace_models_1 = require("../workspace-models");
+/**
+ * Finds the main file of a project.
+ * @param tree File tree for the project.
+ * @param projectName Name of the project in which to search.
+ */
+async function getMainFilePath(tree, projectName) {
+    const workspace = await (0, workspace_1.getWorkspace)(tree);
+    const project = workspace.projects.get(projectName);
+    const buildTarget = project?.targets.get('build');
+    if (!buildTarget) {
+        throw (0, project_targets_1.targetBuildNotFoundError)();
+    }
+    const options = buildTarget.options;
+    return buildTarget.builder === workspace_models_1.Builders.Application ||
+        buildTarget.builder === workspace_models_1.Builders.BuildApplication
+        ? options.browser
+        : options.main;
+}
+/**
+ * Gets a TypeScript source file at a specific path.
+ * @param tree File tree of a project.
+ * @param path Path to the file.
+ */
+function getSourceFile(tree, path) {
+    const content = tree.readText(path);
+    const source = typescript_1.default.createSourceFile(path, content, typescript_1.default.ScriptTarget.Latest, true);
+    return source;
+}
+/** Finds the call to `bootstrapApplication` within a file. */
+function findBootstrapApplicationCall(tree, mainFilePath) {
+    const sourceFile = getSourceFile(tree, mainFilePath);
+    const localName = findImportLocalName(sourceFile, 'bootstrapApplication', '@angular/platform-browser');
+    if (localName) {
+        let result = null;
+        sourceFile.forEachChild(function walk(node) {
+            if (typescript_1.default.isCallExpression(node) &&
+                typescript_1.default.isIdentifier(node.expression) &&
+                node.expression.text === localName) {
+                result = node;
+            }
+            if (!result) {
+                node.forEachChild(walk);
+            }
+        });
+        if (result) {
+            return result;
+        }
+    }
+    throw new schematics_1.SchematicsException(`Could not find bootstrapApplication call in ${mainFilePath}`);
+}
+/**
+ * Finds the local name of an imported symbol. Could be the symbol name itself or its alias.
+ * @param sourceFile File within which to search for the import.
+ * @param name Actual name of the import, not its local alias.
+ * @param moduleName Name of the module from which the symbol is imported.
+ */
+function findImportLocalName(sourceFile, name, moduleName) {
+    for (const node of sourceFile.statements) {
+        // Only look for top-level imports.
+        if (!typescript_1.default.isImportDeclaration(node) ||
+            !typescript_1.default.isStringLiteral(node.moduleSpecifier) ||
+            node.moduleSpecifier.text !== moduleName) {
+            continue;
+        }
+        // Filter out imports that don't have the right shape.
+        if (!node.importClause ||
+            !node.importClause.namedBindings ||
+            !typescript_1.default.isNamedImports(node.importClause.namedBindings)) {
+            continue;
+        }
+        // Look through the elements of the declaration for the specific import.
+        for (const element of node.importClause.namedBindings.elements) {
+            if ((element.propertyName || element.name).text === name) {
+                // The local name is always in `name`.
+                return element.name.text;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Applies a set of changes to a file.
+ * @param tree File tree of the project.
+ * @param path Path to the file that is being changed.
+ * @param changes Changes that should be applied to the file.
+ */
+function applyChangesToFile(tree, path, changes) {
+    if (changes.length > 0) {
+        const recorder = tree.beginUpdate(path);
+        (0, change_1.applyToUpdateRecorder)(recorder, changes);
+        tree.commitUpdate(recorder);
+    }
+}
+/** Checks whether a node is a call to `mergeApplicationConfig`. */
+function isMergeAppConfigCall(node) {
+    if (!typescript_1.default.isCallExpression(node)) {
+        return false;
+    }
+    const localName = findImportLocalName(node.getSourceFile(), 'mergeApplicationConfig', '@angular/core');
+    return !!localName && typescript_1.default.isIdentifier(node.expression) && node.expression.text === localName;
+}
+/** Finds the `providers` array literal within an application config. */
+function findProvidersLiteral(config) {
+    for (const prop of config.properties) {
+        if (typescript_1.default.isPropertyAssignment(prop) &&
+            typescript_1.default.isIdentifier(prop.name) &&
+            prop.name.text === 'providers' &&
+            typescript_1.default.isArrayLiteralExpression(prop.initializer)) {
+            return prop.initializer;
+        }
+    }
+    return null;
+}