webpack 5.21.0 → 5.23.0

package/lib/runtime/RelativeUrlRuntimeModule.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+class RelativeUrlRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("relative url");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString([
+			`${RuntimeGlobals.relativeUrl} = function RelativeURL(url) {`,
+			Template.indent([
+				'var realUrl = new URL(url, "x:/");',
+				"var values = {};",
+				"for (var key in realUrl) values[key] = realUrl[key];",
+				"values.href = url;",
+				'values.pathname = url.replace(/[?#].*/, "");',
+				'values.origin = values.protocol = "";',
+				`values.toString = values.toJSON = ${runtimeTemplate.returningFunction(
+					"url"
+				)};`,
+				"for (var key in values) Object.defineProperty(this, key, Object.assign({ enumerable: true, configurable: true, value: values[key] }));"
+			]),
+			"};",
+			`${RuntimeGlobals.relativeUrl}.prototype = URL.prototype;`
+		]);
+	}
+}
+
+module.exports = RelativeUrlRuntimeModule;

package/lib/runtime/StartupChunkDependenciesPlugin.js

@@ -56,6 +56,7 @@ class StartupChunkDependenciesPlugin {
 					.for(RuntimeGlobals.startupEntrypoint)
 					.tap("StartupChunkDependenciesPlugin", (chunk, set) => {
 						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.require);
 						set.add(RuntimeGlobals.ensureChunk);
 						set.add(RuntimeGlobals.ensureChunkIncludeEntries);
 						compilation.addRuntimeModule(

package/lib/serialization/ObjectMiddleware.js

@@ -208,12 +208,14 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	static getSerializerFor(object) {
-		let c = object.constructor;
-		if (!c) {
-			if (Object.getPrototypeOf(object) === null) {
-				// Object created with Object.create(null)
-				c = null;
-			} else {
+		const proto = Object.getPrototypeOf(object);
+		let c;
+		if (proto === null) {
+			// Object created with Object.create(null)
+			c = null;
+		} else {
+			c = proto.constructor;
+			if (!c) {
 				throw new Error(
 					"Serialization of objects with prototype without valid constructor property not possible"
 				);
@@ -238,6 +240,12 @@ class ObjectMiddleware extends SerializerMiddleware {
 		return serializer;
 	}
 
+	static _getDeserializerForWithoutError(request, name) {
+		const key = request + "/" + name;
+		const serializer = serializerInversed.get(key);
+		return serializer;
+	}
+
 	/**
 	 * @param {DeserializedType} data data
 	 * @param {Object} context context object
@@ -577,25 +585,32 @@ class ObjectMiddleware extends SerializerMiddleware {
 						}
 						const name = read();
 
-						if (request && !loadedRequests.has(request)) {
-							let loaded = false;
-							for (const [regExp, loader] of loaders) {
-								if (regExp.test(request)) {
-									if (loader(request)) {
-										loaded = true;
-										break;
+						serializer = ObjectMiddleware._getDeserializerForWithoutError(
+							request,
+							name
+						);
+
+						if (serializer === undefined) {
+							if (request && !loadedRequests.has(request)) {
+								let loaded = false;
+								for (const [regExp, loader] of loaders) {
+									if (regExp.test(request)) {
+										if (loader(request)) {
+											loaded = true;
+											break;
+										}
 									}
 								}
-							}
-							if (!loaded) {
-								require(request);
+								if (!loaded) {
+									require(request);
+								}
+
+								loadedRequests.add(request);
 							}
 
-							loadedRequests.add(request);
+							serializer = ObjectMiddleware.getDeserializerFor(request, name);
 						}
 
-						serializer = ObjectMiddleware.getDeserializerFor(request, name);
-
 						objectTypeLookup.push(serializer);
 						currentPosTypeLookup++;
 					}

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -12,6 +12,7 @@ const { LogType } = require("../logging/Logger");
 const AggressiveSplittingPlugin = require("../optimize/AggressiveSplittingPlugin");
 const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const SizeLimitsPlugin = require("../performance/SizeLimitsPlugin");
+const { countIterable } = require("../util/IterableHelpers");
 const {
 	compareLocations,
 	compareChunksById,
@@ -360,18 +361,6 @@ const mapObject = (obj, fn) => {
 	return newObj;
 };
 
-/**
- * @template T
- * @param {Iterable<T>} iterable an iterable
- * @returns {number} count of items
- */
-const countIterable = iterable => {
-	let i = 0;
-	// eslint-disable-next-line no-unused-vars
-	for (const _ of iterable) i++;
-	return i;
-};
-
 /**
  * @param {Compilation} compilation the compilation
  * @param {function(Compilation, string): any[]} getItems get items

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -106,6 +106,7 @@ const SIMPLE_PRINTERS = {
 			versionMessage ||
 			errorsMessage ||
 			warningsMessage ||
+			(errorsCount === 0 && warningsCount === 0) ||
 			timeMessage ||
 			hashMessage
 		)
@@ -192,7 +193,11 @@ const SIMPLE_PRINTERS = {
 						childWarnings,
 						"WARNING",
 						"WARNINGS"
-					)} in child compilations`
+					)} in child compilations${
+						compilation.children
+							? ""
+							: " (Use 'stats.children: true' resp. '--stats-children' for more details)"
+					}`
 				);
 			}
 		}
@@ -210,7 +215,11 @@ const SIMPLE_PRINTERS = {
 						childErrors,
 						"ERROR",
 						"ERRORS"
-					)} in child compilations`
+					)} in child compilations${
+						compilation.children
+							? ""
+							: " (Use 'stats.children: true' resp. '--stats-children' for more details)"
+					}`
 				);
 			}
 		}
@@ -1186,10 +1195,14 @@ class DefaultStatsPrinterPlugin {
 								}
 								if (start) {
 									context[color] = str =>
-										`${start}${str.replace(
-											/((\u001b\[39m|\u001b\[22m|\u001b\[0m)+)/g,
-											`$1${start}`
-										)}\u001b[39m\u001b[22m`;
+										`${start}${
+											typeof str === "string"
+												? str.replace(
+														/((\u001b\[39m|\u001b\[22m|\u001b\[0m)+)/g,
+														`$1${start}`
+												  )
+												: str
+										}\u001b[39m\u001b[22m`;
 								} else {
 									context[color] = str => str;
 								}

package/lib/util/IterableHelpers.js

@@ -0,0 +1,46 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @template T
+ * @param {Iterable<T>} set a set
+ * @returns {T | undefined} last item
+ */
+const last = set => {
+	let last;
+	for (const item of set) last = item;
+	return last;
+};
+
+/**
+ * @template T
+ * @param {Iterable<T>} iterable iterable
+ * @param {function(T): boolean} filter predicate
+ * @returns {boolean} true, if some items match the filter predicate
+ */
+const someInIterable = (iterable, filter) => {
+	for (const item of iterable) {
+		if (filter(item)) return true;
+	}
+	return false;
+};
+
+/**
+ * @template T
+ * @param {Iterable<T>} iterable an iterable
+ * @returns {number} count of items
+ */
+const countIterable = iterable => {
+	let i = 0;
+	// eslint-disable-next-line no-unused-vars
+	for (const _ of iterable) i++;
+	return i;
+};
+
+exports.last = last;
+exports.someInIterable = someInIterable;
+exports.countIterable = countIterable;

package/lib/util/LazyBucketSortedSet.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { first } = require("./SetHelpers");
 const SortableSet = require("./SortableSet");
 
 /**
@@ -103,12 +104,12 @@ class LazyBucketSortedSet {
 			this._unsortedItems.clear();
 		}
 		this._keys.sort();
-		const key = this._keys.values().next().value;
+		const key = first(this._keys);
 		const entry = this._map.get(key);
 		if (this._leaf) {
 			const leafEntry = /** @type {SortableSet<T>} */ (entry);
 			leafEntry.sort();
-			const item = leafEntry.values().next().value;
+			const item = first(leafEntry);
 			leafEntry.delete(item);
 			if (leafEntry.size === 0) {
 				this._deleteKey(key);

package/lib/util/SetHelpers.js

@@ -63,6 +63,17 @@ const find = (set, fn) => {
 	}
 };
 
+/**
+ * @template T
+ * @param {Set<T>} set a set
+ * @returns {T | undefined} first item
+ */
+const first = set => {
+	const entry = set.values().next();
+	return entry.done ? undefined : entry.value;
+};
+
 exports.intersect = intersect;
 exports.isSubset = isSubset;
 exports.find = find;
+exports.first = first;

package/lib/webpack.js

@@ -20,6 +20,7 @@ const validateSchema = require("./validateSchema");
 
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("./Compiler").WatchOptions} WatchOptions */
+/** @typedef {import("./MultiCompiler").MultiCompilerOptions} MultiCompilerOptions */
 /** @typedef {import("./MultiStats")} MultiStats */
 /** @typedef {import("./Stats")} Stats */
 
@@ -33,11 +34,12 @@ const validateSchema = require("./validateSchema");
 
 /**
  * @param {WebpackOptions[]} childOptions options array
+ * @param {MultiCompilerOptions} options options
  * @returns {MultiCompiler} a multi-compiler
  */
-const createMultiCompiler = childOptions => {
+const createMultiCompiler = (childOptions, options) => {
 	const compilers = childOptions.map(options => createCompiler(options));
-	const compiler = new MultiCompiler(compilers);
+	const compiler = new MultiCompiler(compilers, options);
 	for (const childCompiler of compilers) {
 		if (childCompiler.options.dependencies) {
 			compiler.setDependencies(
@@ -87,63 +89,67 @@ const createCompiler = rawOptions => {
 
 /**
  * @callback WebpackFunctionMulti
- * @param {WebpackOptions[]} options options objects
+ * @param {WebpackOptions[] & MultiCompilerOptions} options options objects
  * @param {Callback<MultiStats>=} callback callback
  * @returns {MultiCompiler} the multi compiler object
  */
 
-const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ ((
-	options,
-	callback
-) => {
-	const create = () => {
-		validateSchema(webpackOptionsSchema, options);
-		/** @type {MultiCompiler|Compiler} */
-		let compiler;
-		let watch = false;
-		/** @type {WatchOptions|WatchOptions[]} */
-		let watchOptions;
-		if (Array.isArray(options)) {
-			/** @type {MultiCompiler} */
-			compiler = createMultiCompiler(options);
-			watch = options.some(options => options.watch);
-			watchOptions = options.map(options => options.watchOptions || {});
-		} else {
-			/** @type {Compiler} */
-			compiler = createCompiler(options);
-			watch = options.watch;
-			watchOptions = options.watchOptions || {};
-		}
-		return { compiler, watch, watchOptions };
-	};
-	if (callback) {
-		try {
-			const { compiler, watch, watchOptions } = create();
-			if (watch) {
-				compiler.watch(watchOptions, callback);
+const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
+	/**
+	 * @param {WebpackOptions | (WebpackOptions[] & MultiCompilerOptions)} options options
+	 * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
+	 * @returns {Compiler | MultiCompiler}
+	 */
+	(options, callback) => {
+		const create = () => {
+			validateSchema(webpackOptionsSchema, options);
+			/** @type {MultiCompiler|Compiler} */
+			let compiler;
+			let watch = false;
+			/** @type {WatchOptions|WatchOptions[]} */
+			let watchOptions;
+			if (Array.isArray(options)) {
+				/** @type {MultiCompiler} */
+				compiler = createMultiCompiler(options, options);
+				watch = options.some(options => options.watch);
+				watchOptions = options.map(options => options.watchOptions || {});
 			} else {
-				compiler.run((err, stats) => {
-					compiler.close(err2 => {
-						callback(err || err2, stats);
+				/** @type {Compiler} */
+				compiler = createCompiler(options);
+				watch = options.watch;
+				watchOptions = options.watchOptions || {};
+			}
+			return { compiler, watch, watchOptions };
+		};
+		if (callback) {
+			try {
+				const { compiler, watch, watchOptions } = create();
+				if (watch) {
+					compiler.watch(watchOptions, callback);
+				} else {
+					compiler.run((err, stats) => {
+						compiler.close(err2 => {
+							callback(err || err2, stats);
+						});
 					});
-				});
+				}
+				return compiler;
+			} catch (err) {
+				process.nextTick(() => callback(err));
+				return null;
+			}
+		} else {
+			const { compiler, watch } = create();
+			if (watch) {
+				util.deprecate(
+					() => {},
+					"A 'callback' argument need to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
+					"DEP_WEBPACK_WATCH_WITHOUT_CALLBACK"
+				)();
 			}
 			return compiler;
-		} catch (err) {
-			process.nextTick(() => callback(err));
-			return null;
-		}
-	} else {
-		const { compiler, watch } = create();
-		if (watch) {
-			util.deprecate(
-				() => {},
-				"A 'callback' argument need to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
-				"DEP_WEBPACK_WATCH_WITHOUT_CALLBACK"
-			)();
 		}
-		return compiler;
 	}
-});
+);
 
 module.exports = webpack;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.21.0",
+  "version": "5.23.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
@@ -55,12 +55,12 @@
     "eslint": "^7.14.0",
     "eslint-config-prettier": "^7.0.0",
     "eslint-plugin-jest": "^24.1.3",
-    "eslint-plugin-jsdoc": "^31.0.3",
+    "eslint-plugin-jsdoc": "^32.0.2",
     "eslint-plugin-node": "^11.0.0",
     "eslint-plugin-prettier": "^3.1.4",
     "file-loader": "^6.0.0",
     "fork-ts-checker-webpack-plugin": "^6.0.5",
-    "husky": "^4.2.5",
+    "husky": "^5.0.9",
     "is-ci": "^2.0.0",
     "istanbul": "^0.4.5",
     "jest": "^26.6.3",

package/schemas/WebpackOptions.json

@@ -1269,7 +1269,14 @@
         },
         "url": {
           "description": "Enable/disable parsing of new URL() syntax.",
-          "type": "boolean"
+          "anyOf": [
+            {
+              "enum": ["relative"]
+            },
+            {
+              "type": "boolean"
+            }
+          ]
         },
         "worker": {
           "description": "Disable or configure parsing of WebWorker syntax like new Worker() or navigator.serviceWorker.register().",

package/types.d.ts

@@ -118,6 +118,11 @@ declare class AbstractLibraryPlugin<T> {
 		entryName: string,
 		libraryContext: LibraryContext<T>
 	): void;
+	embedInRuntimeBailout(
+		module: Module,
+		renderContext: RenderContextObject,
+		libraryContext: LibraryContext<T>
+	): undefined | string;
 	runtimeRequirements(
 		chunk: Chunk,
 		set: Set<string>,
@@ -128,12 +133,19 @@ declare class AbstractLibraryPlugin<T> {
 		renderContext: RenderContextObject,
 		libraryContext: LibraryContext<T>
 	): Source;
+	renderStartup(
+		source: Source,
+		module: Module,
+		renderContext: StartupRenderContext,
+		libraryContext: LibraryContext<T>
+	): Source;
 	chunkHash(
 		chunk: Chunk,
 		hash: Hash,
 		chunkHashContext: ChunkHashContext,
 		libraryContext: LibraryContext<T>
 	): void;
+	static COMMON_LIBRARY_NAME_MESSAGE: string;
 }
 declare class AggressiveMergingPlugin {
 	constructor(options?: any);
@@ -1646,7 +1658,13 @@ declare interface CompilationHooksJavascriptModulesPlugin {
 	renderChunk: SyncWaterfallHook<[Source, RenderContextObject]>;
 	renderMain: SyncWaterfallHook<[Source, RenderContextObject]>;
 	render: SyncWaterfallHook<[Source, RenderContextObject]>;
+	renderStartup: SyncWaterfallHook<[Source, Module, StartupRenderContext]>;
 	renderRequire: SyncWaterfallHook<[string, RenderBootstrapContext]>;
+	inlineInRuntimeBailout: SyncBailHook<
+		[Module, RenderBootstrapContext],
+		string
+	>;
+	embedInRuntimeBailout: SyncBailHook<[Module, RenderContextObject], string>;
 	chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
 	useSourceMap: SyncBailHook<[Chunk, RenderContextObject], boolean>;
 }
@@ -4412,7 +4430,7 @@ declare class JavascriptParser extends Parser {
 		varDeclarationLet: HookMap<SyncBailHook<[Declaration], boolean | void>>;
 		varDeclarationConst: HookMap<SyncBailHook<[Declaration], boolean | void>>;
 		varDeclarationVar: HookMap<SyncBailHook<[Declaration], boolean | void>>;
-		pattern: HookMap<SyncBailHook<any, any>>;
+		pattern: HookMap<SyncBailHook<[Identifier], boolean | void>>;
 		canRename: HookMap<SyncBailHook<[Expression], boolean | void>>;
 		rename: HookMap<SyncBailHook<[Expression], boolean | void>>;
 		assign: HookMap<SyncBailHook<[AssignmentExpression], boolean | void>>;
@@ -4881,7 +4899,7 @@ declare interface JavascriptParserOptions {
 	/**
 	 * Enable/disable parsing of new URL() syntax.
 	 */
-	url?: boolean;
+	url?: boolean | "relative";
 
 	/**
 	 * Disable or configure parsing of WebWorker syntax like new Worker() or navigator.serviceWorker.register().
@@ -6234,7 +6252,10 @@ declare abstract class ModuleTemplate {
 	readonly runtimeTemplate: any;
 }
 declare class MultiCompiler {
-	constructor(compilers: Compiler[] | Record<string, Compiler>);
+	constructor(
+		compilers: Compiler[] | Record<string, Compiler>,
+		options: MultiCompilerOptions
+	);
 	hooks: Readonly<{
 		done: SyncHook<[MultiStats]>;
 		invalid: MultiHook<SyncHook<[null | string, number]>>;
@@ -6246,7 +6267,7 @@ declare class MultiCompiler {
 	compilers: Compiler[];
 	dependencies: WeakMap<Compiler, string[]>;
 	running: boolean;
-	readonly options: WebpackOptionsNormalized[];
+	readonly options: WebpackOptionsNormalized[] & MultiCompilerOptions;
 	readonly outputPath: string;
 	inputFileSystem: InputFileSystem;
 	outputFileSystem: OutputFileSystem;
@@ -6268,6 +6289,12 @@ declare class MultiCompiler {
 	purgeInputFileSystem(): void;
 	close(callback: CallbackFunction<void>): void;
 }
+declare interface MultiCompilerOptions {
+	/**
+	 * how many Compilers are allows to run at the same time in parallel
+	 */
+	parallelism?: number;
+}
 declare abstract class MultiStats {
 	stats: Stats[];
 	readonly hash: string;
@@ -9860,6 +9887,7 @@ declare abstract class StackedMap<K, V> {
 	readonly size: number;
 	createChild(): StackedMap<K, V>;
 }
+type StartupRenderContext = RenderContextObject & { inlined: boolean };
 type Statement =
 	| FunctionDeclaration
 	| VariableDeclaration
@@ -10448,7 +10476,7 @@ declare interface UpdateHashContextGenerator {
 	chunkGraph: ChunkGraph;
 	runtime: RuntimeSpec;
 }
-type UsageStateType = 0 | 2 | 3 | 1 | 4;
+type UsageStateType = 0 | 1 | 2 | 3 | 4;
 declare interface UserResolveOptions {
 	/**
 	 * A list of module alias configurations or an object which maps key to value
@@ -10689,6 +10717,7 @@ declare abstract class Watching {
 	callbacks: CallbackFunction<void>[];
 	closed: boolean;
 	suspended: boolean;
+	blocked: boolean;
 	watchOptions: {
 		/**
 		 * Delay the rebuilt after the first change. Value is a time in ms.
@@ -11044,14 +11073,14 @@ declare function exports(
 	callback?: CallbackWebpack<Stats>
 ): Compiler;
 declare function exports(
-	options: Configuration[],
+	options: Configuration[] & MultiCompilerOptions,
 	callback?: CallbackWebpack<MultiStats>
 ): MultiCompiler;
 declare namespace exports {
 	export const webpack: {
 		(options: Configuration, callback?: CallbackWebpack<Stats>): Compiler;
 		(
-			options: Configuration[],
+			options: Configuration[] & MultiCompilerOptions,
 			callback?: CallbackWebpack<MultiStats>
 		): MultiCompiler;
 	};
@@ -11172,6 +11201,7 @@ declare namespace exports {
 		export let hasOwnProperty: string;
 		export let systemContext: string;
 		export let baseURI: string;
+		export let relativeUrl: string;
 		export let asyncModule: string;
 	}
 	export const UsageState: Readonly<{
@@ -11453,6 +11483,7 @@ declare namespace exports {
 		WebpackPluginInstance,
 		Asset,
 		AssetInfo,
+		MultiStats,
 		ParserState,
 		StatsCompilation
 	};

package/lib/FlagUsingEvalPlugin.js

@@ -1,44 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
-*/
-
-"use strict";
-
-const InnerGraph = require("./optimize/InnerGraph");
-
-/** @typedef {import("./Compiler")} Compiler */
-
-class FlagUsingEvalPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"FlagUsingEvalPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const handler = parser => {
-					parser.hooks.call.for("eval").tap("FlagUsingEvalPlugin", () => {
-						parser.state.module.buildInfo.moduleConcatenationBailout = "eval()";
-						parser.state.module.buildInfo.usingEval = true;
-						InnerGraph.bailout(parser.state);
-					});
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("FlagUsingEvalPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("FlagUsingEvalPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("FlagUsingEvalPlugin", handler);
-			}
-		);
-	}
-}
-
-module.exports = FlagUsingEvalPlugin;