webpack 5.69.1 → 5.70.0

package/lib/Generator.js

@@ -38,6 +38,7 @@
  * @property {NormalModule} module the module
  * @property {ChunkGraph} chunkGraph
  * @property {RuntimeSpec} runtime
+ * @property {RuntimeTemplate=} runtimeTemplate
  */
 
 /**

package/lib/ModuleHashingError.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @typedef {import("./Module")} Module */
+
+class ModuleHashingError extends WebpackError {
+	/**
+	 * Create a new ModuleHashingError
+	 * @param {Module} module related module
+	 * @param {Error} error Original error
+	 */
+	constructor(module, error) {
+		super();
+
+		this.name = "ModuleHashingError";
+		this.error = error;
+		this.message = error.message;
+		this.details = error.stack;
+		this.module = module;
+	}
+}
+
+module.exports = ModuleHashingError;

package/lib/NodeStuffPlugin.js

@@ -69,6 +69,16 @@ class NodeStuffPlugin {
 									);
 								}
 							});
+						parser.hooks.rename.for("global").tap("NodeStuffPlugin", expr => {
+							const dep = new ConstDependency(
+								RuntimeGlobals.global,
+								expr.range,
+								[RuntimeGlobals.global]
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return false;
+						});
 					}
 
 					const setModuleConstant = (expressionName, fn, warning) => {

package/lib/NormalModule.js

@@ -50,6 +50,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext */
 /** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compiler")} Compiler */
@@ -194,6 +195,25 @@ makeSerializable(
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
  */
 
+/**
+ * @typedef {Object} NormalModuleCreateData
+ * @property {string=} layer an optional layer in which the module is
+ * @property {string} type module type
+ * @property {string} request request string
+ * @property {string} userRequest request intended by user (without loaders from config)
+ * @property {string} rawRequest request without resolving
+ * @property {LoaderItem[]} loaders list of loaders
+ * @property {string} resource path + query of the real resource
+ * @property {Record<string, any>=} resourceResolveData resource resolve data
+ * @property {string} context context directory for resolving
+ * @property {string=} matchResource path + query of the matched resource (virtual)
+ * @property {Parser} parser the parser used
+ * @property {Record<string, any>=} parserOptions the options of the parser used
+ * @property {Generator} generator the generator used
+ * @property {Record<string, any>=} generatorOptions the options of the generator used
+ * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module
+ */
+
 /** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
@@ -246,22 +266,7 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {string=} options.layer an optional layer in which the module is
-	 * @param {string} options.type module type
-	 * @param {string} options.request request string
-	 * @param {string} options.userRequest request intended by user (without loaders from config)
-	 * @param {string} options.rawRequest request without resolving
-	 * @param {LoaderItem[]} options.loaders list of loaders
-	 * @param {string} options.resource path + query of the real resource
-	 * @param {Record<string, any>=} options.resourceResolveData resource resolve data
-	 * @param {string} options.context context directory for resolving
-	 * @param {string | undefined} options.matchResource path + query of the matched resource (virtual)
-	 * @param {Parser} options.parser the parser used
-	 * @param {object} options.parserOptions the options of the parser used
-	 * @param {Generator} options.generator the generator used
-	 * @param {object} options.generatorOptions the options of the generator used
-	 * @param {Object} options.resolveOptions options used for resolving requests from this module
+	 * @param {NormalModuleCreateData} options options object
 	 */
 	constructor({
 		layer,

package/lib/NormalModuleFactory.js

@@ -34,14 +34,19 @@ const {
 } = require("./util/identifier");
 
 /** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./Generator")} Generator */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./NormalModule").NormalModuleCreateData} NormalModuleCreateData */
 /** @typedef {import("./Parser")} Parser */
 /** @typedef {import("./ResolverFactory")} ResolverFactory */
 /** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
+/** @typedef {Pick<RuleSetRule, 'type'|'sideEffects'|'parser'|'generator'|'resolve'|'layer'>} ModuleSettings */
+/** @typedef {Partial<NormalModuleCreateData & {settings: ModuleSettings}>} CreateData */
+
 /**
  * @typedef {Object} ResolveData
  * @property {ModuleFactoryCreateData["contextInfo"]} contextInfo
@@ -51,7 +56,7 @@ const {
  * @property {Record<string, any> | undefined} assertions
  * @property {ModuleDependency[]} dependencies
  * @property {string} dependencyType
- * @property {Object} createData
+ * @property {CreateData} createData
  * @property {LazySet<string>} fileDependencies
  * @property {LazySet<string>} missingDependencies
  * @property {LazySet<string>} contextDependencies
@@ -199,7 +204,7 @@ class NormalModuleFactory extends ModuleFactory {
 	}) {
 		super();
 		this.hooks = Object.freeze({
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], Module | false | void>} */
 			resolve: new AsyncSeriesBailHook(["resolveData"]),
 			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
 			resolveForScheme: new HookMap(
@@ -209,15 +214,15 @@ class NormalModuleFactory extends ModuleFactory {
 			resolveInScheme: new HookMap(
 				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
 			),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
 			factorize: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
 			beforeResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
 			afterResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
 			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
-			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], TODO>} */
+			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */
 			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
 			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
 			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
@@ -301,7 +306,9 @@ class NormalModuleFactory extends ModuleFactory {
 										return callback(new Error("Empty dependency (no request)"));
 									}
 
-									createdModule = new NormalModule(createData);
+									createdModule = new NormalModule(
+										/** @type {NormalModuleCreateData} */ (createData)
+									);
 								}
 
 								createdModule = this.hooks.module.call(

package/lib/ProgressPlugin.js

@@ -531,15 +531,14 @@ class ProgressPlugin {
 			}
 		});
 		interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle");
-		compiler.hooks.initialize.intercept({
+		compiler.hooks.beforeRun.intercept({
 			name: "ProgressPlugin",
 			call() {
 				handler(0, "");
 			}
 		});
-		interceptHook(compiler.hooks.initialize, 0.01, "setup", "initialize");
-		interceptHook(compiler.hooks.beforeRun, 0.02, "setup", "before run");
-		interceptHook(compiler.hooks.run, 0.03, "setup", "run");
+		interceptHook(compiler.hooks.beforeRun, 0.01, "setup", "before run");
+		interceptHook(compiler.hooks.run, 0.02, "setup", "run");
 		interceptHook(compiler.hooks.watchRun, 0.03, "setup", "watch run");
 		interceptHook(
 			compiler.hooks.normalModuleFactory,

package/lib/RuntimeTemplate.js

@@ -83,6 +83,7 @@ class RuntimeTemplate {
 		this.outputOptions = outputOptions || {};
 		this.requestShortener = requestShortener;
 		this.globalObject = getGlobalObject(outputOptions.globalObject);
+		this.contentHashReplacement = "X".repeat(outputOptions.hashDigestLength);
 	}
 
 	isIIFE() {

package/lib/WebpackOptionsApply.js

@@ -35,6 +35,7 @@ const ResolverCachePlugin = require("./cache/ResolverCachePlugin");
 
 const CommonJsPlugin = require("./dependencies/CommonJsPlugin");
 const HarmonyModulesPlugin = require("./dependencies/HarmonyModulesPlugin");
+const ImportMetaContextPlugin = require("./dependencies/ImportMetaContextPlugin");
 const ImportMetaPlugin = require("./dependencies/ImportMetaPlugin");
 const ImportPlugin = require("./dependencies/ImportPlugin");
 const LoaderPlugin = require("./dependencies/LoaderPlugin");
@@ -361,6 +362,7 @@ class WebpackOptionsApply extends OptionsApply {
 		new RequireEnsurePlugin().apply(compiler);
 		new RequireContextPlugin().apply(compiler);
 		new ImportPlugin().apply(compiler);
+		new ImportMetaContextPlugin().apply(compiler);
 		new SystemPlugin().apply(compiler);
 		new ImportMetaPlugin().apply(compiler);
 		new URLPlugin().apply(compiler);

package/lib/asset/AssetGenerator.js

@@ -113,6 +113,7 @@ const decodeDataUriContent = (encoding, content) => {
 
 const JS_TYPES = new Set(["javascript"]);
 const JS_AND_ASSET_TYPES = new Set(["javascript", "asset"]);
+const DEFAULT_ENCODING = "base64";
 
 class AssetGenerator extends Generator {
 	/**
@@ -131,6 +132,65 @@ class AssetGenerator extends Generator {
 		this.emit = emit;
 	}
 
+	/**
+	 * @param {NormalModule} module module
+	 * @param {RuntimeTemplate} runtimeTemplate runtime template
+	 * @returns {string} source file name
+	 */
+	getSourceFileName(module, runtimeTemplate) {
+		return makePathsRelative(
+			runtimeTemplate.compilation.compiler.context,
+			module.matchResource || module.resource,
+			runtimeTemplate.compilation.compiler.root
+		).replace(/^\.\//, "");
+	}
+
+	/**
+	 * @param {NormalModule} module module
+	 * @returns {string} mime type
+	 */
+	getMimeType(module) {
+		if (typeof this.dataUrlOptions === "function") {
+			throw new Error(
+				"This method must not be called when dataUrlOptions is a function"
+			);
+		}
+
+		let mimeType = this.dataUrlOptions.mimetype;
+		if (mimeType === undefined) {
+			const ext = path.extname(module.nameForCondition());
+			if (
+				module.resourceResolveData &&
+				module.resourceResolveData.mimetype !== undefined
+			) {
+				mimeType =
+					module.resourceResolveData.mimetype +
+					module.resourceResolveData.parameters;
+			} else if (ext) {
+				mimeType = mimeTypes.lookup(ext);
+
+				if (typeof mimeType !== "string") {
+					throw new Error(
+						"DataUrl can't be generated automatically, " +
+							`because there is no mimetype for "${ext}" in mimetype database. ` +
+							'Either pass a mimetype via "generator.mimetype" or ' +
+							'use type: "asset/resource" to create a resource file instead of a DataUrl'
+					);
+				}
+			}
+		}
+
+		if (typeof mimeType !== "string") {
+			throw new Error(
+				"DataUrl can't be generated automatically. " +
+					'Either pass a mimetype via "generator.mimetype" or ' +
+					'use type: "asset/resource" to create a resource file instead of a DataUrl'
+			);
+		}
+
+		return mimeType;
+	}
+
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
@@ -170,31 +230,9 @@ class AssetGenerator extends Generator {
 							}
 						}
 						if (encoding === undefined) {
-							encoding = "base64";
-						}
-						let ext;
-						let mimeType = this.dataUrlOptions.mimetype;
-						if (mimeType === undefined) {
-							ext = path.extname(module.nameForCondition());
-							if (
-								module.resourceResolveData &&
-								module.resourceResolveData.mimetype !== undefined
-							) {
-								mimeType =
-									module.resourceResolveData.mimetype +
-									module.resourceResolveData.parameters;
-							} else if (ext) {
-								mimeType = mimeTypes.lookup(ext);
-							}
-						}
-						if (typeof mimeType !== "string") {
-							throw new Error(
-								"DataUrl can't be generated automatically, " +
-									`because there is no mimetype for "${ext}" in mimetype database. ` +
-									'Either pass a mimetype via "generator.mimetype" or ' +
-									'use type: "asset/resource" to create a resource file instead of a DataUrl'
-							);
+							encoding = DEFAULT_ENCODING;
 						}
+						const mimeType = this.getMimeType(module);
 
 						let encodedContent;
 
@@ -238,11 +276,10 @@ class AssetGenerator extends Generator {
 						runtimeTemplate.outputOptions.hashDigestLength
 					);
 					module.buildInfo.fullContentHash = fullHash;
-					const sourceFilename = makePathsRelative(
-						runtimeTemplate.compilation.compiler.context,
-						module.matchResource || module.resource,
-						runtimeTemplate.compilation.compiler.root
-					).replace(/^\.\//, "");
+					const sourceFilename = this.getSourceFileName(
+						module,
+						runtimeTemplate
+					);
 					let { path: filename, info: assetInfo } =
 						runtimeTemplate.compilation.getAssetPathWithInfo(
 							assetModuleFilename,
@@ -368,8 +405,59 @@ class AssetGenerator extends Generator {
 	 * @param {Hash} hash hash that will be modified
 	 * @param {UpdateHashContext} updateHashContext context for updating hash
 	 */
-	updateHash(hash, { module }) {
-		hash.update(module.buildInfo.dataUrl ? "data-url" : "resource");
+	updateHash(hash, { module, runtime, runtimeTemplate, chunkGraph }) {
+		if (module.buildInfo.dataUrl) {
+			hash.update("data-url");
+			// this.dataUrlOptions as function should be pure and only depend on input source and filename
+			// therefore it doesn't need to be hashed
+			if (typeof this.dataUrlOptions === "function") {
+				const ident = /** @type {{ ident?: string }} */ (this.dataUrlOptions)
+					.ident;
+				if (ident) hash.update(ident);
+			} else {
+				if (
+					this.dataUrlOptions.encoding &&
+					this.dataUrlOptions.encoding !== DEFAULT_ENCODING
+				) {
+					hash.update(this.dataUrlOptions.encoding);
+				}
+				if (this.dataUrlOptions.mimetype)
+					hash.update(this.dataUrlOptions.mimetype);
+				// computed mimetype depends only on module filename which is already part of the hash
+			}
+		} else {
+			hash.update("resource");
+
+			const pathData = {
+				module,
+				runtime,
+				filename: this.getSourceFileName(module, runtimeTemplate),
+				chunkGraph,
+				contentHash: runtimeTemplate.contentHashReplacement
+			};
+
+			if (typeof this.publicPath === "function") {
+				hash.update("path");
+				const assetInfo = {};
+				hash.update(this.publicPath(pathData, assetInfo));
+				hash.update(JSON.stringify(assetInfo));
+			} else if (this.publicPath) {
+				hash.update("path");
+				hash.update(this.publicPath);
+			} else {
+				hash.update("no-path");
+			}
+
+			const assetModuleFilename =
+				this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
+			const { path: filename, info } =
+				runtimeTemplate.compilation.getAssetPathWithInfo(
+					assetModuleFilename,
+					pathData
+				);
+			hash.update(filename);
+			hash.update(JSON.stringify(info));
+		}
 	}
 }
 

package/lib/cache/ResolverCachePlugin.js

@@ -128,6 +128,13 @@ class ResolverCachePlugin {
 				fileDependencies: new LazySet(),
 				contextDependencies: new LazySet()
 			};
+			let yieldResult;
+			let withYield = false;
+			if (typeof newResolveContext.yield === "function") {
+				yieldResult = [];
+				withYield = true;
+				newResolveContext.yield = obj => yieldResult.push(obj);
+			}
 			const propagate = key => {
 				if (resolveContext[key]) {
 					addAllToSet(resolveContext[key], newResolveContext[key]);
@@ -155,15 +162,22 @@ class ResolverCachePlugin {
 						snapshotOptions,
 						(err, snapshot) => {
 							if (err) return callback(err);
+							const resolveResult = withYield ? yieldResult : result;
+							// since we intercept resolve hook
+							// we still can get result in callback
+							if (withYield && result) yieldResult.push(result);
 							if (!snapshot) {
-								if (result) return callback(null, result);
+								if (resolveResult) return callback(null, resolveResult);
 								return callback();
 							}
-							itemCache.store(new CacheEntry(result, snapshot), storeErr => {
-								if (storeErr) return callback(storeErr);
-								if (result) return callback(null, result);
-								callback();
-							});
+							itemCache.store(
+								new CacheEntry(resolveResult, snapshot),
+								storeErr => {
+									if (storeErr) return callback(storeErr);
+									if (resolveResult) return callback(null, resolveResult);
+									callback();
+								}
+							);
 						}
 					);
 				}
@@ -173,6 +187,8 @@ class ResolverCachePlugin {
 			factory(type, hook) {
 				/** @type {Map<string, (function(Error=, Object=): void)[]>} */
 				const activeRequests = new Map();
+				/** @type {Map<string, [function(Error=, Object=): void, function(Error=, Object=): void][]>} */
+				const activeRequestsWithYield = new Map();
 				hook.tap(
 					"ResolverCachePlugin",
 					/**
@@ -197,29 +213,67 @@ class ResolverCachePlugin {
 								if (request._ResolverCachePluginCacheMiss || !fileSystemInfo) {
 									return callback();
 								}
-								const identifier = `${type}${optionsIdent}${objectToString(
-									request,
-									!cacheWithContext
-								)}`;
-								const activeRequest = activeRequests.get(identifier);
-								if (activeRequest) {
-									activeRequest.push(callback);
-									return;
+								const withYield = typeof resolveContext.yield === "function";
+								const identifier = `${type}${
+									withYield ? "|yield" : "|default"
+								}${optionsIdent}${objectToString(request, !cacheWithContext)}`;
+
+								if (withYield) {
+									const activeRequest = activeRequestsWithYield.get(identifier);
+									if (activeRequest) {
+										activeRequest[0].push(callback);
+										activeRequest[1].push(resolveContext.yield);
+										return;
+									}
+								} else {
+									const activeRequest = activeRequests.get(identifier);
+									if (activeRequest) {
+										activeRequest.push(callback);
+										return;
+									}
 								}
 								const itemCache = cache.getItemCache(identifier, null);
-								let callbacks;
-								const done = (err, result) => {
-									if (callbacks === undefined) {
-										callback(err, result);
-										callbacks = false;
-									} else {
-										for (const callback of callbacks) {
-											callback(err, result);
-										}
-										activeRequests.delete(identifier);
-										callbacks = false;
-									}
-								};
+								let callbacks, yields;
+								const done = withYield
+									? (err, result) => {
+											if (callbacks === undefined) {
+												if (err) {
+													callback(err);
+												} else {
+													if (result)
+														for (const r of result) resolveContext.yield(r);
+													callback(null, null);
+												}
+												yields = undefined;
+												callbacks = false;
+											} else {
+												if (err) {
+													for (const cb of callbacks) cb(err);
+												} else {
+													for (let i = 0; i < callbacks.length; i++) {
+														const cb = callbacks[i];
+														const yield_ = yields[i];
+														if (result) for (const r of result) yield_(r);
+														cb(null, null);
+													}
+												}
+												activeRequestsWithYield.delete(identifier);
+												yields = undefined;
+												callbacks = false;
+											}
+									  }
+									: (err, result) => {
+											if (callbacks === undefined) {
+												callback(err, result);
+												callbacks = false;
+											} else {
+												for (const callback of callbacks) {
+													callback(err, result);
+												}
+												activeRequests.delete(identifier);
+												callbacks = false;
+											}
+									  };
 								/**
 								 * @param {Error=} err error if any
 								 * @param {CacheEntry=} cacheEntry cache entry
@@ -276,7 +330,14 @@ class ResolverCachePlugin {
 									}
 								};
 								itemCache.get(processCacheResult);
-								if (callbacks === undefined) {
+								if (withYield && callbacks === undefined) {
+									callbacks = [callback];
+									yields = [resolveContext.yield];
+									activeRequestsWithYield.set(
+										identifier,
+										/** @type {[any, any]} */ ([callbacks, yields])
+									);
+								} else if (callbacks === undefined) {
 									callbacks = [callback];
 									activeRequests.set(identifier, callbacks);
 								}

package/lib/config/browserslistTargetHandler.js

@@ -121,8 +121,7 @@ const resolve = browsers => {
 		// 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]
+		node: [12, 17]
 	});
 
 	return {
@@ -248,8 +247,7 @@ const resolve = browsers => {
 			// 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]
+			node: [12, 17]
 		}),
 		dynamicImport: es6DynamicImport,
 		dynamicImportInWorker: es6DynamicImport && !anyNode,
@@ -272,7 +270,7 @@ const resolve = browsers => {
 			// baidu: Unknown support
 			// and_uc: Unknown support
 			// kaios: Unknown support
-			node: [12, 0]
+			node: 12
 		}),
 		optionalChaining: rawChecker({
 			chrome: 80,

package/lib/config/normalization.js

@@ -488,6 +488,7 @@ const getNormalizedEntryStatic = entry => {
 				filename: value.filename,
 				layer: value.layer,
 				runtime: value.runtime,
+				baseUri: value.baseUri,
 				publicPath: value.publicPath,
 				chunkLoading: value.chunkLoading,
 				asyncChunks: value.asyncChunks,

package/lib/dependencies/ContextDependencyHelpers.js

@@ -37,7 +37,7 @@ const splitContextFromPrefix = prefix => {
 	};
 };
 
-/** @typedef {Partial<Omit<ContextDependencyOptions, "resource"|"recursive"|"regExp">>} PartialContextDependencyOptions */
+/** @typedef {Partial<Omit<ContextDependencyOptions, "resource">>} PartialContextDependencyOptions */
 
 /** @typedef {{ new(options: ContextDependencyOptions, range: [number, number], valueRange: [number, number]): ContextDependency }} ContextDependencyConstructor */
 

package/lib/dependencies/HarmonyAcceptImportDependency.js

@@ -7,6 +7,7 @@
 
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
+const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
@@ -28,8 +29,9 @@ makeSerializable(
 	"webpack/lib/dependencies/HarmonyAcceptImportDependency"
 );
 
-HarmonyAcceptImportDependency.Template = class HarmonyAcceptImportDependencyTemplate extends (
-	HarmonyImportDependency.Template
-) {};
+HarmonyAcceptImportDependency.Template =
+	/** @type {typeof HarmonyImportDependency.Template} */ (
+		NullDependency.Template
+	);
 
 module.exports = HarmonyAcceptImportDependency;

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -145,7 +145,10 @@ class HarmonyExportInitFragment extends InitFragment {
 				? `/* unused harmony export ${first(this.unusedExports)} */\n`
 				: "";
 		const definitions = [];
-		for (const [key, value] of this.exportMap) {
+		const orderedExportMap = Array.from(this.exportMap).sort(([a], [b]) =>
+			a < b ? -1 : 1
+		);
+		for (const [key, value] of orderedExportMap) {
 			definitions.push(
 				`\n/* harmony export */   ${JSON.stringify(
 					key

package/lib/dependencies/ImportContextDependency.js

@@ -28,7 +28,6 @@ class ImportContextDependency extends ContextDependency {
 	serialize(context) {
 		const { write } = context;
 
-		write(this.range);
 		write(this.valueRange);
 
 		super.serialize(context);
@@ -37,7 +36,6 @@ class ImportContextDependency extends ContextDependency {
 	deserialize(context) {
 		const { read } = context;
 
-		this.range = read();
 		this.valueRange = read();
 
 		super.deserialize(context);