webpack 5.99.9 → 5.100.0

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -0,0 +1,214 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/**
+ * @param {import("../Module").ExportsType} exportsType exports type
+ * @returns {string} mode
+ */
+function getMakeDeferredNamespaceModeFromExportsType(exportsType) {
+	if (exportsType === "namespace") return `/* ${exportsType} */ 0`;
+	if (exportsType === "default-only") return `/* ${exportsType} */ 1`;
+	if (exportsType === "default-with-named") return `/* ${exportsType} */ 2`;
+	if (exportsType === "dynamic") return `/* ${exportsType} */ 3`;
+	return "";
+}
+/**
+ * @param {import("../ModuleTemplate").RuntimeTemplate} _runtimeTemplate runtimeTemplate
+ * @param {import("../Module").ExportsType} exportsType exportsType
+ * @param {string} moduleId moduleId
+ * @param {(import("../ChunkGraph").ModuleId | null)[]} asyncDepsIds asyncDepsIds
+ * @returns {string} function
+ */
+function getOptimizedDeferredModule(
+	_runtimeTemplate,
+	exportsType,
+	moduleId,
+	asyncDepsIds
+) {
+	const isAsync = asyncDepsIds && asyncDepsIds.length;
+	const init = `${RuntimeGlobals.require}(${moduleId})${
+		isAsync ? `[${RuntimeGlobals.asyncModuleExportSymbol}]` : ""
+	}`;
+	const props = [
+		`/* ${exportsType} */ get a() {`,
+		// if exportsType is "namespace" we can generate the most optimized code,
+		// on the second access, we can avoid trigger the getter.
+		// we can also do this if exportsType is "dynamic" and there is a "__esModule" property on it.
+		exportsType === "namespace" || exportsType === "dynamic"
+			? Template.indent([
+					`var exports = ${init};`,
+					`${
+						exportsType === "dynamic" ? "if (exports.__esModule) " : ""
+					}Object.defineProperty(this, "a", { value: exports });`,
+					"return exports;"
+				])
+			: Template.indent([`return ${init};`]),
+		isAsync ? "}," : "}",
+		isAsync
+			? `[${
+					RuntimeGlobals.makeDeferredNamespaceObjectSymbol
+				}]: ${JSON.stringify(asyncDepsIds.filter(x => x !== null))}`
+			: ""
+	];
+	return Template.asString(["{", Template.indent(props), "}"]);
+}
+
+const strictModuleCache = [
+	"if (cachedModule && cachedModule.error === undefined) {",
+	Template.indent([
+		"var exports = cachedModule.exports;",
+		"if (mode == 0) return exports;",
+		`if (mode == 1) return ${RuntimeGlobals.createFakeNamespaceObject}(exports);`,
+		`if (mode == 2) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 2);`,
+		`if (mode == 3) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 6);` // 2 | 4
+	]),
+	"}"
+];
+const nonStrictModuleCache = [
+	"// optimization not applied when output.strictModuleErrorHandling is off"
+];
+
+class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {boolean} hasAsyncRuntime if async module is used.
+	 */
+	constructor(hasAsyncRuntime) {
+		super("make deferred namespace object");
+		this.hasAsyncRuntime = hasAsyncRuntime;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		if (!this.compilation) return null;
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.makeDeferredNamespaceObject;
+		const hasAsync = this.hasAsyncRuntime;
+		const strictError =
+			this.compilation.options.output.strictModuleErrorHandling;
+		const init = runtimeTemplate.supportsOptionalChaining()
+			? "init?.();"
+			: "if (init) init();";
+		return `${fn} = ${runtimeTemplate.basicFunction("moduleId, mode", [
+			"// mode: 0 => namespace (esm)",
+			"// mode: 1 => default-only (esm strict cjs)",
+			"// mode: 2 => default-with-named (esm-cjs compat)",
+			"// mode: 3 => dynamic (if exports has __esModule, then esm, otherwise default-with-named)",
+			"",
+			"var cachedModule = __webpack_module_cache__[moduleId];",
+			...(strictError ? strictModuleCache : nonStrictModuleCache),
+			"",
+			`var init = ${runtimeTemplate.basicFunction("", [
+				`ns = ${RuntimeGlobals.require}(moduleId);`,
+				hasAsync
+					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in ns) ns = ns[${RuntimeGlobals.asyncModuleExportSymbol}];`
+					: "",
+				"init = null;",
+				"if (mode == 0 || mode == 3 && ns.__esModule && typeof ns === 'object') {",
+				Template.indent([
+					"delete handler.defineProperty;",
+					"delete handler.deleteProperty;",
+					"delete handler.set;",
+					"delete handler.get;",
+					"delete handler.has;",
+					"delete handler.ownKeys;",
+					"delete handler.getOwnPropertyDescriptor;"
+				]),
+				"} else if (mode == 1) {",
+				Template.indent([
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns);`
+				]),
+				"} else if (mode == 2) {",
+				Template.indent([
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, 2);`
+				]),
+				"} else if (mode == 3) {",
+				Template.indent([
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, 6);`
+				]),
+				"}"
+			])};`,
+			"",
+			`var ns = ${
+				strictError ? "" : "cachedModule && cachedModule.exports || "
+			}__webpack_module_deferred_exports__[moduleId] || (__webpack_module_deferred_exports__[moduleId] = { __proto__: null });`,
+			"var handler = {",
+			Template.indent([
+				"__proto__: null,",
+				`get: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent([
+						'case "__esModule": return true;',
+						'case Symbol.toStringTag: return "Deferred Module";',
+						'case "then": return undefined;'
+					]),
+					"}",
+					init,
+					"return ns[name];"
+				])},`,
+				`has: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent(
+						[
+							'case "__esModule":',
+							"case Symbol.toStringTag:",
+							hasAsync
+								? `case ${RuntimeGlobals.makeDeferredNamespaceObjectSymbol}:`
+								: "",
+							Template.indent("return true;"),
+							'case "then":',
+							Template.indent("return false;")
+						].filter(Boolean)
+					),
+					"}",
+					init,
+					"return name in ns;"
+				])},`,
+				`ownKeys: ${runtimeTemplate.basicFunction("", [
+					init,
+					`var keys = Reflect.ownKeys(ns).filter(${runtimeTemplate.expressionFunction('x !== "then"', "x")}).concat([Symbol.toStringTag]);`,
+					"return keys;"
+				])},`,
+				`getOwnPropertyDescriptor: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent([
+						'case "__esModule": return { value: true, configurable: !!mode };',
+						'case Symbol.toStringTag: return { value: "Deferred Module", configurable: !!mode };',
+						'case "then": return undefined;'
+					]),
+					"}",
+					init,
+					"var desc = Reflect.getOwnPropertyDescriptor(ns, name);",
+					'if (mode == 2 && name == "default" && !desc) {',
+					Template.indent("desc = { value: ns, configurable: true };"),
+					"}",
+					"return desc;"
+				])},`,
+				`defineProperty: ${runtimeTemplate.basicFunction("_, name", [
+					init,
+					// Note: This behavior does not match the spec one, but since webpack does not do it either
+					// for a normal Module Namespace object (in MakeNamespaceObjectRuntimeModule), let's keep it simple.
+					"return false;"
+				])},`,
+				`deleteProperty: ${runtimeTemplate.returningFunction("false")},`,
+				`set: ${runtimeTemplate.returningFunction("false")},`
+			]),
+			"}",
+			// we don't fully emulate ES Module semantics in this Proxy to align with normal webpack esm namespace object.
+			"return new Proxy(ns, handler);"
+		])};`;
+	}
+}
+
+module.exports = MakeDeferredNamespaceObjectRuntimeModule;
+module.exports.getMakeDeferredNamespaceModeFromExportsType =
+	getMakeDeferredNamespaceModeFromExportsType;
+module.exports.getOptimizedDeferredModule = getOptimizedDeferredModule;

package/lib/runtime/RuntimeIdRuntimeModule.js

@@ -22,8 +22,9 @@ class RuntimeIdRuntimeModule extends RuntimeModule {
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const runtime = chunk.runtime;
-		if (typeof runtime !== "string")
+		if (typeof runtime !== "string") {
 			throw new Error("RuntimeIdRuntimeModule must be in a single runtime");
+		}
 		const id = chunkGraph.getRuntimeId(runtime);
 		return `${RuntimeGlobals.runtimeId} = ${JSON.stringify(id)};`;
 	}

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -28,9 +28,9 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 	generate() {
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
-		const chunkIds = Array.from(
-			chunkGraph.getChunkEntryDependentChunksIterable(chunk)
-		).map(chunk => chunk.id);
+		const chunkIds = [
+			...chunkGraph.getChunkEntryDependentChunksIterable(chunk)
+		].map(chunk => chunk.id);
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		return Template.asString([
@@ -38,11 +38,12 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 			`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
 				"",
 				!this.asyncChunkLoading
-					? chunkIds
-							.map(
+					? [
+							...chunkIds.map(
 								id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)});`
-							)
-							.concat("return next();")
+							),
+							"return next();"
+						]
 					: chunkIds.length === 1
 						? `return ${RuntimeGlobals.ensureChunk}(${JSON.stringify(
 								chunkIds[0]

package/lib/schemes/FileUriPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { URL, fileURLToPath } = require("url");
+const { fileURLToPath } = require("url");
 const { NormalModule } = require("..");
 
 /** @typedef {import("../Compiler")} Compiler */

package/lib/schemes/HttpUriPlugin.js

@@ -6,13 +6,17 @@
 "use strict";
 
 const EventEmitter = require("events");
-const { extname, basename } = require("path");
-const { URL } = require("url");
-const { createGunzip, createBrotliDecompress, createInflate } = require("zlib");
+const { basename, extname } = require("path");
+const {
+	// eslint-disable-next-line n/no-unsupported-features/node-builtins
+	createBrotliDecompress,
+	createGunzip,
+	createInflate
+} = require("zlib");
 const NormalModule = require("../NormalModule");
 const createSchemaValidation = require("../util/create-schema-validation");
 const createHash = require("../util/createHash");
-const { mkdirp, dirname, join } = require("../util/fs");
+const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("http").IncomingMessage} IncomingMessage */
@@ -32,7 +36,7 @@ const getHttps = memoize(() => require("https"));
 
 /**
  * @param {typeof import("http") | typeof import("https")} request request
- * @param {string | { toString: () => string } | undefined} proxy proxy
+ * @param {string | URL | undefined} proxy proxy
  * @returns {(url: URL, requestOptions: RequestOptions, callback: (incomingMessage: IncomingMessage) => void) => EventEmitter} fn
  */
 const proxyFetch = (request, proxy) => (url, options, callback) => {
@@ -85,7 +89,7 @@ const proxyFetch = (request, proxy) => (url, options, callback) => {
 let inProgressWrite;
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/schemes/HttpUriPlugin.check.js"),
+	require("../../schemas/plugins/schemes/HttpUriPlugin.check"),
 	() => require("../../schemas/plugins/schemes/HttpUriPlugin.json"),
 	{
 		name: "Http Uri Plugin",
@@ -210,8 +214,9 @@ class Lockfile {
 	static parse(content) {
 		// TODO handle merge conflicts
 		const data = JSON.parse(content);
-		if (data.version !== 1)
+		if (data.version !== 1) {
 			throw new Error(`Unsupported lockfile version ${data.version}`);
+		}
 		const lockfile = new Lockfile();
 		for (const key of Object.keys(data)) {
 			if (key === "version") continue;
@@ -234,16 +239,15 @@ class Lockfile {
 	 */
 	toString() {
 		let str = "{\n";
-		const entries = Array.from(this.entries).sort(([a], [b]) =>
-			a < b ? -1 : 1
-		);
+		const entries = [...this.entries].sort(([a], [b]) => (a < b ? -1 : 1));
 		for (const [key, entry] of entries) {
 			if (typeof entry === "string") {
 				str += `  ${JSON.stringify(key)}: ${JSON.stringify(entry)},\n`;
 			} else {
 				str += `  ${JSON.stringify(key)}: { `;
-				if (entry.resolved !== key)
+				if (entry.resolved !== key) {
 					str += `"resolved": ${JSON.stringify(entry.resolved)}, `;
+				}
 				str += `"integrity": ${JSON.stringify(
 					entry.integrity
 				)}, "contentType": ${JSON.stringify(entry.contentType)} },\n`;
@@ -330,8 +334,9 @@ const cachedWithKey = (fn, forceFn = fn) => {
 	const resultFn = (arg, callback) => {
 		const cacheEntry = cache.get(arg);
 		if (cacheEntry !== undefined) {
-			if (cacheEntry.result !== undefined)
+			if (cacheEntry.result !== undefined) {
 				return callback(null, cacheEntry.result);
+			}
 			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
 			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
 			else cacheEntry.callbacks.push(callback);
@@ -361,8 +366,9 @@ const cachedWithKey = (fn, forceFn = fn) => {
 	resultFn.force = (arg, callback) => {
 		const cacheEntry = cache.get(arg);
 		if (cacheEntry !== undefined && cacheEntry.force) {
-			if (cacheEntry.result !== undefined)
+			if (cacheEntry.result !== undefined) {
 				return callback(null, cacheEntry.result);
+			}
 			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
 			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
 			else cacheEntry.callbacks.push(callback);
@@ -531,7 +537,7 @@ class HttpUriPlugin {
 									(err, s) => {
 										if (err) return callback(err);
 										const lockfile = buffer
-											? Lockfile.parse(buffer.toString("utf-8"))
+											? Lockfile.parse(buffer.toString("utf8"))
 											: new Lockfile();
 										lockfileCache = {
 											lockfile,
@@ -611,8 +617,9 @@ class HttpUriPlugin {
 				const storeResult = (lockfile, url, result, callback) => {
 					if (result.storeLock) {
 						storeLockEntry(lockfile, url, result.entry);
-						if (!cacheLocation || !result.content)
+						if (!cacheLocation || !result.content) {
 							return callback(null, result);
+						}
 						const key = getCacheKey(result.entry.resolved);
 						const filePath = join(intermediateFs, cacheLocation, key);
 						mkdirp(intermediateFs, dirname(intermediateFs, filePath), err => {
@@ -831,7 +838,7 @@ class HttpUriPlugin {
 										new Error(
 											`${url} request status code = ${
 												res.statusCode
-											}\n${content.toString("utf-8")}`
+											}\n${content.toString("utf8")}`
 										)
 									);
 								}
@@ -938,8 +945,9 @@ class HttpUriPlugin {
 										const result =
 											/** @type {ResolveContentResult} */
 											(_result);
-										if (!result.storeLock || entryTag === "ignore")
+										if (!result.storeLock || entryTag === "ignore") {
 											return callback(null, result);
+										}
 										if (frozen) {
 											return callback(
 												new Error(
@@ -1058,7 +1066,7 @@ Remove this line from the lockfile to force upgrading.`
 											let isEolChanged = false;
 											try {
 												contentWithChangedEol = Buffer.from(
-													content.toString("utf-8").replace(/\r\n/g, "\n")
+													content.toString("utf8").replace(/\r\n/g, "\n")
 												);
 												isEolChanged = verifyIntegrity(
 													contentWithChangedEol,
@@ -1245,7 +1253,7 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 									return callback(err);
 								}
 								const lockfile = buffer
-									? Lockfile.parse(buffer.toString("utf-8"))
+									? Lockfile.parse(buffer.toString("utf8"))
 									: new Lockfile();
 								for (const [key, value] of /** @type {LockfileUpdates} */ (
 									lockfileUpdates

package/lib/schemes/VirtualUrlPlugin.js

@@ -0,0 +1,222 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const { NormalModule } = require("..");
+const ModuleNotFoundError = require("../ModuleNotFoundError");
+const { parseResourceWithoutFragment } = require("../util/identifier");
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").ValueCacheVersions} ValueCacheVersions */
+/** @typedef {string | Set<string>} ValueCacheVersion */
+
+/**
+ * @template T
+ * @typedef {import("../../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ */
+
+const PLUGIN_NAME = "VirtualUrlPlugin";
+const DEFAULT_SCHEME = "virtual";
+
+/**
+ * @typedef {object} VirtualModuleConfig
+ * @property {string=} type - The module type
+ * @property {(loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string> | string} source - The source function
+ * @property {(() => string) | true | string=} version - Optional version function or value
+ */
+
+/**
+ * @typedef {string | ((loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string> | string) | VirtualModuleConfig} VirtualModuleInput
+ */
+
+/** @typedef {{[key: string]: VirtualModuleInput}} VirtualModules */
+
+/**
+ * Normalizes a virtual module definition into a standard format
+ * @param {VirtualModuleInput} virtualConfig The virtual module to normalize
+ * @returns {VirtualModuleConfig} The normalized virtual module
+ */
+function normalizeModule(virtualConfig) {
+	if (typeof virtualConfig === "string") {
+		return {
+			type: "",
+			source() {
+				return virtualConfig;
+			}
+		};
+	} else if (typeof virtualConfig === "function") {
+		return {
+			type: "",
+			source: virtualConfig
+		};
+	}
+	return virtualConfig;
+}
+
+/**
+ * Normalizes all virtual modules with the given scheme
+ * @param {VirtualModules} virtualConfigs The virtual modules to normalize
+ * @param {string} scheme The URL scheme to use
+ * @returns {{[key: string]: VirtualModuleConfig}} The normalized virtual modules
+ */
+function normalizeModules(virtualConfigs, scheme) {
+	return Object.keys(virtualConfigs).reduce((pre, id) => {
+		pre[toVid(id, scheme)] = normalizeModule(virtualConfigs[id]);
+		return pre;
+	}, /** @type {{[key: string]: VirtualModuleConfig}} */ ({}));
+}
+
+/**
+ * Converts a module id and scheme to a virtual module id
+ * @param {string} id The module id
+ * @param {string} scheme The URL scheme
+ * @returns {string} The virtual module id
+ */
+function toVid(id, scheme) {
+	return `${scheme}:${id}`;
+}
+
+const VALUE_DEP_VERSION = `webpack/${PLUGIN_NAME}/version`;
+
+/**
+ * Converts a module id and scheme to a cache key
+ * @param {string} id The module id
+ * @param {string} scheme The URL scheme
+ * @returns {string} The cache key
+ */
+function toCacheKey(id, scheme) {
+	return `${VALUE_DEP_VERSION}/${toVid(id, scheme)}`;
+}
+
+/**
+ * @typedef {object} VirtualUrlPluginOptions
+ * @property {VirtualModules} modules - The virtual modules
+ * @property {string=} scheme - The URL scheme to use
+ */
+
+class VirtualUrlPlugin {
+	/**
+	 * @param {VirtualModules} modules The virtual modules
+	 * @param {string=} scheme The URL scheme to use
+	 */
+	constructor(modules, scheme) {
+		this.scheme = scheme || DEFAULT_SCHEME;
+		this.modules = normalizeModules(modules, this.scheme);
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const scheme = this.scheme;
+		const cachedParseResourceWithoutFragment =
+			parseResourceWithoutFragment.bindCache(compiler.root);
+
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.resolveForScheme
+					.for(scheme)
+					.tap(PLUGIN_NAME, resourceData => {
+						const virtualConfig = this.findVirtualModuleConfigById(
+							resourceData.resource
+						);
+						const url = cachedParseResourceWithoutFragment(
+							resourceData.resource
+						);
+						const path = url.path;
+						const type = virtualConfig.type;
+						resourceData.path = path + type;
+						resourceData.resource = path;
+
+						if (virtualConfig.version) {
+							const cacheKey = toCacheKey(resourceData.resource, scheme);
+							const cacheVersion = this.getCacheVersion(virtualConfig.version);
+							compilation.valueCacheVersions.set(
+								cacheKey,
+								/** @type {string} */ (cacheVersion)
+							);
+						}
+
+						return true;
+					});
+
+				const hooks = NormalModule.getCompilationHooks(compilation);
+				hooks.readResource
+					.for(scheme)
+					.tapAsync(PLUGIN_NAME, async (loaderContext, callback) => {
+						const { resourcePath } = loaderContext;
+						const module = /** @type {NormalModule} */ (loaderContext._module);
+						const cacheKey = toCacheKey(resourcePath, scheme);
+
+						const addVersionValueDependency = () => {
+							if (!module || !module.buildInfo) return;
+
+							const buildInfo = module.buildInfo;
+							if (!buildInfo.valueDependencies) {
+								buildInfo.valueDependencies = new Map();
+							}
+
+							const cacheVersion = compilation.valueCacheVersions.get(cacheKey);
+							if (compilation.valueCacheVersions.has(cacheKey)) {
+								buildInfo.valueDependencies.set(
+									cacheKey,
+									/** @type {string} */ (cacheVersion)
+								);
+							}
+						};
+
+						try {
+							const virtualConfig =
+								this.findVirtualModuleConfigById(resourcePath);
+							const content = await virtualConfig.source(loaderContext);
+							addVersionValueDependency();
+							callback(null, content);
+						} catch (err) {
+							callback(/** @type {Error} */ (err));
+						}
+					});
+			}
+		);
+	}
+
+	/**
+	 * @param {string} id The module id
+	 * @returns {VirtualModuleConfig} The virtual module config
+	 */
+	findVirtualModuleConfigById(id) {
+		const config = this.modules[id];
+		if (!config) {
+			throw new ModuleNotFoundError(
+				null,
+				new Error(`Can't resolve virtual module ${id}`),
+				{
+					name: `virtual module ${id}`
+				}
+			);
+		}
+		return config;
+	}
+
+	/**
+	 * Get the cache version for a given version value
+	 * @param {(() => string) | true | string} version The version value or function
+	 * @returns {string | undefined} The cache version
+	 */
+	getCacheVersion(version) {
+		return version === true
+			? undefined
+			: (typeof version === "function" ? version() : version) || "unset";
+	}
+}
+
+VirtualUrlPlugin.DEFAULT_SCHEME = DEFAULT_SCHEME;
+
+module.exports = VirtualUrlPlugin;

package/lib/serialization/AggregateErrorSerializer.js

@@ -28,7 +28,7 @@ class AggregateErrorSerializer {
 	deserialize(context) {
 		const errors = context.read();
 		// @ts-expect-error ES2018 doesn't `AggregateError`, but it can be used by developers
-		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax, unicorn/error-message
 		const err = new AggregateError(errors);
 
 		err.message = context.read();

package/lib/serialization/BinaryMiddleware.js

@@ -215,7 +215,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 						(allocationScope.increaseCounter + 1) % 4) &&
 					allocationScope.allocationSize < 16777216
 				) {
-					allocationScope.allocationSize = allocationScope.allocationSize << 1;
+					allocationScope.allocationSize <<= 1;
 				}
 			}
 		};
@@ -281,8 +281,9 @@ class BinaryMiddleware extends SerializerMiddleware {
 			const thing = data[i];
 			switch (typeof thing) {
 				case "function": {
-					if (!SerializerMiddleware.isLazy(thing))
+					if (!SerializerMiddleware.isLazy(thing)) {
 						throw new Error(`Unexpected function ${thing}`);
+					}
 					/** @type {SerializedType | LazyFunction<SerializedType, DeserializedType> | undefined} */
 					let serializedData =
 						SerializerMiddleware.getLazySerializedValue(thing);
@@ -801,7 +802,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 			let mask = 1;
 			while (n !== 0) {
 				result.push((data & mask) !== 0);
-				mask = mask << 1;
+				mask <<= 1;
 				n--;
 			}
 		};
@@ -1155,5 +1156,5 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 module.exports = BinaryMiddleware;
 
-module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
 module.exports.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
+module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;