webpack 5.93.0 → 5.95.0

package/lib/css/walkCssTokens.js

@@ -80,14 +80,11 @@ const CC_GREATER_THAN_SIGN = ">".charCodeAt(0);
  * @param {number} cc char code
  * @returns {boolean} true, if cc is a newline
  */
-const _isNewLine = cc => {
-	return (
-		cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED
-	);
-};
+const _isNewLine = cc =>
+	cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED;
 
 /** @type {CharHandler} */
-const consumeSpace = (input, pos, callbacks) => {
+const consumeSpace = (input, pos, _callbacks) => {
 	/** @type {number} */
 	let cc;
 	do {
@@ -101,52 +98,39 @@ const consumeSpace = (input, pos, callbacks) => {
  * @param {number} cc char code
  * @returns {boolean} true, if cc is a newline
  */
-const _isNewline = cc => {
-	return (
-		cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED
-	);
-};
+const _isNewline = cc =>
+	cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED;
 
 /**
  * @param {number} cc char code
  * @returns {boolean} true, if cc is a space (U+0009 CHARACTER TABULATION or U+0020 SPACE)
  */
-const _isSpace = cc => {
-	return cc === CC_TAB || cc === CC_SPACE;
-};
+const _isSpace = cc => cc === CC_TAB || cc === CC_SPACE;
 
 /**
  * @param {number} cc char code
  * @returns {boolean} true, if cc is a whitespace
  */
-const _isWhiteSpace = cc => {
-	return _isNewline(cc) || _isSpace(cc);
-};
+const _isWhiteSpace = cc => _isNewline(cc) || _isSpace(cc);
 
 /**
  * ident-start code point
  *
  * A letter, a non-ASCII code point, or U+005F LOW LINE (_).
- *
  * @param {number} cc char code
  * @returns {boolean} true, if cc is a start code point of an identifier
  */
-const isIdentStartCodePoint = cc => {
-	return (
-		(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
-		(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
-		cc === CC_LOW_LINE ||
-		cc >= 0x80
-	);
-};
+const isIdentStartCodePoint = cc =>
+	(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
+	(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
+	cc === CC_LOW_LINE ||
+	cc >= 0x80;
 
 /** @type {CharHandler} */
-const consumeDelimToken = (input, pos, callbacks) => {
-	return pos + 1;
-};
+const consumeDelimToken = (input, pos, _callbacks) => pos + 1;
 
 /** @type {CharHandler} */
-const consumeComments = (input, pos, callbacks) => {
+const consumeComments = (input, pos, _callbacks) => {
 	// If the next two input code point are U+002F SOLIDUS (/) followed by a U+002A
 	// ASTERISK (*), consume them and all following code points up to and including
 	// the first U+002A ASTERISK (*) followed by a U+002F SOLIDUS (/), or up to an
@@ -174,9 +158,9 @@ const consumeComments = (input, pos, callbacks) => {
 };
 
 /** @type {function(number): CharHandler} */
-const consumeString = quote_cc => (input, pos, callbacks) => {
+const consumeString = quoteCc => (input, pos, callbacks) => {
 	const start = pos;
-	pos = _consumeString(input, pos, quote_cc);
+	pos = _consumeString(input, pos, quoteCc);
 	if (callbacks.string !== undefined) {
 		pos = callbacks.string(input, start, pos);
 	}
@@ -186,15 +170,15 @@ const consumeString = quote_cc => (input, pos, callbacks) => {
 /**
  * @param {string} input input
  * @param {number} pos position
- * @param {number} quote_cc quote char code
+ * @param {number} quoteCc quote char code
  * @returns {number} new position
  */
-const _consumeString = (input, pos, quote_cc) => {
+const _consumeString = (input, pos, quoteCc) => {
 	pos++;
 	for (;;) {
 		if (pos === input.length) return pos;
 		const cc = input.charCodeAt(pos);
-		if (cc === quote_cc) return pos + 1;
+		if (cc === quoteCc) return pos + 1;
 		if (_isNewLine(cc)) {
 			// bad string
 			return pos;
@@ -215,14 +199,11 @@ const _consumeString = (input, pos, quote_cc) => {
  * @param {number} cc char code
  * @returns {boolean} is identifier start code
  */
-const _isIdentifierStartCode = cc => {
-	return (
-		cc === CC_LOW_LINE ||
-		(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
-		(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
-		cc > 0x80
-	);
-};
+const _isIdentifierStartCode = cc =>
+	cc === CC_LOW_LINE ||
+	(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
+	(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
+	cc > 0x80;
 
 /**
  * @param {number} first first code point
@@ -239,9 +220,7 @@ const _isTwoCodePointsAreValidEscape = (first, second) => {
  * @param {number} cc char code
  * @returns {boolean} is digit
  */
-const _isDigit = cc => {
-	return cc >= CC_0 && cc <= CC_9;
-};
+const _isDigit = cc => cc >= CC_0 && cc <= CC_9;
 
 /**
  * @param {string} input input
@@ -272,7 +251,11 @@ const consumeNumberSign = (input, pos, callbacks) => {
 	const start = pos;
 	pos++;
 	if (pos === input.length) return pos;
-	if (callbacks.isSelector(input, pos) && _startsIdentifier(input, pos)) {
+	if (
+		callbacks.isSelector &&
+		callbacks.isSelector(input, pos) &&
+		_startsIdentifier(input, pos)
+	) {
 		pos = _consumeIdentifier(input, pos, callbacks);
 		if (callbacks.id !== undefined) {
 			return callbacks.id(input, start, pos);
@@ -296,11 +279,10 @@ const consumeMinus = (input, pos, callbacks) => {
 		const cc = input.charCodeAt(pos);
 		if (cc === CC_GREATER_THAN_SIGN) {
 			return pos + 1;
-		} else {
-			pos = _consumeIdentifier(input, pos, callbacks);
-			if (callbacks.identifier !== undefined) {
-				return callbacks.identifier(input, start, pos);
-			}
+		}
+		pos = _consumeIdentifier(input, pos, callbacks);
+		if (callbacks.identifier !== undefined) {
+			return callbacks.identifier(input, start, pos);
 		}
 	} else if (cc === CC_REVERSE_SOLIDUS) {
 		if (pos + 1 === input.length) return pos;
@@ -323,7 +305,10 @@ const consumeDot = (input, pos, callbacks) => {
 	if (pos === input.length) return pos;
 	const cc = input.charCodeAt(pos);
 	if (_isDigit(cc)) return consumeNumericToken(input, pos - 2, callbacks);
-	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
+	if (
+		(callbacks.isSelector && !callbacks.isSelector(input, pos)) ||
+		!_startsIdentifier(input, pos)
+	)
 		return pos;
 	pos = _consumeIdentifier(input, pos, callbacks);
 	if (callbacks.class !== undefined) return callbacks.class(input, start, pos);
@@ -350,10 +335,8 @@ const consumeOtherIdentifier = (input, pos, callbacks) => {
 		if (callbacks.function !== undefined) {
 			return callbacks.function(input, start, pos);
 		}
-	} else {
-		if (callbacks.identifier !== undefined) {
-			return callbacks.identifier(input, start, pos);
-		}
+	} else if (callbacks.identifier !== undefined) {
+		return callbacks.identifier(input, start, pos);
 	}
 	return pos;
 };
@@ -379,43 +362,42 @@ const consumePotentialUrl = (input, pos, callbacks) => {
 				return callbacks.function(input, start, nextPos);
 			}
 			return nextPos;
-		} else {
-			const contentStart = pos;
-			/** @type {number} */
-			let contentEnd;
-			for (;;) {
-				if (cc === CC_REVERSE_SOLIDUS) {
+		}
+		const contentStart = pos;
+		/** @type {number} */
+		let contentEnd;
+		for (;;) {
+			if (cc === CC_REVERSE_SOLIDUS) {
+				pos++;
+				if (pos === input.length) return pos;
+				pos++;
+			} else if (_isWhiteSpace(cc)) {
+				contentEnd = pos;
+				do {
 					pos++;
 					if (pos === input.length) return pos;
-					pos++;
-				} else if (_isWhiteSpace(cc)) {
-					contentEnd = pos;
-					do {
-						pos++;
-						if (pos === input.length) return pos;
-						cc = input.charCodeAt(pos);
-					} while (_isWhiteSpace(cc));
-					if (cc !== CC_RIGHT_PARENTHESIS) return pos;
-					pos++;
-					if (callbacks.url !== undefined) {
-						return callbacks.url(input, start, pos, contentStart, contentEnd);
-					}
-					return pos;
-				} else if (cc === CC_RIGHT_PARENTHESIS) {
-					contentEnd = pos;
-					pos++;
-					if (callbacks.url !== undefined) {
-						return callbacks.url(input, start, pos, contentStart, contentEnd);
-					}
-					return pos;
-				} else if (cc === CC_LEFT_PARENTHESIS) {
-					return pos;
-				} else {
-					pos++;
+					cc = input.charCodeAt(pos);
+				} while (_isWhiteSpace(cc));
+				if (cc !== CC_RIGHT_PARENTHESIS) return pos;
+				pos++;
+				if (callbacks.url !== undefined) {
+					return callbacks.url(input, start, pos, contentStart, contentEnd);
 				}
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
+				return pos;
+			} else if (cc === CC_RIGHT_PARENTHESIS) {
+				contentEnd = pos;
+				pos++;
+				if (callbacks.url !== undefined) {
+					return callbacks.url(input, start, pos, contentStart, contentEnd);
+				}
+				return pos;
+			} else if (cc === CC_LEFT_PARENTHESIS) {
+				return pos;
+			} else {
+				pos++;
 			}
+			if (pos === input.length) return pos;
+			cc = input.charCodeAt(pos);
 		}
 	} else {
 		if (callbacks.identifier !== undefined) {
@@ -429,10 +411,13 @@ const consumePotentialUrl = (input, pos, callbacks) => {
 const consumePotentialPseudo = (input, pos, callbacks) => {
 	const start = pos;
 	pos++;
-	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
+	if (
+		(callbacks.isSelector && !callbacks.isSelector(input, pos)) ||
+		!_startsIdentifier(input, pos)
+	)
 		return pos;
 	pos = _consumeIdentifier(input, pos, callbacks);
-	let cc = input.charCodeAt(pos);
+	const cc = input.charCodeAt(pos);
 	if (cc === CC_LEFT_PARENTHESIS) {
 		pos++;
 		if (callbacks.pseudoFunction !== undefined) {
@@ -574,7 +559,7 @@ const _consumeNumber = (input, pos) => {
 };
 
 /** @type {CharHandler} */
-const consumeLessThan = (input, pos, callbacks) => {
+const consumeLessThan = (input, pos, _callbacks) => {
 	if (input.slice(pos + 1, pos + 4) === "!--") return pos + 4;
 	return pos + 1;
 };
@@ -724,7 +709,7 @@ module.exports.isIdentStartCodePoint = isIdentStartCodePoint;
  */
 module.exports.eatComments = (input, pos) => {
 	for (;;) {
-		let originalPos = pos;
+		const originalPos = pos;
 		pos = consumeComments(input, pos, {});
 		if (originalPos === pos) {
 			break;
@@ -754,7 +739,7 @@ module.exports.eatWhitespace = (input, pos) => {
  */
 module.exports.eatWhitespaceAndComments = (input, pos) => {
 	for (;;) {
-		let originalPos = pos;
+		const originalPos = pos;
 		pos = consumeComments(input, pos, {});
 		while (_isWhiteSpace(input.charCodeAt(pos))) {
 			pos++;

package/lib/debug/ProfilingPlugin.js

@@ -36,12 +36,12 @@ const validate = createSchemaValidation(
 );
 
 /** @type {Inspector | undefined} */
-let inspector = undefined;
+let inspector;
 
 try {
 	// eslint-disable-next-line n/no-unsupported-features/node-builtins
 	inspector = require("inspector");
-} catch (e) {
+} catch (_err) {
 	console.log("Unable to CPU profile in < node 8.0");
 }
 
@@ -92,7 +92,7 @@ class Profiler {
 	sendCommand(method, params) {
 		if (this.hasSession()) {
 			return new Promise((res, rej) => {
-				return this.session.post(method, params, (err, params) => {
+				this.session.post(method, params, (err, params) => {
 					if (err !== null) {
 						rej(err);
 					} else {
@@ -100,9 +100,8 @@ class Profiler {
 					}
 				});
 			});
-		} else {
-			return Promise.resolve();
 		}
+		return Promise.resolve();
 	}
 
 	destroy() {
@@ -234,19 +233,20 @@ class ProfilingPlugin {
 		tracer.profiler.startProfiling();
 
 		// Compiler Hooks
-		Object.keys(compiler.hooks).forEach(hookName => {
-			const hook = compiler.hooks[hookName];
+		for (const hookName of Object.keys(compiler.hooks)) {
+			const hook =
+				compiler.hooks[/** @type {keyof Compiler["hooks"]} */ (hookName)];
 			if (hook) {
 				hook.intercept(makeInterceptorFor("Compiler", tracer)(hookName));
 			}
-		});
+		}
 
-		Object.keys(compiler.resolverFactory.hooks).forEach(hookName => {
+		for (const hookName of Object.keys(compiler.resolverFactory.hooks)) {
 			const hook = compiler.resolverFactory.hooks[hookName];
 			if (hook) {
 				hook.intercept(makeInterceptorFor("Resolver", tracer)(hookName));
 			}
-		});
+		}
 
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
@@ -291,7 +291,9 @@ class ProfilingPlugin {
 						cat: ["toplevel"],
 						ts: cpuStartTime,
 						args: {
+							// eslint-disable-next-line camelcase
 							src_file: "../../ipc/ipc_moji_bootstrap.cc",
+							// eslint-disable-next-line camelcase
 							src_func: "Accept"
 						}
 					});
@@ -339,12 +341,12 @@ class ProfilingPlugin {
  */
 const interceptAllHooksFor = (instance, tracer, logLabel) => {
 	if (Reflect.has(instance, "hooks")) {
-		Object.keys(instance.hooks).forEach(hookName => {
+		for (const hookName of Object.keys(instance.hooks)) {
 			const hook = instance.hooks[hookName];
 			if (hook && !hook._fakeHook) {
 				hook.intercept(makeInterceptorFor(logLabel, tracer)(hookName));
 			}
-		});
+		}
 	}
 };
 
@@ -362,13 +364,13 @@ const interceptAllParserHooks = (moduleFactory, tracer) => {
 		WEBASSEMBLY_MODULE_TYPE_SYNC
 	];
 
-	moduleTypes.forEach(moduleType => {
+	for (const moduleType of moduleTypes) {
 		moduleFactory.hooks.parser
 			.for(moduleType)
 			.tap(PLUGIN_NAME, (parser, parserOpts) => {
 				interceptAllHooksFor(parser, tracer, "Parser");
 			});
-	});
+	}
 };
 
 /**
@@ -400,10 +402,7 @@ const makeInterceptorFor = (instance, tracer) => hookName => ({
 						type,
 						fn
 					});
-		return {
-			...tapInfo,
-			fn: newFn
-		};
+		return { ...tapInfo, fn: newFn };
 	}
 });
 
@@ -476,13 +475,13 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 				let r;
 				try {
 					r = fn(...args);
-				} catch (error) {
+				} catch (err) {
 					tracer.trace.end({
 						name,
 						id,
 						cat: defaultCategory
 					});
-					throw error;
+					throw err;
 				}
 				tracer.trace.end({
 					name,

package/lib/dependencies/AMDDefineDependency.js

@@ -111,7 +111,7 @@ class AMDDefineDependency extends NullDependency {
 	 * @param {Range | null} arrayRange array range
 	 * @param {Range | null} functionRange function range
 	 * @param {Range | null} objectRange object range
-	 * @param {boolean | null} namedModule true, when define is called with a name
+	 * @param {string | null} namedModule true, when define is called with a name
 	 */
 	constructor(range, arrayRange, functionRange, objectRange, namedModule) {
 		super();