Updated the files.

my-app/node_modules/@ngtools/webpack/src/ivy/cache.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.io/license
+ */
+import * as ts from 'typescript';
+export declare class SourceFileCache extends Map<string, ts.SourceFile> {
+    private readonly angularDiagnostics;
+    invalidate(file: string): void;
+    updateAngularDiagnostics(sourceFile: ts.SourceFile, diagnostics: ts.Diagnostic[]): void;
+    getAngularDiagnostics(sourceFile: ts.SourceFile): ts.Diagnostic[] | undefined;
+}

my-app/node_modules/@ngtools/webpack/src/ivy/cache.js

@@ -0,0 +1,32 @@
+"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.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceFileCache = void 0;
+class SourceFileCache extends Map {
+    angularDiagnostics = new Map();
+    invalidate(file) {
+        const sourceFile = this.get(file);
+        if (sourceFile) {
+            this.delete(file);
+            this.angularDiagnostics.delete(sourceFile);
+        }
+    }
+    updateAngularDiagnostics(sourceFile, diagnostics) {
+        if (diagnostics.length > 0) {
+            this.angularDiagnostics.set(sourceFile, diagnostics);
+        }
+        else {
+            this.angularDiagnostics.delete(sourceFile);
+        }
+    }
+    getAngularDiagnostics(sourceFile) {
+        return this.angularDiagnostics.get(sourceFile);
+    }
+}
+exports.SourceFileCache = SourceFileCache;

my-app/node_modules/@ngtools/webpack/src/ivy/diagnostics.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.io/license
+ */
+import { Diagnostic } from 'typescript';
+import type { Compilation } from 'webpack';
+export type DiagnosticsReporter = (diagnostics: readonly Diagnostic[]) => void;
+export declare function createDiagnosticsReporter(compilation: Compilation, formatter: (diagnostic: Diagnostic) => string): DiagnosticsReporter;
+export declare function addWarning(compilation: Compilation, message: string): void;
+export declare function addError(compilation: Compilation, message: string): void;

my-app/node_modules/@ngtools/webpack/src/ivy/diagnostics.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.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addError = exports.addWarning = exports.createDiagnosticsReporter = void 0;
+const typescript_1 = require("typescript");
+function createDiagnosticsReporter(compilation, formatter) {
+    return (diagnostics) => {
+        for (const diagnostic of diagnostics) {
+            const text = formatter(diagnostic);
+            if (diagnostic.category === typescript_1.DiagnosticCategory.Error) {
+                addError(compilation, text);
+            }
+            else {
+                addWarning(compilation, text);
+            }
+        }
+    };
+}
+exports.createDiagnosticsReporter = createDiagnosticsReporter;
+function addWarning(compilation, message) {
+    compilation.warnings.push(new compilation.compiler.webpack.WebpackError(message));
+}
+exports.addWarning = addWarning;
+function addError(compilation, message) {
+    compilation.errors.push(new compilation.compiler.webpack.WebpackError(message));
+}
+exports.addError = addError;

my-app/node_modules/@ngtools/webpack/src/ivy/host.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.io/license
+ */
+import * as ts from 'typescript';
+import { WebpackResourceLoader } from '../resource_loader';
+export declare function augmentHostWithResources(host: ts.CompilerHost, resourceLoader: WebpackResourceLoader, options?: {
+    directTemplateLoading?: boolean;
+    inlineStyleFileExtension?: string;
+}): void;
+/**
+ * Augments a TypeScript Compiler Host's resolveModuleNames function to collect dependencies
+ * of the containing file passed to the resolveModuleNames function. This process assumes
+ * that consumers of the Compiler Host will only call resolveModuleNames with modules that are
+ * actually present in a containing file.
+ * This process is a workaround for gathering a TypeScript SourceFile's dependencies as there
+ * is no currently exposed public method to do so. A BuilderProgram does have a `getAllDependencies`
+ * function. However, that function returns all transitive dependencies as well which can cause
+ * excessive Webpack rebuilds.
+ *
+ * @param host The CompilerHost to augment.
+ * @param dependencies A Map which will be used to store file dependencies.
+ * @param moduleResolutionCache An optional resolution cache to use when the host resolves a module.
+ */
+export declare function augmentHostWithDependencyCollection(host: ts.CompilerHost, dependencies: Map<string, Set<string>>, moduleResolutionCache?: ts.ModuleResolutionCache): void;
+export declare function augmentHostWithReplacements(host: ts.CompilerHost, replacements: Record<string, string>, moduleResolutionCache?: ts.ModuleResolutionCache): void;
+export declare function augmentHostWithSubstitutions(host: ts.CompilerHost, substitutions: Record<string, string>): void;
+export declare function augmentHostWithVersioning(host: ts.CompilerHost): void;
+export declare function augmentProgramWithVersioning(program: ts.Program): void;
+export declare function augmentHostWithCaching(host: ts.CompilerHost, cache: Map<string, ts.SourceFile>): void;

my-app/node_modules/@ngtools/webpack/src/ivy/host.js

@@ -0,0 +1,227 @@
+"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.io/license
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.augmentHostWithCaching = exports.augmentProgramWithVersioning = exports.augmentHostWithVersioning = exports.augmentHostWithSubstitutions = exports.augmentHostWithReplacements = exports.augmentHostWithDependencyCollection = exports.augmentHostWithResources = void 0;
+const crypto_1 = require("crypto");
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const paths_1 = require("./paths");
+function augmentHostWithResources(host, resourceLoader, options = {}) {
+    const resourceHost = host;
+    resourceHost.readResource = function (fileName) {
+        const filePath = (0, paths_1.normalizePath)(fileName);
+        if (options.directTemplateLoading &&
+            (filePath.endsWith('.html') || filePath.endsWith('.svg'))) {
+            const content = this.readFile(filePath);
+            if (content === undefined) {
+                throw new Error('Unable to locate component resource: ' + fileName);
+            }
+            resourceLoader.setAffectedResources(filePath, [filePath]);
+            return content;
+        }
+        else {
+            return resourceLoader.get(filePath);
+        }
+    };
+    resourceHost.resourceNameToFileName = function (resourceName, containingFile) {
+        return path.join(path.dirname(containingFile), resourceName);
+    };
+    resourceHost.getModifiedResourceFiles = function () {
+        return resourceLoader.getModifiedResourceFiles();
+    };
+    resourceHost.transformResource = async function (data, context) {
+        // Only inline style resources are supported currently
+        if (context.resourceFile || context.type !== 'style') {
+            return null;
+        }
+        if (options.inlineStyleFileExtension) {
+            const content = await resourceLoader.process(data, options.inlineStyleFileExtension, context.type, context.containingFile);
+            return { content };
+        }
+        return null;
+    };
+}
+exports.augmentHostWithResources = augmentHostWithResources;
+function augmentResolveModuleNames(host, resolvedModuleModifier, moduleResolutionCache) {
+    if (host.resolveModuleNames) {
+        const baseResolveModuleNames = host.resolveModuleNames;
+        host.resolveModuleNames = function (moduleNames, ...parameters) {
+            return moduleNames.map((name) => {
+                const result = baseResolveModuleNames.call(host, [name], ...parameters);
+                return resolvedModuleModifier(result[0], name);
+            });
+        };
+    }
+    else {
+        host.resolveModuleNames = function (moduleNames, containingFile, _reusedNames, redirectedReference, options) {
+            return moduleNames.map((name) => {
+                const result = ts.resolveModuleName(name, containingFile, options, host, moduleResolutionCache, redirectedReference).resolvedModule;
+                return resolvedModuleModifier(result, name);
+            });
+        };
+    }
+}
+/**
+ * Augments a TypeScript Compiler Host's resolveModuleNames function to collect dependencies
+ * of the containing file passed to the resolveModuleNames function. This process assumes
+ * that consumers of the Compiler Host will only call resolveModuleNames with modules that are
+ * actually present in a containing file.
+ * This process is a workaround for gathering a TypeScript SourceFile's dependencies as there
+ * is no currently exposed public method to do so. A BuilderProgram does have a `getAllDependencies`
+ * function. However, that function returns all transitive dependencies as well which can cause
+ * excessive Webpack rebuilds.
+ *
+ * @param host The CompilerHost to augment.
+ * @param dependencies A Map which will be used to store file dependencies.
+ * @param moduleResolutionCache An optional resolution cache to use when the host resolves a module.
+ */
+function augmentHostWithDependencyCollection(host, dependencies, moduleResolutionCache) {
+    if (host.resolveModuleNames) {
+        const baseResolveModuleNames = host.resolveModuleNames;
+        host.resolveModuleNames = function (moduleNames, containingFile, ...parameters) {
+            const results = baseResolveModuleNames.call(host, moduleNames, containingFile, ...parameters);
+            const containingFilePath = (0, paths_1.normalizePath)(containingFile);
+            for (const result of results) {
+                if (result) {
+                    const containingFileDependencies = dependencies.get(containingFilePath);
+                    if (containingFileDependencies) {
+                        containingFileDependencies.add(result.resolvedFileName);
+                    }
+                    else {
+                        dependencies.set(containingFilePath, new Set([result.resolvedFileName]));
+                    }
+                }
+            }
+            return results;
+        };
+    }
+    else {
+        host.resolveModuleNames = function (moduleNames, containingFile, _reusedNames, redirectedReference, options) {
+            return moduleNames.map((name) => {
+                const result = ts.resolveModuleName(name, containingFile, options, host, moduleResolutionCache, redirectedReference).resolvedModule;
+                if (result) {
+                    const containingFilePath = (0, paths_1.normalizePath)(containingFile);
+                    const containingFileDependencies = dependencies.get(containingFilePath);
+                    if (containingFileDependencies) {
+                        containingFileDependencies.add(result.resolvedFileName);
+                    }
+                    else {
+                        dependencies.set(containingFilePath, new Set([result.resolvedFileName]));
+                    }
+                }
+                return result;
+            });
+        };
+    }
+}
+exports.augmentHostWithDependencyCollection = augmentHostWithDependencyCollection;
+function augmentHostWithReplacements(host, replacements, moduleResolutionCache) {
+    if (Object.keys(replacements).length === 0) {
+        return;
+    }
+    const normalizedReplacements = {};
+    for (const [key, value] of Object.entries(replacements)) {
+        normalizedReplacements[(0, paths_1.normalizePath)(key)] = (0, paths_1.normalizePath)(value);
+    }
+    const tryReplace = (resolvedModule) => {
+        const replacement = resolvedModule && normalizedReplacements[resolvedModule.resolvedFileName];
+        if (replacement) {
+            return {
+                resolvedFileName: replacement,
+                isExternalLibraryImport: /[/\\]node_modules[/\\]/.test(replacement),
+            };
+        }
+        else {
+            return resolvedModule;
+        }
+    };
+    augmentResolveModuleNames(host, tryReplace, moduleResolutionCache);
+}
+exports.augmentHostWithReplacements = augmentHostWithReplacements;
+function augmentHostWithSubstitutions(host, substitutions) {
+    const regexSubstitutions = [];
+    for (const [key, value] of Object.entries(substitutions)) {
+        regexSubstitutions.push([new RegExp(`\\b${key}\\b`, 'g'), value]);
+    }
+    if (regexSubstitutions.length === 0) {
+        return;
+    }
+    const baseReadFile = host.readFile;
+    host.readFile = function (...parameters) {
+        let file = baseReadFile.call(host, ...parameters);
+        if (file) {
+            for (const entry of regexSubstitutions) {
+                file = file.replace(entry[0], entry[1]);
+            }
+        }
+        return file;
+    };
+}
+exports.augmentHostWithSubstitutions = augmentHostWithSubstitutions;
+function augmentHostWithVersioning(host) {
+    const baseGetSourceFile = host.getSourceFile;
+    host.getSourceFile = function (...parameters) {
+        const file = baseGetSourceFile.call(host, ...parameters);
+        if (file && file.version === undefined) {
+            file.version = (0, crypto_1.createHash)('sha256').update(file.text).digest('hex');
+        }
+        return file;
+    };
+}
+exports.augmentHostWithVersioning = augmentHostWithVersioning;
+function augmentProgramWithVersioning(program) {
+    const baseGetSourceFiles = program.getSourceFiles;
+    program.getSourceFiles = function (...parameters) {
+        const files = baseGetSourceFiles(...parameters);
+        for (const file of files) {
+            if (file.version === undefined) {
+                file.version = (0, crypto_1.createHash)('sha256').update(file.text).digest('hex');
+            }
+        }
+        return files;
+    };
+}
+exports.augmentProgramWithVersioning = augmentProgramWithVersioning;
+function augmentHostWithCaching(host, cache) {
+    const baseGetSourceFile = host.getSourceFile;
+    host.getSourceFile = function (fileName, languageVersion, onError, shouldCreateNewSourceFile, ...parameters) {
+        if (!shouldCreateNewSourceFile && cache.has(fileName)) {
+            return cache.get(fileName);
+        }
+        const file = baseGetSourceFile.call(host, fileName, languageVersion, onError, true, ...parameters);
+        if (file) {
+            cache.set(fileName, file);
+        }
+        return file;
+    };
+}
+exports.augmentHostWithCaching = augmentHostWithCaching;

my-app/node_modules/@ngtools/webpack/src/ivy/index.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.io/license
+ */
+export { angularWebpackLoader as default } from './loader';
+export { AngularWebpackPluginOptions, AngularWebpackPlugin, imageDomains } from './plugin';
+export declare const AngularWebpackLoaderPath: string;

my-app/node_modules/@ngtools/webpack/src/ivy/index.js

@@ -0,0 +1,16 @@
+"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.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularWebpackLoaderPath = exports.imageDomains = exports.AngularWebpackPlugin = exports.default = void 0;
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return loader_1.angularWebpackLoader; } });
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "AngularWebpackPlugin", { enumerable: true, get: function () { return plugin_1.AngularWebpackPlugin; } });
+Object.defineProperty(exports, "imageDomains", { enumerable: true, get: function () { return plugin_1.imageDomains; } });
+exports.AngularWebpackLoaderPath = __filename;

my-app/node_modules/@ngtools/webpack/src/ivy/loader.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.io/license
+ */
+import type { LoaderContext } from 'webpack';
+export declare function angularWebpackLoader(this: LoaderContext<unknown>, content: string, map: string): void;
+export { angularWebpackLoader as default };

my-app/node_modules/@ngtools/webpack/src/ivy/loader.js

@@ -0,0 +1,85 @@
+"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.io/license
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.angularWebpackLoader = void 0;
+const path = __importStar(require("path"));
+const symbol_1 = require("./symbol");
+const JS_FILE_REGEXP = /\.[cm]?js$/;
+function angularWebpackLoader(content, map) {
+    const callback = this.async();
+    if (!callback) {
+        throw new Error('Invalid webpack version');
+    }
+    const fileEmitter = this[symbol_1.AngularPluginSymbol];
+    if (!fileEmitter || typeof fileEmitter !== 'object') {
+        if (JS_FILE_REGEXP.test(this.resourcePath)) {
+            // Passthrough for JS files when no plugin is used
+            this.callback(undefined, content, map);
+            return;
+        }
+        callback(new Error('The Angular Webpack loader requires the AngularWebpackPlugin.'));
+        return;
+    }
+    fileEmitter
+        .emit(this.resourcePath)
+        .then((result) => {
+        if (!result) {
+            if (JS_FILE_REGEXP.test(this.resourcePath)) {
+                // Return original content for JS files if not compiled by TypeScript ("allowJs")
+                this.callback(undefined, content, map);
+            }
+            else {
+                // File is not part of the compilation
+                const message = `${this.resourcePath} is missing from the TypeScript compilation. ` +
+                    `Please make sure it is in your tsconfig via the 'files' or 'include' property.`;
+                callback(new Error(message));
+            }
+            return;
+        }
+        result.dependencies.forEach((dependency) => this.addDependency(dependency));
+        let resultContent = result.content || '';
+        let resultMap;
+        if (result.map) {
+            resultContent = resultContent.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, '');
+            resultMap = JSON.parse(result.map);
+            resultMap.sources = resultMap.sources.map((source) => path.join(path.dirname(this.resourcePath), source));
+        }
+        callback(undefined, resultContent, resultMap);
+    })
+        .catch((err) => {
+        // The below is needed to hide stacktraces from users.
+        const message = err instanceof Error ? err.message : err;
+        callback(new Error(message));
+    });
+}
+exports.angularWebpackLoader = angularWebpackLoader;
+exports.default = angularWebpackLoader;

my-app/node_modules/@ngtools/webpack/src/ivy/paths.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.io/license
+ */
+export declare function normalizePath(path: string): string;
+export declare const externalizePath: (path: string) => string;

my-app/node_modules/@ngtools/webpack/src/ivy/paths.js

@@ -0,0 +1,59 @@
+"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.io/license
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.externalizePath = exports.normalizePath = void 0;
+const nodePath = __importStar(require("path"));
+const normalizationCache = new Map();
+function normalizePath(path) {
+    let result = normalizationCache.get(path);
+    if (result === undefined) {
+        result = nodePath.win32.normalize(path).replace(/\\/g, nodePath.posix.sep);
+        normalizationCache.set(path, result);
+    }
+    return result;
+}
+exports.normalizePath = normalizePath;
+const externalizationCache = new Map();
+function externalizeForWindows(path) {
+    let result = externalizationCache.get(path);
+    if (result === undefined) {
+        result = nodePath.win32.normalize(path);
+        externalizationCache.set(path, result);
+    }
+    return result;
+}
+exports.externalizePath = (() => {
+    if (process.platform !== 'win32') {
+        return (path) => path;
+    }
+    return externalizeForWindows;
+})();

my-app/node_modules/@ngtools/webpack/src/ivy/plugin.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @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.io/license
+ */
+import type { CompilerOptions } from '@angular/compiler-cli';
+import type { Compiler } from 'webpack';
+export declare const imageDomains: Set<string>;
+export interface AngularWebpackPluginOptions {
+    tsconfig: string;
+    compilerOptions?: CompilerOptions;
+    fileReplacements: Record<string, string>;
+    substitutions: Record<string, string>;
+    directTemplateLoading: boolean;
+    emitClassMetadata: boolean;
+    emitNgModuleScope: boolean;
+    emitSetClassDebugInfo?: boolean;
+    jitMode: boolean;
+    inlineStyleFileExtension?: string;
+}
+export declare class AngularWebpackPlugin {
+    private readonly pluginOptions;
+    private compilerCliModule?;
+    private watchMode?;
+    private ngtscNextProgram?;
+    private builder?;
+    private sourceFileCache?;
+    private webpackCache?;
+    private webpackCreateHash?;
+    private readonly fileDependencies;
+    private readonly requiredFilesToEmit;
+    private readonly requiredFilesToEmitCache;
+    private readonly fileEmitHistory;
+    constructor(options?: Partial<AngularWebpackPluginOptions>);
+    private get compilerCli();
+    get options(): AngularWebpackPluginOptions;
+    apply(compiler: Compiler): void;
+    private setupCompilation;
+    private registerWithCompilation;
+    private markResourceUsed;
+    private rebuildRequiredFiles;
+    private loadConfiguration;
+    private updateAotProgram;
+    private updateJitProgram;
+    private createFileEmitter;
+    private initializeCompilerCli;
+    private addFileEmitHistory;
+    private getFileEmitHistory;
+}

my-app/node_modules/@ngtools/webpack/src/ivy/plugin.js

@@ -0,0 +1,537 @@
+"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.io/license
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularWebpackPlugin = exports.imageDomains = void 0;
+const assert_1 = require("assert");
+const ts = __importStar(require("typescript"));
+const paths_plugin_1 = require("../paths-plugin");
+const resource_loader_1 = require("../resource_loader");
+const cache_1 = require("./cache");
+const diagnostics_1 = require("./diagnostics");
+const host_1 = require("./host");
+const paths_1 = require("./paths");
+const symbol_1 = require("./symbol");
+const system_1 = require("./system");
+const transformation_1 = require("./transformation");
+/**
+ * The threshold used to determine whether Angular file diagnostics should optimize for full programs
+ * or single files. If the number of affected files for a build is more than the threshold, full
+ * program optimization will be used.
+ */
+const DIAGNOSTICS_AFFECTED_THRESHOLD = 1;
+exports.imageDomains = new Set();
+const PLUGIN_NAME = 'angular-compiler';
+const compilationFileEmitters = new WeakMap();
+class AngularWebpackPlugin {
+    pluginOptions;
+    compilerCliModule;
+    watchMode;
+    ngtscNextProgram;
+    builder;
+    sourceFileCache;
+    webpackCache;
+    webpackCreateHash;
+    fileDependencies = new Map();
+    requiredFilesToEmit = new Set();
+    requiredFilesToEmitCache = new Map();
+    fileEmitHistory = new Map();
+    constructor(options = {}) {
+        this.pluginOptions = {
+            emitClassMetadata: false,
+            emitNgModuleScope: false,
+            jitMode: false,
+            fileReplacements: {},
+            substitutions: {},
+            directTemplateLoading: true,
+            tsconfig: 'tsconfig.json',
+            ...options,
+        };
+    }
+    get compilerCli() {
+        // The compilerCliModule field is guaranteed to be defined during a compilation
+        // due to the `beforeCompile` hook. Usage of this property accessor prior to the
+        // hook execution is an implementation error.
+        assert_1.strict.ok(this.compilerCliModule, `'@angular/compiler-cli' used prior to Webpack compilation.`);
+        return this.compilerCliModule;
+    }
+    get options() {
+        return this.pluginOptions;
+    }
+    apply(compiler) {
+        const { NormalModuleReplacementPlugin, WebpackError, util } = compiler.webpack;
+        this.webpackCreateHash = util.createHash;
+        // Setup file replacements with webpack
+        for (const [key, value] of Object.entries(this.pluginOptions.fileReplacements)) {
+            new NormalModuleReplacementPlugin(new RegExp('^' + key.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&') + '$'), value).apply(compiler);
+        }
+        // Set resolver options
+        const pathsPlugin = new paths_plugin_1.TypeScriptPathsPlugin();
+        compiler.hooks.afterResolvers.tap(PLUGIN_NAME, (compiler) => {
+            compiler.resolverFactory.hooks.resolveOptions
+                .for('normal')
+                .tap(PLUGIN_NAME, (resolveOptions) => {
+                resolveOptions.plugins ??= [];
+                resolveOptions.plugins.push(pathsPlugin);
+                return resolveOptions;
+            });
+        });
+        // Load the compiler-cli if not already available
+        compiler.hooks.beforeCompile.tapPromise(PLUGIN_NAME, () => this.initializeCompilerCli());
+        const compilationState = { pathsPlugin };
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            try {
+                this.setupCompilation(compilation, compilationState);
+            }
+            catch (error) {
+                (0, diagnostics_1.addError)(compilation, `Failed to initialize Angular compilation - ${error instanceof Error ? error.message : error}`);
+            }
+        });
+    }
+    setupCompilation(compilation, state) {
+        const compiler = compilation.compiler;
+        // Register plugin to ensure deterministic emit order in multi-plugin usage
+        const emitRegistration = this.registerWithCompilation(compilation);
+        this.watchMode = compiler.watchMode;
+        // Initialize webpack cache
+        if (!this.webpackCache && compilation.options.cache) {
+            this.webpackCache = compilation.getCache(PLUGIN_NAME);
+        }
+        // Initialize the resource loader if not already setup
+        if (!state.resourceLoader) {
+            state.resourceLoader = new resource_loader_1.WebpackResourceLoader(this.watchMode);
+        }
+        // Setup and read TypeScript and Angular compiler configuration
+        const { compilerOptions, rootNames, errors } = this.loadConfiguration();
+        // Create diagnostics reporter and report configuration file errors
+        const diagnosticsReporter = (0, diagnostics_1.createDiagnosticsReporter)(compilation, (diagnostic) => this.compilerCli.formatDiagnostics([diagnostic]));
+        diagnosticsReporter(errors);
+        // Update TypeScript path mapping plugin with new configuration
+        state.pathsPlugin.update(compilerOptions);
+        // Create a Webpack-based TypeScript compiler host
+        const system = (0, system_1.createWebpackSystem)(
+        // Webpack lacks an InputFileSytem type definition with sync functions
+        compiler.inputFileSystem, (0, paths_1.normalizePath)(compiler.context));
+        const host = ts.createIncrementalCompilerHost(compilerOptions, system);
+        // Setup source file caching and reuse cache from previous compilation if present
+        let cache = this.sourceFileCache;
+        let changedFiles;
+        if (cache) {
+            changedFiles = new Set();
+            for (const changedFile of [
+                ...(compiler.modifiedFiles ?? []),
+                ...(compiler.removedFiles ?? []),
+            ]) {
+                const normalizedChangedFile = (0, paths_1.normalizePath)(changedFile);
+                // Invalidate file dependencies
+                this.fileDependencies.delete(normalizedChangedFile);
+                // Invalidate existing cache
+                cache.invalidate(normalizedChangedFile);
+                changedFiles.add(normalizedChangedFile);
+            }
+        }
+        else {
+            // Initialize a new cache
+            cache = new cache_1.SourceFileCache();
+            // Only store cache if in watch mode
+            if (this.watchMode) {
+                this.sourceFileCache = cache;
+            }
+        }
+        (0, host_1.augmentHostWithCaching)(host, cache);
+        const moduleResolutionCache = ts.createModuleResolutionCache(host.getCurrentDirectory(), host.getCanonicalFileName.bind(host), compilerOptions);
+        // Setup source file dependency collection
+        (0, host_1.augmentHostWithDependencyCollection)(host, this.fileDependencies, moduleResolutionCache);
+        // Setup resource loading
+        state.resourceLoader.update(compilation, changedFiles);
+        (0, host_1.augmentHostWithResources)(host, state.resourceLoader, {
+            directTemplateLoading: this.pluginOptions.directTemplateLoading,
+            inlineStyleFileExtension: this.pluginOptions.inlineStyleFileExtension,
+        });
+        // Setup source file adjustment options
+        (0, host_1.augmentHostWithReplacements)(host, this.pluginOptions.fileReplacements, moduleResolutionCache);
+        (0, host_1.augmentHostWithSubstitutions)(host, this.pluginOptions.substitutions);
+        // Create the file emitter used by the webpack loader
+        const { fileEmitter, builder, internalFiles } = this.pluginOptions.jitMode
+            ? this.updateJitProgram(compilerOptions, rootNames, host, diagnosticsReporter)
+            : this.updateAotProgram(compilerOptions, rootNames, host, diagnosticsReporter, state.resourceLoader);
+        // Set of files used during the unused TypeScript file analysis
+        const currentUnused = new Set();
+        for (const sourceFile of builder.getSourceFiles()) {
+            if (internalFiles?.has(sourceFile)) {
+                continue;
+            }
+            // Ensure all program files are considered part of the compilation and will be watched.
+            // Webpack does not normalize paths. Therefore, we need to normalize the path with FS seperators.
+            compilation.fileDependencies.add((0, paths_1.externalizePath)(sourceFile.fileName));
+            // Add all non-declaration files to the initial set of unused files. The set will be
+            // analyzed and pruned after all Webpack modules are finished building.
+            if (!sourceFile.isDeclarationFile) {
+                currentUnused.add((0, paths_1.normalizePath)(sourceFile.fileName));
+            }
+        }
+        compilation.hooks.finishModules.tapPromise(PLUGIN_NAME, async (modules) => {
+            // Rebuild any remaining AOT required modules
+            await this.rebuildRequiredFiles(modules, compilation, fileEmitter);
+            // Clear out the Webpack compilation to avoid an extra retaining reference
+            state.resourceLoader?.clearParentCompilation();
+            // Analyze program for unused files
+            if (compilation.errors.length > 0) {
+                return;
+            }
+            for (const webpackModule of modules) {
+                const resource = webpackModule.resource;
+                if (resource) {
+                    this.markResourceUsed((0, paths_1.normalizePath)(resource), currentUnused);
+                }
+            }
+            for (const unused of currentUnused) {
+                if (state.previousUnused?.has(unused)) {
+                    continue;
+                }
+                (0, diagnostics_1.addWarning)(compilation, `${unused} is part of the TypeScript compilation but it's unused.\n` +
+                    `Add only entry points to the 'files' or 'include' properties in your tsconfig.`);
+            }
+            state.previousUnused = currentUnused;
+        });
+        // Store file emitter for loader usage
+        emitRegistration.update(fileEmitter);
+    }
+    registerWithCompilation(compilation) {
+        let fileEmitters = compilationFileEmitters.get(compilation);
+        if (!fileEmitters) {
+            fileEmitters = new symbol_1.FileEmitterCollection();
+            compilationFileEmitters.set(compilation, fileEmitters);
+            compilation.compiler.webpack.NormalModule.getCompilationHooks(compilation).loader.tap(PLUGIN_NAME, (loaderContext) => {
+                loaderContext[symbol_1.AngularPluginSymbol] = fileEmitters;
+            });
+        }
+        const emitRegistration = fileEmitters.register();
+        return emitRegistration;
+    }
+    markResourceUsed(normalizedResourcePath, currentUnused) {
+        if (!currentUnused.has(normalizedResourcePath)) {
+            return;
+        }
+        currentUnused.delete(normalizedResourcePath);
+        const dependencies = this.fileDependencies.get(normalizedResourcePath);
+        if (!dependencies) {
+            return;
+        }
+        for (const dependency of dependencies) {
+            this.markResourceUsed((0, paths_1.normalizePath)(dependency), currentUnused);
+        }
+    }
+    async rebuildRequiredFiles(modules, compilation, fileEmitter) {
+        if (this.requiredFilesToEmit.size === 0) {
+            return;
+        }
+        const filesToRebuild = new Set();
+        for (const requiredFile of this.requiredFilesToEmit) {
+            const history = await this.getFileEmitHistory(requiredFile);
+            if (history) {
+                const emitResult = await fileEmitter(requiredFile);
+                if (emitResult?.content === undefined ||
+                    history.length !== emitResult.content.length ||
+                    emitResult.hash === undefined ||
+                    Buffer.compare(history.hash, emitResult.hash) !== 0) {
+                    // New emit result is different so rebuild using new emit result
+                    this.requiredFilesToEmitCache.set(requiredFile, emitResult);
+                    filesToRebuild.add(requiredFile);
+                }
+            }
+            else {
+                // No emit history so rebuild
+                filesToRebuild.add(requiredFile);
+            }
+        }
+        if (filesToRebuild.size > 0) {
+            const rebuild = (webpackModule) => new Promise((resolve) => compilation.rebuildModule(webpackModule, () => resolve()));
+            const modulesToRebuild = [];
+            for (const webpackModule of modules) {
+                const resource = webpackModule.resource;
+                if (resource && filesToRebuild.has((0, paths_1.normalizePath)(resource))) {
+                    modulesToRebuild.push(webpackModule);
+                }
+            }
+            await Promise.all(modulesToRebuild.map((webpackModule) => rebuild(webpackModule)));
+        }
+        this.requiredFilesToEmit.clear();
+        this.requiredFilesToEmitCache.clear();
+    }
+    loadConfiguration() {
+        const { options: compilerOptions, rootNames, errors, } = this.compilerCli.readConfiguration(this.pluginOptions.tsconfig, this.pluginOptions.compilerOptions);
+        compilerOptions.noEmitOnError = false;
+        compilerOptions.suppressOutputPathCheck = true;
+        compilerOptions.outDir = undefined;
+        compilerOptions.inlineSources = compilerOptions.sourceMap;
+        compilerOptions.inlineSourceMap = false;
+        compilerOptions.mapRoot = undefined;
+        compilerOptions.sourceRoot = undefined;
+        compilerOptions.allowEmptyCodegenFiles = false;
+        compilerOptions.annotationsAs = 'decorators';
+        compilerOptions.enableResourceInlining = false;
+        return { compilerOptions, rootNames, errors };
+    }
+    updateAotProgram(compilerOptions, rootNames, host, diagnosticsReporter, resourceLoader) {
+        // Create the Angular specific program that contains the Angular compiler
+        const angularProgram = new this.compilerCli.NgtscProgram(rootNames, compilerOptions, host, this.ngtscNextProgram);
+        const angularCompiler = angularProgram.compiler;
+        // The `ignoreForEmit` return value can be safely ignored when emitting. Only files
+        // that will be bundled (requested by Webpack) will be emitted. Combined with TypeScript's
+        // eliding of type only imports, this will cause type only files to be automatically ignored.
+        // Internal Angular type check files are also not resolvable by the bundler. Even if they
+        // were somehow errantly imported, the bundler would error before an emit was attempted.
+        // Diagnostics are still collected for all files which requires using `ignoreForDiagnostics`.
+        const { ignoreForDiagnostics, ignoreForEmit } = angularCompiler;
+        // SourceFile versions are required for builder programs.
+        // The wrapped host inside NgtscProgram adds additional files that will not have versions.
+        const typeScriptProgram = angularProgram.getTsProgram();
+        (0, host_1.augmentProgramWithVersioning)(typeScriptProgram);
+        let builder;
+        if (this.watchMode) {
+            builder = this.builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(typeScriptProgram, host, this.builder);
+            this.ngtscNextProgram = angularProgram;
+        }
+        else {
+            // When not in watch mode, the startup cost of the incremental analysis can be avoided by
+            // using an abstract builder that only wraps a TypeScript program.
+            builder = ts.createAbstractBuilder(typeScriptProgram, host);
+        }
+        // Update semantic diagnostics cache
+        const affectedFiles = new Set();
+        // Analyze affected files when in watch mode for incremental type checking
+        if ('getSemanticDiagnosticsOfNextAffectedFile' in builder) {
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const result = builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
+                    // If the affected file is a TTC shim, add the shim's original source file.
+                    // This ensures that changes that affect TTC are typechecked even when the changes
+                    // are otherwise unrelated from a TS perspective and do not result in Ivy codegen changes.
+                    // For example, changing @Input property types of a directive used in another component's
+                    // template.
+                    if (ignoreForDiagnostics.has(sourceFile) &&
+                        sourceFile.fileName.endsWith('.ngtypecheck.ts')) {
+                        // This file name conversion relies on internal compiler logic and should be converted
+                        // to an official method when available. 15 is length of `.ngtypecheck.ts`
+                        const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts';
+                        const originalSourceFile = builder.getSourceFile(originalFilename);
+                        if (originalSourceFile) {
+                            affectedFiles.add(originalSourceFile);
+                        }
+                        return true;
+                    }
+                    return false;
+                });
+                if (!result) {
+                    break;
+                }
+                affectedFiles.add(result.affected);
+            }
+        }
+        // Collect program level diagnostics
+        const diagnostics = [
+            ...angularCompiler.getOptionDiagnostics(),
+            ...builder.getOptionsDiagnostics(),
+            ...builder.getGlobalDiagnostics(),
+        ];
+        diagnosticsReporter(diagnostics);
+        // Collect source file specific diagnostics
+        for (const sourceFile of builder.getSourceFiles()) {
+            if (!ignoreForDiagnostics.has(sourceFile)) {
+                diagnosticsReporter(builder.getSyntacticDiagnostics(sourceFile));
+                diagnosticsReporter(builder.getSemanticDiagnostics(sourceFile));
+            }
+        }
+        const transformers = (0, transformation_1.createAotTransformers)(builder, this.pluginOptions, exports.imageDomains);
+        const getDependencies = (sourceFile) => {
+            const dependencies = [];
+            for (const resourcePath of angularCompiler.getResourceDependencies(sourceFile)) {
+                dependencies.push(resourcePath, 
+                // Retrieve all dependencies of the resource (stylesheet imports, etc.)
+                ...resourceLoader.getResourceDependencies(resourcePath));
+            }
+            return dependencies;
+        };
+        // Required to support asynchronous resource loading
+        // Must be done before creating transformers or getting template diagnostics
+        const pendingAnalysis = angularCompiler
+            .analyzeAsync()
+            .then(() => {
+            this.requiredFilesToEmit.clear();
+            for (const sourceFile of builder.getSourceFiles()) {
+                if (sourceFile.isDeclarationFile) {
+                    continue;
+                }
+                // Collect sources that are required to be emitted
+                if (!ignoreForEmit.has(sourceFile) &&
+                    !angularCompiler.incrementalCompilation.safeToSkipEmit(sourceFile)) {
+                    this.requiredFilesToEmit.add((0, paths_1.normalizePath)(sourceFile.fileName));
+                    // If required to emit, diagnostics may have also changed
+                    if (!ignoreForDiagnostics.has(sourceFile)) {
+                        affectedFiles.add(sourceFile);
+                    }
+                }
+                else if (this.sourceFileCache &&
+                    !affectedFiles.has(sourceFile) &&
+                    !ignoreForDiagnostics.has(sourceFile)) {
+                    // Use cached Angular diagnostics for unchanged and unaffected files
+                    const angularDiagnostics = this.sourceFileCache.getAngularDiagnostics(sourceFile);
+                    if (angularDiagnostics) {
+                        diagnosticsReporter(angularDiagnostics);
+                    }
+                }
+            }
+            // Collect new Angular diagnostics for files affected by changes
+            const OptimizeFor = this.compilerCli.OptimizeFor;
+            const optimizeDiagnosticsFor = affectedFiles.size <= DIAGNOSTICS_AFFECTED_THRESHOLD
+                ? OptimizeFor.SingleFile
+                : OptimizeFor.WholeProgram;
+            for (const affectedFile of affectedFiles) {
+                const angularDiagnostics = angularCompiler.getDiagnosticsForFile(affectedFile, optimizeDiagnosticsFor);
+                diagnosticsReporter(angularDiagnostics);
+                this.sourceFileCache?.updateAngularDiagnostics(affectedFile, angularDiagnostics);
+            }
+            return {
+                emitter: this.createFileEmitter(builder, (0, transformation_1.mergeTransformers)(angularCompiler.prepareEmit().transformers, transformers), getDependencies, (sourceFile) => {
+                    this.requiredFilesToEmit.delete((0, paths_1.normalizePath)(sourceFile.fileName));
+                    angularCompiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);
+                }),
+            };
+        })
+            .catch((err) => ({ errorMessage: err instanceof Error ? err.message : `${err}` }));
+        const analyzingFileEmitter = async (file) => {
+            const analysis = await pendingAnalysis;
+            if ('errorMessage' in analysis) {
+                throw new Error(analysis.errorMessage);
+            }
+            return analysis.emitter(file);
+        };
+        return {
+            fileEmitter: analyzingFileEmitter,
+            builder,
+            internalFiles: ignoreForEmit,
+        };
+    }
+    updateJitProgram(compilerOptions, rootNames, host, diagnosticsReporter) {
+        let builder;
+        if (this.watchMode) {
+            builder = this.builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, compilerOptions, host, this.builder);
+        }
+        else {
+            // When not in watch mode, the startup cost of the incremental analysis can be avoided by
+            // using an abstract builder that only wraps a TypeScript program.
+            builder = ts.createAbstractBuilder(rootNames, compilerOptions, host);
+        }
+        const diagnostics = [
+            ...builder.getOptionsDiagnostics(),
+            ...builder.getGlobalDiagnostics(),
+            ...builder.getSyntacticDiagnostics(),
+            // Gather incremental semantic diagnostics
+            ...builder.getSemanticDiagnostics(),
+        ];
+        diagnosticsReporter(diagnostics);
+        const transformers = (0, transformation_1.createJitTransformers)(builder, this.compilerCli, this.pluginOptions);
+        return {
+            fileEmitter: this.createFileEmitter(builder, transformers, () => []),
+            builder,
+            internalFiles: undefined,
+        };
+    }
+    createFileEmitter(program, transformers = {}, getExtraDependencies, onAfterEmit) {
+        return async (file) => {
+            const filePath = (0, paths_1.normalizePath)(file);
+            if (this.requiredFilesToEmitCache.has(filePath)) {
+                return this.requiredFilesToEmitCache.get(filePath);
+            }
+            const sourceFile = program.getSourceFile(filePath);
+            if (!sourceFile) {
+                return undefined;
+            }
+            let content;
+            let map;
+            program.emit(sourceFile, (filename, data) => {
+                if (filename.endsWith('.map')) {
+                    map = data;
+                }
+                else if (filename.endsWith('.js')) {
+                    content = data;
+                }
+            }, undefined, undefined, transformers);
+            onAfterEmit?.(sourceFile);
+            // Capture emit history info for Angular rebuild analysis
+            const hash = content ? (await this.addFileEmitHistory(filePath, content)).hash : undefined;
+            const dependencies = [
+                ...(this.fileDependencies.get(filePath) || []),
+                ...getExtraDependencies(sourceFile),
+            ].map(paths_1.externalizePath);
+            return { content, map, dependencies, hash };
+        };
+    }
+    async initializeCompilerCli() {
+        if (this.compilerCliModule) {
+            return;
+        }
+        // This uses a dynamic import to load `@angular/compiler-cli` which may be ESM.
+        // CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
+        // will currently, unconditionally downlevel dynamic import into a require call.
+        // require calls cannot load ESM code and will result in a runtime error. To workaround
+        // this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
+        // Once TypeScript provides support for keeping the dynamic import this workaround can
+        // be dropped.
+        this.compilerCliModule = await new Function(`return import('@angular/compiler-cli');`)();
+    }
+    async addFileEmitHistory(filePath, content) {
+        assert_1.strict.ok(this.webpackCreateHash, 'File emitter is used prior to Webpack compilation');
+        const historyData = {
+            length: content.length,
+            hash: this.webpackCreateHash('xxhash64').update(content).digest(),
+        };
+        if (this.webpackCache) {
+            const history = await this.getFileEmitHistory(filePath);
+            if (!history || Buffer.compare(history.hash, historyData.hash) !== 0) {
+                // Hash doesn't match or item doesn't exist.
+                await this.webpackCache.storePromise(filePath, null, historyData);
+            }
+        }
+        else if (this.watchMode) {
+            // The in memory file emit history is only required during watch mode.
+            this.fileEmitHistory.set(filePath, historyData);
+        }
+        return historyData;
+    }
+    async getFileEmitHistory(filePath) {
+        return this.webpackCache
+            ? this.webpackCache.getPromise(filePath, null)
+            : this.fileEmitHistory.get(filePath);
+    }
+}
+exports.AngularWebpackPlugin = AngularWebpackPlugin;

my-app/node_modules/@ngtools/webpack/src/ivy/symbol.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export declare const AngularPluginSymbol: unique symbol;
+export interface EmitFileResult {
+    content?: string;
+    map?: string;
+    dependencies: readonly string[];
+    hash?: Uint8Array;
+}
+export type FileEmitter = (file: string) => Promise<EmitFileResult | undefined>;
+export declare class FileEmitterRegistration {
+    #private;
+    update(emitter: FileEmitter): void;
+    emit(file: string): Promise<EmitFileResult | undefined>;
+}
+export declare class FileEmitterCollection {
+    #private;
+    register(): FileEmitterRegistration;
+    emit(file: string): Promise<EmitFileResult | undefined>;
+}

my-app/node_modules/@ngtools/webpack/src/ivy/symbol.js

@@ -0,0 +1,44 @@
+"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.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileEmitterCollection = exports.FileEmitterRegistration = exports.AngularPluginSymbol = void 0;
+exports.AngularPluginSymbol = Symbol.for('@ngtools/webpack[angular-compiler]');
+class FileEmitterRegistration {
+    #fileEmitter;
+    update(emitter) {
+        this.#fileEmitter = emitter;
+    }
+    emit(file) {
+        if (!this.#fileEmitter) {
+            throw new Error('Emit attempted before Angular Webpack plugin initialization.');
+        }
+        return this.#fileEmitter(file);
+    }
+}
+exports.FileEmitterRegistration = FileEmitterRegistration;
+class FileEmitterCollection {
+    #registrations = [];
+    register() {
+        const registration = new FileEmitterRegistration();
+        this.#registrations.push(registration);
+        return registration;
+    }
+    async emit(file) {
+        if (this.#registrations.length === 1) {
+            return this.#registrations[0].emit(file);
+        }
+        for (const registration of this.#registrations) {
+            const result = await registration.emit(file);
+            if (result) {
+                return result;
+            }
+        }
+    }
+}
+exports.FileEmitterCollection = FileEmitterCollection;

my-app/node_modules/@ngtools/webpack/src/ivy/system.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.io/license
+ */
+import * as ts from 'typescript';
+import { Compiler } from 'webpack';
+export type InputFileSystem = Compiler['inputFileSystem'];
+export interface InputFileSystemSync extends InputFileSystem {
+    readFileSync(path: string): Buffer;
+    statSync(path: string): {
+        size: number;
+        mtime: Date;
+        isDirectory(): boolean;
+        isFile(): boolean;
+    };
+}
+export declare function createWebpackSystem(input: InputFileSystemSync, currentDirectory: string): ts.System;

my-app/node_modules/@ngtools/webpack/src/ivy/system.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.io/license
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebpackSystem = void 0;
+const ts = __importStar(require("typescript"));
+const paths_1 = require("./paths");
+function shouldNotWrite() {
+    throw new Error('Webpack TypeScript System should not write.');
+}
+function createWebpackSystem(input, currentDirectory) {
+    // Webpack's CachedInputFileSystem uses the default directory separator in the paths it uses
+    // for keys to its cache. If the keys do not match then the file watcher will not purge outdated
+    // files and cause stale data to be used in the next rebuild. TypeScript always uses a `/` (POSIX)
+    // directory separator internally which is also supported with Windows system APIs. However,
+    // if file operations are performed with the non-default directory separator, the Webpack cache
+    // will contain a key that will not be purged. `externalizePath` ensures the paths are as expected.
+    const system = {
+        ...ts.sys,
+        readFile(path) {
+            let data;
+            try {
+                data = input.readFileSync((0, paths_1.externalizePath)(path));
+            }
+            catch {
+                return undefined;
+            }
+            // Strip BOM if present
+            let start = 0;
+            if (data.length > 3 && data[0] === 0xef && data[1] === 0xbb && data[2] === 0xbf) {
+                start = 3;
+            }
+            return data.toString('utf8', start);
+        },
+        getFileSize(path) {
+            try {
+                return input.statSync((0, paths_1.externalizePath)(path)).size;
+            }
+            catch {
+                return 0;
+            }
+        },
+        fileExists(path) {
+            try {
+                return input.statSync((0, paths_1.externalizePath)(path)).isFile();
+            }
+            catch {
+                return false;
+            }
+        },
+        directoryExists(path) {
+            try {
+                return input.statSync((0, paths_1.externalizePath)(path)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        getModifiedTime(path) {
+            try {
+                return input.statSync((0, paths_1.externalizePath)(path)).mtime;
+            }
+            catch {
+                return undefined;
+            }
+        },
+        getCurrentDirectory() {
+            return currentDirectory;
+        },
+        writeFile: shouldNotWrite,
+        createDirectory: shouldNotWrite,
+        deleteFile: shouldNotWrite,
+        setModifiedTime: shouldNotWrite,
+    };
+    return system;
+}
+exports.createWebpackSystem = createWebpackSystem;

my-app/node_modules/@ngtools/webpack/src/ivy/transformation.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.io/license
+ */
+import * as ts from 'typescript';
+export declare function createAotTransformers(builder: ts.BuilderProgram, options: {
+    emitClassMetadata?: boolean;
+    emitNgModuleScope?: boolean;
+    emitSetClassDebugInfo?: boolean;
+}, imageDomains: Set<string>): ts.CustomTransformers;
+export declare function createJitTransformers(builder: ts.BuilderProgram, compilerCli: typeof import('@angular/compiler-cli'), options: {
+    inlineStyleFileExtension?: string;
+}): ts.CustomTransformers;
+export declare function mergeTransformers(first: ts.CustomTransformers, second: ts.CustomTransformers): ts.CustomTransformers;
+export declare function replaceBootstrap(getTypeChecker: () => ts.TypeChecker): ts.TransformerFactory<ts.SourceFile>;

my-app/node_modules/@ngtools/webpack/src/ivy/transformation.js

@@ -0,0 +1,127 @@
+"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.io/license
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceBootstrap = exports.mergeTransformers = exports.createJitTransformers = exports.createAotTransformers = void 0;
+const ts = __importStar(require("typescript"));
+const elide_imports_1 = require("../transformers/elide_imports");
+const find_image_domains_1 = require("../transformers/find_image_domains");
+const remove_ivy_jit_support_calls_1 = require("../transformers/remove-ivy-jit-support-calls");
+const replace_resources_1 = require("../transformers/replace_resources");
+function createAotTransformers(builder, options, imageDomains) {
+    const getTypeChecker = () => builder.getProgram().getTypeChecker();
+    const transformers = {
+        before: [(0, find_image_domains_1.findImageDomains)(imageDomains), replaceBootstrap(getTypeChecker)],
+        after: [],
+    };
+    const removeClassMetadata = !options.emitClassMetadata;
+    const removeNgModuleScope = !options.emitNgModuleScope;
+    const removeSetClassDebugInfo = !options.emitSetClassDebugInfo;
+    if (removeClassMetadata || removeNgModuleScope || removeSetClassDebugInfo) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        transformers.before.push((0, remove_ivy_jit_support_calls_1.removeIvyJitSupportCalls)(removeClassMetadata, removeNgModuleScope, removeSetClassDebugInfo, getTypeChecker));
+    }
+    return transformers;
+}
+exports.createAotTransformers = createAotTransformers;
+function createJitTransformers(builder, compilerCli, options) {
+    const getTypeChecker = () => builder.getProgram().getTypeChecker();
+    return {
+        before: [
+            (0, replace_resources_1.replaceResources)(() => true, getTypeChecker, options.inlineStyleFileExtension),
+            compilerCli.constructorParametersDownlevelTransform(builder.getProgram()),
+        ],
+    };
+}
+exports.createJitTransformers = createJitTransformers;
+function mergeTransformers(first, second) {
+    const result = {};
+    if (first.before || second.before) {
+        result.before = [...(first.before || []), ...(second.before || [])];
+    }
+    if (first.after || second.after) {
+        result.after = [...(first.after || []), ...(second.after || [])];
+    }
+    if (first.afterDeclarations || second.afterDeclarations) {
+        result.afterDeclarations = [
+            ...(first.afterDeclarations || []),
+            ...(second.afterDeclarations || []),
+        ];
+    }
+    return result;
+}
+exports.mergeTransformers = mergeTransformers;
+/**
+ * The name of the Angular platform that should be replaced within
+ * bootstrap call expressions to support AOT.
+ */
+const PLATFORM_BROWSER_DYNAMIC_NAME = 'platformBrowserDynamic';
+function replaceBootstrap(getTypeChecker) {
+    return (context) => {
+        let bootstrapImport;
+        let bootstrapNamespace;
+        const replacedNodes = [];
+        const nodeFactory = context.factory;
+        const visitNode = (node) => {
+            if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+                const target = node.expression;
+                if (target.text === PLATFORM_BROWSER_DYNAMIC_NAME) {
+                    if (!bootstrapNamespace) {
+                        bootstrapNamespace = nodeFactory.createUniqueName('__NgCli_bootstrap_');
+                        bootstrapImport = nodeFactory.createImportDeclaration(undefined, nodeFactory.createImportClause(false, undefined, nodeFactory.createNamespaceImport(bootstrapNamespace)), nodeFactory.createStringLiteral('@angular/platform-browser'));
+                    }
+                    replacedNodes.push(target);
+                    return nodeFactory.updateCallExpression(node, nodeFactory.createPropertyAccessExpression(bootstrapNamespace, 'platformBrowser'), node.typeArguments, node.arguments);
+                }
+            }
+            return ts.visitEachChild(node, visitNode, context);
+        };
+        return (sourceFile) => {
+            if (!sourceFile.text.includes(PLATFORM_BROWSER_DYNAMIC_NAME)) {
+                return sourceFile;
+            }
+            let updatedSourceFile = ts.visitEachChild(sourceFile, visitNode, context);
+            if (bootstrapImport) {
+                // Remove any unused platform browser dynamic imports
+                const removals = (0, elide_imports_1.elideImports)(updatedSourceFile, replacedNodes, getTypeChecker, context.getCompilerOptions());
+                if (removals.size > 0) {
+                    updatedSourceFile = ts.visitEachChild(updatedSourceFile, (node) => (removals.has(node) ? undefined : node), context);
+                }
+                // Add new platform browser import
+                return nodeFactory.updateSourceFile(updatedSourceFile, ts.setTextRange(nodeFactory.createNodeArray([bootstrapImport, ...updatedSourceFile.statements]), sourceFile.statements));
+            }
+            else {
+                return updatedSourceFile;
+            }
+        };
+    };
+}
+exports.replaceBootstrap = replaceBootstrap;