/*

MIT License http://www.opensource.org/licenses/mit-license.php

Author Tobias Koppers @sokra

*/

"use strict";

const asyncLib = require("neo-async");

const util = require("util");

const { CachedSource } = require("webpack-sources");

const {

Tapable,

SyncHook,

SyncBailHook,

SyncWaterfallHook,

AsyncSeriesHook

} = require("tapable");

const EntryModuleNotFoundError = require("./EntryModuleNotFoundError");

const ModuleNotFoundError = require("./ModuleNotFoundError");

const ModuleDependencyWarning = require("./ModuleDependencyWarning");

const ModuleDependencyError = require("./ModuleDependencyError");

const ChunkGroup = require("./ChunkGroup");

const Chunk = require("./Chunk");

const Entrypoint = require("./Entrypoint");

const MainTemplate = require("./MainTemplate");

const ChunkTemplate = require("./ChunkTemplate");

const HotUpdateChunkTemplate = require("./HotUpdateChunkTemplate");

const ModuleTemplate = require("./ModuleTemplate");

const RuntimeTemplate = require("./RuntimeTemplate");

const Dependency = require("./Dependency");

const ChunkRenderError = require("./ChunkRenderError");

const AsyncDependencyToInitialChunkError = require("./AsyncDependencyToInitialChunkError");

const Stats = require("./Stats");

const Semaphore = require("./util/Semaphore");

const createHash = require("./util/createHash");

const Queue = require("./util/Queue");

const SortableSet = require("./util/SortableSet");

const GraphHelpers = require("./GraphHelpers");

const byId = (a, b) => {

if (a.id < b.id) return -1;

if (a.id > b.id) return 1;

return 0;

};

const byIdOrIdentifier = (a, b) => {

if (a.id < b.id) return -1;

if (a.id > b.id) return 1;

const identA = a.identifier();

const identB = b.identifier();

if (identA < identB) return -1;

if (identA > identB) return 1;

return 0;

};

const byIndexOrIdentifier = (a, b) => {

if (a.index < b.index) return -1;

if (a.index > b.index) return 1;

const identA = a.identifier();

const identB = b.identifier();

if (identA < identB) return -1;

if (identA > identB) return 1;

return 0;

};

const byNameOrHash = (a, b) => {

if (a.name < b.name) return -1;

if (a.name > b.name) return 1;

if (a.fullHash < b.fullHash) return -1;

if (a.fullhash > b.fullHash) return 1;

return 0;

};

const iterationBlockVariable = (variables, fn) => {

for (

let indexVariable = 0;

indexVariable < variables.length;

indexVariable++

) {

const varDep = variables[indexVariable].dependencies;

for (let indexVDep = 0; indexVDep < varDep.length; indexVDep++) {

fn(varDep[indexVDep]);

}

}

};

const iterationOfArrayCallback = (arr, fn) => {

for (let index = 0; index < arr.length; index++) {

fn(arr[index]);

}

};

function addAllToSet(set, otherSet) {

for (const item of otherSet) {

set.add(item);

}

}

class Compilation extends Tapable {

constructor(compiler) {

super();

this.hooks = {

buildModule: new SyncHook(["module"]),

rebuildModule: new SyncHook(["module"]),

failedModule: new SyncHook(["module", "error"]),

succeedModule: new SyncHook(["module"]),

finishModules: new SyncHook(["modules"]),

finishRebuildingModule: new SyncHook(["module"]),

unseal: new SyncHook([]),

seal: new SyncHook([]),

optimizeDependenciesBasic: new SyncBailHook(["modules"]),

optimizeDependencies: new SyncBailHook(["modules"]),

optimizeDependenciesAdvanced: new SyncBailHook(["modules"]),

afterOptimizeDependencies: new SyncHook(["modules"]),

optimize: new SyncHook([]),

optimizeModulesBasic: new SyncBailHook(["modules"]),

optimizeModules: new SyncBailHook(["modules"]),

optimizeModulesAdvanced: new SyncBailHook(["modules"]),

afterOptimizeModules: new SyncHook(["modules"]),

optimizeChunksBasic: new SyncBailHook(["chunks", "chunkGroups"]),

optimizeChunks: new SyncBailHook(["chunks", "chunkGroups"]),

optimizeChunksAdvanced: new SyncBailHook(["chunks", "chunkGroups"]),

afterOptimizeChunks: new SyncHook(["chunks", "chunkGroups"]),

optimizeTree: new AsyncSeriesHook(["chunks", "modules"]),

afterOptimizeTree: new SyncHook(["chunks", "modules"]),

optimizeChunkModulesBasic: new SyncBailHook(["chunks", "modules"]),

optimizeChunkModules: new SyncBailHook(["chunks", "modules"]),

optimizeChunkModulesAdvanced: new SyncBailHook(["chunks", "modules"]),

afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]),

shouldRecord: new SyncBailHook([]),

reviveModules: new SyncHook(["modules", "records"]),

optimizeModuleOrder: new SyncHook(["modules"]),

advancedOptimizeModuleOrder: new SyncHook(["modules"]),

beforeModuleIds: new SyncHook(["modules"]),

moduleIds: new SyncHook(["modules"]),

optimizeModuleIds: new SyncHook(["modules"]),

afterOptimizeModuleIds: new SyncHook(["modules"]),

reviveChunks: new SyncHook(["chunks", "records"]),

optimizeChunkOrder: new SyncHook(["chunks"]),

beforeChunkIds: new SyncHook(["chunks"]),

optimizeChunkIds: new SyncHook(["chunks"]),

afterOptimizeChunkIds: new SyncHook(["chunks"]),

recordModules: new SyncHook(["modules", "records"]),

recordChunks: new SyncHook(["chunks", "records"]),

beforeHash: new SyncHook([]),

contentHash: new SyncHook(["chunk"]),

afterHash: new SyncHook([]),

recordHash: new SyncHook(["records"]),

record: new SyncHook(["compilation", "records"]),

beforeModuleAssets: new SyncHook([]),

shouldGenerateChunkAssets: new SyncBailHook([]),

beforeChunkAssets: new SyncHook([]),

additionalChunkAssets: new SyncHook(["chunks"]),

additionalAssets: new AsyncSeriesHook([]),

optimizeChunkAssets: new AsyncSeriesHook(["chunks"]),

afterOptimizeChunkAssets: new SyncHook(["chunks"]),

optimizeAssets: new AsyncSeriesHook(["assets"]),

afterOptimizeAssets: new SyncHook(["assets"]),

needAdditionalSeal: new SyncBailHook([]),

afterSeal: new AsyncSeriesHook([]),

chunkHash: new SyncHook(["chunk", "chunkHash"]),

moduleAsset: new SyncHook(["module", "filename"]),

chunkAsset: new SyncHook(["chunk", "filename"]),

assetPath: new SyncWaterfallHook(["filename", "data"]), // TODO MainTemplate

needAdditionalPass: new SyncBailHook([]),

childCompiler: new SyncHook([

"childCompiler",

"compilerName",

"compilerIndex"

]),

// TODO the following hooks are weirdly located here

// TODO move them for webpack 5

normalModuleLoader: new SyncHook(["loaderContext", "module"]),

optimizeExtractedChunksBasic: new SyncBailHook(["chunks"]),

optimizeExtractedChunks: new SyncBailHook(["chunks"]),

optimizeExtractedChunksAdvanced: new SyncBailHook(["chunks"]),

afterOptimizeExtractedChunks: new SyncHook(["chunks"])

};

this._pluginCompat.tap("Compilation", options => {

switch (options.name) {

case "optimize-tree":

case "additional-assets":

case "optimize-chunk-assets":

case "optimize-assets":

case "after-seal":

options.async = true;

break;

}

});

this.name = undefined;

this.compiler = compiler;

this.resolverFactory = compiler.resolverFactory;

this.inputFileSystem = compiler.inputFileSystem;

this.requestShortener = compiler.requestShortener;

const options = (this.options = compiler.options);

this.outputOptions = options && options.output;

this.bail = options && options.bail;

this.profile = options && options.profile;

this.performance = options && options.performance;

this.mainTemplate = new MainTemplate(this.outputOptions);

this.chunkTemplate = new ChunkTemplate(this.outputOptions);

this.hotUpdateChunkTemplate = new HotUpdateChunkTemplate(

this.outputOptions

);

this.runtimeTemplate = new RuntimeTemplate(

this.outputOptions,

this.requestShortener

);

this.moduleTemplates = {

javascript: new ModuleTemplate(this.runtimeTemplate, "javascript"),

webassembly: new ModuleTemplate(this.runtimeTemplate, "webassembly")

};

this.semaphore = new Semaphore(options.parallelism || 100);

this.entries = [];

this._preparedEntrypoints = [];

this.entrypoints = new Map();

this.chunks = [];

this.chunkGroups = [];

this.namedChunkGroups = new Map();

this.namedChunks = new Map();

this.modules = [];

this._modules = new Map();

this.cache = null;

this.records = null;

this.nextFreeModuleIndex = undefined;

this.nextFreeModuleIndex2 = undefined;

this.additionalChunkAssets = [];

this.assets = {};

this.errors = [];

this.warnings = [];

this.children = [];

this.dependencyFactories = new Map();

this.dependencyTemplates = new Map();

this.dependencyTemplates.set("hash", "");

this.childrenCounters = {};

this.usedChunkIds = null;

this.usedModuleIds = null;

this.fileTimestamps = undefined;

this.contextTimestamps = undefined;

this.compilationDependencies = undefined;

this.needAdditionalPass = false;

this._buildingModules = new Map();

this._rebuildingModules = new Map();

}

getStats() {

return new Stats(this);

}

addModule(module, cacheGroup) {

const identifier = module.identifier();

const alreadyAddedModule = this._modules.get(identifier);

if (alreadyAddedModule) {

return {

module: alreadyAddedModule,

issuer: false,

build: false,

dependencies: false

};

}

const cacheName = (cacheGroup || "m") + identifier;

if (this.cache && this.cache[cacheName]) {

const cacheModule = this.cache[cacheName];

if (typeof cacheModule.updateCacheModule === "function")

cacheModule.updateCacheModule(module);

let rebuild = true;

if (this.fileTimestamps && this.contextTimestamps) {

rebuild = cacheModule.needRebuild(

this.fileTimestamps,

this.contextTimestamps

);

}

if (!rebuild) {

cacheModule.disconnect();

this._modules.set(identifier, cacheModule);

this.modules.push(cacheModule);

for (const err of cacheModule.errors) this.errors.push(err);

for (const err of cacheModule.warnings) this.warnings.push(err);

return {

module: cacheModule,

issuer: true,

build: false,

dependencies: true

};

}

cacheModule.unbuild();

module = cacheModule;

}

this._modules.set(identifier, module);

if (this.cache) {

this.cache[cacheName] = module;

}

this.modules.push(module);

return {

module: module,

issuer: true,

build: true,

dependencies: true

};

}

getModule(module) {

const identifier = module.identifier();

return this._modules.get(identifier);

}

findModule(identifier) {

return this._modules.get(identifier);

}

waitForBuildingFinished(module, callback) {

let callbackList = this._buildingModules.get(module);

if (callbackList) {

callbackList.push(() => callback());

} else {

process.nextTick(callback);

}

}

buildModule(module, optional, origin, dependencies, thisCallback) {

let callbackList = this._buildingModules.get(module);

if (callbackList) {

callbackList.push(thisCallback);

return;

}

this._buildingModules.set(module, (callbackList = [thisCallback]));

const callback = err => {

this._buildingModules.delete(module);

for (const cb of callbackList) cb(err);

};

this.hooks.buildModule.call(module);

module.build(

this.options,

this,

this.resolverFactory.get("normal", module.resolveOptions),

this.inputFileSystem,

error => {

const errors = module.errors;

for (let indexError = 0; indexError < errors.length; indexError++) {

const err = errors[indexError];

err.origin = origin;

err.dependencies = dependencies;

if (optional) this.warnings.push(err);

else this.errors.push(err);

}

const warnings = module.warnings;

for (

let indexWarning = 0;

indexWarning < warnings.length;

indexWarning++

) {

const war = warnings[indexWarning];

war.origin = origin;

war.dependencies = dependencies;

this.warnings.push(war);

}

module.dependencies.sort(Dependency.compare);

if (error) {

this.hooks.failedModule.call(module, error);

return callback(error);

}

this.hooks.succeedModule.call(module);

return callback();

}

);

}

processModuleDependencies(module, callback) {

const dependencies = new Map();

const addDependency = dep => {

const resourceIdent = dep.getResourceIdentifier();

if (resourceIdent) {

const factory = this.dependencyFactories.get(dep.constructor);

if (factory === undefined)

throw new Error(

`No module factory available for dependency type: ${

dep.constructor.name

}`

);

let innerMap = dependencies.get(factory);

if (innerMap === undefined)

dependencies.set(factory, (innerMap = new Map()));

let list = innerMap.get(resourceIdent);

if (list === undefined) innerMap.set(resourceIdent, (list = []));

list.push(dep);

}

};

const addDependenciesBlock = block => {

if (block.dependencies) {

iterationOfArrayCallback(block.dependencies, addDependency);

}

if (block.blocks) {

iterationOfArrayCallback(block.blocks, addDependenciesBlock);

}

if (block.variables) {

iterationBlockVariable(block.variables, addDependency);

}

};

try {

addDependenciesBlock(module);

} catch (e) {

callback(e);

}

const sortedDependencies = [];

for (const pair1 of dependencies) {

for (const pair2 of pair1[1]) {

sortedDependencies.push({

factory: pair1[0],

dependencies: pair2[1]

});

}

}

this.addModuleDependencies(

module,

sortedDependencies,

this.bail,

null,

true,

callback

);

}

addModuleDependencies(

module,

dependencies,

bail,

cacheGroup,

recursive,

callback

) {

const start = this.profile && Date.now();

const currentProfile = this.profile && {};

asyncLib.forEach(

dependencies,

(item, callback) => {

const dependencies = item.dependencies;

const errorAndCallback = err => {

err.origin = module;

this.errors.push(err);

if (bail) {

callback(err);

} else {

callback();

}

};

const warningAndCallback = err => {

err.origin = module;

this.warnings.push(err);

callback();

};

const semaphore = this.semaphore;

semaphore.acquire(() => {

const factory = item.factory;

factory.create(

{

contextInfo: {

issuer: module.nameForCondition && module.nameForCondition(),

compiler: this.compiler.name

},

resolveOptions: module.resolveOptions,

context: module.context,

dependencies: dependencies

},

(err, dependentModule) => {

let afterFactory;

const isOptional = () => {

return dependencies.every(d => d.optional);

};

const errorOrWarningAndCallback = err => {

if (isOptional()) {

return warningAndCallback(err);

} else {

return errorAndCallback(err);

}

};

if (err) {

semaphore.release();

return errorOrWarningAndCallback(

new ModuleNotFoundError(module, err, dependencies)

);

}

if (!dependentModule) {

semaphore.release();

return process.nextTick(callback);

}

if (currentProfile) {

afterFactory = Date.now();

currentProfile.factory = afterFactory - start;

}

const iterationDependencies = depend => {

for (let index = 0; index < depend.length; index++) {

const dep = depend[index];

dep.module = dependentModule;

dependentModule.addReason(module, dep);

}

};

const addModuleResult = this.addModule(

dependentModule,

cacheGroup

);

dependentModule = addModuleResult.module;

iterationDependencies(dependencies);

const afterBuild = () => {

if (currentProfile) {

const afterBuilding = Date.now();

currentProfile.building = afterBuilding - afterFactory;

}

if (recursive && addModuleResult.dependencies) {

this.processModuleDependencies(dependentModule, callback);

} else {

return callback();

}

};

if (addModuleResult.issuer) {

if (currentProfile) {

dependentModule.profile = currentProfile;

}

dependentModule.issuer = module;

} else {

if (this.profile) {

if (module.profile) {

const time = Date.now() - start;

if (

!module.profile.dependencies ||

time > module.profile.dependencies

) {

module.profile.dependencies = time;

}

}

}

}

if (addModuleResult.build) {

this.buildModule(

dependentModule,

isOptional(),

module,

dependencies,

err => {

if (err) {

semaphore.release();

return errorOrWarningAndCallback(err);

}

if (currentProfile) {

const afterBuilding = Date.now();

currentProfile.building = afterBuilding - afterFactory;

}

semaphore.release();

afterBuild();

}

);

} else {

semaphore.release();

this.waitForBuildingFinished(dependentModule, afterBuild);

}

}

);

});

},

err => {

// In V8, the Error objects keep a reference to the functions on the stack. These warnings &

// errors are created inside closures that keep a reference to the Compilation, so errors are

// leaking the Compilation object.

if (err) {

err.stack = err.stack;

return callback(err);

}

return process.nextTick(callback);

}

);

}

_addModuleChain(context, dependency, onModule, callback) {

const start = this.profile && Date.now();

const currentProfile = this.profile && {};

const errorAndCallback = this.bail

? err => {

callback(err);

}

: err => {

err.dependencies = [dependency];

this.errors.push(err);

callback();

};

if (

typeof dependency !== "object" ||

dependency === null ||

!dependency.constructor

) {

throw new Error("Parameter 'dependency' must be a Dependency");

}

const moduleFactory = this.dependencyFactories.get(dependency.constructor);

if (!moduleFactory) {

throw new Error(

`No dependency factory available for this dependency type: ${

dependency.constructor.name

}`

);

}

this.semaphore.acquire(() => {

moduleFactory.create(

{

contextInfo: {

issuer: "",

compiler: this.compiler.name

},

context: context,

dependencies: [dependency]

},

(err, module) => {

if (err) {

this.semaphore.release();

return errorAndCallback(new EntryModuleNotFoundError(err));

}

let afterFactory;

if (currentProfile) {

afterFactory = Date.now();

currentProfile.factory = afterFactory - start;

}

const addModuleResult = this.addModule(module);

module = addModuleResult.module;

onModule(module);

dependency.module = module;

module.addReason(null, dependency);

const afterBuild = () => {

if (currentProfile) {

const afterBuilding = Date.now();

currentProfile.building = afterBuilding - afterFactory;

}

if (addModuleResult.dependencies) {

this.processModuleDependencies(module, err => {

if (err) return callback(err);

callback(null, module);

});

} else {

return callback(null, module);

}

};

if (addModuleResult.issuer) {

if (currentProfile) {

module.profile = currentProfile;

}

}

if (addModuleResult.build) {

this.buildModule(module, false, null, null, err => {

if (err) {

this.semaphore.release();

return errorAndCallback(err);

}

if (currentProfile) {

const afterBuilding = Date.now();

currentProfile.building = afterBuilding - afterFactory;

}

this.semaphore.release();

afterBuild();

});

} else {

this.semaphore.release();

this.waitForBuildingFinished(module, afterBuild);

}

}

);

});

}

addEntry(context, entry, name, callback) {

const slot = {

name: name,

request: entry.request,

module: null

};

this._preparedEntrypoints.push(slot);

this._addModuleChain(

context,

entry,

module => {

this.entries.push(module);

},

(err, module) => {

if (err) {

return callback(err);

}

if (module) {

slot.module = module;

} else {

const idx = this._preparedEntrypoints.indexOf(slot);

this._preparedEntrypoints.splice(idx, 1);

}

return callback(null, module);

}

);

}

prefetch(context, dependency, callback) {

this._addModuleChain(

context,

dependency,

module => {

module.prefetched = true;

},

callback

);

}

rebuildModule(module, thisCallback) {

let callbackList = this._rebuildingModules.get(module);

if (callbackList) {

callbackList.push(thisCallback);

return;

}

this._rebuildingModules.set(module, (callbackList = [thisCallback]));

const callback = err => {

this._rebuildingModules.delete(module);

for (const cb of callbackList) cb(err);

};

this.hooks.rebuildModule.call(module);

const oldDependencies = module.dependencies.slice();

const oldVariables = module.variables.slice();

const oldBlocks = module.blocks.slice();

module.unbuild();

this.buildModule(module, false, module, null, err => {

if (err) {

this.hooks.finishRebuildingModule.call(module);

return callback(err);

}

this.processModuleDependencies(module, err => {

if (err) return callback(err);

this.removeReasonsOfDependencyBlock(module, {

dependencies: oldDependencies,

variables: oldVariables,

blocks: oldBlocks

});

this.hooks.finishRebuildingModule.call(module);

callback();

});

});

}

finish() {

const modules = this.modules;

this.hooks.finishModules.call(modules);

for (let index = 0; index < modules.length; index++) {

const module = modules[index];

this.reportDependencyErrorsAndWarnings(module, [module]);

}

}

unseal() {

this.hooks.unseal.call();

this.chunks.length = 0;

this.chunkGroups.length = 0;

this.namedChunks.clear();

this.namedChunkGroups.clear();

this.additionalChunkAssets.length = 0;

this.assets = {};

for (const module of this.modules) {

module.unseal();

}

}

seal(callback) {

this.hooks.seal.call();

while (

this.hooks.optimizeDependenciesBasic.call(this.modules) ||

this.hooks.optimizeDependencies.call(this.modules) ||

this.hooks.optimizeDependenciesAdvanced.call(this.modules)

) {

/* empty */

}

this.hooks.afterOptimizeDependencies.call(this.modules);

this.nextFreeModuleIndex = 0;

this.nextFreeModuleIndex2 = 0;

for (const preparedEntrypoint of this._preparedEntrypoints) {

const module = preparedEntrypoint.module;

const name = preparedEntrypoint.name;

const chunk = this.addChunk(name);

const entrypoint = new Entrypoint(name);

entrypoint.setRuntimeChunk(chunk);

entrypoint.addOrigin(null, name, preparedEntrypoint.request);

this.namedChunkGroups.set(name, entrypoint);

this.entrypoints.set(name, entrypoint);

this.chunkGroups.push(entrypoint);

GraphHelpers.connectChunkGroupAndChunk(entrypoint, chunk);

GraphHelpers.connectChunkAndModule(chunk, module);

chunk.entryModule = module;

chunk.name = name;

this.assignIndex(module);

this.assignDepth(module);

}

this.processDependenciesBlocksForChunkGroups(this.chunkGroups.slice());

this.sortModules(this.modules);

this.hooks.optimize.call();

while (

this.hooks.optimizeModulesBasic.call(this.modules) ||

this.hooks.optimizeModules.call(this.modules) ||

this.hooks.optimizeModulesAdvanced.call(this.modules)

) {

/* empty */

}

this.hooks.afterOptimizeModules.call(this.modules);

while (

this.hooks.optimizeChunksBasic.call(this.chunks, this.chunkGroups) ||

this.hooks.optimizeChunks.call(this.chunks, this.chunkGroups) ||

this.hooks.optimizeChunksAdvanced.call(this.chunks, this.chunkGroups)

) {

/* empty */

}

this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups);

this.hooks.optimizeTree.callAsync(this.chunks, this.modules, err => {

if (err) {

return callback(err);

}

this.hooks.afterOptimizeTree.call(this.chunks, this.modules);

while (

this.hooks.optimizeChunkModulesBasic.call(this.chunks, this.modules) ||

this.hooks.optimizeChunkModules.call(this.chunks, this.modules) ||

this.hooks.optimizeChunkModulesAdvanced.call(this.chunks, this.modules)

) {

/* empty */

}

this.hooks.afterOptimizeChunkModules.call(this.chunks, this.modules);

const shouldRecord = this.hooks.shouldRecord.call() !== false;

this.hooks.reviveModules.call(this.modules, this.records);

this.hooks.optimizeModuleOrder.call(this.modules);

this.hooks.advancedOptimizeModuleOrder.call(this.modules);

this.hooks.beforeModuleIds.call(this.modules);

this.hooks.moduleIds.call(this.modules);

this.applyModuleIds();

this.hooks.optimizeModuleIds.call(this.modules);

this.hooks.afterOptimizeModuleIds.call(this.modules);

this.sortItemsWithModuleIds();

this.hooks.reviveChunks.call(this.chunks, this.records);

this.hooks.optimizeChunkOrder.call(this.chunks);

this.hooks.beforeChunkIds.call(this.chunks);

this.applyChunkIds();

this.hooks.optimizeChunkIds.call(this.chunks);

this.hooks.afterOptimizeChunkIds.call(this.chunks);

this.sortItemsWithChunkIds();

if (shouldRecord)

this.hooks.recordModules.call(this.modules, this.records);

if (shouldRecord) this.hooks.recordChunks.call(this.chunks, this.records);

this.hooks.beforeHash.call();

this.createHash();

this.hooks.afterHash.call();

if (shouldRecord) this.hooks.recordHash.call(this.records);

this.hooks.beforeModuleAssets.call();

this.createModuleAssets();

if (this.hooks.shouldGenerateChunkAssets.call() !== false) {

this.hooks.beforeChunkAssets.call();

this.createChunkAssets();

}

this.hooks.additionalChunkAssets.call(this.chunks);

this.summarizeDependencies();

if (shouldRecord) this.hooks.record.call(this, this.records);

this.hooks.additionalAssets.callAsync(err => {

if (err) {

return callback(err);

}

this.hooks.optimizeChunkAssets.callAsync(this.chunks, err => {

if (err) {

return callback(err);

}

this.hooks.afterOptimizeChunkAssets.call(this.chunks);

this.hooks.optimizeAssets.callAsync(this.assets, err => {

if (err) {

return callback(err);

}

this.hooks.afterOptimizeAssets.call(this.assets);

if (this.hooks.needAdditionalSeal.call()) {

this.unseal();

return this.seal(callback);

}

return this.hooks.afterSeal.callAsync(callback);

});

});

});

});

}

sortModules(modules) {

modules.sort(byIndexOrIdentifier);

}

reportDependencyErrorsAndWarnings(module, blocks) {

for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {

const block = blocks[indexBlock];

const dependencies = block.dependencies;

for (let indexDep = 0; indexDep < dependencies.length; indexDep++) {

const d = dependencies[indexDep];

const warnings = d.getWarnings();

if (warnings) {

for (let indexWar = 0; indexWar < warnings.length; indexWar++) {

const w = warnings[indexWar];

const warning = new ModuleDependencyWarning(module, w, d.loc);

this.warnings.push(warning);

}

}

const errors = d.getErrors();

if (errors) {

for (let indexErr = 0; indexErr < errors.length; indexErr++) {

const e = errors[indexErr];

const error = new ModuleDependencyError(module, e, d.loc);