@angular-devkit/build-angular 0.803.21 → 0.803.25

package/package.json

@@ -1,32 +1,32 @@
 {
   "name": "@angular-devkit/build-angular",
-  "version": "0.803.21",
+  "version": "0.803.25",
   "description": "Angular Webpack Build Facade",
   "experimental": true,
   "main": "src/index.js",
   "typings": "src/index.d.ts",
   "builders": "builders.json",
   "dependencies": {
-    "@angular-devkit/architect": "0.803.21",
-    "@angular-devkit/build-optimizer": "0.803.21",
-    "@angular-devkit/build-webpack": "0.803.21",
-    "@angular-devkit/core": "8.3.21",
-    "@babel/core": "7.7.5",
-    "@babel/preset-env": "7.7.6",
-    "@ngtools/webpack": "8.3.21",
+    "@angular-devkit/architect": "0.803.25",
+    "@angular-devkit/build-optimizer": "0.803.25",
+    "@angular-devkit/build-webpack": "0.803.25",
+    "@angular-devkit/core": "8.3.25",
+    "@babel/core": "7.8.3",
+    "@babel/preset-env": "7.8.3",
+    "@ngtools/webpack": "8.3.25",
     "ajv": "6.10.2",
     "autoprefixer": "9.6.1",
-    "browserslist": "4.6.6",
+    "browserslist": "4.8.6",
     "cacache": "12.0.2",
-    "caniuse-lite": "1.0.30000989",
+    "caniuse-lite": "1.0.30001024",
     "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.2.1",
+    "core-js": "3.6.4",
     "file-loader": "4.2.0",
     "find-cache-dir": "3.0.0",
     "glob": "7.1.4",
-    "istanbul-instrumenter-loader": "3.0.1",
     "jest-worker": "24.9.0",
     "karma-source-map-support": "1.4.0",
     "less": "3.9.0",
@@ -53,8 +53,8 @@
     "style-loader": "1.0.0",
     "stylus": "0.54.5",
     "stylus-loader": "3.0.2",
-    "tree-kill": "1.2.1",
-    "terser": "4.3.9",
+    "tree-kill": "1.2.2",
+    "terser": "4.6.3",
     "terser-webpack-plugin": "1.4.3",
     "webpack": "4.39.2",
     "webpack-dev-middleware": "3.7.2",

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

@@ -8,7 +8,7 @@
 import { logging } from '@angular-devkit/core';
 import { ParsedConfiguration } from '@angular/compiler-cli';
 import { ScriptTarget } from 'typescript';
-import { AssetPatternClass, Budget, ExtraEntryPoint, OptimizationClass, SourceMapClass } from '../../browser/schema';
+import { AssetPatternClass, Budget, CrossOrigin, ExtraEntryPoint, OptimizationClass, SourceMapClass } from '../../browser/schema';
 import { NormalizedFileReplacement } from '../../utils/normalize-file-replacements';
 export interface BuildOptions {
     optimization: OptimizationClass;
@@ -43,6 +43,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,14 @@ 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.string.match';
+import 'core-js/modules/es.string.replace';
+import 'core-js/modules/es.string.search';
+import 'core-js/modules/es.string.split';
 
 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/test.js

@@ -21,7 +21,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 = [
@@ -37,8 +36,8 @@ function getTestConfig(wco) {
             });
         }
         extraRules.push({
-            test: /\.(js|ts)$/,
-            loader: 'istanbul-instrumenter-loader',
+            test: /\.(jsx?|tsx?)$/,
+            loader: require.resolve('coverage-istanbul-loader'),
             options: { esModules: true },
             enforce: 'post',
             exclude,

package/src/angular-cli-files/utilities/stats.js

@@ -66,11 +66,19 @@ function statsToString(json, statsConfig) {
     }
 }
 exports.statsToString = statsToString;
+// TODO(#16193): Don't emit this warning in the first place rather than just suppressing it.
+const ERRONEOUS_WARNINGS = [
+    /multiple assets emit different content.*3rdpartylicenses\.txt/i,
+];
 function statsWarningsToString(json, statsConfig) {
     const colors = statsConfig.colors;
     const rs = (x) => colors ? reset(x) : x;
     const y = (x) => colors ? bold(yellow(x)) : x;
-    return rs('\n' + json.warnings.map((warning) => y(`WARNING in ${warning}`)).join('\n\n'));
+    return rs('\n' + json.warnings
+        .map((warning) => `${warning}`)
+        .filter((warning) => !ERRONEOUS_WARNINGS.some((erroneous) => erroneous.test(warning)))
+        .map((warning) => y(`WARNING in ${warning}`))
+        .join('\n\n'));
 }
 exports.statsWarningsToString = statsWarningsToString;
 function statsErrorsToString(json, statsConfig) {

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

@@ -12,6 +12,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/browser/action-cache.js

@@ -56,26 +56,30 @@ class BundleActionCache {
         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/browser/index.js

@@ -212,12 +212,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
                         let filename = path.resolve(core_1.getSystemPath(root), options.outputPath, file.file);
@@ -236,6 +230,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({
@@ -289,6 +284,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/tslint/index.js

@@ -22,7 +22,10 @@ async function _loadTslint() {
         throw new Error('Unable to find TSLint. Ensure TSLint is installed.');
     }
     const version = tslint.Linter.VERSION && tslint.Linter.VERSION.split('.');
-    if (!version || version.length < 2 || Number(version[0]) < 5 || Number(version[1]) < 5) {
+    if (!version || version.length < 2
+        || (Number(version[0]) === 5 && Number(version[1]) < 5) // 5.5+
+        || Number(version[0]) < 5 // 6.0+
+    ) {
         throw new Error('TSLint must be version 5.5 or higher.');
     }
     return tslint;

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

@@ -10,8 +10,8 @@ export declare const fullDifferential: boolean;
 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

@@ -18,7 +18,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;
     }
     /**
@@ -48,7 +48,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.
@@ -63,7 +63,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/process-bundle.d.ts

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

package/src/utils/process-bundle.js

@@ -22,7 +22,7 @@ function setup(options) {
 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 },
         });
     }
@@ -47,21 +47,24 @@ async function process(options) {
     // if code size is larger than 1 MB, manually handle sourcemaps with newer source-map package.
     const codeSize = Buffer.byteLength(options.code);
     const mapSize = options.map ? Buffer.byteLength(options.map) : 0;
-    const manualSourceMaps = codeSize >= 1024 * 1024 || mapSize >= 1024 * 1024;
+    const manualSourceMaps = codeSize >= 500 * 1024 || mapSize >= 500 * 1024;
     const sourceCode = options.code;
-    const sourceMap = options.map ? JSON.parse(options.map) : undefined;
+    const sourceMap = options.map ? JSON.parse(options.map) : false;
     let downlevelCode;
     let downlevelMap;
     if (downlevel) {
         // Downlevel the bundle
         const transformResult = await core_1.transformAsync(sourceCode, {
             filename: options.filename,
-            inputSourceMap: manualSourceMaps ? undefined : sourceMap,
+            // using false ensures that babel will NOT search and process sourcemap comments (large memory usage)
+            inputSourceMap: manualSourceMaps ? false : sourceMap,
             babelrc: 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
@@ -86,38 +89,20 @@ async function process(options) {
             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 (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(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;
 }
@@ -166,24 +151,40 @@ async function mergeSourcemaps(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 (optimize) {
+        result = terserMangle(code, {
+            filename,
+            map: rawMap,
+            compress: !isOriginal,
+            ecma: isOriginal ? 6 : 5,
+        });
+    }
+    else {
+        if (rawMap) {
+            rawMap.file = filename;
+        }
+        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 = {}) {
@@ -257,38 +258,17 @@ 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);
-        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,
+        }),
+    };
 }