@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/DependenciesBlock.js

@@ -53,6 +53,7 @@ class DependenciesBlock {
 	}
 
 	/**
+	 * Adds the provided dependency to the dependencies block.
 	 * @param {Dependency} dependency dependency being tied to block.
 	 * This is an "edge" pointing to another "node" on module graph.
 	 * @returns {void}
@@ -62,6 +63,7 @@ class DependenciesBlock {
 	}
 
 	/**
+	 * Removes dependency.
 	 * @param {Dependency} dependency dependency being removed
 	 * @returns {void}
 	 */
@@ -73,7 +75,7 @@ class DependenciesBlock {
 	}
 
 	/**
-	 * Removes all dependencies and blocks
+	 * Clear dependencies and blocks.
 	 * @returns {void}
 	 */
 	clearDependenciesAndBlocks() {
@@ -82,6 +84,7 @@ class DependenciesBlock {
 	}
 
 	/**
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash the hash used to track dependencies
 	 * @param {UpdateHashContext} context context
 	 * @returns {void}
@@ -96,6 +99,7 @@ class DependenciesBlock {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize({ write }) {
@@ -104,6 +108,7 @@ class DependenciesBlock {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize({ read }) {

package/lib/Dependency.js

@@ -14,13 +14,14 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./errors/WebpackError")} WebpackError */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
 /**
+ * Defines the update hash context type used by this module.
  * @typedef {object} UpdateHashContext
  * @property {ChunkGraph} chunkGraph
  * @property {RuntimeSpec} runtime
@@ -28,12 +29,14 @@ const memoize = require("./util/memoize");
  */
 
 /**
+ * Defines the source position type used by this module.
  * @typedef {object} SourcePosition
  * @property {number} line
  * @property {number=} column
  */
 
 /**
+ * Defines the real dependency location type used by this module.
  * @typedef {object} RealDependencyLocation
  * @property {SourcePosition} start
  * @property {SourcePosition=} end
@@ -41,6 +44,7 @@ const memoize = require("./util/memoize");
  */
 
 /**
+ * Defines the synthetic dependency location type used by this module.
  * @typedef {object} SyntheticDependencyLocation
  * @property {string} name
  * @property {number=} index
@@ -51,20 +55,24 @@ const memoize = require("./util/memoize");
 /** @typedef {string} ExportInfoName */
 
 /**
+ * Defines the export spec type used by this module.
  * @typedef {object} ExportSpec
  * @property {ExportInfoName} name the name of the export
  * @property {boolean=} canMangle can the export be renamed (defaults to true)
  * @property {boolean=} terminalBinding is the export a terminal binding that should be checked for export star conflicts
+ * @property {boolean=} isPure calling this export has no observable side effects
  * @property {(string | ExportSpec)[]=} exports nested exports
  * @property {ModuleGraphConnection=} from when reexported: from which module
  * @property {string[] | null=} export when reexported: from which export
  * @property {number=} priority when reexported: with which priority
  * @property {boolean=} hidden export is not visible, because another export blends over it
+ * @property {import("./optimize/InlineExports").InlinedValue=} inlined when set: the export binds to a small primitive constant eligible for inlining
  */
 
 /** @typedef {Set<string>} ExportsSpecExcludeExports */
 
 /**
+ * Defines the exports spec type used by this module.
  * @typedef {object} ExportsSpec
  * @property {(string | ExportSpec)[] | true | null} exports exported names, true for unknown exports or null for no exports
  * @property {ExportsSpecExcludeExports=} excludeExports when exports = true, list of unaffected exports
@@ -73,13 +81,16 @@ const memoize = require("./util/memoize");
  * @property {number=} priority when reexported: with which priority
  * @property {boolean=} canMangle can the export be renamed (defaults to true)
  * @property {boolean=} terminalBinding are the exports terminal bindings that should be checked for export star conflicts
+ * @property {boolean=} isPure calling these exports has no observable side effects
  * @property {Module[]=} dependencies module on which the result depends on
  */
 
 /**
+ * Defines the referenced export type used by this module.
  * @typedef {object} ReferencedExport
  * @property {string[]} name name of the referenced export
  * @property {boolean=} canMangle when false, referenced export can not be mangled, defaults to true
+ * @property {boolean=} canInline when false, the referenced export can not be substituted with an inlined literal at this site, defaults to true
  */
 
 /** @typedef {string[][]} RawReferencedExports */
@@ -87,6 +98,20 @@ const memoize = require("./util/memoize");
 
 /** @typedef {(moduleGraphConnection: ModuleGraphConnection, runtime: RuntimeSpec) => ConnectionState} GetConditionFn */
 
+/**
+ * Lazy barrel classification of a dependency within a side-effect-free module.
+ * `LAZY_UNTIL_LOCAL`: locally provided export name (`getLazyName`), requesting it requires no dependency.
+ * `LAZY_UNTIL_ID`: named re-export (`getLazyName`) deferred until the export name is requested.
+ * `LAZY_UNTIL_FALLBACK`: star re-export, deferred until an unknown name or all names are requested.
+ * `LAZY_UNTIL_REQUEST`: deferred together with other dependencies of the same request.
+ * @typedef {"local" | "id" | "*" | "@"} LazyUntil
+ */
+
+const LAZY_UNTIL_LOCAL = /** @type {"local"} */ ("local");
+const LAZY_UNTIL_ID = /** @type {"id"} */ ("id");
+const LAZY_UNTIL_FALLBACK = /** @type {"*"} */ ("*");
+const LAZY_UNTIL_REQUEST = /** @type {"@"} */ ("@");
+
 const TRANSITIVE = /** @type {symbol} */ (Symbol("transitive"));
 
 const getIgnoredModule = memoize(() => {
@@ -105,15 +130,16 @@ class Dependency {
 		this._parentDependenciesBlock = undefined;
 		/** @type {number} */
 		this._parentDependenciesBlockIndex = -1;
-		// TODO check if this can be moved into ModuleDependency
-		/** @type {boolean} */
-		this.weak = false;
-		// TODO check if this can be moved into ModuleDependency
+		// stays on base: also set on ContextDependency, which is not a ModuleDependency
 		/** @type {boolean | undefined} */
 		this.optional = false;
+		/** @type {number} */
 		this._locSL = 0;
+		/** @type {number} */
 		this._locSC = 0;
+		/** @type {number} */
 		this._locEL = 0;
+		/** @type {number} */
 		this._locEC = 0;
 		/** @type {undefined | number} */
 		this._locI = undefined;
@@ -124,6 +150,7 @@ class Dependency {
 	}
 
 	/**
+	 * Returns a display name for the type of dependency.
 	 * @returns {string} a display name for the type of dependency
 	 */
 	get type() {
@@ -131,6 +158,7 @@ class Dependency {
 	}
 
 	/**
+	 * Returns a dependency category, typical categories are "commonjs", "amd", "esm".
 	 * @returns {string} a dependency category, typical categories are "commonjs", "amd", "esm"
 	 */
 	get category() {
@@ -138,6 +166,7 @@ class Dependency {
 	}
 
 	/**
+	 * Returns location.
 	 * @returns {DependencyLocation} location
 	 */
 	get loc() {
@@ -179,10 +208,14 @@ class Dependency {
 		}
 		this._locI = "index" in loc ? loc.index : undefined;
 		this._locN = "name" in loc ? loc.name : undefined;
-		this._loc = loc;
+		// Don't retain the passed object; `get loc` rebuilds it from the numbers
+		// above on demand, so dependencies whose loc is never read hold 4 numbers
+		// instead of a SourceLocation + two Position objects.
+		this._loc = undefined;
 	}
 
 	/**
+	 * Updates loc using the provided start line.
 	 * @param {number} startLine start line
 	 * @param {number} startColumn start column
 	 * @param {number} endLine end line
@@ -199,6 +232,43 @@ class Dependency {
 	}
 
 	/**
+	 * Updates loc from a source location plus an explicit index, without
+	 * materializing the `loc` object (keeps `get loc` lazy). Replaces the
+	 * `dep.loc = Object.create(loc); dep.loc.index = i` pattern, which both
+	 * allocated a copy and stored the index outside the serialized fields.
+	 * @param {DependencyLocation} loc source location (start/end/name read from it)
+	 * @param {number} index dependency index within the statement
+	 */
+	setLocWithIndex(loc, index) {
+		this.loc = loc;
+		this._locI = index;
+	}
+
+	/**
+	 * Compares two dependencies by source location for sorting a module's
+	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
+	 * its result, so comparing through it would retain a location object on every
+	 * sorted dependency). These dependencies always carry a real source position,
+	 * so only start (line, column) and the within-statement index are compared; a
+	 * dependency without an index sorts after one that has an index at the same
+	 * position.
+	 * @param {Dependency} a first dependency
+	 * @param {Dependency} b second dependency
+	 * @returns {-1 | 0 | 1} compare result
+	 */
+	static compareLocations(a, b) {
+		if (a._locSL !== b._locSL) return a._locSL < b._locSL ? -1 : 1;
+		if (a._locSC !== b._locSC) return a._locSC < b._locSC ? -1 : 1;
+		const ai = a._locI;
+		const bi = b._locI;
+		if (ai === bi) return 0;
+		if (ai === undefined) return 1;
+		if (bi === undefined) return -1;
+		return ai < bi ? -1 : 1;
+	}
+
+	/**
+	 * Returns a request context.
 	 * @returns {string | undefined} a request context
 	 */
 	getContext() {
@@ -206,6 +276,7 @@ class Dependency {
 	}
 
 	/**
+	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
@@ -213,12 +284,52 @@ class Dependency {
 	}
 
 	/**
+	 * Could affect referencing module.
 	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
 	 */
 	couldAffectReferencingModule() {
 		return TRANSITIVE;
 	}
 
+	/**
+	 * Returns the export name this dependency requests from its target module (lazy barrel optimization).
+	 * @returns {string | true | null} export name, true for all exports, null for none
+	 */
+	getForwardId() {
+		// unknown dependency types conservatively request all exports
+		return true;
+	}
+
+	/**
+	 * Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).
+	 * @returns {LazyUntil | null} lazy classification, null when it must be processed eagerly
+	 */
+	getLazyUntil() {
+		return null;
+	}
+
+	/**
+	 * Returns the export name for a `LAZY_UNTIL_LOCAL`/`LAZY_UNTIL_ID` classification (lazy barrel optimization).
+	 * @returns {string | null} export name, null when not applicable
+	 */
+	getLazyName() {
+		return null;
+	}
+
+	/**
+	 * Whether the lazy barrel currently defers creating this dependency's target module (lazy barrel optimization).
+	 * @returns {boolean} true while deferred, so it must not be processed or rendered
+	 */
+	isLazy() {
+		return false;
+	}
+
+	/**
+	 * Sets whether the lazy barrel defers creating this dependency's target module (lazy barrel optimization).
+	 * @param {boolean} value true to defer, false to create it now
+	 */
+	setLazy(value) {}
+
 	/**
 	 * Returns the referenced module and export
 	 * @deprecated
@@ -242,6 +353,7 @@ class Dependency {
 	}
 
 	/**
+	 * Returns function to determine if the connection is active.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
 	 */
@@ -259,7 +371,7 @@ class Dependency {
 	}
 
 	/**
-	 * Returns warnings
+	 * Returns warnings.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {WebpackError[] | null | undefined} warnings
 	 */
@@ -268,7 +380,7 @@ class Dependency {
 	}
 
 	/**
-	 * Returns errors
+	 * Returns errors.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {WebpackError[] | null | undefined} errors
 	 */
@@ -277,7 +389,7 @@ class Dependency {
 	}
 
 	/**
-	 * Update the hash
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash hash to be updated
 	 * @param {UpdateHashContext} context context
 	 * @returns {void}
@@ -293,6 +405,7 @@ class Dependency {
 	}
 
 	/**
+	 * Gets module evaluation side effects state.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
 	 */
@@ -301,6 +414,7 @@ class Dependency {
 	}
 
 	/**
+	 * Creates an ignored module.
 	 * @param {string} context context directory
 	 * @returns {Module} ignored module
 	 */
@@ -309,10 +423,18 @@ class Dependency {
 	}
 
 	/**
+	 * Returns true if this dependency can be concatenated
+	 * @returns {boolean} true if this dependency can be concatenated
+	 */
+	canConcatenate() {
+		return false;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize({ write }) {
-		write(this.weak);
 		write(this.optional);
 		write(this._locSL);
 		write(this._locSC);
@@ -323,10 +445,10 @@ class Dependency {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize({ read }) {
-		this.weak = read();
 		this.optional = read();
 		this._locSL = read();
 		this._locSC = read();
@@ -341,10 +463,16 @@ class Dependency {
 Dependency.NO_EXPORTS_REFERENCED = [];
 /** @type {RawReferencedExports} */
 Dependency.EXPORTS_OBJECT_REFERENCED = [[]];
+// Like EXPORTS_OBJECT_REFERENCED, but the reference can be rendered as a
+// decoupled namespace object, so the module's exports stay mangleable.
+// Same shape as EXPORTS_OBJECT_REFERENCED; only distinguished by identity.
+/** @type {RawReferencedExports} */
+Dependency.EXPORTS_OBJECT_REFERENCED_MANGLEABLE = [[]];
 
 // TODO remove in webpack 6
 Object.defineProperty(Dependency.prototype, "module", {
 	/**
+	 * Returns throws.
 	 * @deprecated
 	 * @returns {EXPECTED_ANY} throws
 	 */
@@ -355,6 +483,7 @@ Object.defineProperty(Dependency.prototype, "module", {
 	},
 
 	/**
+	 * Updates module.
 	 * @deprecated
 	 * @returns {never} throws
 	 */
@@ -366,15 +495,30 @@ Object.defineProperty(Dependency.prototype, "module", {
 });
 
 /**
+ * Returns true if the dependency is a low priority dependency.
  * @param {Dependency} dependency dep
  * @returns {boolean} true if the dependency is a low priority dependency
  */
 Dependency.isLowPriorityDependency = (dependency) =>
 	/** @type {ModuleDependency} */ (dependency).sourceOrder === Infinity;
 
+// TODO in webpack 6, call canConcatenate() directly on the dependency instance instead of using this static method.
+/**
+ * Returns true if the dependency can be concatenated (scope hoisting).
+ * @param {Dependency} dependency dep
+ * @returns {boolean} true if this dependency supports concatenation
+ */
+Dependency.canConcatenate = (dependency) => {
+	if (typeof dependency.canConcatenate === "function") {
+		return dependency.canConcatenate();
+	}
+	return false;
+};
+
 // TODO remove in webpack 6
 Object.defineProperty(Dependency.prototype, "disconnect", {
 	/**
+	 * Returns throws.
 	 * @deprecated
 	 * @returns {EXPECTED_ANY} throws
 	 */
@@ -386,5 +530,9 @@ Object.defineProperty(Dependency.prototype, "disconnect", {
 });
 
 Dependency.TRANSITIVE = TRANSITIVE;
+Dependency.LAZY_UNTIL_LOCAL = LAZY_UNTIL_LOCAL;
+Dependency.LAZY_UNTIL_ID = LAZY_UNTIL_ID;
+Dependency.LAZY_UNTIL_FALLBACK = LAZY_UNTIL_FALLBACK;
+Dependency.LAZY_UNTIL_REQUEST = LAZY_UNTIL_REQUEST;
 
 module.exports = Dependency;

package/lib/DependencyTemplate.js

@@ -19,11 +19,13 @@
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 
 /**
+ * Defines the init fragment type used by this module.
  * @template T
  * @typedef {import("./InitFragment")<T>} InitFragment
  */
 
 /**
+ * Defines the dependency template context type used by this module.
  * @typedef {object} DependencyTemplateContext
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
@@ -39,15 +41,18 @@
  */
 
 /**
+ * Defines the css dependency template context extras type used by this module.
  * @typedef {object} CssDependencyTemplateContextExtras
  * @property {CssData} cssData the css exports data
  * @property {string} type the css exports data
  */
 
 /**
+ * Defines the css data type used by this module.
  * @typedef {object} CssData
  * @property {boolean} esModule whether export __esModule
  * @property {Map<string, string>} exports the css exports
+ * @property {Map<string, { line: number, column: number }>=} exportLocs source position (line is 1-based, column is 0-based) of each export's defining identifier in the original CSS, used to emit fine-grained JS-to-CSS source mappings
  */
 
 /** @typedef {DependencyTemplateContext & CssDependencyTemplateContextExtras} CssDependencyTemplateContext */
@@ -55,6 +60,7 @@
 class DependencyTemplate {
 	/* istanbul ignore next */
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @abstract
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
@@ -62,7 +68,7 @@ class DependencyTemplate {
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const AbstractMethodError = require("./AbstractMethodError");
+		const AbstractMethodError = require("./errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}

package/lib/DependencyTemplates.js

@@ -14,6 +14,7 @@ const createHash = require("./util/createHash");
 
 class DependencyTemplates {
 	/**
+	 * Creates an instance of DependencyTemplates.
 	 * @param {HashFunction} hashFunction the hash function to use
 	 */
 	constructor(hashFunction = DEFAULTS.HASH_FUNCTION) {
@@ -26,6 +27,7 @@ class DependencyTemplates {
 	}
 
 	/**
+	 * Returns template for this dependency.
 	 * @param {DependencyConstructor} dependency Constructor of Dependency
 	 * @returns {DependencyTemplate | undefined} template for this dependency
 	 */
@@ -34,6 +36,7 @@ class DependencyTemplates {
 	}
 
 	/**
+	 * Updates value using the provided dependency.
 	 * @param {DependencyConstructor} dependency Constructor of Dependency
 	 * @param {DependencyTemplate} dependencyTemplate template for this dependency
 	 * @returns {void}
@@ -43,6 +46,7 @@ class DependencyTemplates {
 	}
 
 	/**
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {string} part additional hash contributor
 	 * @returns {void}
 	 */

package/lib/DotenvPlugin.js

@@ -214,6 +214,7 @@ const envToDefinitions = (env) => {
 
 class DotenvPlugin {
 	/**
+	 * Creates an instance of DotenvPlugin.
 	 * @param {DotenvPluginOptions=} options options object
 	 */
 	constructor(options = {}) {
@@ -222,6 +223,7 @@ class DotenvPlugin {
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -355,6 +357,7 @@ class DotenvPlugin {
 	}
 
 	/**
+	 * Loads the provided compiler.
 	 * @private
 	 * @param {Compiler} compiler compiler
 	 * @param {ItemCacheFacade} itemCache item cache facade

package/lib/DynamicEntryPlugin.js

@@ -21,6 +21,7 @@ const PLUGIN_NAME = "DynamicEntryPlugin";
 
 class DynamicEntryPlugin {
 	/**
+	 * Creates an instance of DynamicEntryPlugin.
 	 * @param {string} context the context path
 	 * @param {EntryDynamic} entry the entry value
 	 */
@@ -32,7 +33,7 @@ class DynamicEntryPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -65,6 +66,7 @@ class DynamicEntryPlugin {
 							promises.push(
 								new Promise(
 									/**
+									 * Handles the callback logic for this hook.
 									 * @param {(value?: undefined) => void} resolve resolve
 									 * @param {(reason?: Error) => void} reject reject
 									 */

package/lib/EntryOptionPlugin.js

@@ -5,15 +5,41 @@
 
 "use strict";
 
+const { SyncBailHook } = require("tapable");
+
 /** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
 /** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 
+/**
+ * @typedef {object} EntryOptionPluginHooks
+ * @property {SyncBailHook<[string, string, EntryDescription], string | undefined>} entry transform an entry into a different request (e.g. wrap a non-HTML entry in a synthetic HTML module); return `undefined` to keep the default behavior
+ */
+
 const PLUGIN_NAME = "EntryOptionPlugin";
 
+/** @type {WeakMap<Compiler, EntryOptionPluginHooks>} */
+const hooksMap = new WeakMap();
+
 class EntryOptionPlugin {
 	/**
+	 * @param {Compiler} compiler the compiler
+	 * @returns {EntryOptionPluginHooks} the hooks
+	 */
+	static getHooks(compiler) {
+		let hooks = hooksMap.get(compiler);
+		if (hooks === undefined) {
+			hooks = {
+				entry: new SyncBailHook(["context", "name", "entryDescription"])
+			};
+			hooksMap.set(compiler, hooks);
+		}
+		return hooks;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance one is tapping into
 	 * @returns {void}
 	 */
@@ -25,6 +51,7 @@ class EntryOptionPlugin {
 	}
 
 	/**
+	 * Apply entry option.
 	 * @param {Compiler} compiler the compiler
 	 * @param {string} context context directory
 	 * @param {Entry} entry request
@@ -48,14 +75,26 @@ class EntryOptionPlugin {
 				const descImport =
 					/** @type {Exclude<EntryDescription["import"], undefined>} */
 					(desc.import);
-				for (const entry of descImport) {
-					new EntryPlugin(context, entry, options).apply(compiler);
+				// A plugin (e.g. HtmlModulesPlugin) may rewrite the entry into a
+				// single synthetic request; otherwise each import becomes an entry.
+				const request = EntryOptionPlugin.getHooks(compiler).entry.call(
+					context,
+					name,
+					desc
+				);
+				if (request !== undefined) {
+					new EntryPlugin(context, request, options).apply(compiler);
+				} else {
+					for (const entry of descImport) {
+						new EntryPlugin(context, entry, options).apply(compiler);
+					}
 				}
 			}
 		}
 	}
 
 	/**
+	 * Entry description to options.
 	 * @param {Compiler} compiler the compiler
 	 * @param {string} name entry name
 	 * @param {EntryDescription} desc entry description
@@ -74,6 +113,7 @@ class EntryOptionPlugin {
 			chunkLoading: desc.chunkLoading,
 			asyncChunks: desc.asyncChunks,
 			wasmLoading: desc.wasmLoading,
+			worker: desc.worker,
 			library: desc.library
 		};
 		if (desc.chunkLoading) {

package/lib/EntryPlugin.js

@@ -20,13 +20,15 @@ class EntryPlugin {
 	 * @param {EntryOptions | string=} options entry options (passing a string is deprecated)
 	 */
 	constructor(context, entry, options) {
+		/** @type {string} */
 		this.context = context;
+		/** @type {string} */
 		this.entry = entry;
 		this.options = options || "";
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -52,6 +54,7 @@ class EntryPlugin {
 	}
 
 	/**
+	 * Creates a dependency.
 	 * @param {string} entry entry request
 	 * @param {EntryOptions | string} options entry options (passing string is deprecated)
 	 * @returns {EntryDependency} the dependency