hunk.code_window:   // Enable Differential loading to run both size checks
     await replaceInFile(
       '.browserslistrc',
       'not IE 9-11',
       'IE 9-11',
     );
     // Remove the cache so that an initial build and build with cache can be tested
     await rimraf('./node_modules/.cache');
  
hunk.labels: keep keep keep keep replace replace keep keep keep keep
hunk.after_edit:     'not IE 11',
       'IE 11',
  
hunk.file_path: tests/legacy-cli/e2e/tests/build/differential-cache.ts
hunk.type: replace
file: /**
   * @license
   * Copyright Google Inc. 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 webpack from 'webpack';
  import { NormalizedEntryPoint } from '../models/webpack-configs';
  
  /**
   * Webpack stats may incorrectly mark extra entry points `initial` chunks, when
   * they are actually loaded asynchronously and thus not in the main bundle. This
   * function finds extra entry points in Webpack stats and corrects this value
   * whereever necessary. Does not modify {@param webpackStats}.
   */
  export function markAsyncChunksNonInitial(
    webpackStats: webpack.Stats.ToJsonOutput,
    extraEntryPoints: NormalizedEntryPoint[],
  ): Exclude<webpack.Stats.ToJsonOutput['chunks'], undefined> {
    const {chunks = [], entrypoints: entryPoints = {}} = webpackStats;
  
    // Find all Webpack chunk IDs not injected into the main bundle. We don't have
    // to worry about transitive dependencies because extra entry points cannot be
    // depended upon in Webpack, thus any extra entry point with `inject: false`,
    // **cannot** be loaded in main bundle.
    const asyncEntryPoints = extraEntryPoints.filter((entryPoint) => !entryPoint.inject);
    const asyncChunkIds = flatMap(asyncEntryPoints,
        (entryPoint) => entryPoints[entryPoint.bundleName].chunks);
  
    // Find chunks for each ID.
    const asyncChunks = asyncChunkIds.map((chunkId) => {
        const chunk = chunks.find((chunk) => chunk.id === chunkId);
        if (!chunk) {
          throw new Error(`Failed to find chunk (${chunkId}) in set:\n${
              JSON.stringify(chunks)}`);
        }
  
        return chunk;
      })
      // All Webpack chunks are dependent on `runtime`, which is never an async
      // entry point, simply ignore this one.
      .filter((chunk) => chunk.names.indexOf('runtime') === -1);
  
    // A chunk is considered `initial` only if Webpack already belives it to be initial
    // and the application developer did not mark it async via an extra entry point.
    return chunks.map((chunk) => ({
      ...chunk,
      initial: chunk.initial && !asyncChunks.find((asyncChunk) => asyncChunk === chunk),
    }));
  }
  
  function flatMap<T, R>(list: T[], mapper: (item: T, index: number, array: T[]) => R[]): R[] {
    return ([] as R[]).concat(...list.map(mapper));
  }
  