webpack 5.2.1 → 5.4.0

package/lib/config/browserslistTargetHandler.js

@@ -75,29 +75,6 @@ const load = (input, context) => {
  * @returns {EcmaTargetProperties & PlatformTargetProperties & ApiTargetProperties} target properties
  */
 const resolve = browsers => {
-	/**
-	 * Checks only browser against the browserslist feature query
-	 * @param {string} feature an ES feature to test
-	 * @returns {boolean} true if supports
-	 */
-	const browserslistChecker = feature => {
-		const supportsFeature = browserslist(`supports ${feature}`);
-		return browsers.every(v => /^node /.test(v) || supportsFeature.includes(v));
-	};
-	/**
-	 * Checks only node.js version against a version
-	 * @param {number} major major version
-	 * @param {number} minor minor version
-	 * @returns {boolean} true if supports
-	 */
-	const nodeChecker = (major, minor = 0) => {
-		return browsers.every(v => {
-			const match = /^node (\d+)(?:\.\d+)?/.exec(v);
-			if (!match) return true;
-			const [, v1, v2] = match;
-			return major === +v1 ? +v2 >= minor : +v1 > major;
-		});
-	};
 	/**
 	 * Checks all against a version number
 	 * @param {Record<string, number | [number, number]>} versions first supported version
@@ -105,50 +82,197 @@ const resolve = browsers => {
 	 */
 	const rawChecker = versions => {
 		return browsers.every(v => {
-			const match = /^([^ ]+) (\d+)(?:\.\d+)?/.exec(v);
-			if (!match) return false;
-			const [, name, major, minor] = match;
-			const version = versions[name];
-			if (!version) return false;
-			if (typeof version === "number") return +major >= version;
-			return version[0] === +major ? +minor >= version[1] : +major > version[0];
+			const [name, parsedVersion] = v.split(" ");
+			if (!name) return false;
+			const requiredVersion = versions[name];
+			if (!requiredVersion) return false;
+			const [parsedMajor, parserMinor] =
+				// safari TP supports all features for normal safari
+				parsedVersion === "TP"
+					? [Infinity, Infinity]
+					: parsedVersion.split(".");
+			if (typeof requiredVersion === "number") {
+				return +parsedMajor >= requiredVersion;
+			}
+			return requiredVersion[0] === +parsedMajor
+				? +parserMinor >= requiredVersion[1]
+				: +parsedMajor > requiredVersion[0];
 		});
 	};
 	const anyNode = browsers.some(b => /^node /.test(b));
 	const anyBrowser = browsers.some(b => /^(?!node)/.test(b));
 	const browserProperty = !anyBrowser ? false : anyNode ? null : true;
 	const nodeProperty = !anyNode ? false : anyBrowser ? null : true;
-	const es6 = browserslistChecker("es6");
-	const letConst = browserslistChecker("let");
-	const arrowFunctions = browserslistChecker("arrow-functions");
-	const es6DynamicImport = browserslistChecker("es6-module-dynamic-import");
-	const node6 = nodeChecker(6);
+	// Internet Explorer Mobile, Blackberry browser and Opera Mini are very old browsers, they do not support new features
+	const es6DynamicImport = rawChecker({
+		chrome: 63,
+		and_chr: 63,
+		edge: 79,
+		firefox: 67,
+		and_ff: 67,
+		// ie: Not supported
+		opera: 50,
+		op_mob: 46,
+		safari: [11, 1],
+		ios_saf: [11, 3],
+		samsung: [8, 2],
+		android: 63,
+		and_qq: [10, 4],
+		// baidu: Not supported
+		// and_uc: Not supported
+		// kaios: Not supported
+		// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
+		node: [13, 14]
+	});
+
 	return {
-		const: letConst && node6,
-		arrowFunction: arrowFunctions && node6,
-		forOf: es6 && nodeChecker(5),
-		destructuring: es6 && node6,
-		bigIntLiteral: browserslistChecker("bigint") && nodeChecker(10, 4),
-		module: browserslistChecker("es6-module") && nodeChecker(12, 17),
-		dynamicImport: es6DynamicImport && nodeChecker(10, 17),
-		dynamicImportInWorker: es6DynamicImport && nodeChecker(Infinity),
+		const: rawChecker({
+			chrome: 49,
+			and_chr: 49,
+			edge: 12,
+			// Prior to Firefox 13, <code>const</code> is implemented, but re-assignment is not failing.
+			// Prior to Firefox 46, a <code>TypeError</code> was thrown on redeclaration instead of a <code>SyntaxError</code>.
+			firefox: 36,
+			and_ff: 36,
+			// Not supported in for-in and for-of loops
+			// ie: Not supported
+			opera: 36,
+			op_mob: 36,
+			safari: [10, 0],
+			ios_saf: [10, 0],
+			// Before 5.0 supported correctly in strict mode, otherwise supported without block scope
+			samsung: [5, 0],
+			android: 37,
+			and_qq: [10, 4],
+			// Supported correctly in strict mode, otherwise supported without block scope
+			// baidu: Not supported
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: [6, 0]
+		}),
+		arrowFunction: rawChecker({
+			chrome: 45,
+			and_chr: 45,
+			edge: 12,
+			// The initial implementation of arrow functions in Firefox made them automatically strict. This has been changed as of Firefox 24. The use of <code>'use strict';</code> is now required.
+			// Prior to Firefox 39, a line terminator (<code>\\n</code>) was incorrectly allowed after arrow function arguments. This has been fixed to conform to the ES2015 specification and code like <code>() \\n => {}</code> will now throw a <code>SyntaxError</code> in this and later versions.
+			firefox: 39,
+			and_ff: 39,
+			// ie: Not supported,
+			opera: 32,
+			op_mob: 32,
+			safari: 10,
+			ios_saf: 10,
+			samsung: [5, 0],
+			android: 45,
+			and_qq: [10, 4],
+			baidu: [7, 12],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: [6, 0]
+		}),
+		forOf: rawChecker({
+			chrome: 38,
+			and_chr: 38,
+			edge: 12,
+			// Prior to Firefox 51, using the for...of loop construct with the const keyword threw a SyntaxError ("missing = in const declaration").
+			firefox: 51,
+			and_ff: 51,
+			// ie: Not supported,
+			opera: 25,
+			op_mob: 25,
+			safari: 7,
+			ios_saf: 7,
+			samsung: [3, 0],
+			android: 38,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			// kaios: Unknown support
+			node: [0, 12]
+		}),
+		destructuring: rawChecker({
+			chrome: 49,
+			and_chr: 49,
+			edge: 14,
+			firefox: 41,
+			and_ff: 41,
+			// ie: Not supported,
+			opera: 36,
+			op_mob: 36,
+			safari: 8,
+			ios_saf: 8,
+			samsung: [5, 0],
+			android: 49,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			// kaios: Unknown support
+			node: [6, 0]
+		}),
+		bigIntLiteral: rawChecker({
+			chrome: 67,
+			and_chr: 67,
+			edge: 79,
+			firefox: 68,
+			and_ff: 68,
+			// ie: Not supported,
+			opera: 54,
+			op_mob: 48,
+			safari: 14,
+			ios_saf: 14,
+			samsung: [9, 2],
+			android: 67,
+			// and_qq: Not supported
+			// baidu: Not supported
+			// and_uc: Not supported
+			// kaios: Not supported
+			node: [10, 4]
+		}),
+		// Support syntax `import` and `export` and no limitations and bugs on Node.js
+		// Not include `export * as namespace`
+		module: rawChecker({
+			chrome: 61,
+			and_chr: 61,
+			edge: 16,
+			firefox: 60,
+			and_ff: 60,
+			// ie: Not supported,
+			opera: 48,
+			op_mob: 45,
+			safari: [10, 1],
+			ios_saf: [10, 3],
+			samsung: [8, 0],
+			android: 61,
+			and_qq: [10, 4],
+			// baidu: Not supported
+			// and_uc: Not supported
+			// kaios: Not supported
+			// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
+			node: [13, 14]
+		}),
+		dynamicImport: es6DynamicImport,
+		dynamicImportInWorker: es6DynamicImport && !anyNode,
 		// browserslist does not have info about globalThis
 		// so this is based on mdn-browser-compat-data
 		globalThis: rawChecker({
 			chrome: 71,
-			chrome_android: 71,
+			and_chr: 71,
 			edge: 79,
 			firefox: 65,
-			firefox_android: 65,
+			and_ff: 65,
 			// ie: Not supported,
-			nodejs: 12,
 			opera: 58,
-			opera_android: 50,
+			op_mob: 50,
 			safari: [12, 1],
-			safari_ios: [12, 2],
-			// cspell:word samsunginternet
-			samsunginternet_android: [10, 0],
-			webview_android: 71
+			ios_saf: [12, 2],
+			samsung: [10, 1],
+			android: 71,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			// kaios: Unknown support
+			node: [12, 0]
 		}),
 
 		browser: browserProperty,

package/lib/config/defaults.js

@@ -848,7 +848,7 @@ const applyOptimizationDefaults = (
 		if (development) return "named";
 		return "natural";
 	});
-	D(optimization, "sideEffects", true);
+	F(optimization, "sideEffects", () => (production ? true : "flag"));
 	D(optimization, "providedExports", true);
 	D(optimization, "usedExports", production);
 	D(optimization, "innerGraph", production);

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const Template = require("../Template");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 const NullDependency = require("./NullDependency");
@@ -62,14 +63,41 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 	 */
 	apply(dependency, source, templateContext) {
 		const dep = /** @type {HarmonyAcceptDependency} */ (dependency);
-		const { module, runtimeTemplate } = templateContext;
+		const {
+			module,
+			runtime,
+			runtimeRequirements,
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph
+		} = templateContext;
 		const content = dep.dependencies
-			.filter(dependency =>
-				HarmonyImportDependency.Template.isImportEmitted(dependency, module)
-			)
 			.map(dependency => {
+				const referencedModule = moduleGraph.getModule(dependency);
+				return {
+					dependency,
+					runtimeCondition: referencedModule
+						? HarmonyImportDependency.Template.getImportEmittedRuntime(
+								module,
+								referencedModule
+						  )
+						: false
+				};
+			})
+			.filter(({ runtimeCondition }) => runtimeCondition !== false)
+			.map(({ dependency, runtimeCondition }) => {
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtime,
+					runtimeCondition,
+					runtimeRequirements
+				});
 				const s = dependency.getImportStatement(true, templateContext);
-				return s[0] + s[1];
+				const code = s[0] + s[1];
+				if (condition !== "true") {
+					return `if (${condition}) {\n${Template.indent(code)}\n}\n`;
+				}
+				return code;
 			})
 			.join("");
 

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -244,11 +244,6 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 						mode.fakeType = 2;
 						break;
 					case "dynamic":
-						mode = new ExportMode("reexport-fake-namespace-object");
-						mode.name = name;
-						mode.partialNamespaceExportInfo = exportInfo;
-						mode.fakeType = 6;
-						break;
 					default:
 						mode = new ExportMode("reexport-namespace-object");
 						mode.name = name;

package/lib/dependencies/HarmonyImportDependency.js

@@ -5,11 +5,13 @@
 
 "use strict";
 
+const ConditionalInitFragment = require("../ConditionalInitFragment");
 const Dependency = require("../Dependency");
 const HarmonyLinkingError = require("../HarmonyLinkingError");
 const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
+const { filterRuntime, mergeRuntime } = require("../util/runtime");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -199,21 +201,38 @@ class HarmonyImportDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		const { chunkGraph } = context;
+		const { chunkGraph, runtime, runtimeTemplate } = context;
 		const { moduleGraph } = chunkGraph;
 		super.updateHash(hash, context);
-		const importedModule = moduleGraph.getModule(this);
-		if (importedModule) {
-			const parentModule = moduleGraph.getParentModule(this);
-			hash.update(
-				importedModule.getExportsType(
-					moduleGraph,
-					parentModule.buildMeta && parentModule.buildMeta.strictHarmonyModule
-				)
-			);
-			if (moduleGraph.isAsync(importedModule)) hash.update("async");
-		}
 		hash.update(`${this.sourceOrder}`);
+		const connection = moduleGraph.getConnection(this);
+		if (connection) {
+			const importedModule = connection.module;
+			if (importedModule) {
+				const parentModule = moduleGraph.getParentModule(this);
+				hash.update(
+					importedModule.getExportsType(
+						moduleGraph,
+						parentModule.buildMeta && parentModule.buildMeta.strictHarmonyModule
+					)
+				);
+				if (moduleGraph.isAsync(importedModule)) hash.update("async");
+			}
+			if (runtimeTemplate) {
+				const runtimeRequirements = new Set();
+				hash.update(
+					runtimeTemplate.runtimeConditionExpression({
+						chunkGraph,
+						runtimeCondition: filterRuntime(runtime, runtime => {
+							return connection.isTargetActive(runtime);
+						}),
+						runtime,
+						runtimeRequirements
+					})
+				);
+				for (const rr of runtimeRequirements) hash.update(rr);
+			}
+		}
 	}
 
 	serialize(context) {
@@ -231,6 +250,7 @@ class HarmonyImportDependency extends ModuleDependency {
 
 module.exports = HarmonyImportDependency;
 
+/** @type {WeakMap<Module, WeakMap<Module, RuntimeSpec | boolean>>} */
 const importEmittedMap = new WeakMap();
 
 HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends ModuleDependency.Template {
@@ -265,23 +285,42 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 			: dep.request;
 		const key = `harmony import ${moduleKey}`;
 
-		if (module) {
-			let emittedModules = importEmittedMap.get(dep);
+		const runtimeCondition = dep.weak
+			? false
+			: connection
+			? filterRuntime(runtime, r => connection.isTargetActive(r))
+			: true;
+
+		if (module && referencedModule) {
+			let emittedModules = importEmittedMap.get(module);
 			if (emittedModules === undefined) {
-				emittedModules = new WeakSet();
-				importEmittedMap.set(dep, emittedModules);
+				emittedModules = new WeakMap();
+				importEmittedMap.set(module, emittedModules);
+			}
+			let mergedRuntimeCondition = runtimeCondition;
+			const oldRuntimeCondition = emittedModules.get(referencedModule) || false;
+			if (oldRuntimeCondition !== false && mergedRuntimeCondition !== true) {
+				if (mergedRuntimeCondition === false || oldRuntimeCondition === true) {
+					mergedRuntimeCondition = oldRuntimeCondition;
+				} else {
+					mergedRuntimeCondition = mergeRuntime(
+						oldRuntimeCondition,
+						mergedRuntimeCondition
+					);
+				}
 			}
-			emittedModules.add(module);
+			emittedModules.set(referencedModule, mergedRuntimeCondition);
 		}
 
 		const importStatement = dep.getImportStatement(false, templateContext);
 		if (templateContext.moduleGraph.isAsync(referencedModule)) {
 			templateContext.initFragments.push(
-				new InitFragment(
+				new ConditionalInitFragment(
 					importStatement[0],
 					InitFragment.STAGE_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key
+					key,
+					runtimeCondition
 				)
 			);
 			templateContext.initFragments.push(
@@ -290,20 +329,22 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 				)
 			);
 			templateContext.initFragments.push(
-				new InitFragment(
+				new ConditionalInitFragment(
 					importStatement[1],
 					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key + " compat"
+					key + " compat",
+					runtimeCondition
 				)
 			);
 		} else {
 			templateContext.initFragments.push(
-				new InitFragment(
+				new ConditionalInitFragment(
 					importStatement[0] + importStatement[1],
 					InitFragment.STAGE_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key
+					key,
+					runtimeCondition
 				)
 			);
 		}
@@ -311,12 +352,13 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 
 	/**
 	 *
-	 * @param {Dependency} dep the dependency
 	 * @param {Module} module the module
-	 * @returns {boolean} true, when for this dependency and module a import init fragment was created
+	 * @param {Module} referencedModule the referenced module
+	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted
 	 */
-	static isImportEmitted(dep, module) {
-		const emittedModules = importEmittedMap.get(dep);
-		return emittedModules !== undefined && emittedModules.has(module);
+	static getImportEmittedRuntime(module, referencedModule) {
+		const emittedModules = importEmittedMap.get(module);
+		if (emittedModules === undefined) return false;
+		return emittedModules.get(referencedModule) || false;
 	}
 };

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -59,9 +59,13 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			(statement, source) => {
 				parser.state.lastHarmonyImportOrder =
 					(parser.state.lastHarmonyImportOrder || 0) + 1;
-				const clearDep = new ConstDependency("", statement.range);
+				const clearDep = new ConstDependency(
+					parser.isAsiPosition(statement.range[0]) ? ";" : "",
+					statement.range
+				);
 				clearDep.loc = statement.loc;
 				parser.state.module.addPresentationalDependency(clearDep);
+				parser.unsetAsiPosition(statement.range[1]);
 				const sideEffectDep = new HarmonyImportSideEffectDependency(
 					source,
 					parser.state.lastHarmonyImportOrder

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -196,7 +196,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		const { chunkGraph } = context;
+		const { chunkGraph, runtime } = context;
 		super.updateHash(hash, context);
 		const moduleGraph = chunkGraph.moduleGraph;
 		const importedModule = moduleGraph.getModule(this);
@@ -204,7 +204,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		hash.update(ids.join());
 		if (importedModule) {
 			const exportsInfo = moduleGraph.getExportsInfo(importedModule);
-			hash.update(`${exportsInfo.getUsedName(ids, context.runtime)}`);
+			hash.update(`${exportsInfo.getUsedName(ids, runtime)}`);
 		}
 	}
 

package/lib/dependencies/PureExpressionDependency.js

@@ -7,6 +7,7 @@
 
 const { UsageState } = require("../ExportsInfo");
 const makeSerializable = require("../util/makeSerializable");
+const { filterRuntime } = require("../util/runtime");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -74,22 +75,45 @@ PureExpressionDependency.Template = class PureExpressionDependencyTemplate exten
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { moduleGraph, runtime }) {
+	apply(
+		dependency,
+		source,
+		{ chunkGraph, moduleGraph, runtime, runtimeTemplate, runtimeRequirements }
+	) {
 		const dep = /** @type {PureExpressionDependency} */ (dependency);
 
-		if (dep.usedByExports !== false) {
+		const usedByExports = dep.usedByExports;
+		if (usedByExports !== false) {
 			const selfModule = moduleGraph.getParentModule(dep);
 			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-			for (const exportName of dep.usedByExports) {
-				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
-					return;
+			const runtimeCondition = filterRuntime(runtime, runtime => {
+				for (const exportName of usedByExports) {
+					if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
+						return true;
+					}
 				}
+				return false;
+			});
+			if (runtimeCondition === true) return;
+			if (runtimeCondition !== false) {
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtime,
+					runtimeCondition,
+					runtimeRequirements
+				});
+				source.insert(
+					dep.range[0],
+					`(/* runtime-dependent pure expression or super */ ${condition} ? (`
+				);
+				source.insert(dep.range[1], ") : null)");
+				return;
 			}
 		}
 
 		source.insert(
 			dep.range[0],
-			"(/* unused pure expression or super */ null && ("
+			`(/* unused pure expression or super */ null && (`
 		);
 		source.insert(dep.range[1], "))");
 	}

package/lib/dependencies/WorkerPlugin.js

@@ -12,6 +12,7 @@ const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const formatLocation = require("../formatLocation");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 const { equals } = require("../util/ArrayHelpers");
+const { contextify } = require("../util/identifier");
 const {
 	harmonySpecifierTag
 } = require("./HarmonyImportDependencyParserPlugin");
@@ -48,6 +49,10 @@ class WorkerPlugin {
 		if (this._chunkLoading) {
 			new EnableChunkLoadingPlugin(this._chunkLoading).apply(compiler);
 		}
+		const cachedContextify = contextify.bindContextCache(
+			compiler.context,
+			compiler.root
+		);
 		compiler.hooks.thisCompilation.tap(
 			"WorkerPlugin",
 			(compilation, { normalModuleFactory }) => {
@@ -213,9 +218,9 @@ class WorkerPlugin {
 							}
 
 							if (!entryOptions.runtime) {
-								entryOptions.runtime = `${parser.state.module.identifier()}|${formatLocation(
-									expr.loc
-								)}`;
+								entryOptions.runtime = `${cachedContextify(
+									parser.state.module.identifier()
+								)}|${formatLocation(expr.loc)}`;
 							}
 
 							const block = new AsyncDependenciesBlock({