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

package/lib/dependencies/ImportMetaResolveDependency.js

@@ -0,0 +1,90 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+const URLDependency = require("./URLDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+// `import.meta.resolve(specifier)` is the string form of
+// `new URL(specifier, import.meta.url)`, so it reuses the URL asset pipeline
+// but renders to the resolved URL string (`.href`) over the whole call.
+class ImportMetaResolveDependency extends URLDependency {
+	get type() {
+		return "import.meta.resolve()";
+	}
+}
+
+ImportMetaResolveDependency.Template = class ImportMetaResolveDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const {
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtimeTemplate,
+			runtime
+		} = templateContext;
+		const dep = /** @type {ImportMetaResolveDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering the dependency when it is conditional and inactive.
+		if (connection && !connection.isTargetActive(runtime)) {
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				"/* unused asset import */ undefined"
+			);
+			return;
+		}
+
+		runtimeRequirements.add(RuntimeGlobals.require);
+
+		const moduleRaw = runtimeTemplate.moduleRaw({
+			chunkGraph,
+			module: moduleGraph.getModule(dep),
+			request: dep.request,
+			runtimeRequirements,
+			weak: false
+		});
+
+		if (dep.relative) {
+			runtimeRequirements.add(RuntimeGlobals.relativeUrl);
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				`(new ${RuntimeGlobals.relativeUrl}(/* asset import */ ${moduleRaw})).href`
+			);
+		} else {
+			runtimeRequirements.add(RuntimeGlobals.baseURI);
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				`(new URL(/* asset import */ ${moduleRaw}, ${RuntimeGlobals.baseURI})).href`
+			);
+		}
+	}
+};
+
+makeSerializable(
+	ImportMetaResolveDependency,
+	"webpack/lib/dependencies/ImportMetaResolveDependency"
+);
+
+module.exports = ImportMetaResolveDependency;

package/lib/dependencies/ImportParserPlugin.js

@@ -6,12 +6,13 @@
 "use strict";
 
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
-const CommentCompilationWarning = require("../CommentCompilationWarning");
-const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const {
 	VariableInfo,
 	getImportAttributes
 } = require("../javascript/JavascriptParser");
+const memoize = require("../util/memoize");
 const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 const { getNonOptionalPart } = require("./HarmonyImportDependency");
@@ -42,11 +43,14 @@ const ImportWeakDependency = require("./ImportWeakDependency");
 /** @typedef {{ references: RawReferencedExports, expression: ImportExpression }} ImportSettings */
 /** @typedef {WeakMap<ImportExpression, RawReferencedExports>} State */
 
+const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
+
 /** @type {WeakMap<JavascriptParserState, State>} */
 const parserStateMap = new WeakMap();
 const dynamicImportTag = Symbol("import()");
 
 /**
+ * Returns import parser plugin state.
  * @param {JavascriptParser} parser javascript parser
  * @returns {State} import parser plugin state
  */
@@ -58,6 +62,7 @@ function getState(parser) {
 }
 
 /**
+ * Tag dynamic import referenced.
  * @param {JavascriptParser} parser javascript parser
  * @param {ImportExpression} importCall import expression
  * @param {string} variableName variable name
@@ -78,6 +83,7 @@ function tagDynamicImportReferenced(parser, importCall, variableName) {
 }
 
 /**
+ * Gets fulfilled callback namespace obj.
  * @param {CallExpression} importThen import().then() call
  * @returns {Identifier | ObjectPattern | undefined} the dynamic imported namespace obj
  */
@@ -96,6 +102,7 @@ function getFulfilledCallbackNamespaceObj(importThen) {
 }
 
 /**
+ * Walk import then fulfilled callback.
  * @param {JavascriptParser} parser javascript parser
  * @param {ImportExpression} importCall import expression
  * @param {ArrowFunctionExpression | FunctionExpression} fulfilledCallback the fulfilled callback
@@ -157,6 +164,7 @@ function walkImportThenFulfilledCallback(
 }
 
 /**
+ * Exports from enumerable.
  * @template T
  * @param {Iterable<T>} enumerable enumerable
  * @returns {T[][]} array of array
@@ -166,15 +174,59 @@ const exportsFromEnumerable = (enumerable) =>
 
 const PLUGIN_NAME = "ImportParserPlugin";
 
+/**
+ * Whether an `import()` second argument is a fully static attributes object
+ * (every `with`/`assert` value is a string literal). Only then can webpack use
+ * the attributes at build time; otherwise the argument must be evaluated and
+ * validated at runtime per spec.
+ * @param {import("estree").Expression | null | undefined} node the second-argument AST node
+ * @returns {boolean} true if statically extractable
+ */
+const isStaticStringAttributes = (node) => {
+	if (!node || node.type !== "ObjectExpression") return false;
+	for (const prop of node.properties) {
+		if (prop.type !== "Property" || prop.kind !== "init" || prop.computed) {
+			return false;
+		}
+		const key = prop.key;
+		const keyName =
+			key.type === "Identifier"
+				? key.name
+				: key.type === "Literal"
+					? key.value
+					: undefined;
+		if (keyName === "with" || keyName === "assert") {
+			const value = prop.value;
+			if (value.type !== "ObjectExpression") return false;
+			for (const attr of value.properties) {
+				if (attr.type !== "Property" || attr.kind !== "init" || attr.computed) {
+					return false;
+				}
+				const attrValue = attr.value;
+				if (
+					attrValue.type !== "Literal" ||
+					typeof attrValue.value !== "string"
+				) {
+					return false;
+				}
+			}
+		}
+	}
+	return true;
+};
+
 class ImportParserPlugin {
 	/**
+	 * Creates an instance of ImportParserPlugin.
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
+		/** @type {JavascriptParserOptions} */
 		this.options = options;
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
@@ -266,6 +318,7 @@ class ImportParserPlugin {
 
 			const {
 				dynamicImportPreload,
+				dynamicImportCssPreload,
 				dynamicImportPrefetch,
 				dynamicImportFetchPriority
 			} = this.options;
@@ -276,6 +329,13 @@ class ImportParserPlugin {
 				groupOptions.preloadOrder =
 					dynamicImportPreload === true ? 0 : dynamicImportPreload;
 			}
+			if (
+				dynamicImportCssPreload !== undefined &&
+				dynamicImportCssPreload !== false
+			) {
+				groupOptions.cssPreloadOrder =
+					dynamicImportCssPreload === true ? 0 : dynamicImportCssPreload;
+			}
 			if (
 				dynamicImportPrefetch !== undefined &&
 				dynamicImportPrefetch !== false
@@ -299,7 +359,7 @@ class ImportParserPlugin {
 					parser.state.module.addWarning(
 						new CommentCompilationWarning(
 							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-							/** @type {DependencyLocation} */ (comment.loc)
+							parser.getLocation(comment)
 						)
 					);
 				}
@@ -316,7 +376,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else if (importOptions.webpackIgnore) {
@@ -329,7 +389,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -341,7 +401,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -357,7 +417,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					}
@@ -371,7 +431,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					}
@@ -388,7 +448,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackFetchPriority\` expected true or "low", "high" or "auto", but received: ${importOptions.webpackFetchPriority}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					}
@@ -401,7 +461,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -416,7 +476,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -424,19 +484,17 @@ class ImportParserPlugin {
 					}
 				}
 				if (importOptions.webpackExports !== undefined) {
-					if (
-						!(
-							typeof importOptions.webpackExports === "string" ||
-							(Array.isArray(importOptions.webpackExports) &&
-								importOptions.webpackExports.every(
-									(item) => typeof item === "string"
-								))
-						)
-					) {
+					if (!(
+						typeof importOptions.webpackExports === "string" ||
+						(Array.isArray(importOptions.webpackExports) &&
+							importOptions.webpackExports.every(
+								(item) => typeof item === "string"
+							))
+					)) {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else if (typeof importOptions.webpackExports === "string") {
@@ -445,6 +503,20 @@ class ImportParserPlugin {
 						exports = exportsFromEnumerable(importOptions.webpackExports);
 					}
 				}
+				// `worker` is an internal entry option set only for workers
+				if (
+					importOptions.webpackEntryOptions !== undefined &&
+					typeof importOptions.webpackEntryOptions === "object" &&
+					importOptions.webpackEntryOptions !== null &&
+					importOptions.webpackEntryOptions.worker !== undefined
+				) {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							"`worker` entry option is not supported in `import()`, it only applies to workers (e.g. `new Worker(new URL(...))`).",
+							parser.getLocation(expr)
+						)
+					);
+				}
 			}
 
 			if (
@@ -456,7 +528,7 @@ class ImportParserPlugin {
 				parser.state.module.addWarning(
 					new UnsupportedFeatureWarning(
 						`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
-						/** @type {DependencyLocation} */ (expr.loc)
+						parser.getLocation(expr)
 					)
 				);
 				mode = "lazy";
@@ -477,7 +549,7 @@ class ImportParserPlugin {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
 							"You don't need `webpackExports` if the usage of dynamic import is statically analyse-able. You can safely remove the `webpackExports` magic comment.",
-							/** @type {DependencyLocation} */ (expr.loc)
+							parser.getLocation(expr)
 						)
 					);
 				}
@@ -529,20 +601,35 @@ class ImportParserPlugin {
 							...groupOptions,
 							name: chunkName
 						},
-						/** @type {DependencyLocation} */ (expr.loc),
+						parser.getLocation(expr),
 						param.string
 					);
+					// A second argument that isn't a statically extractable attributes
+					// object still has to be evaluated and validated at runtime, so
+					// drop the (unreliable) static attributes for it.
+					const optionsNode = expr.options;
+					const runtimeValidateOptions = Boolean(
+						optionsNode && !isStaticStringAttributes(optionsNode)
+					);
 					const dep = new ImportDependency(
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
 						phase,
-						attributes
+						runtimeValidateOptions ? undefined : attributes
 					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					if (runtimeValidateOptions && optionsNode && optionsNode.range) {
+						dep.optionsRange = /** @type {Range} */ (optionsNode.range);
+						// The options expression stays in the output, so walk it to
+						// register its variable references and keep them from being
+						// tree-shaken away.
+						parser.walkExpression(optionsNode);
+					}
+					dep.loc = parser.getLocation(expr);
 					dep.optional = Boolean(parser.scope.inTry);
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
+					getHarmonyImportGuard().attachDependencyGuards(parser, dep);
 				}
 			} else {
 				if (mode === "weak") {
@@ -575,7 +662,7 @@ class ImportParserPlugin {
 					parser
 				);
 				if (!dep) return;
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.current.addDependency(dep);
 			}

package/lib/dependencies/ImportPhase.js

@@ -8,7 +8,7 @@
 const memoize = require("../util/memoize");
 
 const getCommentCompilationWarning = memoize(() =>
-	require("../CommentCompilationWarning")
+	require("../errors/CommentCompilationWarning")
 );
 
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
@@ -28,6 +28,7 @@ const ImportPhase = Object.freeze({
 /** @typedef {"defer" | "source" | "evaluation"} ImportPhaseName */
 
 /**
+ * Defines the import phase utils type used by this module.
  * @typedef {object} ImportPhaseUtils
  * @property {(phase: ImportPhaseType | undefined) => boolean} isEvaluation true if phase is evaluation
  * @property {(phase: ImportPhaseType | undefined) => boolean} isDefer true if phase is defer
@@ -59,10 +60,12 @@ const ImportPhaseUtils = {
 };
 
 /**
+ * Defines the get comment options type used by this module.
  * @typedef {() => Record<string, EXPECTED_ANY> | null} GetCommentOptions
  */
 
 /**
+ * Defines the get import phase callback.
  * @callback GetImportPhase
  * @param {JavascriptParser} parser parser
  * @param {ExportNamedDeclaration | ExportAllDeclaration | ImportDeclaration | ImportExpression} node node
@@ -71,8 +74,9 @@ const ImportPhaseUtils = {
  */
 
 /**
- * @param {boolean=} enableDeferPhase enable import phase detection
- * @param {boolean=} enableSourcePhase enable import phase detection
+ * Creates an import phase resolver.
+ * @param {boolean=} enableDeferPhase enable defer phase detection
+ * @param {boolean=} enableSourcePhase enable source phase detection
  * @returns {GetImportPhase} evaluates the import phase for ast node
  */
 function createGetImportPhase(enableDeferPhase, enableSourcePhase) {
@@ -99,15 +103,13 @@ function createGetImportPhase(enableDeferPhase, enableSourcePhase) {
 				if (!node.range) return null;
 				const { options, errors } = parser.parseCommentOptions(node.range);
 				if (errors) {
+					const CommentCompilationWarning = getCommentCompilationWarning();
 					for (const e of errors) {
 						const { comment } = e;
-						if (!comment.loc) continue;
-
-						const CommentCompilationWarning = getCommentCompilationWarning();
 						parser.state.module.addWarning(
 							new CommentCompilationWarning(
 								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-								comment.loc
+								parser.getLocation(comment)
 							)
 						);
 					}
@@ -130,13 +132,15 @@ function createGetImportPhase(enableDeferPhase, enableSourcePhase) {
 		if (enableDeferPhase && typeof options.webpackDefer !== "undefined") {
 			if (typeof webpackDefer === "boolean") {
 				return webpackDefer ? ImportPhase.Defer : phaseBySyntax;
-			} else if (node.loc) {
+			}
+			const loc = parser.getLocation(node);
+			if (loc) {
 				const CommentCompilationWarning = getCommentCompilationWarning();
 
 				parser.state.module.addWarning(
 					new CommentCompilationWarning(
 						"webpackDefer magic comment expected a boolean value.",
-						node.loc
+						loc
 					)
 				);
 			}
@@ -145,13 +149,15 @@ function createGetImportPhase(enableDeferPhase, enableSourcePhase) {
 		if (enableSourcePhase && typeof options.webpackSource !== "undefined") {
 			if (typeof webpackSource === "boolean") {
 				return webpackSource ? ImportPhase.Source : phaseBySyntax;
-			} else if (node.loc) {
+			}
+			const loc = parser.getLocation(node);
+			if (loc) {
 				const CommentCompilationWarning = getCommentCompilationWarning();
 
 				parser.state.module.addWarning(
 					new CommentCompilationWarning(
 						"webpackSource magic comment expected a boolean value.",
-						node.loc
+						loc
 					)
 				);
 			}

package/lib/dependencies/ImportPlugin.js

@@ -24,7 +24,7 @@ const PLUGIN_NAME = "ImportPlugin";
 
 class ImportPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -69,6 +69,7 @@ class ImportPlugin {
 				);
 
 				/**
+				 * Handles the hook callback for this code path.
 				 * @param {Parser} parser parser parser
 				 * @param {JavascriptParserOptions} parserOptions parserOptions
 				 * @returns {void}

package/lib/dependencies/ImportWeakDependency.js

@@ -20,6 +20,7 @@ const ImportDependency = require("./ImportDependency");
 
 class ImportWeakDependency extends ImportDependency {
 	/**
+	 * Creates an instance of ImportWeakDependency.
 	 * @param {string} request the request
 	 * @param {Range} range expression range
 	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
@@ -28,6 +29,7 @@ class ImportWeakDependency extends ImportDependency {
 	 */
 	constructor(request, range, referencedExports, phase, attributes) {
 		super(request, range, referencedExports, phase, attributes);
+		/** @type {boolean} */
 		this.weak = true;
 	}
 
@@ -45,6 +47,7 @@ ImportWeakDependency.Template = class ImportDependencyTemplate extends (
 	ImportDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object

package/lib/dependencies/JsonExportsDependency.js

@@ -14,11 +14,12 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../json/JsonData")} JsonData */
 /** @typedef {import("../json/JsonData").JsonValue} JsonValue */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[JsonData, number]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[JsonData, number]>} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 
 /**
+ * Defines the get exports from data fn callback.
  * @callback GetExportsFromDataFn
  * @param {JsonValue} data raw json data
  * @param {number=} curDepth current depth
@@ -26,6 +27,7 @@ const NullDependency = require("./NullDependency");
  */
 
 /**
+ * Gets exports with depth.
  * @param {number} exportsDepth exportsDepth
  * @returns {GetExportsFromDataFn} value
  */
@@ -71,12 +73,15 @@ const getExportsWithDepth = (exportsDepth) =>
 
 class JsonExportsDependency extends NullDependency {
 	/**
+	 * Creates an instance of JsonExportsDependency.
 	 * @param {JsonData} data json data
 	 * @param {number} exportsDepth the depth of json exports to analyze
 	 */
 	constructor(data, exportsDepth) {
 		super();
+		/** @type {JsonData} */
 		this.data = data;
+		/** @type {number} */
 		this.exportsDepth = exportsDepth;
 	}
 
@@ -99,7 +104,7 @@ class JsonExportsDependency extends NullDependency {
 	}
 
 	/**
-	 * 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}
@@ -109,23 +114,23 @@ class JsonExportsDependency extends NullDependency {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.data);
-		write(this.exportsDepth);
+		context.write(this.data).write(this.exportsDepth);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.data = read();
-		this.exportsDepth = read();
-		super.deserialize(context);
+		this.data = context.read();
+		const c1 = context.rest;
+		this.exportsDepth = c1.read();
+		super.deserialize(c1.rest);
 	}
 }
 

package/lib/dependencies/LoaderDependency.js

@@ -12,6 +12,7 @@ const ModuleDependency = require("./ModuleDependency");
 
 class LoaderDependency extends ModuleDependency {
 	/**
+	 * Creates an instance of LoaderDependency.
 	 * @param {string} request request string
 	 */
 	constructor(request) {
@@ -27,6 +28,7 @@ class LoaderDependency extends ModuleDependency {
 	}
 
 	/**
+	 * 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
 	 */

package/lib/dependencies/LoaderImportDependency.js

@@ -12,10 +12,12 @@ const ModuleDependency = require("./ModuleDependency");
 
 class LoaderImportDependency extends ModuleDependency {
 	/**
+	 * Creates an instance of LoaderImportDependency.
 	 * @param {string} request request string
 	 */
 	constructor(request) {
 		super(request);
+		/** @type {boolean} */
 		this.weak = true;
 	}
 
@@ -28,6 +30,7 @@ class LoaderImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * 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
 	 */