webpack 3.3.0 → 3.5.1

package/lib/SourceMapDevToolPlugin.js

@@ -17,6 +17,38 @@ const basename = (name) => {
 	return name.substr(name.lastIndexOf("/") + 1);
 };
 
+function getTaskForFile(file, chunk, options, compilation) {
+	const asset = compilation.assets[file];
+	if(asset.__SourceMapDevToolFile === file && asset.__SourceMapDevToolData) {
+		const data = asset.__SourceMapDevToolData;
+		for(const cachedFile in data) {
+			compilation.assets[cachedFile] = data[cachedFile];
+			if(cachedFile !== file)
+				chunk.files.push(cachedFile);
+		}
+		return;
+	}
+	let source, sourceMap;
+	if(asset.sourceAndMap) {
+		const sourceAndMap = asset.sourceAndMap(options);
+		sourceMap = sourceAndMap.map;
+		source = sourceAndMap.source;
+	} else {
+		sourceMap = asset.map(options);
+		source = asset.source();
+	}
+	if(sourceMap) {
+		return {
+			chunk,
+			file,
+			asset,
+			source,
+			sourceMap,
+			modules: undefined
+		};
+	}
+}
+
 class SourceMapDevToolPlugin {
 	constructor(options) {
 		if(arguments.length > 1)
@@ -43,57 +75,41 @@ class SourceMapDevToolPlugin {
 		const requestShortener = new RequestShortener(compiler.context);
 		const options = this.options;
 		options.test = options.test || /\.(js|css)($|\?)/i;
+
+		const matchObject = ModuleFilenameHelpers.matchObject.bind(undefined, options);
+
 		compiler.plugin("compilation", compilation => {
 			new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
+
 			compilation.plugin("after-optimize-chunk-assets", function(chunks) {
 				const moduleToSourceNameMapping = new Map();
 				const tasks = [];
+
 				chunks.forEach(function(chunk) {
-					chunk.files.filter(ModuleFilenameHelpers.matchObject.bind(undefined, options)).map(function(file) {
-						const asset = compilation.assets[file];
-						if(asset.__SourceMapDevToolFile === file && asset.__SourceMapDevToolData) {
-							const data = asset.__SourceMapDevToolData;
-							for(const cachedFile in data) {
-								compilation.assets[cachedFile] = data[cachedFile];
-								if(cachedFile !== file)
-									chunk.files.push(cachedFile);
-							}
-							return;
-						}
-						let source, sourceMap;
-						if(asset.sourceAndMap) {
-							const sourceAndMap = asset.sourceAndMap(options);
-							sourceMap = sourceAndMap.map;
-							source = sourceAndMap.source;
-						} else {
-							sourceMap = asset.map(options);
-							source = asset.source();
-						}
-						if(sourceMap) {
-							return {
-								chunk,
-								file,
-								asset,
-								source,
-								sourceMap
-							};
-						}
-					}).filter(Boolean).map(task => {
-						const modules = task.sourceMap.sources.map(source => {
-							const module = compilation.findModule(source);
-							return module || source;
-						});
-						for(const module of modules) {
-							if(!moduleToSourceNameMapping.get(module)) {
-								moduleToSourceNameMapping.set(module, ModuleFilenameHelpers.createFilename(module, moduleFilenameTemplate, requestShortener));
+					chunk.files.forEach(file => {
+						if(matchObject(file)) {
+							const task = getTaskForFile(file, chunk, options, compilation);
+
+							if(task) {
+								const modules = task.sourceMap.sources.map(source => {
+									const module = compilation.findModule(source);
+									return module || source;
+								});
+
+								for(const module of modules) {
+									if(!moduleToSourceNameMapping.get(module)) {
+										moduleToSourceNameMapping.set(module, ModuleFilenameHelpers.createFilename(module, moduleFilenameTemplate, requestShortener));
+									}
+								}
+
+								task.modules = modules;
+
+								tasks.push(task);
 							}
 						}
-						task.modules = modules;
-						return task;
-					}).forEach(task => {
-						tasks.push(task);
 					});
 				});
+
 				const usedNamesSet = new Set(moduleToSourceNameMapping.values());
 				const conflictDetectionSet = new Set();
 

package/lib/Stats.js

@@ -7,8 +7,13 @@
 const RequestShortener = require("./RequestShortener");
 const SizeFormatHelpers = require("./SizeFormatHelpers");
 const formatLocation = require("./formatLocation");
+const identifierUtils = require("./util/identifier");
 
-const optionOrFallback = (optionValue, fallbackValue) => typeof optionValue !== "undefined" ? optionValue : fallbackValue;
+const optionsOrFallback = function() {
+	let optionValues = [];
+	optionValues.push.apply(optionValues, arguments);
+	return optionValues.find(optionValue => typeof optionValue !== "undefined");
+};
 
 class Stats {
 	constructor(compilation) {
@@ -79,8 +84,20 @@ class Stats {
 			typeof v !== "undefined" ? v :
 			typeof options.all !== "undefined" ? options.all : def;
 
+		const testAgainstGivenOption = (item) => {
+			if(typeof item === "string") {
+				const regExp = new RegExp(`[\\\\/]${item.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")}([\\\\/]|$|!|\\?)`); // eslint-disable-line no-useless-escape
+				return ident => regExp.test(ident);
+			}
+			if(item && typeof item === "object" && typeof item.test === "function")
+				return ident => item.test(ident);
+			if(typeof item === "function")
+				return item;
+		};
+
 		const compilation = this.compilation;
-		const requestShortener = new RequestShortener(optionOrFallback(options.context, process.cwd()));
+		const context = optionsOrFallback(options.context, process.cwd());
+		const requestShortener = new RequestShortener(context);
 		const showPerformance = optionOrLocalFallback(options.performance, true);
 		const showHash = optionOrLocalFallback(options.hash, true);
 		const showVersion = optionOrLocalFallback(options.version, true);
@@ -104,22 +121,14 @@ class Stats {
 		const showErrors = optionOrLocalFallback(options.errors, true);
 		const showErrorDetails = optionOrLocalFallback(options.errorDetails, !forToString);
 		const showWarnings = optionOrLocalFallback(options.warnings, true);
-		const warningsFilter = optionOrFallback(options.warningsFilter, null);
+		const warningsFilter = optionsOrFallback(options.warningsFilter, null);
 		const showPublicPath = optionOrLocalFallback(options.publicPath, !forToString);
-		const excludeModules = [].concat(optionOrFallback(options.exclude, [])).map(item => {
-			if(typeof item === "string") {
-				const regExp = new RegExp(`[\\\\/]${item.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")}([\\\\/]|$|!|\\?)`);
-				return ident => regExp.test(ident);
-			}
-			if(item && typeof item === "object" && typeof item.test === "function")
-				return ident => item.test(ident);
-			if(typeof item === "function")
-				return item;
-		});
-		const maxModules = optionOrFallback(options.maxModules, forToString ? 15 : Infinity);
-		const sortModules = optionOrFallback(options.modulesSort, "id");
-		const sortChunks = optionOrFallback(options.chunksSort, "id");
-		const sortAssets = optionOrFallback(options.assetsSort, "");
+		const excludeModules = [].concat(optionsOrFallback(options.excludeModules, options.exclude, [])).map(testAgainstGivenOption);
+		const excludeAssets = [].concat(optionsOrFallback(options.excludeAssets, [])).map(testAgainstGivenOption);
+		const maxModules = optionsOrFallback(options.maxModules, forToString ? 15 : Infinity);
+		const sortModules = optionsOrFallback(options.modulesSort, "id");
+		const sortChunks = optionsOrFallback(options.chunksSort, "id");
+		const sortAssets = optionsOrFallback(options.assetsSort, "");
 
 		if(!showCachedModules) {
 			excludeModules.push((ident, module) => !module.built);
@@ -138,6 +147,18 @@ class Stats {
 			};
 		};
 
+		const createAssetFilter = () => {
+			return asset => {
+				if(excludeAssets.length > 0) {
+					const ident = asset.name;
+					const excluded = excludeAssets.some(fn => fn(ident, asset));
+					if(excluded)
+						return false;
+				}
+				return showCachedAssets || asset.emitted;
+			};
+		};
+
 		const sortByFieldAndOrder = (fieldKey, a, b) => {
 			if(a[fieldKey] === null && b[fieldKey] === null) return 0;
 			if(a[fieldKey] === null) return 1;
@@ -229,8 +250,9 @@ class Stats {
 		}
 		if(showAssets) {
 			const assetsByFile = {};
+			const compilationAssets = Object.keys(compilation.assets);
 			obj.assetsByChunkName = {};
-			obj.assets = Object.keys(compilation.assets).map(asset => {
+			obj.assets = compilationAssets.map(asset => {
 				const obj = {
 					name: asset,
 					size: compilation.assets[asset].size(),
@@ -245,7 +267,8 @@ class Stats {
 
 				assetsByFile[asset] = obj;
 				return obj;
-			}).filter(asset => showCachedAssets || asset.emitted);
+			}).filter(createAssetFilter());
+			obj.filteredAssets = compilationAssets.length - obj.assets.length;
 
 			compilation.chunks.forEach(chunk => {
 				chunk.files.forEach(asset => {
@@ -391,7 +414,8 @@ class Stats {
 				const obj = new Stats(child).toJson(childOptions, forToString);
 				delete obj.hash;
 				delete obj.version;
-				obj.name = child.name;
+				if(child.name)
+					obj.name = identifierUtils.makePathsRelative(context, child.name, compilation.cache);
 				return obj;
 			});
 		}
@@ -406,7 +430,7 @@ class Stats {
 			options = {};
 		}
 
-		const useColors = optionOrFallback(options.colors, false);
+		const useColors = optionsOrFallback(options.colors, false);
 
 		const obj = this.toJson(options, true);
 
@@ -573,6 +597,16 @@ class Stats {
 			});
 			table(t, "rrrlll");
 		}
+		if(obj.filteredAssets > 0) {
+			colors.normal(" ");
+			if(obj.assets.length > 0)
+				colors.normal("+ ");
+			colors.normal(obj.filteredAssets);
+			if(obj.assets.length > 0)
+				colors.normal(" hidden");
+			colors.normal(obj.filteredAssets !== 1 ? " assets" : " asset");
+			newline();
+		}
 		if(obj.entrypoints) {
 			Object.keys(obj.entrypoints).forEach(name => {
 				const ep = obj.entrypoints[name];
@@ -650,7 +684,7 @@ class Stats {
 			if(module.usedExports !== undefined) {
 				if(module.usedExports !== true) {
 					colors.normal(prefix);
-					if(module.usedExports === false)
+					if(module.usedExports === false || module.usedExports.length === 0)
 						colors.cyan("[no exports used]");
 					else
 						colors.cyan(`[only some exports used: ${module.usedExports.join(", ")}]`);
@@ -687,9 +721,9 @@ class Stats {
 				const path = [];
 				let current = module;
 				while(current.issuer) {
-					path.unshift(current = current.issuer);
+					path.push(current = current.issuer);
 				}
-				path.forEach(module => {
+				path.reverse().forEach(module => {
 					colors.normal("[");
 					colors.normal(module.id);
 					colors.normal("] ");

package/lib/Template.js

@@ -28,7 +28,7 @@ module.exports = class Template extends Tapable {
 
 	static toPath(str) {
 		if(typeof str !== "string") return "";
-		return str.replace(/[^a-zA-Z0-9_!§$()=\-\^°]+/g, "-").replace(/^-|-$/, "");
+		return str.replace(/[^a-zA-Z0-9_!§$()=\-^°]+/g, "-").replace(/^-|-$/, "");
 	}
 
 	// map number to a single character a-z, A-Z or <_ + number> if number is too big

package/lib/dependencies/DelegatedExportsDependency.js

@@ -0,0 +1,33 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class DelegatedExportsDependency extends NullDependency {
+	constructor(originModule, exports) {
+		super();
+		this.originModule = originModule;
+		this.exports = exports;
+	}
+
+	get type() {
+		return "delegated exports";
+	}
+
+	getReference() {
+		return {
+			module: this.originModule,
+			importedNames: true
+		};
+	}
+
+	getExports() {
+		return {
+			exports: this.exports
+		};
+	}
+}
+
+module.exports = DelegatedExportsDependency;

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -21,7 +21,7 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 		const usedExports = dep.originModule.usedExports;
 		if(usedExports && !Array.isArray(usedExports)) {
 			const exportName = dep.originModule.exportsArgument || "exports";
-			const content = `Object.defineProperty(${exportName}, \"__esModule\", { value: true });\n`;
+			const content = `Object.defineProperty(${exportName}, "__esModule", { value: true });\n`;
 			source.insert(-10, content);
 		}
 	}

package/lib/dependencies/ImportParserPlugin.js

@@ -5,6 +5,8 @@
 "use strict";
 
 const ImportEagerContextDependency = require("./ImportEagerContextDependency");
+const ImportWeakDependency = require("./ImportWeakDependency");
+const ImportWeakContextDependency = require("./ImportWeakContextDependency");
 const ImportLazyOnceContextDependency = require("./ImportLazyOnceContextDependency");
 const ImportLazyContextDependency = require("./ImportLazyContextDependency");
 const ImportDependenciesBlock = require("./ImportDependenciesBlock");
@@ -46,26 +48,31 @@ class ImportParserPlugin {
 			}
 
 			if(param.isString()) {
-				if(mode !== "lazy" && mode !== "eager") {
-					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy' or 'eager', but received: ${mode}.`));
+				if(mode !== "lazy" && mode !== "eager" && mode !== "weak") {
+					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`));
 				}
 
 				if(mode === "eager") {
 					const dep = new ImportEagerDependency(param.string, expr.range);
 					parser.state.current.addDependency(dep);
+				} else if(mode === "weak") {
+					const dep = new ImportWeakDependency(param.string, expr.range);
+					parser.state.current.addDependency(dep);
 				} else {
 					const depBlock = new ImportDependenciesBlock(param.string, expr.range, chunkName, parser.state.module, expr.loc);
 					parser.state.current.addBlock(depBlock);
 				}
 				return true;
 			} else {
-				if(mode !== "lazy" && mode !== "lazy-once" && mode !== "eager") {
-					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy', 'lazy-once' or 'eager', but received: ${mode}.`));
+				if(mode !== "lazy" && mode !== "lazy-once" && mode !== "eager" && mode !== "weak") {
+					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`));
 				}
 
 				let Dep = ImportLazyContextDependency;
 				if(mode === "eager") {
 					Dep = ImportEagerContextDependency;
+				} else if(mode === "weak") {
+					Dep = ImportWeakContextDependency;
 				} else if(mode === "lazy-once") {
 					Dep = ImportLazyOnceContextDependency;
 				}

package/lib/dependencies/ImportPlugin.js

@@ -6,7 +6,9 @@
 
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
+const ImportWeakDependency = require("./ImportWeakDependency");
 const ImportEagerContextDependency = require("./ImportEagerContextDependency");
+const ImportWeakContextDependency = require("./ImportWeakContextDependency");
 const ImportLazyOnceContextDependency = require("./ImportLazyOnceContextDependency");
 const ImportLazyContextDependency = require("./ImportLazyContextDependency");
 const ImportParserPlugin = require("./ImportParserPlugin");
@@ -28,9 +30,15 @@ class ImportPlugin {
 			compilation.dependencyFactories.set(ImportEagerDependency, normalModuleFactory);
 			compilation.dependencyTemplates.set(ImportEagerDependency, new ImportEagerDependency.Template());
 
+			compilation.dependencyFactories.set(ImportWeakDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(ImportWeakDependency, new ImportWeakDependency.Template());
+
 			compilation.dependencyFactories.set(ImportEagerContextDependency, contextModuleFactory);
 			compilation.dependencyTemplates.set(ImportEagerContextDependency, new ImportEagerContextDependency.Template());
 
+			compilation.dependencyFactories.set(ImportWeakContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportWeakContextDependency, new ImportWeakContextDependency.Template());
+
 			compilation.dependencyFactories.set(ImportLazyOnceContextDependency, contextModuleFactory);
 			compilation.dependencyTemplates.set(ImportLazyOnceContextDependency, new ImportLazyOnceContextDependency.Template());
 

package/lib/dependencies/ImportWeakContextDependency.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ImportContextDependency = require("./ImportContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportWeakContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "async-weak";
+	}
+
+	get type() {
+		return "import() context weak";
+	}
+}
+
+ImportWeakContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportWeakContextDependency;

package/lib/dependencies/ImportWeakDependency.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const webpackMissingPromiseModule = require("./WebpackMissingModule").promise;
+
+class ImportWeakDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+		this.weak = true;
+	}
+
+	get type() {
+		return "import() weak";
+	}
+}
+
+ImportWeakDependency.Template = class ImportDependencyTemplate {
+	apply(dep, source, outputOptions, requestShortener) {
+		const comment = this.getOptionalComment(outputOptions.pathinfo, requestShortener.shorten(dep.request));
+
+		const content = this.getContent(dep, comment);
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+
+	getOptionalComment(pathinfo, shortenedRequest) {
+		if(!pathinfo) {
+			return "";
+		}
+
+		return `/*! ${shortenedRequest} */ `;
+	}
+
+	getContent(dep, comment) {
+		if(dep.module) {
+			const stringifiedId = JSON.stringify(dep.module.id);
+			return `Promise.resolve(${comment}${stringifiedId}).then(function(id) { if(!__webpack_require__.m[id]) throw new Error("Module '" + id + "' is not available (weak dependency)"); return __webpack_require__(id); })`;
+		}
+
+		return webpackMissingPromiseModule(dep.request);
+	}
+};
+
+module.exports = ImportWeakDependency;

package/lib/dependencies/RequireContextDependency.js

@@ -7,9 +7,13 @@ const ContextDependency = require("./ContextDependency");
 const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
 
 class RequireContextDependency extends ContextDependency {
-	constructor(request, recursive, regExp, range) {
+	constructor(request, recursive, regExp, asyncMode, range) {
 		super(request, recursive, regExp);
 		this.range = range;
+
+		if(asyncMode) {
+			this.async = asyncMode;
+		}
 	}
 
 	get type() {

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -11,7 +11,15 @@ module.exports = class RequireContextDependencyParserPlugin {
 		parser.plugin("call require.context", expr => {
 			let regExp = /^\.\/.*$/;
 			let recursive = true;
+			let asyncMode;
 			switch(expr.arguments.length) {
+				case 4:
+					{
+						const asyncModeExpr = parser.evaluateExpression(expr.arguments[3]);
+						if(!asyncModeExpr.isString()) return;
+						asyncMode = asyncModeExpr.string;
+					}
+					// falls through
 				case 3:
 					{
 						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
@@ -30,7 +38,7 @@ module.exports = class RequireContextDependencyParserPlugin {
 					{
 						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
 						if(!requestExpr.isString()) return;
-						const dep = new RequireContextDependency(requestExpr.string, recursive, regExp, expr.range);
+						const dep = new RequireContextDependency(requestExpr.string, recursive, regExp, asyncMode, expr.range);
 						dep.loc = expr.loc;
 						dep.optional = parser.scope.inTry;
 						parser.state.current.addDependency(dep);

package/lib/dependencies/RequireResolveDependencyParserPlugin.js

@@ -62,7 +62,7 @@ class RequireResolveDependencyParserPlugin {
 			if(!dep) return;
 			dep.loc = expr.loc;
 			dep.optional = !!parser.scope.inTry;
-			dep.weak = weak;
+			dep.async = weak ? "weak" : false;
 			parser.state.current.addDependency(dep);
 			return true;
 		});

package/lib/optimize/AggressiveMergingPlugin.js

@@ -31,86 +31,80 @@ class AggressiveMergingPlugin {
 					for(let i = 0; i < idx; i++) {
 						const b = chunks[i];
 						if(b.isInitial()) continue;
-						combinations.push([b, a]);
+						combinations.push({
+							a,
+							b,
+							improvement: undefined
+						});
 					}
 				});
 
 				combinations.forEach((pair) => {
-					const a = pair[0].size({
+					const a = pair.b.size({
 						chunkOverhead: 0
 					});
-					const b = pair[1].size({
+					const b = pair.a.size({
 						chunkOverhead: 0
 					});
-					const ab = pair[0].integratedSize(pair[1], {
+					const ab = pair.b.integratedSize(pair.a, {
 						chunkOverhead: 0
 					});
-					pair.push({
-						a: a,
-						b: b,
-						ab: ab
-					});
 					let newSize;
 					if(ab === false) {
-						pair.unshift(false);
+						pair.improvement = false;
+						return;
 					} else if(options.moveToParents) {
 						const aOnly = ab - b;
 						const bOnly = ab - a;
 						const common = a + b - ab;
-						newSize = common + getParentsWeight(pair[0]) * aOnly + getParentsWeight(pair[1]) * bOnly;
-						pair.push({
-							aOnly: aOnly,
-							bOnly: bOnly,
-							common: common,
-							newSize: newSize
-						});
+						newSize = common + getParentsWeight(pair.b) * aOnly + getParentsWeight(pair.a) * bOnly;
 					} else {
 						newSize = ab;
 					}
 
-					pair.unshift((a + b) / newSize);
+					pair.improvement = (a + b) / newSize;
 				});
 				combinations = combinations.filter((pair) => {
-					return pair[0] !== false;
+					return pair.improvement !== false;
 				});
 				combinations.sort((a, b) => {
-					return b[0] - a[0];
+					return b.improvement - a.improvement;
 				});
 
 				const pair = combinations[0];
 
 				if(!pair) return;
-				if(pair[0] < minSizeReduce) return;
+				if(pair.improvement < minSizeReduce) return;
 
 				if(options.moveToParents) {
-					const commonModules = pair[1].modules.filter((m) => {
-						return pair[2].modules.indexOf(m) >= 0;
+					const commonModules = pair.b.modules.filter((m) => {
+						return pair.a.modules.indexOf(m) >= 0;
 					});
-					const aOnlyModules = pair[1].modules.filter((m) => {
+					const aOnlyModules = pair.b.modules.filter((m) => {
 						return commonModules.indexOf(m) < 0;
 					});
-					const bOnlyModules = pair[2].modules.filter((m) => {
+					const bOnlyModules = pair.a.modules.filter((m) => {
 						return commonModules.indexOf(m) < 0;
 					});
 					aOnlyModules.forEach((m) => {
-						pair[1].removeModule(m);
-						m.removeChunk(pair[1]);
-						pair[1].parents.forEach((c) => {
+						pair.b.removeModule(m);
+						m.removeChunk(pair.b);
+						pair.b.parents.forEach((c) => {
 							c.addModule(m);
 							m.addChunk(c);
 						});
 					});
 					bOnlyModules.forEach((m) => {
-						pair[2].removeModule(m);
-						m.removeChunk(pair[2]);
-						pair[2].parents.forEach((c) => {
+						pair.a.removeModule(m);
+						m.removeChunk(pair.a);
+						pair.a.parents.forEach((c) => {
 							c.addModule(m);
 							m.addChunk(c);
 						});
 					});
 				}
-				if(pair[1].integrate(pair[2], "aggressive-merge")) {
-					chunks.splice(chunks.indexOf(pair[2]), 1);
+				if(pair.b.integrate(pair.a, "aggressive-merge")) {
+					chunks.splice(chunks.indexOf(pair.a), 1);
 					return true;
 				}
 			});