hunk.code_window:       hashFuncNames: ['sha384'],
       }));
     }
     // TODO_WEBPACK_5: Investigate build/serve issues with the `license-webpack-plugin` package
     if (extractLicenses && isWebpackFiveOrHigher()) {
       wco.logger.warn(
         'Warning: License extraction is currently disabled when using Webpack 5. ' +
           'This is temporary and will be corrected in a future update.',
       );
     } else if (extractLicenses) {
       const LicenseWebpackPlugin = require('license-webpack-plugin').LicenseWebpackPlugin;
       extraPlugins.push(new LicenseWebpackPlugin({
         stats: {
  
hunk.labels: keep keep keep keep replace replace replace replace replace replace replace keep keep keep
hunk.after_edit:   if (extractLicenses) {
  
hunk.file_path: packages/angular_devkit/build_angular/src/webpack/configs/browser.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 {
    Rule,
    SchematicContext,
    SchematicsException,
    Tree,
    apply,
    chain,
    empty,
    mergeWith,
    move,
    noop,
    schematic,
  } from '@angular-devkit/schematics';
  import {
    NodePackageInstallTask,
    NodePackageLinkTask,
    RepositoryInitializerTask,
  } from '@angular-devkit/schematics/tasks';
  import { Schema as ApplicationOptions } from '../application/schema';
  import { validateProjectName } from '../utility/validation';
  import { Schema as WorkspaceOptions } from '../workspace/schema';
  import { Schema as NgNewOptions } from './schema';
  
  
  export default function(options: NgNewOptions): Rule {
    if (!options.name) {
      throw new SchematicsException(`Invalid options, "name" is required.`);
    }
  
    validateProjectName(options.name);
  
    if (!options.directory) {
      options.directory = options.name;
    }
  
    const workspaceOptions: WorkspaceOptions = {
      name: options.name,
      version: options.version,
      newProjectRoot: options.newProjectRoot,
      minimal: options.minimal,
      strict: options.strict,
      packageManager: options.packageManager,
    };
    const applicationOptions: ApplicationOptions = {
      projectRoot: '',
      name: options.name,
      inlineStyle: options.inlineStyle,
      inlineTemplate: options.inlineTemplate,
      prefix: options.prefix,
      viewEncapsulation: options.viewEncapsulation,
      routing: options.routing,
      style: options.style,
      skipTests: options.skipTests,
      skipPackageJson: false,
      // always 'skipInstall' here, so that we do it after the move
      skipInstall: true,
      strict: options.strict,
      minimal: options.minimal,
      legacyBrowsers: options.legacyBrowsers,
    };
  
    return chain([
      mergeWith(
        apply(empty(), [
          schematic('workspace', workspaceOptions),
          options.createApplication ? schematic('application', applicationOptions) : noop,
          move(options.directory),
        ]),
      ),
      (_host: Tree, context: SchematicContext) => {
        let packageTask;
        if (!options.skipInstall) {
          packageTask = context.addTask(
            new NodePackageInstallTask({
              workingDirectory: options.directory,
              packageManager: options.packageManager,
            }),
          );
          if (options.linkCli) {
            packageTask = context.addTask(
              new NodePackageLinkTask('@angular/cli', options.directory),
              [packageTask],
            );
          }
        }
        if (!options.skipGit) {
          const commit = typeof options.commit == 'object'
            ? options.commit
            : (!!options.commit ? {} : false);
  
          context.addTask(
            new RepositoryInitializerTask(
              options.directory,
              commit,
            ),
            packageTask ? [packageTask] : [],
          );
        }
      },
    ]);
  }
  