node_modules/webpack/lib/optimize/ModuleConcatenationPlugin.js - nifi-fds - Git at Google

 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 "use strict";

 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const ModuleHotAcceptDependency = require("../dependencies/ModuleHotAcceptDependency");
 const ModuleHotDeclineDependency = require("../dependencies/ModuleHotDeclineDependency");
 const ConcatenatedModule = require("./ConcatenatedModule");
 const HarmonyCompatibilityDependency = require("../dependencies/HarmonyCompatibilityDependency");
 const StackedSetMap = require("../util/StackedSetMap");

 const formatBailoutReason = msg => {
 	return "ModuleConcatenation bailout: " + msg;
 };

 class ModuleConcatenationPlugin {
 	constructor(options) {
 		if (typeof options !== "object") options = {};
 		this.options = options;
 	}

 	apply(compiler) {
 		compiler.hooks.compilation.tap(
 			"ModuleConcatenationPlugin",
 			(compilation, { normalModuleFactory }) => {
 				const handler = (parser, parserOptions) => {
 					parser.hooks.call.for("eval").tap("ModuleConcatenationPlugin", () => {
 						// Because of variable renaming we can't use modules with eval.
 						parser.state.module.buildMeta.moduleConcatenationBailout = "eval()";
 					});
 				};

 				normalModuleFactory.hooks.parser
 					.for("javascript/auto")
 					.tap("ModuleConcatenationPlugin", handler);
 				normalModuleFactory.hooks.parser
 					.for("javascript/dynamic")
 					.tap("ModuleConcatenationPlugin", handler);
 				normalModuleFactory.hooks.parser
 					.for("javascript/esm")
 					.tap("ModuleConcatenationPlugin", handler);

 				const bailoutReasonMap = new Map();

 				const setBailoutReason = (module, reason) => {
 					bailoutReasonMap.set(module, reason);
 					module.optimizationBailout.push(
 						typeof reason === "function"
 							? rs => formatBailoutReason(reason(rs))
 							: formatBailoutReason(reason)
 					);
 				};

 				const getBailoutReason = (module, requestShortener) => {
 					const reason = bailoutReasonMap.get(module);
 					if (typeof reason === "function") return reason(requestShortener);
 					return reason;
 				};

 				compilation.hooks.optimizeChunkModules.tap(
 					"ModuleConcatenationPlugin",
 					(allChunks, modules) => {
 						const relevantModules = [];
 						const possibleInners = new Set();
 						for (const module of modules) {
 							// Only harmony modules are valid for optimization
 							if (
 								!module.buildMeta ||
 								module.buildMeta.exportsType !== "namespace" ||
 								!module.dependencies.some(
 									d => d instanceof HarmonyCompatibilityDependency
 								)
 							) {
 								setBailoutReason(module, "Module is not an ECMAScript module");
 								continue;
 							}

 							// Some expressions are not compatible with module concatenation
 							// because they may produce unexpected results. The plugin bails out
 							// if some were detected upfront.
 							if (
 								module.buildMeta &&
 								module.buildMeta.moduleConcatenationBailout
 							) {
 								setBailoutReason(
 									module,
 									`Module uses ${module.buildMeta.moduleConcatenationBailout}`
 								);
 								continue;
 							}

 							// Exports must be known (and not dynamic)
 							if (!Array.isArray(module.buildMeta.providedExports)) {
 								setBailoutReason(module, "Module exports are unknown");
 								continue;
 							}

 							// Using dependency variables is not possible as this wraps the code in a function
 							if (module.variables.length > 0) {
 								setBailoutReason(
 									module,
 									`Module uses injected variables (${module.variables
 										.map(v => v.name)
 										.join(", ")})`
 								);
 								continue;
 							}

 							// Hot Module Replacement need it's own module to work correctly
 							if (
 								module.dependencies.some(
 									dep =>
 										dep instanceof ModuleHotAcceptDependency ||
 										dep instanceof ModuleHotDeclineDependency
 								)
 							) {
 								setBailoutReason(module, "Module uses Hot Module Replacement");
 								continue;
 							}

 							relevantModules.push(module);

 							// Module must not be the entry points
 							if (module.isEntryModule()) {
 								setBailoutReason(module, "Module is an entry point");
 								continue;
 							}

 							// Module must be in any chunk (we don't want to do useless work)
 							if (module.getNumberOfChunks() === 0) {
 								setBailoutReason(module, "Module is not in any chunk");
 								continue;
 							}

 							// Module must only be used by Harmony Imports
 							const nonHarmonyReasons = module.reasons.filter(
 								reason =>
 									!reason.dependency ||
 									!(reason.dependency instanceof HarmonyImportDependency)
 							);
 							if (nonHarmonyReasons.length > 0) {
 								const importingModules = new Set(
 									nonHarmonyReasons.map(r => r.module).filter(Boolean)
 								);
 								const importingExplanations = new Set(
 									nonHarmonyReasons.map(r => r.explanation).filter(Boolean)
 								);
 								const importingModuleTypes = new Map(
 									Array.from(importingModules).map(
 										m => /** @type {[string, Set]} */ ([
 											m,
 											new Set(
 												nonHarmonyReasons
 													.filter(r => r.module === m)
 													.map(r => r.dependency.type)
 													.sort()
 											)
 										])
 									)
 								);
 								setBailoutReason(module, requestShortener => {
 									const names = Array.from(importingModules)
 										.map(
 											m =>
 												`${m.readableIdentifier(
 													requestShortener
 												)} (referenced with ${Array.from(
 													importingModuleTypes.get(m)
 												).join(", ")})`
 										)
 										.sort();
 									const explanations = Array.from(importingExplanations).sort();
 									if (names.length > 0 && explanations.length === 0) {
 										return `Module is referenced from these modules with unsupported syntax: ${names.join(
 											", "
 										)}`;
 									} else if (names.length === 0 && explanations.length > 0) {
 										return `Module is referenced by: ${explanations.join(
 											", "
 										)}`;
 									} else if (names.length > 0 && explanations.length > 0) {
 										return `Module is referenced from these modules with unsupported syntax: ${names.join(
 											", "
 										)} and by: ${explanations.join(", ")}`;
 									} else {
 										return "Module is referenced in a unsupported way";
 									}
 								});
 								continue;
 							}

 							possibleInners.add(module);
 						}
 						// sort by depth
 						// modules with lower depth are more likely suited as roots
 						// this improves performance, because modules already selected as inner are skipped
 						relevantModules.sort((a, b) => {
 							return a.depth - b.depth;
 						});
 						const concatConfigurations = [];
 						const usedAsInner = new Set();
 						for (const currentRoot of relevantModules) {
 							// when used by another configuration as inner:
 							// the other configuration is better and we can skip this one
 							if (usedAsInner.has(currentRoot)) continue;

 							// create a configuration with the root
 							const currentConfiguration = new ConcatConfiguration(currentRoot);

 							// cache failures to add modules
 							const failureCache = new Map();

 							// try to add all imports
 							for (const imp of this._getImports(compilation, currentRoot)) {
 								const problem = this._tryToAdd(
 									compilation,
 									currentConfiguration,
 									imp,
 									possibleInners,
 									failureCache
 								);
 								if (problem) {
 									failureCache.set(imp, problem);
 									currentConfiguration.addWarning(imp, problem);
 								}
 							}
 							if (!currentConfiguration.isEmpty()) {
 								concatConfigurations.push(currentConfiguration);
 								for (const module of currentConfiguration.getModules()) {
 									if (module !== currentConfiguration.rootModule) {
 										usedAsInner.add(module);
 									}
 								}
 							}
 						}
 						// HACK: Sort configurations by length and start with the longest one
 						// to get the biggers groups possible. Used modules are marked with usedModules
 						// TODO: Allow to reuse existing configuration while trying to add dependencies.
 						// This would improve performance. O(n^2) -> O(n)
 						concatConfigurations.sort((a, b) => {
 							return b.modules.size - a.modules.size;
 						});
 						const usedModules = new Set();
 						for (const concatConfiguration of concatConfigurations) {
 							if (usedModules.has(concatConfiguration.rootModule)) continue;
 							const modules = concatConfiguration.getModules();
 							const rootModule = concatConfiguration.rootModule;
 							const newModule = new ConcatenatedModule(
 								rootModule,
 								Array.from(modules),
 								ConcatenatedModule.createConcatenationList(
 									rootModule,
 									modules,
 									compilation
 								)
 							);
 							for (const warning of concatConfiguration.getWarningsSorted()) {
 								newModule.optimizationBailout.push(requestShortener => {
 									const reason = getBailoutReason(warning[0], requestShortener);
 									const reasonWithPrefix = reason ? ` (<- ${reason})` : "";
 									if (warning[0] === warning[1]) {
 										return formatBailoutReason(
 											`Cannot concat with ${warning[0].readableIdentifier(
 												requestShortener
 											)}${reasonWithPrefix}`
 										);
 									} else {
 										return formatBailoutReason(
 											`Cannot concat with ${warning[0].readableIdentifier(
 												requestShortener
 											)} because of ${warning[1].readableIdentifier(
 												requestShortener
 											)}${reasonWithPrefix}`
 										);
 									}
 								});
 							}
 							const chunks = concatConfiguration.rootModule.getChunks();
 							for (const m of modules) {
 								usedModules.add(m);
 								for (const chunk of chunks) {
 									chunk.removeModule(m);
 								}
 							}
 							for (const chunk of chunks) {
 								chunk.addModule(newModule);
 								newModule.addChunk(chunk);
 							}
 							for (const chunk of allChunks) {
 								if (chunk.entryModule === concatConfiguration.rootModule) {
 									chunk.entryModule = newModule;
 								}
 							}
 							compilation.modules.push(newModule);
 							for (const reason of newModule.reasons) {
 								if (reason.dependency.module === concatConfiguration.rootModule)
 									reason.dependency.module = newModule;
 								if (
 									reason.dependency.redirectedModule ===
 									concatConfiguration.rootModule
 								)
 									reason.dependency.redirectedModule = newModule;
 							}
 							// TODO: remove when LTS node version contains fixed v8 version
 							// @see https://github.com/webpack/webpack/pull/6613
 							// Turbofan does not correctly inline for-of loops with polymorphic input arrays.
 							// Work around issue by using a standard for loop and assigning dep.module.reasons
 							for (let i = 0; i < newModule.dependencies.length; i++) {
 								let dep = newModule.dependencies[i];
 								if (dep.module) {
 									let reasons = dep.module.reasons;
 									for (let j = 0; j < reasons.length; j++) {
 										let reason = reasons[j];
 										if (reason.dependency === dep) {
 											reason.module = newModule;
 										}
 									}
 								}
 							}
 						}
 						compilation.modules = compilation.modules.filter(
 							m => !usedModules.has(m)
 						);
 					}
 				);
 			}
 		);
 	}

 	_getImports(compilation, module) {
 		return new Set(
 			module.dependencies

 				// Get reference info only for harmony Dependencies
 				.map(dep => {
 					if (!(dep instanceof HarmonyImportDependency)) return null;
 					if (!compilation) return dep.getReference();
 					return compilation.getDependencyReference(module, dep);
 				})

 				// Reference is valid and has a module
 				// Dependencies are simple enough to concat them
 				.filter(
 					ref =>
 						ref &&
 						ref.module &&
 						(Array.isArray(ref.importedNames) ||
 							Array.isArray(ref.module.buildMeta.providedExports))
 				)

 				// Take the imported module
 				.map(ref => ref.module)
 		);
 	}

 	_tryToAdd(compilation, config, module, possibleModules, failureCache) {
 		const cacheEntry = failureCache.get(module);
 		if (cacheEntry) {
 			return cacheEntry;
 		}

 		// Already added?
 		if (config.has(module)) {
 			return null;
 		}

 		// Not possible to add?
 		if (!possibleModules.has(module)) {
 			failureCache.set(module, module); // cache failures for performance
 			return module;
 		}

 		// module must be in the same chunks
 		if (!config.rootModule.hasEqualsChunks(module)) {
 			failureCache.set(module, module); // cache failures for performance
 			return module;
 		}

 		// Clone config to make experimental changes
 		const testConfig = config.clone();

 		// Add the module
 		testConfig.add(module);

 		// Every module which depends on the added module must be in the configuration too.
 		for (const reason of module.reasons) {
 			// Modules that are not used can be ignored
 			if (
 				reason.module.factoryMeta.sideEffectFree &&
 				reason.module.used === false
 			)
 				continue;

 			const problem = this._tryToAdd(
 				compilation,
 				testConfig,
 				reason.module,
 				possibleModules,
 				failureCache
 			);
 			if (problem) {
 				failureCache.set(module, problem); // cache failures for performance
 				return problem;
 			}
 		}

 		// Commit experimental changes
 		config.set(testConfig);

 		// Eagerly try to add imports too if possible
 		for (const imp of this._getImports(compilation, module)) {
 			const problem = this._tryToAdd(
 				compilation,
 				config,
 				imp,
 				possibleModules,
 				failureCache
 			);
 			if (problem) {
 				config.addWarning(imp, problem);
 			}
 		}
 		return null;
 	}
 }

 class ConcatConfiguration {
 	constructor(rootModule, cloneFrom) {
 		this.rootModule = rootModule;
 		if (cloneFrom) {
 			this.modules = cloneFrom.modules.createChild(5);
 			this.warnings = cloneFrom.warnings.createChild(5);
 		} else {
 			this.modules = new StackedSetMap();
 			this.modules.add(rootModule);
 			this.warnings = new StackedSetMap();
 		}
 	}

 	add(module) {
 		this.modules.add(module);
 	}

 	has(module) {
 		return this.modules.has(module);
 	}

 	isEmpty() {
 		return this.modules.size === 1;
 	}

 	addWarning(module, problem) {
 		this.warnings.set(module, problem);
 	}

 	getWarningsSorted() {
 		return new Map(
 			this.warnings.asPairArray().sort((a, b) => {
 				const ai = a[0].identifier();
 				const bi = b[0].identifier();
 				if (ai < bi) return -1;
 				if (ai > bi) return 1;
 				return 0;
 			})
 		);
 	}

 	getModules() {
 		return this.modules.asSet();
 	}

 	clone() {
 		return new ConcatConfiguration(this.rootModule, this);
 	}

 	set(config) {
 		this.rootModule = config.rootModule;
 		this.modules = config.modules;
 		this.warnings = config.warnings;
 	}
 }

 module.exports = ModuleConcatenationPlugin;
	/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
	*/
	"use strict";

	const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
	const ModuleHotAcceptDependency = require("../dependencies/ModuleHotAcceptDependency");
	const ModuleHotDeclineDependency = require("../dependencies/ModuleHotDeclineDependency");
	const ConcatenatedModule = require("./ConcatenatedModule");
	const HarmonyCompatibilityDependency = require("../dependencies/HarmonyCompatibilityDependency");
	const StackedSetMap = require("../util/StackedSetMap");

	const formatBailoutReason = msg => {
	return "ModuleConcatenation bailout: " + msg;
	};

	class ModuleConcatenationPlugin {
	constructor(options) {
	if (typeof options !== "object") options = {};
	this.options = options;
	}

	apply(compiler) {
	compiler.hooks.compilation.tap(
	"ModuleConcatenationPlugin",
	(compilation, { normalModuleFactory }) => {
	const handler = (parser, parserOptions) => {
	parser.hooks.call.for("eval").tap("ModuleConcatenationPlugin", () => {
	// Because of variable renaming we can't use modules with eval.
	parser.state.module.buildMeta.moduleConcatenationBailout = "eval()";
	});
	};

	normalModuleFactory.hooks.parser
	.for("javascript/auto")
	.tap("ModuleConcatenationPlugin", handler);
	normalModuleFactory.hooks.parser
	.for("javascript/dynamic")
	.tap("ModuleConcatenationPlugin", handler);
	normalModuleFactory.hooks.parser
	.for("javascript/esm")
	.tap("ModuleConcatenationPlugin", handler);

	const bailoutReasonMap = new Map();

	const setBailoutReason = (module, reason) => {
	bailoutReasonMap.set(module, reason);
	module.optimizationBailout.push(
	typeof reason === "function"
	? rs => formatBailoutReason(reason(rs))
	: formatBailoutReason(reason)
	);
	};

	const getBailoutReason = (module, requestShortener) => {
	const reason = bailoutReasonMap.get(module);
	if (typeof reason === "function") return reason(requestShortener);
	return reason;
	};

	compilation.hooks.optimizeChunkModules.tap(
	"ModuleConcatenationPlugin",
	(allChunks, modules) => {
	const relevantModules = [];
	const possibleInners = new Set();
	for (const module of modules) {
	// Only harmony modules are valid for optimization
	if (
	!module.buildMeta \|\|
	module.buildMeta.exportsType !== "namespace" \|\|
	!module.dependencies.some(
	d => d instanceof HarmonyCompatibilityDependency
	)
	) {
	setBailoutReason(module, "Module is not an ECMAScript module");
	continue;
	}

	// Some expressions are not compatible with module concatenation
	// because they may produce unexpected results. The plugin bails out
	// if some were detected upfront.
	if (
	module.buildMeta &&
	module.buildMeta.moduleConcatenationBailout
	) {
	setBailoutReason(
	module,
	`Module uses ${module.buildMeta.moduleConcatenationBailout}`
	);
	continue;
	}

	// Exports must be known (and not dynamic)
	if (!Array.isArray(module.buildMeta.providedExports)) {
	setBailoutReason(module, "Module exports are unknown");
	continue;
	}

	// Using dependency variables is not possible as this wraps the code in a function
	if (module.variables.length > 0) {
	setBailoutReason(
	module,
	`Module uses injected variables (${module.variables
	.map(v => v.name)
	.join(", ")})`
	);
	continue;
	}

	// Hot Module Replacement need it's own module to work correctly
	if (
	module.dependencies.some(
	dep =>
	dep instanceof ModuleHotAcceptDependency \|\|
	dep instanceof ModuleHotDeclineDependency
	)
	) {
	setBailoutReason(module, "Module uses Hot Module Replacement");
	continue;
	}

	relevantModules.push(module);

	// Module must not be the entry points
	if (module.isEntryModule()) {
	setBailoutReason(module, "Module is an entry point");
	continue;
	}

	// Module must be in any chunk (we don't want to do useless work)
	if (module.getNumberOfChunks() === 0) {
	setBailoutReason(module, "Module is not in any chunk");
	continue;
	}

	// Module must only be used by Harmony Imports
	const nonHarmonyReasons = module.reasons.filter(
	reason =>
	!reason.dependency \|\|
	!(reason.dependency instanceof HarmonyImportDependency)
	);
	if (nonHarmonyReasons.length > 0) {
	const importingModules = new Set(
	nonHarmonyReasons.map(r => r.module).filter(Boolean)
	);
	const importingExplanations = new Set(
	nonHarmonyReasons.map(r => r.explanation).filter(Boolean)
	);
	const importingModuleTypes = new Map(
	Array.from(importingModules).map(
	m => /** @type {[string, Set]} */ ([
	m,
	new Set(
	nonHarmonyReasons
	.filter(r => r.module === m)
	.map(r => r.dependency.type)
	.sort()
	)
	])
	)
	);
	setBailoutReason(module, requestShortener => {
	const names = Array.from(importingModules)
	.map(
	m =>
	`${m.readableIdentifier(
	requestShortener
	)} (referenced with ${Array.from(
	importingModuleTypes.get(m)
	).join(", ")})`
	)
	.sort();
	const explanations = Array.from(importingExplanations).sort();
	if (names.length > 0 && explanations.length === 0) {
	return `Module is referenced from these modules with unsupported syntax: ${names.join(
	", "
	)}`;
	} else if (names.length === 0 && explanations.length > 0) {
	return `Module is referenced by: ${explanations.join(
	", "
	)}`;
	} else if (names.length > 0 && explanations.length > 0) {
	return `Module is referenced from these modules with unsupported syntax: ${names.join(
	", "
	)} and by: ${explanations.join(", ")}`;
	} else {
	return "Module is referenced in a unsupported way";
	}
	});
	continue;
	}

	possibleInners.add(module);
	}
	// sort by depth
	// modules with lower depth are more likely suited as roots
	// this improves performance, because modules already selected as inner are skipped
	relevantModules.sort((a, b) => {
	return a.depth - b.depth;
	});
	const concatConfigurations = [];
	const usedAsInner = new Set();
	for (const currentRoot of relevantModules) {
	// when used by another configuration as inner:
	// the other configuration is better and we can skip this one
	if (usedAsInner.has(currentRoot)) continue;

	// create a configuration with the root
	const currentConfiguration = new ConcatConfiguration(currentRoot);

	// cache failures to add modules
	const failureCache = new Map();

	// try to add all imports
	for (const imp of this._getImports(compilation, currentRoot)) {
	const problem = this._tryToAdd(
	compilation,
	currentConfiguration,
	imp,
	possibleInners,
	failureCache
	);
	if (problem) {
	failureCache.set(imp, problem);
	currentConfiguration.addWarning(imp, problem);
	}
	}
	if (!currentConfiguration.isEmpty()) {
	concatConfigurations.push(currentConfiguration);
	for (const module of currentConfiguration.getModules()) {
	if (module !== currentConfiguration.rootModule) {
	usedAsInner.add(module);
	}
	}
	}
	}
	// HACK: Sort configurations by length and start with the longest one
	// to get the biggers groups possible. Used modules are marked with usedModules
	// TODO: Allow to reuse existing configuration while trying to add dependencies.
	// This would improve performance. O(n^2) -> O(n)
	concatConfigurations.sort((a, b) => {
	return b.modules.size - a.modules.size;
	});
	const usedModules = new Set();
	for (const concatConfiguration of concatConfigurations) {
	if (usedModules.has(concatConfiguration.rootModule)) continue;
	const modules = concatConfiguration.getModules();
	const rootModule = concatConfiguration.rootModule;
	const newModule = new ConcatenatedModule(
	rootModule,
	Array.from(modules),
	ConcatenatedModule.createConcatenationList(
	rootModule,
	modules,
	compilation
	)
	);
	for (const warning of concatConfiguration.getWarningsSorted()) {
	newModule.optimizationBailout.push(requestShortener => {
	const reason = getBailoutReason(warning[0], requestShortener);
	const reasonWithPrefix = reason ? ` (<- ${reason})` : "";
	if (warning[0] === warning[1]) {
	return formatBailoutReason(
	`Cannot concat with ${warning[0].readableIdentifier(
	requestShortener
	)}${reasonWithPrefix}`
	);
	} else {
	return formatBailoutReason(
	`Cannot concat with ${warning[0].readableIdentifier(
	requestShortener
	)} because of ${warning[1].readableIdentifier(
	requestShortener
	)}${reasonWithPrefix}`
	);
	}
	});
	}
	const chunks = concatConfiguration.rootModule.getChunks();
	for (const m of modules) {
	usedModules.add(m);
	for (const chunk of chunks) {
	chunk.removeModule(m);
	}
	}
	for (const chunk of chunks) {
	chunk.addModule(newModule);
	newModule.addChunk(chunk);
	}
	for (const chunk of allChunks) {
	if (chunk.entryModule === concatConfiguration.rootModule) {
	chunk.entryModule = newModule;
	}
	}
	compilation.modules.push(newModule);
	for (const reason of newModule.reasons) {
	if (reason.dependency.module === concatConfiguration.rootModule)
	reason.dependency.module = newModule;
	if (
	reason.dependency.redirectedModule ===
	concatConfiguration.rootModule
	)
	reason.dependency.redirectedModule = newModule;
	}
	// TODO: remove when LTS node version contains fixed v8 version
	// @see https://github.com/webpack/webpack/pull/6613
	// Turbofan does not correctly inline for-of loops with polymorphic input arrays.
	// Work around issue by using a standard for loop and assigning dep.module.reasons
	for (let i = 0; i < newModule.dependencies.length; i++) {
	let dep = newModule.dependencies[i];
	if (dep.module) {
	let reasons = dep.module.reasons;
	for (let j = 0; j < reasons.length; j++) {
	let reason = reasons[j];
	if (reason.dependency === dep) {
	reason.module = newModule;
	}
	}
	}
	}
	}
	compilation.modules = compilation.modules.filter(
	m => !usedModules.has(m)
	);
	}
	);
	}
	);
	}

	_getImports(compilation, module) {
	return new Set(
	module.dependencies

	// Get reference info only for harmony Dependencies
	.map(dep => {
	if (!(dep instanceof HarmonyImportDependency)) return null;
	if (!compilation) return dep.getReference();
	return compilation.getDependencyReference(module, dep);
	})

	// Reference is valid and has a module
	// Dependencies are simple enough to concat them
	.filter(
	ref =>
	ref &&
	ref.module &&
	(Array.isArray(ref.importedNames) \|\|
	Array.isArray(ref.module.buildMeta.providedExports))
	)

	// Take the imported module
	.map(ref => ref.module)
	);
	}

	_tryToAdd(compilation, config, module, possibleModules, failureCache) {
	const cacheEntry = failureCache.get(module);
	if (cacheEntry) {
	return cacheEntry;
	}

	// Already added?
	if (config.has(module)) {
	return null;
	}

	// Not possible to add?
	if (!possibleModules.has(module)) {
	failureCache.set(module, module); // cache failures for performance
	return module;
	}

	// module must be in the same chunks
	if (!config.rootModule.hasEqualsChunks(module)) {
	failureCache.set(module, module); // cache failures for performance
	return module;
	}

	// Clone config to make experimental changes
	const testConfig = config.clone();

	// Add the module
	testConfig.add(module);

	// Every module which depends on the added module must be in the configuration too.
	for (const reason of module.reasons) {
	// Modules that are not used can be ignored
	if (
	reason.module.factoryMeta.sideEffectFree &&
	reason.module.used === false
	)
	continue;

	const problem = this._tryToAdd(
	compilation,
	testConfig,
	reason.module,
	possibleModules,
	failureCache
	);
	if (problem) {
	failureCache.set(module, problem); // cache failures for performance
	return problem;
	}
	}

	// Commit experimental changes
	config.set(testConfig);

	// Eagerly try to add imports too if possible
	for (const imp of this._getImports(compilation, module)) {
	const problem = this._tryToAdd(
	compilation,
	config,
	imp,
	possibleModules,
	failureCache
	);
	if (problem) {
	config.addWarning(imp, problem);
	}
	}
	return null;
	}
	}

	class ConcatConfiguration {
	constructor(rootModule, cloneFrom) {
	this.rootModule = rootModule;
	if (cloneFrom) {
	this.modules = cloneFrom.modules.createChild(5);
	this.warnings = cloneFrom.warnings.createChild(5);
	} else {
	this.modules = new StackedSetMap();
	this.modules.add(rootModule);
	this.warnings = new StackedSetMap();
	}
	}

	add(module) {
	this.modules.add(module);
	}

	has(module) {
	return this.modules.has(module);
	}

	isEmpty() {
	return this.modules.size === 1;
	}

	addWarning(module, problem) {
	this.warnings.set(module, problem);
	}

	getWarningsSorted() {
	return new Map(
	this.warnings.asPairArray().sort((a, b) => {
	const ai = a[0].identifier();
	const bi = b[0].identifier();
	if (ai < bi) return -1;
	if (ai > bi) return 1;
	return 0;
	})
	);
	}

	getModules() {
	return this.modules.asSet();
	}

	clone() {
	return new ConcatConfiguration(this.rootModule, this);
	}

	set(config) {
	this.rootModule = config.rootModule;
	this.modules = config.modules;
	this.warnings = config.warnings;
	}
	}

	module.exports = ModuleConcatenationPlugin;