webpack 5.79.0 → 5.80.0

package/README.md

@@ -35,6 +35,9 @@
 	<a href="https://gitter.im/webpack/webpack">
 		<img src="https://badges.gitter.im/webpack/webpack.svg">
 	</a>
+  <a href="https://twitter.com/Webpack">
+		<img src="https://img.shields.io/twitter/follow/Webpack?style=social">
+	</a>
   <h1>webpack</h1>
   <p>
     Webpack is a module bundler. Its main purpose is to bundle JavaScript files for usage in a browser, yet it is also capable of transforming, bundling, or packaging just about any resource or asset.

package/lib/NormalModuleFactory.js

@@ -1020,7 +1020,7 @@ If changing the source code is not an option there is also a resolve options cal
 					context,
 					item.loader,
 					resolveContext,
-					(err, result) => {
+					(err, result, resolveRequest) => {
 						if (
 							err &&
 							/^[^/]*$/.test(item.loader) &&
@@ -1047,8 +1047,18 @@ If changing the source code is not an option there is also a resolve options cal
 						if (err) return callback(err);
 
 						const parsedResult = this._parseResourceWithoutFragment(result);
+
+						const type = /\.mjs$/i.test(parsedResult.path)
+							? "module"
+							: /\.cjs$/i.test(parsedResult.path)
+							? "commonjs"
+							: resolveRequest.descriptionFileData === undefined
+							? undefined
+							: resolveRequest.descriptionFileData.type;
+
 						const resolved = {
 							loader: parsedResult.path,
+							type,
 							options:
 								item.options === undefined
 									? parsedResult.query

package/lib/WarnCaseSensitiveModulesPlugin.js

@@ -9,6 +9,7 @@ const CaseSensitiveModulesWarning = require("./CaseSensitiveModulesWarning");
 
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./NormalModule")} NormalModule */
 
 class WarnCaseSensitiveModulesPlugin {
 	/**
@@ -25,6 +26,17 @@ class WarnCaseSensitiveModulesPlugin {
 					const moduleWithoutCase = new Map();
 					for (const module of compilation.modules) {
 						const identifier = module.identifier();
+
+						// Ignore `data:` URLs, because it's not a real path
+						if (
+							/** @type {NormalModule} */
+							(module).resourceResolveData !== undefined &&
+							/** @type {NormalModule} */
+							(module).resourceResolveData.encodedContent !== undefined
+						) {
+							continue;
+						}
+
 						const lowerIdentifier = identifier.toLowerCase();
 						let map = moduleWithoutCase.get(lowerIdentifier);
 						if (map === undefined) {

package/lib/asset/AssetGenerator.js

@@ -108,9 +108,17 @@ const encodeDataUri = (encoding, source) => {
 
 const decodeDataUriContent = (encoding, content) => {
 	const isBase64 = encoding === "base64";
-	return isBase64
-		? Buffer.from(content, "base64")
-		: Buffer.from(decodeURIComponent(content), "ascii");
+
+	if (isBase64) {
+		return Buffer.from(content, "base64");
+	}
+
+	// If we can't decode return the original body
+	try {
+		return Buffer.from(decodeURIComponent(content), "ascii");
+	} catch (_) {
+		return Buffer.from(content, "ascii");
+	}
 };
 
 const JS_TYPES = new Set(["javascript"]);

package/lib/css/CssParser.js

@@ -17,21 +17,54 @@ const walkCssTokens = require("./walkCssTokens");
 
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
-
 const CC_LEFT_CURLY = "{".charCodeAt(0);
 const CC_RIGHT_CURLY = "}".charCodeAt(0);
 const CC_COLON = ":".charCodeAt(0);
 const CC_SLASH = "/".charCodeAt(0);
 const CC_SEMICOLON = ";".charCodeAt(0);
 
-const cssUnescape = str => {
-	return str.replace(/\\([0-9a-fA-F]{1,6}[ \t\n\r\f]?|[\s\S])/g, match => {
-		if (match.length > 2) {
-			return String.fromCharCode(parseInt(match.slice(1).trim(), 16));
-		} else {
-			return match[1];
+// https://www.w3.org/TR/css-syntax-3/#newline
+// We don't have `preprocessing` stage, so we need specify all of them
+const STRING_MULTILINE = /\\[\n\r\f]/g;
+// https://www.w3.org/TR/css-syntax-3/#whitespace
+const TRIM_WHITE_SPACES = /(^[ \t\n\r\f]*|[ \t\n\r\f]*$)/g;
+const UNESCAPE = /\\([0-9a-fA-F]{1,6}[ \t\n\r\f]?|[\s\S])/g;
+const IMAGE_SET_FUNCTION = /^(-\w+-)?image-set$/i;
+
+const normalizeUrl = (str, isString) => {
+	// Remove extra spaces and newlines:
+	// `url("im\
+	// g.png")`
+	if (isString) {
+		str = str.replace(STRING_MULTILINE, "");
+	}
+
+	str = str
+		// Remove unnecessary spaces from `url("   img.png	 ")`
+		.replace(TRIM_WHITE_SPACES, "")
+		// Unescape
+		.replace(UNESCAPE, match => {
+			if (match.length > 2) {
+				return String.fromCharCode(parseInt(match.slice(1).trim(), 16));
+			} else {
+				return match[1];
+			}
+		});
+
+	if (/^data:/i.test(str)) {
+		return str;
+	}
+
+	if (str.includes("%")) {
+		// Convert `url('%2E/img.png')` -> `url('./img.png')`
+		try {
+			str = decodeURIComponent(str);
+		} catch (error) {
+			// Ignore
 		}
-	});
+	}
+
+	return str;
 };
 
 class LocConverter {
@@ -137,8 +170,11 @@ class CssParser extends Parser {
 		let modeData = undefined;
 		let singleClassSelector = undefined;
 		let lastIdentifier = undefined;
-		const modeStack = [];
 		let awaitRightParenthesis = false;
+		/** @type [string, number, number][] */
+		const functionStack = [];
+		const modeStack = [];
+
 		const isTopLevelLocal = () =>
 			modeData === "local" ||
 			(this.defaultMode === "local" && modeData === undefined);
@@ -304,8 +340,11 @@ class CssParser extends Parser {
 			isSelector: () => {
 				return mode !== CSS_MODE_IN_RULE && mode !== CSS_MODE_IN_LOCAL_RULE;
 			},
-			url: (input, start, end, contentStart, contentEnd) => {
-				const value = cssUnescape(input.slice(contentStart, contentEnd));
+			url: (input, start, end, contentStart, contentEnd, isString) => {
+				let value = normalizeUrl(
+					input.slice(contentStart, contentEnd),
+					isString
+				);
 				switch (mode) {
 					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
 						modeData.url = value;
@@ -321,6 +360,15 @@ class CssParser extends Parser {
 							)} at ${start} during ${explainMode(mode)}`
 						);
 					default: {
+						if (
+							// Ignore `url(#highlight)` URLs
+							/^#/.test(value) ||
+							// Ignore `url()`, `url('')` and `url("")`, they are valid by spec
+							value.length === 0
+						) {
+							break;
+						}
+
 						const dep = new CssUrlDependency(value, [start, end], "url");
 						const { line: sl, column: sc } = locConverter.get(start);
 						const { line: el, column: ec } = locConverter.get(end);
@@ -335,10 +383,44 @@ class CssParser extends Parser {
 			string: (input, start, end) => {
 				switch (mode) {
 					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
-						modeData.url = cssUnescape(input.slice(start + 1, end - 1));
+						modeData.url = normalizeUrl(input.slice(start + 1, end - 1), true);
 						mode = CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS;
 						break;
 					}
+					default: {
+						// TODO move escaped parsing to tokenizer
+						const lastFunction = functionStack[functionStack.length - 1];
+
+						if (
+							lastFunction &&
+							(lastFunction[0].replace(/\\/g, "").toLowerCase() === "url" ||
+								IMAGE_SET_FUNCTION.test(lastFunction[0].replace(/\\/g, "")))
+						) {
+							let value = normalizeUrl(input.slice(start + 1, end - 1), true);
+
+							if (
+								// Ignore `url(#highlight)` URLs
+								/^#/.test(value) ||
+								// Ignore `url()`, `url('')` and `url("")`, they are valid by spec
+								value.length === 0
+							) {
+								break;
+							}
+
+							const isUrl =
+								lastFunction[0].replace(/\\/g, "").toLowerCase() === "url";
+							const dep = new CssUrlDependency(
+								value,
+								[start, end],
+								isUrl ? "string" : "url"
+							);
+							const { line: sl, column: sc } = locConverter.get(start);
+							const { line: el, column: ec } = locConverter.get(end);
+							dep.setLoc(sl, sc, el, ec);
+							module.addDependency(dep);
+							module.addCodeGenerationDependency(dep);
+						}
+					}
 				}
 				return end;
 			},
@@ -523,6 +605,8 @@ class CssParser extends Parser {
 				return end;
 			},
 			rightParenthesis: (input, start, end) => {
+				functionStack.pop();
+
 				switch (mode) {
 					case CSS_MODE_TOP_LEVEL: {
 						if (awaitRightParenthesis) {
@@ -537,6 +621,7 @@ class CssParser extends Parser {
 						break;
 					}
 				}
+
 				return end;
 			},
 			pseudoClass: (input, start, end) => {
@@ -564,9 +649,14 @@ class CssParser extends Parser {
 				return end;
 			},
 			pseudoFunction: (input, start, end) => {
+				let name = input.slice(start, end - 1);
+
+				functionStack.push([name, start, end]);
+
 				switch (mode) {
 					case CSS_MODE_TOP_LEVEL: {
-						const name = input.slice(start, end - 1).toLowerCase();
+						name = name.toLowerCase();
+
 						if (this.allowModeSwitch && name === ":global") {
 							modeStack.push(modeData);
 							modeData = "global";
@@ -587,9 +677,14 @@ class CssParser extends Parser {
 				return end;
 			},
 			function: (input, start, end) => {
+				let name = input.slice(start, end - 1);
+
+				functionStack.push([name, start, end]);
+
 				switch (mode) {
 					case CSS_MODE_IN_LOCAL_RULE: {
-						const name = input.slice(start, end - 1).toLowerCase();
+						name = name.toLowerCase();
+
 						if (name === "var") {
 							let pos = walkCssTokens.eatWhitespaceAndComments(input, end);
 							if (pos === input.length) return pos;

package/lib/css/walkCssTokens.js

@@ -36,14 +36,16 @@ const CC_FORM_FEED = "\f".charCodeAt(0);
 const CC_TAB = "\t".charCodeAt(0);
 const CC_SPACE = " ".charCodeAt(0);
 
-const CC_SLASH = "/".charCodeAt(0);
-const CC_BACK_SLASH = "\\".charCodeAt(0);
+const CC_SOLIDUS = "/".charCodeAt(0);
+const CC_REVERSE_SOLIDUS = "\\".charCodeAt(0);
 const CC_ASTERISK = "*".charCodeAt(0);
 
 const CC_LEFT_PARENTHESIS = "(".charCodeAt(0);
 const CC_RIGHT_PARENTHESIS = ")".charCodeAt(0);
 const CC_LEFT_CURLY = "{".charCodeAt(0);
 const CC_RIGHT_CURLY = "}".charCodeAt(0);
+const CC_LEFT_SQUARE = "[".charCodeAt(0);
+const CC_RIGHT_SQUARE = "]".charCodeAt(0);
 
 const CC_QUOTATION_MARK = '"'.charCodeAt(0);
 const CC_APOSTROPHE = "'".charCodeAt(0);
@@ -100,28 +102,46 @@ const _isWhiteSpace = cc => {
 	);
 };
 
+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
+	);
+};
+
 /** @type {CharHandler} */
-const consumeSingleCharToken = (input, pos, callbacks) => {
+const consumeDelimToken = (input, pos, callbacks) => {
 	return pos + 1;
 };
 
 /** @type {CharHandler} */
-const consumePotentialComment = (input, pos, callbacks) => {
-	pos++;
-	if (pos === input.length) return pos;
-	let cc = input.charCodeAt(pos);
-	if (cc !== CC_ASTERISK) return pos;
-	for (;;) {
-		pos++;
-		if (pos === input.length) return pos;
-		cc = input.charCodeAt(pos);
-		while (cc === CC_ASTERISK) {
+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
+	// EOF code point. Return to the start of this step.
+	//
+	// If the preceding paragraph ended by consuming an EOF code point, this is a parse error.
+	// But we are silent on errors.
+	if (
+		input.charCodeAt(pos) === CC_SOLIDUS &&
+		input.charCodeAt(pos + 1) === CC_ASTERISK
+	) {
+		pos += 1;
+		while (pos < input.length) {
+			if (
+				input.charCodeAt(pos) === CC_ASTERISK &&
+				input.charCodeAt(pos + 1) === CC_SOLIDUS
+			) {
+				pos += 2;
+				break;
+			}
 			pos++;
-			if (pos === input.length) return pos;
-			cc = input.charCodeAt(pos);
-			if (cc === CC_SLASH) return pos + 1;
 		}
 	}
+	return pos;
 };
 
 /** @type {function(number): CharHandler} */
@@ -144,7 +164,7 @@ const _consumeString = (input, pos, end) => {
 			// bad string
 			return pos;
 		}
-		if (cc === CC_BACK_SLASH) {
+		if (cc === CC_REVERSE_SOLIDUS) {
 			// we don't need to fully parse the escaped code point
 			// just skip over a potential new line
 			pos++;
@@ -165,6 +185,12 @@ const _isIdentifierStartCode = cc => {
 	);
 };
 
+const _isTwoCodePointsAreValidEscape = (first, second) => {
+	if (first !== CC_REVERSE_SOLIDUS) return false;
+	if (_isNewLine(second)) return false;
+	return true;
+};
+
 const _isDigit = cc => {
 	return cc >= CC_0 && cc <= CC_9;
 };
@@ -175,13 +201,13 @@ const _startsIdentifier = (input, pos) => {
 		if (pos === input.length) return false;
 		const cc = input.charCodeAt(pos + 1);
 		if (cc === CC_HYPHEN_MINUS) return true;
-		if (cc === CC_BACK_SLASH) {
+		if (cc === CC_REVERSE_SOLIDUS) {
 			const cc = input.charCodeAt(pos + 2);
 			return !_isNewLine(cc);
 		}
 		return _isIdentifierStartCode(cc);
 	}
-	if (cc === CC_BACK_SLASH) {
+	if (cc === CC_REVERSE_SOLIDUS) {
 		const cc = input.charCodeAt(pos + 1);
 		return !_isNewLine(cc);
 	}
@@ -208,6 +234,7 @@ const consumeMinus = (input, pos, callbacks) => {
 	pos++;
 	if (pos === input.length) return pos;
 	const cc = input.charCodeAt(pos);
+	// If the input stream starts with a number, reconsume the current input code point, consume a numeric token, and return it.
 	if (cc === CC_FULL_STOP || _isDigit(cc)) {
 		return consumeNumericToken(input, pos, callbacks);
 	} else if (cc === CC_HYPHEN_MINUS) {
@@ -222,7 +249,7 @@ const consumeMinus = (input, pos, callbacks) => {
 				return callbacks.identifier(input, start, pos);
 			}
 		}
-	} else if (cc === CC_BACK_SLASH) {
+	} else if (cc === CC_REVERSE_SOLIDUS) {
 		if (pos + 1 === input.length) return pos;
 		const cc = input.charCodeAt(pos + 1);
 		if (_isNewLine(cc)) return pos;
@@ -231,11 +258,7 @@ const consumeMinus = (input, pos, callbacks) => {
 			return callbacks.identifier(input, start, pos);
 		}
 	} else if (_isIdentifierStartCode(cc)) {
-		pos++;
-		pos = _consumeIdentifier(input, pos);
-		if (callbacks.identifier !== undefined) {
-			return callbacks.identifier(input, start, pos);
-		}
+		pos = consumeOtherIdentifier(input, pos - 1, callbacks);
 	}
 	return pos;
 };
@@ -289,9 +312,10 @@ const consumeOtherIdentifier = (input, pos, callbacks) => {
 const consumePotentialUrl = (input, pos, callbacks) => {
 	const start = pos;
 	pos = _consumeIdentifier(input, pos);
+	const nextPos = pos + 1;
 	if (
 		pos === start + 3 &&
-		input.slice(start, pos + 1).toLowerCase() === "url("
+		input.slice(start, nextPos).toLowerCase() === "url("
 	) {
 		pos++;
 		let cc = input.charCodeAt(pos);
@@ -301,26 +325,15 @@ const consumePotentialUrl = (input, pos, callbacks) => {
 			cc = input.charCodeAt(pos);
 		}
 		if (cc === CC_QUOTATION_MARK || cc === CC_APOSTROPHE) {
-			pos++;
-			const contentStart = pos;
-			pos = _consumeString(input, pos, cc);
-			const contentEnd = pos - 1;
-			cc = input.charCodeAt(pos);
-			while (_isWhiteSpace(cc)) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
+			if (callbacks.function !== undefined) {
+				return callbacks.function(input, start, nextPos);
 			}
-			if (cc !== CC_RIGHT_PARENTHESIS) return pos;
-			pos++;
-			if (callbacks.url !== undefined)
-				return callbacks.url(input, start, pos, contentStart, contentEnd);
-			return pos;
+			return nextPos;
 		} else {
 			const contentStart = pos;
 			let contentEnd;
 			for (;;) {
-				if (cc === CC_BACK_SLASH) {
+				if (cc === CC_REVERSE_SOLIDUS) {
 					pos++;
 					if (pos === input.length) return pos;
 					pos++;
@@ -439,7 +452,7 @@ const consumeComma = (input, pos, callbacks) => {
 const _consumeIdentifier = (input, pos) => {
 	for (;;) {
 		const cc = input.charCodeAt(pos);
-		if (cc === CC_BACK_SLASH) {
+		if (cc === CC_REVERSE_SOLIDUS) {
 			pos++;
 			if (pos === input.length) return pos;
 			pos++;
@@ -513,7 +526,6 @@ const consumeLessThan = (input, pos, callbacks) => {
 	return pos + 1;
 };
 
-/** @type {CharHandler} */
 const consumeAt = (input, pos, callbacks) => {
 	const start = pos;
 	pos++;
@@ -527,65 +539,102 @@ const consumeAt = (input, pos, callbacks) => {
 	return pos;
 };
 
+/** @type {CharHandler} */
+const consumeReverseSolidus = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (pos === input.length) return pos;
+	// If the input stream starts with a valid escape, reconsume the current input code point, consume an ident-like token, and return it.
+	if (
+		_isTwoCodePointsAreValidEscape(
+			input.charCodeAt(start),
+			input.charCodeAt(pos)
+		)
+	) {
+		return consumeOtherIdentifier(input, pos - 1, callbacks);
+	}
+	// Otherwise, this is a parse error. Return a <delim-token> with its value set to the current input code point.
+	return pos;
+};
+
 const CHAR_MAP = Array.from({ length: 0x80 }, (_, cc) => {
 	// https://drafts.csswg.org/css-syntax/#consume-token
 	switch (cc) {
+		// whitespace
 		case CC_LINE_FEED:
 		case CC_CARRIAGE_RETURN:
 		case CC_FORM_FEED:
 		case CC_TAB:
 		case CC_SPACE:
 			return consumeSpace;
+		// U+0022 QUOTATION MARK (")
 		case CC_QUOTATION_MARK:
-		case CC_APOSTROPHE:
 			return consumeString(cc);
+		// U+0023 NUMBER SIGN (#)
 		case CC_NUMBER_SIGN:
 			return consumeNumberSign;
-		case CC_SLASH:
-			return consumePotentialComment;
-		// case CC_LEFT_SQUARE:
-		// case CC_RIGHT_SQUARE:
-		// case CC_COMMA:
-		// case CC_COLON:
-		// 	return consumeSingleCharToken;
-		case CC_COMMA:
-			return consumeComma;
-		case CC_SEMICOLON:
-			return consumeSemicolon;
+		// U+0027 APOSTROPHE (')
+		case CC_APOSTROPHE:
+			return consumeString(cc);
+		// U+0028 LEFT PARENTHESIS (()
 		case CC_LEFT_PARENTHESIS:
 			return consumeLeftParenthesis;
+		// U+0029 RIGHT PARENTHESIS ())
 		case CC_RIGHT_PARENTHESIS:
 			return consumeRightParenthesis;
-		case CC_LEFT_CURLY:
-			return consumeLeftCurlyBracket;
-		case CC_RIGHT_CURLY:
-			return consumeRightCurlyBracket;
-		case CC_COLON:
-			return consumePotentialPseudo;
+		// U+002B PLUS SIGN (+)
 		case CC_PLUS_SIGN:
 			return consumeNumericToken;
-		case CC_FULL_STOP:
-			return consumeDot;
+		// U+002C COMMA (,)
+		case CC_COMMA:
+			return consumeComma;
+		// U+002D HYPHEN-MINUS (-)
 		case CC_HYPHEN_MINUS:
 			return consumeMinus;
+		// U+002E FULL STOP (.)
+		case CC_FULL_STOP:
+			return consumeDot;
+		// U+003A COLON (:)
+		case CC_COLON:
+			return consumePotentialPseudo;
+		// U+003B SEMICOLON (;)
+		case CC_SEMICOLON:
+			return consumeSemicolon;
+		// U+003C LESS-THAN SIGN (<)
 		case CC_LESS_THAN_SIGN:
 			return consumeLessThan;
+		// U+0040 COMMERCIAL AT (@)
 		case CC_AT_SIGN:
 			return consumeAt;
+		// U+005B LEFT SQUARE BRACKET ([)
+		case CC_LEFT_SQUARE:
+			return consumeDelimToken;
+		// U+005C REVERSE SOLIDUS (\)
+		case CC_REVERSE_SOLIDUS:
+			return consumeReverseSolidus;
+		// U+005D RIGHT SQUARE BRACKET (])
+		case CC_RIGHT_SQUARE:
+			return consumeDelimToken;
+		// U+007B LEFT CURLY BRACKET ({)
+		case CC_LEFT_CURLY:
+			return consumeLeftCurlyBracket;
+		// U+007D RIGHT CURLY BRACKET (})
+		case CC_RIGHT_CURLY:
+			return consumeRightCurlyBracket;
+		// Optimization
 		case CC_LOWER_U:
 		case CC_UPPER_U:
 			return consumePotentialUrl;
-		case CC_LOW_LINE:
-			return consumeOtherIdentifier;
 		default:
+			// digit
 			if (_isDigit(cc)) return consumeNumericToken;
-			if (
-				(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
-				(cc >= CC_UPPER_A && cc <= CC_UPPER_Z)
-			) {
+			// ident-start code point
+			if (_isIdentStartCodePoint(cc)) {
 				return consumeOtherIdentifier;
 			}
-			return consumeSingleCharToken;
+			// EOF, but we don't have it
+			// anything else
+			return consumeDelimToken;
 	}
 });
 
@@ -595,9 +644,15 @@ const CHAR_MAP = Array.from({ length: 0x80 }, (_, cc) => {
  * @returns {void}
  */
 module.exports = (input, callbacks) => {
+	// This section describes how to consume a token from a stream of code points. It will return a single token of any type.
 	let pos = 0;
 	while (pos < input.length) {
+		// Consume comments.
+		pos = consumeComments(input, pos, callbacks);
+
 		const cc = input.charCodeAt(pos);
+
+		// Consume the next input code point.
 		if (cc < 0x80) {
 			pos = CHAR_MAP[cc](input, pos, callbacks);
 		} else {
@@ -609,7 +664,7 @@ module.exports = (input, callbacks) => {
 module.exports.eatComments = (input, pos) => {
 	loop: for (;;) {
 		const cc = input.charCodeAt(pos);
-		if (cc === CC_SLASH) {
+		if (cc === CC_SOLIDUS) {
 			if (pos === input.length) return pos;
 			let cc = input.charCodeAt(pos + 1);
 			if (cc !== CC_ASTERISK) return pos;
@@ -622,7 +677,7 @@ module.exports.eatComments = (input, pos) => {
 					pos++;
 					if (pos === input.length) return pos;
 					cc = input.charCodeAt(pos);
-					if (cc === CC_SLASH) {
+					if (cc === CC_SOLIDUS) {
 						pos++;
 						continue loop;
 					}
@@ -636,7 +691,7 @@ module.exports.eatComments = (input, pos) => {
 module.exports.eatWhitespaceAndComments = (input, pos) => {
 	loop: for (;;) {
 		const cc = input.charCodeAt(pos);
-		if (cc === CC_SLASH) {
+		if (cc === CC_SOLIDUS) {
 			if (pos === input.length) return pos;
 			let cc = input.charCodeAt(pos + 1);
 			if (cc !== CC_ASTERISK) return pos;
@@ -649,7 +704,7 @@ module.exports.eatWhitespaceAndComments = (input, pos) => {
 					pos++;
 					if (pos === input.length) return pos;
 					cc = input.charCodeAt(pos);
-					if (cc === CC_SLASH) {
+					if (cc === CC_SOLIDUS) {
 						pos++;
 						continue loop;
 					}