webpack 5.102.1 → 5.104.0

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -8,8 +8,12 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("../Module").ExportsType} ExportsType */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
+
 /**
- * @param {import("../Module").ExportsType} exportsType exports type
+ * @param {ExportsType} exportsType exports type
  * @returns {string} mode
  */
 function getMakeDeferredNamespaceModeFromExportsType(exportsType) {
@@ -19,61 +23,81 @@ function getMakeDeferredNamespaceModeFromExportsType(exportsType) {
 	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
+ * @param {ExportsType} exportsType exportsType
+ * @param {(ModuleId | null)[]} asyncDepsIds asyncDepsIds
+ * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+ * @returns {string} call make optimized deferred namespace object
  */
 function getOptimizedDeferredModule(
-	_runtimeTemplate,
-	exportsType,
 	moduleId,
-	asyncDepsIds
+	exportsType,
+	asyncDepsIds,
+	runtimeRequirements
 ) {
-	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))}`
+	runtimeRequirements.add(RuntimeGlobals.makeOptimizedDeferredNamespaceObject);
+	const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
+	return `${RuntimeGlobals.makeOptimizedDeferredNamespaceObject}(${moduleId}, ${mode}${
+		asyncDepsIds.length > 0
+			? `, ${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 MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {boolean} hasAsyncRuntime if async module is used.
+	 */
+	constructor(hasAsyncRuntime) {
+		super("make optimized deferred namespace object");
+		this.hasAsyncRuntime = hasAsyncRuntime;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		if (!this.compilation) return null;
+		const fn = RuntimeGlobals.makeOptimizedDeferredNamespaceObject;
+		const hasAsync = this.hasAsyncRuntime;
+		return Template.asString([
+			// Note: must be a function (not arrow), because this is used in body!
+			`${fn} = function(moduleId, mode${hasAsync ? ", asyncDeps" : ""}) {`,
+			Template.indent([
+				"// 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 r = this;",
+				hasAsync ? "var isAsync = asyncDeps && asyncDeps.length;" : "",
+				"var obj = {",
+				Template.indent([
+					"get a() {",
+					Template.indent([
+						"var exports = r(moduleId);",
+						hasAsync
+							? `if(isAsync) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
+							: "",
+						// 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.
+						'if(mode == 0 || (mode == 3 && exports.__esModule)) Object.defineProperty(this, "a", { value: exports });',
+						"return exports;"
+					]),
+					"}"
+				]),
+				"};",
+				hasAsync
+					? `if(isAsync) obj[${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}] = asyncDeps;`
+					: "",
+				"return obj;"
+			]),
+			"};"
+		]);
+	}
+}
 
 class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	/**
@@ -92,8 +116,6 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 		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();";
@@ -104,7 +126,18 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 			"// mode: 3 => dynamic (if exports has __esModule, then esm, otherwise default-with-named)",
 			"",
 			"var cachedModule = __webpack_module_cache__[moduleId];",
-			...(strictError ? strictModuleCache : nonStrictModuleCache),
+			"if (cachedModule && cachedModule.error === undefined) {",
+			Template.indent([
+				"var exports = cachedModule.exports;",
+				hasAsync
+					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in exports) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
+					: "",
+				"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
+			]),
+			"}",
 			"",
 			`var init = ${runtimeTemplate.basicFunction("", [
 				`ns = ${RuntimeGlobals.require}(moduleId);`,
@@ -137,9 +170,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				"}"
 			])};`,
 			"",
-			`var ns = ${
-				strictError ? "" : "cachedModule && cachedModule.exports || "
-			}__webpack_module_deferred_exports__[moduleId] || (__webpack_module_deferred_exports__[moduleId] = { __proto__: null });`,
+			"var ns = __webpack_module_deferred_exports__[moduleId] || (__webpack_module_deferred_exports__[moduleId] = { __proto__: null });",
 			"var handler = {",
 			Template.indent([
 				"__proto__: null,",
@@ -161,7 +192,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 							'case "__esModule":',
 							"case Symbol.toStringTag:",
 							hasAsync
-								? `case ${RuntimeGlobals.makeDeferredNamespaceObjectSymbol}:`
+								? `case ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}:`
 								: "",
 							Template.indent("return true;"),
 							'case "then":',
@@ -208,7 +239,10 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	}
 }
 
-module.exports = MakeDeferredNamespaceObjectRuntimeModule;
+module.exports.MakeDeferredNamespaceObjectRuntimeModule =
+	MakeDeferredNamespaceObjectRuntimeModule;
+module.exports.MakeOptimizedDeferredNamespaceObjectRuntimeModule =
+	MakeOptimizedDeferredNamespaceObjectRuntimeModule;
 module.exports.getMakeDeferredNamespaceModeFromExportsType =
 	getMakeDeferredNamespaceModeFromExportsType;
 module.exports.getOptimizedDeferredModule = getOptimizedDeferredModule;

package/lib/schemes/HttpUriPlugin.js

@@ -34,6 +34,8 @@ const memoize = require("../util/memoize");
 const getHttp = memoize(() => require("http"));
 const getHttps = memoize(() => require("https"));
 
+const MAX_REDIRECTS = 5;
+
 /**
  * @param {typeof import("http") | typeof import("https")} request request
  * @param {string | URL | undefined} proxy proxy
@@ -200,6 +202,22 @@ const areLockfileEntriesEqual = (a, b) =>
 const entryToString = (entry) =>
 	`resolved: ${entry.resolved}, integrity: ${entry.integrity}, contentType: ${entry.contentType}`;
 
+/**
+ * Sanitize URL for inclusion in error messages
+ * @param {string} href URL string to sanitize
+ * @returns {string} sanitized URL text for logs/errors
+ */
+const sanitizeUrlForError = (href) => {
+	try {
+		const u = new URL(href);
+		return `${u.protocol}//${u.host}`;
+	} catch (_err) {
+		return String(href)
+			.slice(0, 200)
+			.replace(/[\r\n]/g, "");
+	}
+};
+
 class Lockfile {
 	constructor() {
 		this.version = 1;
@@ -317,7 +335,7 @@ const cachedWithoutKey = (fn) => {
  * @template R
  * @param {FnWithKey<T, R>} fn function
  * @param {FnWithKey<T, R>=} forceFn function for the second try
- * @returns {(FnWithKey<T, R>) & { force: FnWithKey<T, R> }} cached function
+ * @returns {FnWithKey<T, R> & { force: FnWithKey<T, R> }} cached function
  */
 const cachedWithKey = (fn, forceFn = fn) => {
 	/**
@@ -636,12 +654,47 @@ class HttpUriPlugin {
 				};
 
 				for (const { scheme, fetch } of schemes) {
+					/**
+					 * @param {string} location Location header value (relative or absolute)
+					 * @param {string} base current absolute URL
+					 * @returns {string} absolute, validated redirect target
+					 */
+					const validateRedirectLocation = (location, base) => {
+						let nextUrl;
+						try {
+							nextUrl = new URL(location, base);
+						} catch (err) {
+							throw new Error(
+								`Invalid redirect URL: ${sanitizeUrlForError(location)}`,
+								{ cause: err }
+							);
+						}
+						if (nextUrl.protocol !== "http:" && nextUrl.protocol !== "https:") {
+							throw new Error(
+								`Redirected URL uses disallowed protocol: ${sanitizeUrlForError(nextUrl.href)}`
+							);
+						}
+						if (!isAllowed(nextUrl.href)) {
+							throw new Error(
+								`${nextUrl.href} doesn't match the allowedUris policy after redirect. These URIs are allowed:\n${allowedUris
+									.map((uri) => ` - ${uri}`)
+									.join("\n")}`
+							);
+						}
+						return nextUrl.href;
+					};
 					/**
 					 * @param {string} url URL
 					 * @param {string | null} integrity integrity
 					 * @param {(err: Error | null, resolveContentResult?: ResolveContentResult) => void} callback callback
+					 * @param {number=} redirectCount number of followed redirects
 					 */
-					const resolveContent = (url, integrity, callback) => {
+					const resolveContent = (
+						url,
+						integrity,
+						callback,
+						redirectCount = 0
+					) => {
 						/**
 						 * @param {Error | null} err error
 						 * @param {FetchResult=} _result fetch result
@@ -653,8 +706,18 @@ class HttpUriPlugin {
 							const result = /** @type {FetchResult} */ (_result);
 
 							if ("location" in result) {
+								// Validate redirect target before following
+								let absolute;
+								try {
+									absolute = validateRedirectLocation(result.location, url);
+								} catch (err_) {
+									return callback(/** @type {Error} */ (err_));
+								}
+								if (redirectCount >= MAX_REDIRECTS) {
+									return callback(new Error("Too many redirects"));
+								}
 								return resolveContent(
-									result.location,
+									absolute,
 									integrity,
 									(err, innerResult) => {
 										if (err) return callback(err);
@@ -665,7 +728,8 @@ class HttpUriPlugin {
 											content,
 											storeLock: storeLock && result.storeLock
 										});
-									}
+									},
+									redirectCount + 1
 								);
 							}
 
@@ -781,9 +845,16 @@ class HttpUriPlugin {
 								res.statusCode >= 301 &&
 								res.statusCode <= 308
 							) {
-								const result = {
-									location: new URL(location, url).href
-								};
+								let absolute;
+								try {
+									absolute = validateRedirectLocation(location, url);
+								} catch (err) {
+									logger.log(
+										`GET ${url} [${res.statusCode}] -> ${String(location)} (rejected: ${/** @type {Error} */ (err).message})`
+									);
+									return callback(/** @type {Error} */ (err));
+								}
+								const result = { location: absolute };
 								if (
 									!cachedResult ||
 									!("location" in cachedResult) ||

package/lib/serialization/AggregateErrorSerializer.js

@@ -7,7 +7,7 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
-/** @typedef {Error & { cause: unknown, errors: EXPECTED_ANY[] }} AggregateError */
+/** @typedef {Error & { cause?: unknown, errors: EXPECTED_ANY[] }} AggregateError */
 
 class AggregateErrorSerializer {
 	/**
@@ -27,7 +27,6 @@ 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, unicorn/error-message
 		const err = new AggregateError(errors);
 

package/lib/serialization/ObjectMiddleware.js

@@ -157,11 +157,9 @@ jsTypes.set(ReferenceError, new ErrorObjectSerializer(ReferenceError));
 jsTypes.set(SyntaxError, new ErrorObjectSerializer(SyntaxError));
 jsTypes.set(TypeError, new ErrorObjectSerializer(TypeError));
 
-// @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
 if (typeof AggregateError !== "undefined") {
 	jsTypes.set(
-		// @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
 		AggregateError,
 		new AggregateErrorSerializer()

package/lib/serialization/SingleItemMiddleware.js

@@ -8,7 +8,7 @@ const SerializerMiddleware = require("./SerializerMiddleware");
 
 /** @typedef {EXPECTED_ANY} DeserializedType */
 /** @typedef {EXPECTED_ANY[]} SerializedType */
-/** @typedef {{}} Context */
+/** @typedef {EXPECTED_OBJECT} Context */
 
 /**
  * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}

package/lib/sharing/ConsumeSharedModule.js

@@ -8,7 +8,7 @@
 const { RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
-const { CONSUME_SHARED_TYPES } = require("../ModuleSourceTypesConstants");
+const { CONSUME_SHARED_TYPES } = require("../ModuleSourceTypeConstants");
 const {
 	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
 } = require("../ModuleTypeConstants");

package/lib/sharing/ConsumeSharedPlugin.js

@@ -119,11 +119,13 @@ class ConsumeSharedPlugin {
 					normalModuleFactory
 				);
 
-				/** @type {Map<string, ConsumeOptions>} */
+				/** @typedef {Map<string, ConsumeOptions>} Consumes */
+
+				/** @type {Consumes} */
 				let unresolvedConsumes;
-				/** @type {Map<string, ConsumeOptions>} */
+				/** @type {Consumes} */
 				let resolvedConsumes;
-				/** @type {Map<string, ConsumeOptions>} */
+				/** @type {Consumes} */
 				let prefixedConsumes;
 				const promise = resolveMatchedConfigs(compilation, this._consumes).then(
 					({ resolved, unresolved, prefixed }) => {

package/lib/sharing/ProvideSharedModule.js

@@ -7,7 +7,7 @@
 
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
-const { SHARED_INIT_TYPES } = require("../ModuleSourceTypesConstants");
+const { SHARED_INIT_TYPES } = require("../ModuleSourceTypeConstants");
 const { WEBPACK_MODULE_TYPE_PROVIDE } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");

package/lib/sharing/resolveMatchedConfigs.js

@@ -10,14 +10,20 @@ const LazySet = require("../util/LazySet");
 
 /** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compilation").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
 
+/**
+ * @template T
+ * @typedef {Map<string, T>} MatchedConfigsItem
+ */
+
 /**
  * @template T
  * @typedef {object} MatchedConfigs
- * @property {Map<string, T>} resolved
- * @property {Map<string, T>} unresolved
- * @property {Map<string, T>} prefixed
+ * @property {MatchedConfigsItem<T>} resolved
+ * @property {MatchedConfigsItem<T>} unresolved
+ * @property {MatchedConfigsItem<T>} prefixed
  */
 
 /** @type {ResolveOptionsWithDependencyType} */
@@ -30,11 +36,11 @@ const RESOLVE_OPTIONS = { dependencyType: "esm" };
  * @returns {Promise<MatchedConfigs<T>>} resolved matchers
  */
 module.exports.resolveMatchedConfigs = (compilation, configs) => {
-	/** @type {Map<string, T>} */
+	/** @type {MatchedConfigsItem<T>} */
 	const resolved = new Map();
-	/** @type {Map<string, T>} */
+	/** @type {MatchedConfigsItem<T>} */
 	const unresolved = new Map();
-	/** @type {Map<string, T>} */
+	/** @type {MatchedConfigsItem<T>} */
 	const prefixed = new Map();
 	/** @type {ResolveContext} */
 	const resolveContext = {
@@ -84,15 +90,15 @@ module.exports.resolveMatchedConfigs = (compilation, configs) => {
 		})
 	).then(() => {
 		compilation.contextDependencies.addAll(
-			/** @type {LazySet<string>} */
+			/** @type {FileSystemDependencies} */
 			(resolveContext.contextDependencies)
 		);
 		compilation.fileDependencies.addAll(
-			/** @type {LazySet<string>} */
+			/** @type {FileSystemDependencies} */
 			(resolveContext.fileDependencies)
 		);
 		compilation.missingDependencies.addAll(
-			/** @type {LazySet<string>} */
+			/** @type {FileSystemDependencies} */
 			(resolveContext.missingDependencies)
 		);
 		return { resolved, unresolved, prefixed };

package/lib/sharing/utils.js

@@ -379,7 +379,7 @@ const getRequiredVersionFromDescriptionFile = (data, packageName) => {
 			packageName in dependency
 		) {
 			return normalizeVersion(
-				/** @type {Exclude<JsonPrimitive, null | boolean| number>} */ (
+				/** @type {Exclude<JsonPrimitive, null | boolean | number>} */ (
 					dependency[packageName]
 				)
 			);

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -49,6 +49,8 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleProfile")} ModuleProfile */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../serialization/AggregateErrorSerializer").AggregateError} AggregateError */
+/** @typedef {import("../serialization/ErrorObjectSerializer").ErrorWithCause} ErrorWithCause */
 /** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 
 /**
@@ -370,13 +372,17 @@ const uniqueArray = (items, selector) => {
 const uniqueOrderedArray = (items, selector, comparator) =>
 	uniqueArray(items, selector).sort(comparator);
 
-/** @template T @template R @typedef {{ [P in keyof T]: R }} MappedValues<T, R> */
+/**
+ * @template T
+ * @template R
+ * @typedef {{ [P in keyof T]: R }} MappedValues<T, R>
+ */
 
 /**
  * @template {object} T
  * @template {object} R
  * @param {T} obj object to be mapped
- * @param {function(T[keyof T], keyof T): R} fn mapping function
+ * @param {(value: T[keyof T], key: keyof T) => R} fn mapping function
  * @returns {MappedValues<T, R>} mapped object
  */
 const mapObject = (obj, fn) => {
@@ -406,9 +412,6 @@ const countWithChildren = (compilation, getItems) => {
 	return count;
 };
 
-/** @typedef {Error & { cause?: unknown }} ErrorWithCause */
-/** @typedef {Error & { errors: EXPECTED_ANY[] }} AggregateError */
-
 /** @type {ExtractorsByOption<string | ErrorWithCause | AggregateError | WebpackError, StatsError>} */
 const EXTRACT_ERROR = {
 	_: (object, error, context, { requestShortener }) => {

package/lib/stats/DefaultStatsPresetPlugin.js

@@ -30,7 +30,7 @@ const applyDefaults = (options, defaults) => {
 	}
 };
 
-/** @typedef {{ [Key in Exclude<StatsValue, boolean | object | "normal">]: StatsOptions }} NamedPresets */
+/** @typedef {{ [Key in Exclude<StatsValue, boolean | EXPECTED_OBJECT | "normal">]: StatsOptions }} NamedPresets */
 
 /** @type {NamedPresets} */
 const NAMED_PRESETS = {

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -76,7 +76,7 @@ const getResourceName = (resource) => {
 
 /**
  * @param {string} name module name
- * @returns {[string,string]} prefix and module name
+ * @returns {[string, string]} prefix and module name
  */
 const getModuleName = (name) => {
 	const [, prefix, resource] =

package/lib/util/StringXor.js

@@ -36,7 +36,7 @@
  */
 class StringXor {
 	constructor() {
-		/** @type {Buffer|undefined} */
+		/** @type {Buffer | undefined} */
 		this._value = undefined;
 	}
 

package/lib/util/URLAbsoluteSpecifier.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {(error: Error|null, result?: Buffer) => void} ErrorFirstCallback */
+/** @typedef {(error: Error | null, result?: Buffer) => void} ErrorFirstCallback */
 
 const backSlashCharCode = "\\".charCodeAt(0);
 const slashCharCode = "/".charCodeAt(0);
@@ -25,7 +25,7 @@ const queryCharCode = "?".charCodeAt(0);
  * e.g. Absolute specifiers like 'file:///user/webpack/index.js'
  * https://tools.ietf.org/html/rfc3986#section-3.1
  * @param {string} specifier specifier
- * @returns {string|undefined} scheme if absolute URL specifier provided
+ * @returns {string | undefined} scheme if absolute URL specifier provided
  */
 function getScheme(specifier) {
 	const start = specifier.charCodeAt(0);

package/lib/util/binarySearchBounds.js

@@ -8,8 +8,8 @@
 /* cspell:disable-next-line */
 // Refactor: Peter Somogyvari @petermetz
 
-/** @typedef {">=" | "<=" | "<" | ">" | "-" } BinarySearchPredicate */
-/** @typedef {"GE" | "GT" | "LT" | "LE" | "EQ" } SearchPredicateSuffix */
+/** @typedef {">=" | "<=" | "<" | ">" | "-"} BinarySearchPredicate */
+/** @typedef {"GE" | "GT" | "LT" | "LE" | "EQ"} SearchPredicateSuffix */
 
 /**
  * Helper function for compiling binary search functions.