@angular-devkit/build-angular 0.900.0-rc.7 → 0.900.1

package/package.json

@@ -1,34 +1,34 @@
 {
   "name": "@angular-devkit/build-angular",
-  "version": "0.900.0-rc.7",
+  "version": "0.900.1",
   "description": "Angular Webpack Build Facade",
   "experimental": true,
   "main": "src/index.js",
   "typings": "src/index.d.ts",
   "builders": "builders.json",
   "dependencies": {
-    "@angular-devkit/architect": "0.900.0-rc.7",
-    "@angular-devkit/build-optimizer": "0.900.0-rc.7",
-    "@angular-devkit/build-webpack": "0.900.0-rc.7",
-    "@angular-devkit/core": "9.0.0-rc.7",
-    "@babel/core": "7.7.2",
-    "@babel/generator": "7.7.2",
-    "@babel/preset-env": "7.7.1",
-    "@ngtools/webpack": "9.0.0-rc.7",
+    "@angular-devkit/architect": "0.900.1",
+    "@angular-devkit/build-optimizer": "0.900.1",
+    "@angular-devkit/build-webpack": "0.900.1",
+    "@angular-devkit/core": "9.0.1",
+    "@babel/core": "7.7.7",
+    "@babel/generator": "7.7.7",
+    "@babel/preset-env": "7.7.7",
+    "@ngtools/webpack": "9.0.1",
     "ajv": "6.10.2",
     "autoprefixer": "9.7.1",
     "babel-loader": "8.0.6",
-    "browserslist": "4.7.2",
+    "browserslist": "4.8.3",
     "cacache": "13.0.1",
-    "caniuse-lite": "1.0.30001006",
+    "caniuse-lite": "1.0.30001020",
+    "cssnano": "4.1.10",
     "circular-dependency-plugin": "5.2.0",
-    "clean-css": "4.2.1",
+    "coverage-istanbul-loader": "2.0.3",
     "copy-webpack-plugin": "5.1.1",
-    "core-js": "3.3.6",
+    "core-js": "3.6.0",
     "file-loader": "4.2.0",
     "find-cache-dir": "3.0.0",
     "glob": "7.1.5",
-    "istanbul-instrumenter-loader": "3.0.1",
     "jest-worker": "24.9.0",
     "karma-source-map-support": "1.4.0",
     "less": "3.10.3",
@@ -58,9 +58,9 @@
     "style-loader": "1.0.0",
     "stylus": "0.54.7",
     "stylus-loader": "3.0.2",
-    "tree-kill": "1.2.1",
-    "terser": "4.4.2",
-    "terser-webpack-plugin": "2.2.1",
+    "tree-kill": "1.2.2",
+    "terser": "4.5.1",
+    "terser-webpack-plugin": "2.3.3",
     "webpack": "4.41.2",
     "webpack-dev-middleware": "3.7.2",
     "webpack-dev-server": "3.9.0",
@@ -71,7 +71,7 @@
   },
   "peerDependencies": {
     "@angular/compiler-cli": ">=9.0.0-beta < 10",
-    "typescript": ">=3.6 < 3.7"
+    "typescript": ">=3.6 < 3.8"
   },
   "peerDependenciesMeta": {
     "@angular/localize": {
@@ -92,7 +92,6 @@
   "engines": {
     "node": ">= 10.13.0",
     "npm": ">= 6.11.0",
-    "pnpm": ">= 3.2.0",
     "yarn": ">= 1.13.0"
   },
   "author": "Angular Authors",

package/src/angular-cli-files/models/build-options.d.ts

@@ -7,7 +7,7 @@
  */
 import { logging } from '@angular-devkit/core';
 import { ParsedConfiguration } from '@angular/compiler-cli';
-import { AssetPatternClass, Budget, ExtraEntryPoint, I18NMissingTranslation, Localize, OptimizationClass, SourceMapClass } from '../../browser/schema';
+import { AssetPatternClass, Budget, CrossOrigin, ExtraEntryPoint, I18NMissingTranslation, Localize, OptimizationClass, SourceMapClass } from '../../browser/schema';
 import { NormalizedFileReplacement } from '../../utils/normalize-file-replacements';
 export interface BuildOptions {
     optimization: OptimizationClass;
@@ -46,6 +46,7 @@ export interface BuildOptions {
     showCircularDependencies?: boolean;
     buildOptimizer?: boolean;
     namedChunks?: boolean;
+    crossOrigin?: CrossOrigin;
     subresourceIntegrity?: boolean;
     serviceWorker?: boolean;
     webWorkerTsConfig?: string;

package/src/angular-cli-files/models/es5-polyfills.js

@@ -91,7 +91,10 @@ import 'core-js/modules/es.parse-float';
 import 'core-js/es/number';
 import 'core-js/es/math';
 import 'core-js/es/date';
-import 'core-js/es/regexp';
+
+import 'core-js/modules/es.regexp.constructor';
+import 'core-js/modules/es.regexp.to-string';
+import 'core-js/modules/es.regexp.flags';
 
 import 'core-js/modules/es.map';
 import 'core-js/modules/es.weak-map';

package/src/angular-cli-files/models/webpack-configs/browser.js

@@ -12,38 +12,46 @@ const utils_1 = require("./utils");
 const SubresourceIntegrityPlugin = require('webpack-subresource-integrity');
 function getBrowserConfig(wco) {
     const { buildOptions } = wco;
+    const { crossOrigin = 'none', subresourceIntegrity, evalSourceMap, extractLicenses, vendorChunk, commonChunk, styles, } = buildOptions;
     const extraPlugins = [];
     let isEval = false;
     const { styles: stylesOptimization, scripts: scriptsOptimization } = buildOptions.optimization;
     const { styles: stylesSourceMap, scripts: scriptsSourceMap, hidden: hiddenSourceMap, } = buildOptions.sourceMap;
     // See https://webpack.js.org/configuration/devtool/ for sourcemap types.
     if ((stylesSourceMap || scriptsSourceMap) &&
-        buildOptions.evalSourceMap &&
+        evalSourceMap &&
         !stylesOptimization &&
         !scriptsOptimization) {
         // Produce eval sourcemaps for development with serve, which are faster.
         isEval = true;
     }
-    if (buildOptions.subresourceIntegrity) {
+    if (subresourceIntegrity) {
         extraPlugins.push(new SubresourceIntegrityPlugin({
             hashFuncNames: ['sha384'],
         }));
     }
-    if (buildOptions.extractLicenses) {
+    if (extractLicenses) {
         extraPlugins.push(new license_webpack_plugin_1.LicenseWebpackPlugin({
             stats: {
                 warnings: false,
                 errors: false,
             },
             perChunkOutput: false,
-            outputFilename: `3rdpartylicenses.txt`,
+            outputFilename: '3rdpartylicenses.txt',
         }));
     }
     if (!isEval && (scriptsSourceMap || stylesSourceMap)) {
         extraPlugins.push(utils_1.getSourceMapDevTool(scriptsSourceMap, stylesSourceMap, wco.differentialLoadingMode ? true : hiddenSourceMap));
     }
-    const globalStylesBundleNames = utils_1.normalizeExtraEntryPoints(buildOptions.styles, 'styles')
+    const globalStylesBundleNames = utils_1.normalizeExtraEntryPoints(styles, 'styles')
         .map(style => style.bundleName);
+    let crossOriginLoading = false;
+    if (subresourceIntegrity && crossOrigin === 'none') {
+        crossOriginLoading = 'anonymous';
+    }
+    else if (crossOrigin !== 'none') {
+        crossOriginLoading = crossOrigin;
+    }
     return {
         devtool: isEval ? 'eval' : false,
         resolve: {
@@ -53,19 +61,19 @@ function getBrowserConfig(wco) {
             ],
         },
         output: {
-            crossOriginLoading: buildOptions.subresourceIntegrity ? 'anonymous' : false,
+            crossOriginLoading,
         },
         optimization: {
             runtimeChunk: 'single',
             splitChunks: {
                 maxAsyncRequests: Infinity,
                 cacheGroups: {
-                    default: !!buildOptions.commonChunk && {
+                    default: !!commonChunk && {
                         chunks: 'async',
                         minChunks: 2,
                         priority: 10,
                     },
-                    common: !!buildOptions.commonChunk && {
+                    common: !!commonChunk && {
                         name: 'common',
                         chunks: 'async',
                         minChunks: 2,
@@ -73,7 +81,7 @@ function getBrowserConfig(wco) {
                         priority: 5,
                     },
                     vendors: false,
-                    vendor: !!buildOptions.vendorChunk && {
+                    vendor: !!vendorChunk && {
                         name: 'vendor',
                         chunks: 'initial',
                         enforce: true,

package/src/angular-cli-files/models/webpack-configs/common.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const build_optimizer_1 = require("@angular-devkit/build-optimizer");
 const core_1 = require("@angular-devkit/core");
 const CopyWebpackPlugin = require("copy-webpack-plugin");
+const fs_1 = require("fs");
 const path = require("path");
 const typescript_1 = require("typescript");
 const webpack_1 = require("webpack");
@@ -18,8 +19,8 @@ const utils_1 = require("../../../utils");
 const cache_path_1 = require("../../../utils/cache-path");
 const environment_options_1 = require("../../../utils/environment-options");
 const bundle_budget_1 = require("../../plugins/bundle-budget");
-const cleancss_webpack_plugin_1 = require("../../plugins/cleancss-webpack-plugin");
 const named_chunks_plugin_1 = require("../../plugins/named-chunks-plugin");
+const optimize_css_webpack_plugin_1 = require("../../plugins/optimize-css-webpack-plugin");
 const scripts_webpack_plugin_1 = require("../../plugins/scripts-webpack-plugin");
 const webpack_2 = require("../../plugins/webpack");
 const find_up_1 = require("../../utilities/find-up");
@@ -32,10 +33,6 @@ function getCommonConfig(wco) {
     const { root, projectRoot, buildOptions, tsConfig } = wco;
     const { styles: stylesOptimization, scripts: scriptsOptimization } = buildOptions.optimization;
     const { styles: stylesSourceMap, scripts: scriptsSourceMap, vendor: vendorSourceMap, } = buildOptions.sourceMap;
-    const nodeModules = find_up_1.findUp('node_modules', projectRoot);
-    if (!nodeModules) {
-        throw new Error('Cannot locate node_modules directory.');
-    }
     const extraPlugins = [];
     const extraRules = [];
     const entryPoints = {};
@@ -158,21 +155,24 @@ function getCommonConfig(wco) {
     }
     // process global scripts
     const globalScriptsByBundleName = utils_2.normalizeExtraEntryPoints(buildOptions.scripts, 'scripts').reduce((prev, curr) => {
-        const bundleName = curr.bundleName;
-        const resolvedPath = path.resolve(root, curr.input);
+        const { bundleName, inject, input } = curr;
+        const resolvedPath = path.resolve(root, input);
+        if (!fs_1.existsSync(resolvedPath)) {
+            throw new Error(`Script file ${input} does not exist.`);
+        }
         const existingEntry = prev.find(el => el.bundleName === bundleName);
         if (existingEntry) {
-            if (existingEntry.inject && !curr.inject) {
+            if (existingEntry.inject && !inject) {
                 // All entries have to be lazy for the bundle to be lazy.
-                throw new Error(`The ${curr.bundleName} bundle is mixing injected and non-injected scripts.`);
+                throw new Error(`The ${bundleName} bundle is mixing injected and non-injected scripts.`);
             }
             existingEntry.paths.push(resolvedPath);
         }
         else {
             prev.push({
                 bundleName,
+                inject,
                 paths: [resolvedPath],
-                inject: curr.inject,
             });
         }
         return prev;
@@ -274,12 +274,12 @@ function getCommonConfig(wco) {
             ? 'rxjs/_esm2015/path-mapping'
             : 'rxjs/_esm5/path-mapping';
         const rxPaths = require(require.resolve(rxjsPathMappingImport, { paths: [projectRoot] }));
-        alias = rxPaths(nodeModules);
+        alias = rxPaths();
     }
     catch (_a) { }
     const extraMinimizers = [];
     if (stylesOptimization) {
-        extraMinimizers.push(new cleancss_webpack_plugin_1.CleanCssWebpackPlugin({
+        extraMinimizers.push(new optimize_css_webpack_plugin_1.OptimizeCssWebpackPlugin({
             sourceMap: stylesSourceMap,
             // component styles retain their original file name
             test: file => /\.(?:css|scss|sass|less|styl)$/.test(file),
@@ -313,31 +313,34 @@ function getCommonConfig(wco) {
             safari10: true,
             output: {
                 ecma: terserEcma,
+                // For differential loading, this is handled in the bundle processing.
+                // This should also work with just true but the experimental rollup support breaks without this check.
+                ascii_only: !differentialLoadingMode,
                 // default behavior (undefined value) is to keep only important comments (licenses, etc.)
                 comments: !buildOptions.extractLicenses && undefined,
                 webkit: true,
+                beautify: environment_options_1.shouldBeautify,
             },
             // On server, we don't want to compress anything. We still set the ngDevMode = false for it
             // to remove dev code, and ngI18nClosureMode to remove Closure compiler i18n code
-            compress: buildOptions.platform == 'server'
-                ? {
-                    ecma: terserEcma,
-                    global_defs: angularGlobalDefinitions,
-                    keep_fnames: true,
-                }
-                : {
-                    ecma: terserEcma,
-                    pure_getters: buildOptions.buildOptimizer,
-                    // PURE comments work best with 3 passes.
-                    // See https://github.com/webpack/webpack/issues/2899#issuecomment-317425926.
-                    passes: buildOptions.buildOptimizer ? 3 : 1,
-                    global_defs: angularGlobalDefinitions,
-                },
+            compress: environment_options_1.allowMinify &&
+                (buildOptions.platform == 'server'
+                    ? {
+                        ecma: terserEcma,
+                        global_defs: angularGlobalDefinitions,
+                        keep_fnames: true,
+                    }
+                    : {
+                        ecma: terserEcma,
+                        pure_getters: buildOptions.buildOptimizer,
+                        // PURE comments work best with 3 passes.
+                        // See https://github.com/webpack/webpack/issues/2899#issuecomment-317425926.
+                        passes: buildOptions.buildOptimizer ? 3 : 1,
+                        global_defs: angularGlobalDefinitions,
+                    }),
             // We also want to avoid mangling on server.
             // Name mangling is handled within the browser builder
-            mangle: !environment_options_1.manglingDisabled &&
-                buildOptions.platform !== 'server' &&
-                !differentialLoadingMode,
+            mangle: environment_options_1.allowMangle && buildOptions.platform !== 'server' && !differentialLoadingMode,
         };
         extraMinimizers.push(new TerserPlugin({
             sourceMap: scriptsSourceMap,
@@ -357,7 +360,7 @@ function getCommonConfig(wco) {
             chunkFilter: (chunk) => globalScriptsByBundleName.some(s => s.bundleName === chunk.name),
             terserOptions: {
                 ...terserOptions,
-                compress: {
+                compress: environment_options_1.allowMinify && {
                     ...terserOptions.compress,
                     ecma: 5,
                 },
@@ -365,7 +368,7 @@ function getCommonConfig(wco) {
                     ...terserOptions.output,
                     ecma: 5,
                 },
-                mangle: !environment_options_1.manglingDisabled && buildOptions.platform !== 'server',
+                mangle: environment_options_1.allowMangle && buildOptions.platform !== 'server',
             },
         }));
     }

package/src/angular-cli-files/models/webpack-configs/test.js

@@ -14,7 +14,6 @@ function getTestConfig(wco) {
     const { root, buildOptions, sourceRoot: include } = wco;
     const extraRules = [];
     const extraPlugins = [];
-    // if (buildOptions.codeCoverage && CliConfig.fromProject()) {
     if (buildOptions.codeCoverage) {
         const codeCoverageExclude = buildOptions.codeCoverageExclude;
         const exclude = [
@@ -31,7 +30,7 @@ function getTestConfig(wco) {
         }
         extraRules.push({
             test: /\.(jsx?|tsx?)$/,
-            loader: require.resolve('istanbul-instrumenter-loader'),
+            loader: require.resolve('coverage-istanbul-loader'),
             options: { esModules: true },
             enforce: 'post',
             exclude,

package/src/angular-cli-files/models/webpack-configs/typescript.js

@@ -92,9 +92,12 @@ function getAotConfig(wco, i18nExtract = false) {
         });
     }
     const test = /(?:\.ngfactory\.js|\.ngstyle\.js|\.tsx?)$/;
+    const optimize = wco.buildOptions.optimization.scripts;
     return {
         module: { rules: [{ test, use: loaders }] },
-        plugins: [_createAotPlugin(wco, { tsConfigPath }, i18nExtract)]
+        plugins: [
+            _createAotPlugin(wco, { tsConfigPath, emitClassMetadata: !optimize, emitNgModuleScope: !optimize }, i18nExtract),
+        ],
     };
 }
 exports.getAotConfig = getAotConfig;

package/src/angular-cli-files/plugins/{cleancss-webpack-plugin.d.ts → optimize-css-webpack-plugin.d.ts}

@@ -1,10 +1,10 @@
 import { Compiler } from 'webpack';
-export interface CleanCssWebpackPluginOptions {
+export interface OptimizeCssWebpackPluginOptions {
     sourceMap: boolean;
     test: (file: string) => boolean;
 }
-export declare class CleanCssWebpackPlugin {
+export declare class OptimizeCssWebpackPlugin {
     private readonly _options;
-    constructor(options: Partial<CleanCssWebpackPluginOptions>);
+    constructor(options: Partial<OptimizeCssWebpackPluginOptions>);
     apply(compiler: Compiler): void;
 }

package/src/angular-cli-files/plugins/{cleancss-webpack-plugin.js → optimize-css-webpack-plugin.js}

@@ -7,14 +7,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * 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
  */
-const CleanCSS = require("clean-css");
+const cssNano = require("cssnano");
 const webpack_sources_1 = require("webpack-sources");
 function hook(compiler, action) {
-    compiler.hooks.compilation.tap('cleancss-webpack-plugin', (compilation) => {
-        compilation.hooks.optimizeChunkAssets.tapPromise('cleancss-webpack-plugin', chunks => action(compilation, chunks));
+    compiler.hooks.compilation.tap('optimize-css-webpack-plugin', (compilation) => {
+        compilation.hooks.optimizeChunkAssets.tapPromise('optimize-css-webpack-plugin', chunks => action(compilation, chunks));
     });
 }
-class CleanCssWebpackPlugin {
+class OptimizeCssWebpackPlugin {
     constructor(options) {
         this._options = {
             sourceMap: false,
@@ -24,20 +24,6 @@ class CleanCssWebpackPlugin {
     }
     apply(compiler) {
         hook(compiler, (compilation, chunks) => {
-            const cleancss = new CleanCSS({
-                compatibility: 'ie9',
-                level: {
-                    2: {
-                        skipProperties: [
-                            'transition',
-                            'font',
-                        ],
-                    },
-                },
-                inline: false,
-                returnPromise: true,
-                sourceMap: this._options.sourceMap,
-            });
             const files = [...compilation.additionalChunkAssets];
             chunks.forEach(chunk => {
                 if (chunk.files && chunk.files.length > 0) {
@@ -65,28 +51,32 @@ class CleanCssWebpackPlugin {
                 if (content.length === 0) {
                     return;
                 }
-                const output = await cleancss.minify(content, map);
-                let hasWarnings = false;
-                if (output.warnings && output.warnings.length > 0) {
-                    compilation.warnings.push(...output.warnings);
-                    hasWarnings = true;
-                }
-                if (output.errors && output.errors.length > 0) {
-                    output.errors.forEach((error) => compilation.errors.push(new Error(error)));
-                    return;
-                }
-                // generally means invalid syntax so bail
-                if (hasWarnings && output.stats.minifiedSize === 0) {
-                    return;
+                const cssNanoOptions = {
+                    preset: 'default',
+                };
+                const postCssOptions = {
+                    from: file,
+                    map: map && { annotation: false, prev: map },
+                };
+                const output = await new Promise((resolve, reject) => {
+                    // the last parameter is not in the typings
+                    // tslint:disable-next-line: no-any
+                    cssNano.process(content, postCssOptions, cssNanoOptions)
+                        .then(resolve)
+                        .catch(reject);
+                });
+                const warnings = output.warnings();
+                if (warnings.length) {
+                    compilation.warnings.push(...warnings.map(({ text }) => text));
                 }
                 let newSource;
-                if (output.sourceMap) {
-                    newSource = new webpack_sources_1.SourceMapSource(output.styles, file, 
+                if (output.map) {
+                    newSource = new webpack_sources_1.SourceMapSource(output.css, file, 
                     // tslint:disable-next-line: no-any
-                    output.sourceMap.toString(), content, map);
+                    output.map.toString(), content, map);
                 }
                 else {
-                    newSource = new webpack_sources_1.RawSource(output.styles);
+                    newSource = new webpack_sources_1.RawSource(output.css);
                 }
                 compilation.assets[file] = newSource;
             });
@@ -94,4 +84,4 @@ class CleanCssWebpackPlugin {
         });
     }
 }
-exports.CleanCssWebpackPlugin = CleanCssWebpackPlugin;
+exports.OptimizeCssWebpackPlugin = OptimizeCssWebpackPlugin;

package/src/angular-cli-files/plugins/webpack.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 export { AnyComponentStyleBudgetChecker } from './any-component-style-budget-checker';
-export { CleanCssWebpackPlugin, CleanCssWebpackPluginOptions } from './cleancss-webpack-plugin';
+export { OptimizeCssWebpackPlugin, OptimizeCssWebpackPluginOptions } from './optimize-css-webpack-plugin';
 export { BundleBudgetPlugin, BundleBudgetPluginOptions } from './bundle-budget';
 export { ScriptsWebpackPlugin, ScriptsWebpackPluginOptions } from './scripts-webpack-plugin';
 export { SuppressExtractedTextChunksWebpackPlugin } from './suppress-entry-chunks-webpack-plugin';

package/src/angular-cli-files/plugins/webpack.js

@@ -10,8 +10,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // Exports the webpack plugins we use internally.
 var any_component_style_budget_checker_1 = require("./any-component-style-budget-checker");
 exports.AnyComponentStyleBudgetChecker = any_component_style_budget_checker_1.AnyComponentStyleBudgetChecker;
-var cleancss_webpack_plugin_1 = require("./cleancss-webpack-plugin");
-exports.CleanCssWebpackPlugin = cleancss_webpack_plugin_1.CleanCssWebpackPlugin;
+var optimize_css_webpack_plugin_1 = require("./optimize-css-webpack-plugin");
+exports.OptimizeCssWebpackPlugin = optimize_css_webpack_plugin_1.OptimizeCssWebpackPlugin;
 var bundle_budget_1 = require("./bundle-budget");
 exports.BundleBudgetPlugin = bundle_budget_1.BundleBudgetPlugin;
 var scripts_webpack_plugin_1 = require("./scripts-webpack-plugin");

package/src/browser/index.js

@@ -233,12 +233,6 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                         if (!es5Polyfills) {
                             moduleFiles.push(file);
                         }
-                        // If not optimizing then ES2015 polyfills do not need processing
-                        // Unlike other module scripts, it is never downleveled
-                        const es2015Polyfills = file.file.startsWith('polyfills-es20');
-                        if (!actionOptions.optimize && es2015Polyfills) {
-                            continue;
-                        }
                         // Retrieve the content/map for the file
                         // NOTE: Additional future optimizations will read directly from memory
                         // tslint:disable-next-line: no-non-null-assertion
@@ -258,6 +252,7 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                             fs.unlinkSync(filename);
                             filename = filename.replace(/\-es20\d{2}/, '');
                         }
+                        const es2015Polyfills = file.file.startsWith('polyfills-es20');
                         // Record the bundle processing action
                         // The runtime chunk gets special processing for lazy loaded files
                         actions.push({
@@ -307,6 +302,7 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                             const runtimeOptions = {
                                 ...processRuntimeAction,
                                 runtimeData: processResults,
+                                supportedBrowsers: buildBrowserFeatures.supportedBrowsers,
                             };
                             processResults.push(await Promise.resolve().then(() => require('../utils/process-bundle')).then(m => m.process(runtimeOptions)));
                         }

package/src/dev-server/index.js

@@ -254,6 +254,7 @@ async function setupLocalize(i18n, browserOptions, webpackConfig) {
                 loader: require.resolve('babel-loader'),
                 options: {
                     babelrc: false,
+                    configFile: false,
                     compact: false,
                     cacheCompression: false,
                     cacheDirectory: cache_path_1.findCachePath('babel-loader'),

package/src/protractor/index.js

@@ -27,21 +27,14 @@ function runProtractor(root, options) {
 async function updateWebdriver() {
     // The webdriver-manager update command can only be accessed via a deep import.
     const webdriverDeepImport = 'webdriver-manager/built/lib/cmds/update';
-    const importOptions = [
-        // When using npm, webdriver is within protractor/node_modules.
-        `protractor/node_modules/${webdriverDeepImport}`,
-        // When using yarn, webdriver is found as a root module.
-        webdriverDeepImport,
-    ];
     let path;
-    for (const importOption of importOptions) {
-        try {
-            path = require.resolve(importOption);
-        }
-        catch (error) {
-            if (error.code !== 'MODULE_NOT_FOUND') {
-                throw error;
-            }
+    try {
+        const protractorPath = require.resolve('protractor');
+        path = require.resolve(webdriverDeepImport, { paths: [protractorPath] });
+    }
+    catch (error) {
+        if (error.code !== 'MODULE_NOT_FOUND') {
+            throw error;
         }
     }
     if (!path) {

package/src/utils/action-cache.d.ts

@@ -13,6 +13,6 @@ export declare class BundleActionCache {
     static copyEntryContent(entry: CacheEntry | string, dest: fs.PathLike): void;
     generateBaseCacheKey(content: string): string;
     generateCacheKeys(action: ProcessBundleOptions): string[];
-    getCacheEntries(cacheKeys: (string | null)[]): Promise<(CacheEntry | null)[] | false>;
+    getCacheEntries(cacheKeys: (string | undefined)[]): Promise<(CacheEntry | null)[] | false>;
     getCachedBundleResult(action: ProcessBundleOptions): Promise<ProcessBundleResult | null>;
 }

package/src/utils/action-cache.js

@@ -35,32 +35,36 @@ class BundleActionCache {
             .update(content)
             .digest('base64');
         let baseCacheKey = `${packageVersion}|${content.length}|${algorithm}-${codeHash}`;
-        if (environment_options_1.manglingDisabled) {
+        if (!environment_options_1.allowMangle) {
             baseCacheKey += '|MD';
         }
         return baseCacheKey;
     }
     generateCacheKeys(action) {
-        const baseCacheKey = this.generateBaseCacheKey(action.code);
-        // Postfix added to sourcemap cache keys when vendor sourcemaps are present
+        // Postfix added to sourcemap cache keys when vendor, hidden sourcemaps are present
         // Allows non-destructive caching of both variants
-        const SourceMapVendorPostfix = !!action.sourceMaps && action.vendorSourceMaps ? '|vendor' : '';
+        const sourceMapVendorPostfix = action.sourceMaps && action.vendorSourceMaps ? '|vendor' : '';
+        // sourceMappingURL is added at the very end which causes the code to be the same when sourcemaps are enabled/disabled
+        // When using hiddenSourceMaps we can omit the postfix since sourceMappingURL will not be added.
+        // When having sourcemaps a hashed file and non hashed file can have the same content. But the sourceMappingURL will differ.
+        const sourceMapPostFix = action.sourceMaps && !action.hiddenSourceMaps ? `|sourcemap|${action.filename}` : '';
+        const baseCacheKey = this.generateBaseCacheKey(action.code);
         // Determine cache entries required based on build settings
         const cacheKeys = [];
         // If optimizing and the original is not ignored, add original as required
-        if ((action.optimize || action.optimizeOnly) && !action.ignoreOriginal) {
-            cacheKeys[0 /* OriginalCode */] = baseCacheKey + '|orig';
+        if (!action.ignoreOriginal) {
+            cacheKeys[0 /* OriginalCode */] = baseCacheKey + sourceMapPostFix + '|orig';
             // If sourcemaps are enabled, add original sourcemap as required
             if (action.sourceMaps) {
-                cacheKeys[1 /* OriginalMap */] = baseCacheKey + SourceMapVendorPostfix + '|orig-map';
+                cacheKeys[1 /* OriginalMap */] = baseCacheKey + sourceMapVendorPostfix + '|orig-map';
             }
         }
         // If not only optimizing, add downlevel as required
         if (!action.optimizeOnly) {
-            cacheKeys[2 /* DownlevelCode */] = baseCacheKey + '|dl';
+            cacheKeys[2 /* DownlevelCode */] = baseCacheKey + sourceMapPostFix + '|dl';
             // If sourcemaps are enabled, add downlevel sourcemap as required
             if (action.sourceMaps) {
-                cacheKeys[3 /* DownlevelMap */] = baseCacheKey + SourceMapVendorPostfix + '|dl-map';
+                cacheKeys[3 /* DownlevelMap */] = baseCacheKey + sourceMapVendorPostfix + '|dl-map';
             }
         }
         return cacheKeys;

package/src/utils/build-browser-features.d.ts

@@ -9,8 +9,8 @@ import * as ts from 'typescript';
 export declare class BuildBrowserFeatures {
     private projectRoot;
     private scriptTarget;
-    private readonly _supportedBrowsers;
     private readonly _es6TargetOrLater;
+    readonly supportedBrowsers: string[];
     constructor(projectRoot: string, scriptTarget: ts.ScriptTarget);
     /**
      * True, when one or more browsers requires ES5

package/src/utils/build-browser-features.js

@@ -14,7 +14,7 @@ class BuildBrowserFeatures {
     constructor(projectRoot, scriptTarget) {
         this.projectRoot = projectRoot;
         this.scriptTarget = scriptTarget;
-        this._supportedBrowsers = browserslist(undefined, { path: this.projectRoot });
+        this.supportedBrowsers = browserslist(undefined, { path: this.projectRoot });
         this._es6TargetOrLater = this.scriptTarget > ts.ScriptTarget.ES5;
     }
     /**
@@ -44,7 +44,7 @@ class BuildBrowserFeatures {
             'safari 10.1',
             'ios_saf 10.3',
         ];
-        return this._supportedBrowsers.some(browser => safariBrowsers.includes(browser));
+        return this.supportedBrowsers.some(browser => safariBrowsers.includes(browser));
     }
     /**
      * True, when a browser feature is supported partially or fully.
@@ -59,7 +59,7 @@ class BuildBrowserFeatures {
             'a',
         ];
         const data = caniuse_lite_1.feature(caniuse_lite_1.features[featureId]);
-        return !this._supportedBrowsers
+        return !this.supportedBrowsers
             .some(browser => {
             const [agentId, version] = browser.split(' ');
             const browserData = data.stats[agentId];

package/src/utils/environment-options.d.ts

@@ -1,3 +1,5 @@
-export declare const manglingDisabled: boolean;
+export declare const allowMangle: boolean;
+export declare const shouldBeautify: boolean;
+export declare const allowMinify: boolean;
 export declare const cachingDisabled: boolean;
 export declare const cachingBasePath: string | null;

package/src/utils/environment-options.js

@@ -8,14 +8,57 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * found in the LICENSE file at https://angular.io/license
  */
 const path = require("path");
+function isDisabled(variable) {
+    return variable === '0' || variable.toLowerCase() === 'false';
+}
+function isEnabled(variable) {
+    return variable === '1' || variable.toLowerCase() === 'true';
+}
+function isPresent(variable) {
+    return typeof variable === 'string' && variable !== '';
+}
+const debugOptimizeVariable = process.env['NG_BUILD_DEBUG_OPTIMIZE'];
+const debugOptimize = (() => {
+    if (!isPresent(debugOptimizeVariable) || isDisabled(debugOptimizeVariable)) {
+        return {
+            mangle: true,
+            minify: true,
+            beautify: false,
+        };
+    }
+    const debugValue = {
+        mangle: false,
+        minify: false,
+        beautify: true,
+    };
+    if (isEnabled(debugOptimizeVariable)) {
+        return debugValue;
+    }
+    for (const part of debugOptimizeVariable.split(',')) {
+        switch (part.trim().toLowerCase()) {
+            case 'mangle':
+                debugValue.mangle = true;
+                break;
+            case 'minify':
+                debugValue.minify = true;
+                break;
+            case 'beautify':
+                debugValue.beautify = true;
+                break;
+        }
+    }
+    return debugValue;
+})();
 const mangleVariable = process.env['NG_BUILD_MANGLE'];
-exports.manglingDisabled = !!mangleVariable && (mangleVariable === '0' || mangleVariable.toLowerCase() === 'false');
+exports.allowMangle = isPresent(mangleVariable)
+    ? !isDisabled(mangleVariable)
+    : debugOptimize.mangle;
+exports.shouldBeautify = debugOptimize.beautify;
+exports.allowMinify = debugOptimize.minify;
 const cacheVariable = process.env['NG_BUILD_CACHE'];
-exports.cachingDisabled = !!cacheVariable && (cacheVariable === '0' || cacheVariable.toLowerCase() === 'false');
+exports.cachingDisabled = isPresent(cacheVariable) && isDisabled(cacheVariable);
 exports.cachingBasePath = (() => {
-    if (exports.cachingDisabled ||
-        !cacheVariable ||
-        (cacheVariable === '1' || cacheVariable.toLowerCase() === 'true')) {
+    if (exports.cachingDisabled || !isPresent(cacheVariable) || isEnabled(cacheVariable)) {
         return null;
     }
     if (!path.isAbsolute(cacheVariable)) {

package/src/utils/process-bundle.d.ts

@@ -11,10 +11,11 @@ export interface ProcessBundleOptions {
     optimize?: boolean;
     optimizeOnly?: boolean;
     ignoreOriginal?: boolean;
-    cacheKeys?: (string | null)[];
+    cacheKeys?: (string | undefined)[];
     integrityAlgorithm?: 'sha256' | 'sha384' | 'sha512';
     runtimeData?: ProcessBundleResult[];
     replacements?: [string, string][];
+    supportedBrowsers?: string[] | Record<string, string>;
 }
 export interface ProcessBundleResult {
     name: string;

package/src/utils/process-bundle.js

@@ -18,6 +18,8 @@ const webpack_sources_1 = require("webpack-sources");
 const environment_options_1 = require("./environment-options");
 const cacache = require('cacache');
 const deserialize = v8.deserialize;
+// If code size is larger than 500KB, consider lower fidelity but faster sourcemap merge
+const FAST_SOURCEMAP_THRESHOLD = 500 * 1024;
 let cachePath;
 let i18n;
 function setup(data) {
@@ -30,7 +32,7 @@ function setup(data) {
 exports.setup = setup;
 async function cachePut(content, key, integrity) {
     if (cachePath && key) {
-        await cacache.put(cachePath, key, content, {
+        await cacache.put(cachePath, key || null, content, {
             metadata: { integrity },
         });
     }
@@ -52,11 +54,6 @@ async function process(options) {
     const filename = path.basename(options.filename);
     const downlevelFilename = filename.replace(/\-es20\d{2}/, '-es5');
     const downlevel = !options.optimizeOnly;
-    // if code size is larger than 500kB, manually handle sourcemaps with newer source-map package.
-    // babel currently uses an older version that still supports sync calls
-    const codeSize = Buffer.byteLength(options.code);
-    const mapSize = options.map ? Buffer.byteLength(options.map) : 0;
-    const manualSourceMaps = codeSize >= 500 * 1024 || mapSize >= 500 * 1024;
     const sourceCode = options.code;
     const sourceMap = options.map ? JSON.parse(options.map) : undefined;
     let downlevelCode;
@@ -64,12 +61,18 @@ async function process(options) {
     if (downlevel) {
         // Downlevel the bundle
         const transformResult = await core_1.transformAsync(sourceCode, {
-            filename: options.filename,
-            inputSourceMap: manualSourceMaps ? undefined : sourceMap,
+            filename,
+            // using false ensures that babel will NOT search and process sourcemap comments (large memory usage)
+            // The types do not include the false option even though it is valid
+            // tslint:disable-next-line: no-any
+            inputSourceMap: false,
             babelrc: false,
+            configFile: false,
             presets: [[
                     require.resolve('@babel/preset-env'),
                     {
+                        // browserslist-compatible query or object of minimum environment versions to support
+                        targets: options.supportedBrowsers,
                         // modules aren't needed since the bundles use webpack's custom module loading
                         modules: false,
                         // 'transform-typeof-symbol' generates slower code
@@ -77,61 +80,46 @@ async function process(options) {
                     },
                 ]],
             plugins: options.replacements ? [createReplacePlugin(options.replacements)] : [],
-            minified: options.optimize,
-            // `false` ensures it is disabled and prevents large file warnings
-            compact: options.optimize || false,
+            minified: environment_options_1.allowMinify && !!options.optimize,
+            compact: !environment_options_1.shouldBeautify && !!options.optimize,
             sourceMaps: !!sourceMap,
         });
         if (!transformResult || !transformResult.code) {
             throw new Error(`Unknown error occurred processing bundle for "${options.filename}".`);
         }
         downlevelCode = transformResult.code;
-        if (manualSourceMaps && sourceMap && transformResult.map) {
-            downlevelMap = await mergeSourceMapsFast(sourceMap, transformResult.map);
-        }
-        else {
-            // undefined is needed here to normalize the property type
-            downlevelMap = transformResult.map || undefined;
-        }
-    }
-    if (options.optimize) {
-        if (downlevelCode) {
-            const minifyResult = terserMangle(downlevelCode, {
-                filename: downlevelFilename,
-                map: downlevelMap,
-                compress: true,
-            });
-            downlevelCode = minifyResult.code;
-            downlevelMap = minifyResult.map;
-        }
-        if (!options.ignoreOriginal) {
-            result.original = await mangleOriginal(options);
+        if (sourceMap && transformResult.map) {
+            // String length is used as an estimate for byte length
+            const fastSourceMaps = sourceCode.length > FAST_SOURCEMAP_THRESHOLD;
+            downlevelMap = await mergeSourceMaps(sourceCode, sourceMap, downlevelCode, transformResult.map, filename, 
+            // When not optimizing, the sourcemaps are significantly less complex
+            // and can use the higher fidelity merge
+            !!options.optimize && fastSourceMaps);
         }
     }
     if (downlevelCode) {
-        const downlevelPath = path.join(basePath, downlevelFilename);
-        let mapContent;
-        if (downlevelMap) {
-            if (!options.hiddenSourceMaps) {
-                downlevelCode += `\n//# sourceMappingURL=${downlevelFilename}.map`;
-            }
-            mapContent = JSON.stringify(downlevelMap);
-            await cachePut(mapContent, options.cacheKeys[3 /* DownlevelMap */]);
-            fs.writeFileSync(downlevelPath + '.map', mapContent);
-        }
-        result.downlevel = createFileEntry(path.join(basePath, downlevelFilename), downlevelCode, mapContent, options.integrityAlgorithm);
-        await cachePut(downlevelCode, options.cacheKeys[2 /* DownlevelCode */], result.downlevel.integrity);
-        fs.writeFileSync(downlevelPath, downlevelCode);
+        result.downlevel = await processBundle({
+            ...options,
+            code: downlevelCode,
+            map: downlevelMap,
+            filename: path.join(basePath, downlevelFilename),
+            isOriginal: false,
+        });
     }
-    // If original was not processed, add info
     if (!result.original && !options.ignoreOriginal) {
-        result.original = createFileEntry(options.filename, options.code, options.map, options.integrityAlgorithm);
+        result.original = await processBundle({
+            ...options,
+            isOriginal: true,
+        });
     }
     return result;
 }
 exports.process = process;
-function mergeSourceMaps(inputCode, inputSourceMap, resultCode, resultSourceMap, filename) {
-    // More accurate but significantly more costly
+async function mergeSourceMaps(inputCode, inputSourceMap, resultCode, resultSourceMap, filename, fast = false) {
+    if (fast) {
+        return mergeSourceMapsFast(inputSourceMap, resultSourceMap);
+    }
+    // SourceMapSource produces high-quality sourcemaps
     // The last argument is not yet in the typings
     // tslint:disable-next-line: no-any
     return new webpack_sources_1.SourceMapSource(resultCode, filename, resultSourceMap, inputCode, inputSourceMap, true).map();
@@ -180,45 +168,58 @@ async function mergeSourceMapsFast(first, second) {
     }
     return map;
 }
-async function mangleOriginal(options) {
-    const result = terserMangle(options.code, {
-        filename: path.basename(options.filename),
-        map: options.map ? JSON.parse(options.map) : undefined,
-        ecma: 6,
-    });
+async function processBundle(options) {
+    const { optimize, isOriginal, code, map, filename: filepath, hiddenSourceMaps, cacheKeys = [], integrityAlgorithm, } = options;
+    const rawMap = typeof map === 'string' ? JSON.parse(map) : map;
+    const filename = path.basename(filepath);
+    let result;
+    if (rawMap) {
+        rawMap.file = filename;
+    }
+    if (optimize) {
+        result = await terserMangle(code, {
+            filename,
+            map: rawMap,
+            compress: !isOriginal,
+            ecma: isOriginal ? 6 : 5,
+        });
+    }
+    else {
+        result = {
+            map: rawMap,
+            code,
+        };
+    }
     let mapContent;
     if (result.map) {
-        if (!options.hiddenSourceMaps) {
-            result.code += `\n//# sourceMappingURL=${path.basename(options.filename)}.map`;
+        if (!hiddenSourceMaps) {
+            result.code += `\n//# sourceMappingURL=${filename}.map`;
         }
         mapContent = JSON.stringify(result.map);
-        await cachePut(mapContent, (options.cacheKeys && options.cacheKeys[1 /* OriginalMap */]) || null);
-        fs.writeFileSync(options.filename + '.map', mapContent);
+        await cachePut(mapContent, cacheKeys[isOriginal ? 1 /* OriginalMap */ : 3 /* DownlevelMap */]);
+        fs.writeFileSync(filepath + '.map', mapContent);
     }
-    const fileResult = createFileEntry(options.filename, result.code, mapContent, options.integrityAlgorithm);
-    await cachePut(result.code, (options.cacheKeys && options.cacheKeys[0 /* OriginalCode */]) || null, fileResult.integrity);
-    fs.writeFileSync(options.filename, result.code);
+    const fileResult = createFileEntry(filepath, result.code, mapContent, integrityAlgorithm);
+    await cachePut(result.code, cacheKeys[isOriginal ? 0 /* OriginalCode */ : 2 /* DownlevelCode */], fileResult.integrity);
+    fs.writeFileSync(filepath, result.code);
     return fileResult;
 }
-function terserMangle(code, options = {}) {
+async function terserMangle(code, options = {}) {
     // Note: Investigate converting the AST instead of re-parsing
     // estree -> terser is already supported; need babel -> estree/terser
     // Mangle downlevel code
-    const minifyOutput = terser_1.minify(code, {
-        compress: options.compress || false,
+    const minifyOutput = terser_1.minify(options.filename ? { [options.filename]: code } : code, {
+        compress: environment_options_1.allowMinify && !!options.compress,
         ecma: options.ecma || 5,
-        mangle: !environment_options_1.manglingDisabled,
+        mangle: environment_options_1.allowMangle,
         safari10: true,
         output: {
             ascii_only: true,
             webkit: true,
+            beautify: environment_options_1.shouldBeautify,
         },
         sourceMap: !!options.map &&
             {
-                filename: options.filename,
-                // terser uses an old version of the sourcemap typings
-                // tslint:disable-next-line: no-any
-                content: options.map,
                 asObject: true,
             },
     });
@@ -226,7 +227,12 @@ function terserMangle(code, options = {}) {
         throw minifyOutput.error;
     }
     // tslint:disable-next-line: no-non-null-assertion
-    return { code: minifyOutput.code, map: minifyOutput.map };
+    const outputCode = minifyOutput.code;
+    let outputMap;
+    if (options.map && minifyOutput.map) {
+        outputMap = await mergeSourceMaps(code, options.map, outputCode, minifyOutput.map, options.filename || '0', code.length > FAST_SOURCEMAP_THRESHOLD);
+    }
+    return { code: outputCode, map: outputMap };
 }
 function createFileEntry(filename, code, map, integrityAlgorithm) {
     return {
@@ -271,42 +277,19 @@ async function processRuntime(options) {
     // Adjust lazy loaded scripts to point to the proper variant
     // Extra spacing is intentional to align source line positions
     downlevelCode = downlevelCode.replace(/"\-es20\d{2}\./, '   "-es5.');
-    const downlevelFilePath = options.filename.replace(/\-es20\d{2}/, '-es5');
-    let downlevelMap;
-    let result;
-    if (options.optimize) {
-        const minifiyResults = terserMangle(downlevelCode, {
-            filename: path.basename(downlevelFilePath),
-            map: options.map === undefined ? undefined : JSON.parse(options.map),
-        });
-        downlevelCode = minifiyResults.code;
-        downlevelMap = JSON.stringify(minifiyResults.map);
-        result = {
-            original: await mangleOriginal({ ...options, code: originalCode }),
-            downlevel: createFileEntry(downlevelFilePath, downlevelCode, downlevelMap, options.integrityAlgorithm),
-        };
-    }
-    else {
-        if (options.map) {
-            const rawMap = JSON.parse(options.map);
-            rawMap.file = path.basename(downlevelFilePath);
-            downlevelMap = JSON.stringify(rawMap);
-        }
-        result = {
-            original: createFileEntry(options.filename, originalCode, options.map, options.integrityAlgorithm),
-            downlevel: createFileEntry(downlevelFilePath, downlevelCode, downlevelMap, options.integrityAlgorithm),
-        };
-    }
-    if (downlevelMap) {
-        await cachePut(downlevelMap, (options.cacheKeys && options.cacheKeys[3 /* DownlevelMap */]) || null);
-        fs.writeFileSync(downlevelFilePath + '.map', downlevelMap);
-        if (!options.hiddenSourceMaps) {
-            downlevelCode += `\n//# sourceMappingURL=${path.basename(downlevelFilePath)}.map`;
-        }
-    }
-    await cachePut(downlevelCode, (options.cacheKeys && options.cacheKeys[2 /* DownlevelCode */]) || null);
-    fs.writeFileSync(downlevelFilePath, downlevelCode);
-    return result;
+    return {
+        original: await processBundle({
+            ...options,
+            code: originalCode,
+            isOriginal: true,
+        }),
+        downlevel: await processBundle({
+            ...options,
+            code: downlevelCode,
+            filename: options.filename.replace(/\-es20\d{2}/, '-es5'),
+            isOriginal: false,
+        }),
+    };
 }
 function createReplacePlugin(replacements) {
     return {
@@ -345,7 +328,8 @@ async function inlineLocales(options) {
     if (positions.length === 0 && !options.setLocale) {
         return inlineCopyOnly(options);
     }
-    let content = new MagicString(options.code);
+    // tslint:disable-next-line: no-any
+    let content = new MagicString(options.code, { filename: options.filename });
     const inputMap = options.map && JSON.parse(options.map);
     let contentClone;
     for (const locale of i18n.inlineLocales) {
@@ -365,7 +349,7 @@ async function inlineLocales(options) {
             // If locale data is provided, load it and prepend to file
             const localeDataPath = i18n.locales[locale] && i18n.locales[locale].dataPath;
             if (localeDataPath) {
-                const localDataContent = loadLocaleData(localeDataPath, true);
+                const localDataContent = await loadLocaleData(localeDataPath, true);
                 // The semicolon ensures that there is no syntax error between statements
                 content.prepend(localDataContent + ';');
             }
@@ -375,7 +359,7 @@ async function inlineLocales(options) {
         fs.writeFileSync(outputPath, output);
         if (inputMap) {
             const contentMap = content.generateMap();
-            const outputMap = mergeSourceMaps(options.code, inputMap, output, contentMap, options.filename);
+            const outputMap = mergeSourceMaps(options.code, inputMap, output, contentMap, options.filename, options.code.length > FAST_SOURCEMAP_THRESHOLD);
             fs.writeFileSync(outputPath + '.map', JSON.stringify(outputMap));
         }
         if (contentClone) {
@@ -406,7 +390,9 @@ utils) {
     try {
         ast = core_1.parseSync(options.code, {
             babelrc: false,
+            configFile: false,
             sourceType: 'script',
+            filename: options.filename,
         });
     }
     catch (error) {
@@ -464,12 +450,12 @@ utils) {
     }
     return positions;
 }
-function loadLocaleData(path, optimize) {
+async function loadLocaleData(path, optimize) {
     // The path is validated during option processing before the build starts
     const content = fs.readFileSync(path, 'utf8');
     // NOTE: This can be removed once the locale data files are preprocessed in the framework
     if (optimize) {
-        const result = terserMangle(content, {
+        const result = await terserMangle(content, {
             compress: true,
             ecma: 5,
         });

package/src/utils/webpack-browser-config.js

@@ -94,6 +94,27 @@ async function generateI18nBrowserWebpackConfigFromContext(options, context, web
             config.resolve.alias = {};
         }
         config.resolve.alias['@angular/localize/init'] = require.resolve('./empty.js');
+        // Update file hashes to include translation file content
+        const i18nHash = Object.values(i18n.locales).reduce((data, locale) => data + (locale.integrity || ''), '');
+        if (!config.plugins) {
+            config.plugins = [];
+        }
+        config.plugins.push({
+            apply(compiler) {
+                compiler.hooks.compilation.tap('build-angular', compilation => {
+                    // Webpack typings do not contain template hashForChunk hook
+                    // tslint:disable-next-line: no-any
+                    compilation.mainTemplate.hooks.hashForChunk.tap('build-angular', (hash) => {
+                        hash.update('$localize' + i18nHash);
+                    });
+                    // Webpack typings do not contain hooks property
+                    // tslint:disable-next-line: no-any
+                    compilation.chunkTemplate.hooks.hashForChunk.tap('build-angular', (hash) => {
+                        hash.update('$localize' + i18nHash);
+                    });
+                });
+            },
+        });
     }
     return { ...result, i18n };
 }