webpack 5.81.0 → 5.82.0

package/lib/css/CssParser.js

@@ -5,7 +5,9 @@
 
 "use strict";
 
+const ModuleDependencyWarning = require("../ModuleDependencyWarning");
 const Parser = require("../Parser");
+const WebpackError = require("../WebpackError");
 const ConstDependency = require("../dependencies/ConstDependency");
 const CssExportDependency = require("../dependencies/CssExportDependency");
 const CssImportDependency = require("../dependencies/CssImportDependency");
@@ -34,6 +36,11 @@ const OPTIONALLY_VENDOR_PREFIXED_KEYFRAMES_AT_RULE = /^@(-\w+-)?keyframes$/;
 const OPTIONALLY_VENDOR_PREFIXED_ANIMATION_PROPERTY =
 	/^(-\w+-)?animation(-name)?$/i;
 
+/**
+ * @param {string} str url string
+ * @param {boolean} isString is url wrapped in quotes
+ * @returns {string} normalized url
+ */
 const normalizeUrl = (str, isString) => {
 	// Remove extra spaces and newlines:
 	// `url("im\
@@ -71,6 +78,9 @@ const normalizeUrl = (str, isString) => {
 };
 
 class LocConverter {
+	/**
+	 * @param {string} input input
+	 */
 	constructor(input) {
 		this._input = input;
 		this.line = 1;
@@ -78,6 +88,10 @@ class LocConverter {
 		this.pos = 0;
 	}
 
+	/**
+	 * @param {number} pos position
+	 * @returns {LocConverter} location converter
+	 */
 	get(pos) {
 		if (this.pos !== pos) {
 			if (this.pos < pos) {
@@ -110,26 +124,8 @@ const CSS_MODE_IN_RULE = 1;
 const CSS_MODE_IN_LOCAL_RULE = 2;
 const CSS_MODE_AT_IMPORT_EXPECT_URL = 3;
 const CSS_MODE_AT_IMPORT_EXPECT_LAYER_OR_SUPPORTS_OR_MEDIA = 4;
-const CSS_MODE_AT_OTHER = 5;
-
-const explainMode = mode => {
-	switch (mode) {
-		case CSS_MODE_TOP_LEVEL:
-			return "parsing top level css";
-		case CSS_MODE_IN_RULE:
-			return "parsing css rule content (global)";
-		case CSS_MODE_IN_LOCAL_RULE:
-			return "parsing css rule content (local)";
-		case CSS_MODE_AT_IMPORT_EXPECT_URL:
-			return "parsing @import (expecting url)";
-		case CSS_MODE_AT_IMPORT_EXPECT_LAYER_OR_SUPPORTS_OR_MEDIA:
-			return "parsing @import (expecting optionally layer, supports or media query)";
-		case CSS_MODE_AT_OTHER:
-			return "parsing at-rule";
-		default:
-			return mode;
-	}
-};
+const CSS_MODE_AT_IMPORT_INVALID = 5;
+const CSS_MODE_AT_NAMESPACE_INVALID = 6;
 
 class CssParser extends Parser {
 	constructor({
@@ -143,6 +139,25 @@ class CssParser extends Parser {
 		this.defaultMode = defaultMode;
 	}
 
+	/**
+	 * @param {ParserState} state parser state
+	 * @param {string} message warning message
+	 * @param {LocConverter} locConverter location converter
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 */
+	_emitWarning(state, message, locConverter, start, end) {
+		const { line: sl, column: sc } = locConverter.get(start);
+		const { line: el, column: ec } = locConverter.get(end);
+
+		state.current.addWarning(
+			new ModuleDependencyWarning(state.module, new WebpackError(message), {
+				start: { line: sl, column: sc },
+				end: { line: el, column: ec }
+			})
+		);
+	}
+
 	/**
 	 * @param {string | Buffer | PreparsedAst} source the source to parse
 	 * @param {ParserState} state the parser state
@@ -163,11 +178,18 @@ class CssParser extends Parser {
 		const declaredCssVariables = new Set();
 
 		const locConverter = new LocConverter(source);
+		/** @type {number} */
 		let mode = CSS_MODE_TOP_LEVEL;
+		/** @type {number} */
 		let modeNestingLevel = 0;
+		/** @type {boolean} */
+		let allowImportAtRule = true;
 		let modeData = undefined;
+		/** @type {string | boolean | undefined} */
 		let singleClassSelector = undefined;
+		/** @type {[number, number] | undefined} */
 		let lastIdentifier = undefined;
+		/** @type {boolean} */
 		let awaitRightParenthesis = false;
 		/** @type [string, number, number][] */
 		let balanced = [];
@@ -176,18 +198,6 @@ class CssParser extends Parser {
 		const isTopLevelLocal = () =>
 			modeData === "local" ||
 			(this.defaultMode === "local" && modeData === undefined);
-		const eatWhiteLine = (input, pos) => {
-			for (;;) {
-				const cc = input.charCodeAt(pos);
-				if (cc === 32 || cc === 9) {
-					pos++;
-					continue;
-				}
-				if (cc === 10) pos++;
-				break;
-			}
-			return pos;
-		};
 		const eatUntil = chars => {
 			const charCodes = Array.from({ length: chars.length }, (_, i) =>
 				chars.charCodeAt(i)
@@ -238,10 +248,16 @@ class CssParser extends Parser {
 		const parseExports = (input, pos) => {
 			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
 			const cc = input.charCodeAt(pos);
-			if (cc !== CC_LEFT_CURLY)
-				throw new Error(
-					`Unexpected ${input[pos]} at ${pos} during parsing of ':export' (expected '{')`
+			if (cc !== CC_LEFT_CURLY) {
+				this._emitWarning(
+					state,
+					`Unexpected '${input[pos]}' at ${pos} during parsing of ':export' (expected '{')`,
+					locConverter,
+					pos,
+					pos
 				);
+				return pos;
+			}
 			pos++;
 			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
 			for (;;) {
@@ -253,9 +269,14 @@ class CssParser extends Parser {
 				[pos, name] = eatText(input, pos, eatExportName);
 				if (pos === input.length) return pos;
 				if (input.charCodeAt(pos) !== CC_COLON) {
-					throw new Error(
-						`Unexpected ${input[pos]} at ${pos} during parsing of export name in ':export' (expected ':')`
+					this._emitWarning(
+						state,
+						`Unexpected '${input[pos]}' at ${pos} during parsing of export name in ':export' (expected ':')`,
+						locConverter,
+						start,
+						pos
 					);
+					return pos;
 				}
 				pos++;
 				if (pos === input.length) return pos;
@@ -271,9 +292,14 @@ class CssParser extends Parser {
 					pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
 					if (pos === input.length) return pos;
 				} else if (cc !== CC_RIGHT_CURLY) {
-					throw new Error(
-						`Unexpected ${input[pos]} at ${pos} during parsing of export value in ':export' (expected ';' or '}')`
+					this._emitWarning(
+						state,
+						`Unexpected '${input[pos]}' at ${pos} during parsing of export value in ':export' (expected ';' or '}')`,
+						locConverter,
+						start,
+						pos
 					);
+					return pos;
 				}
 				const dep = new CssExportDependency(name, value);
 				const { line: sl, column: sc } = locConverter.get(start);
@@ -283,7 +309,7 @@ class CssParser extends Parser {
 			}
 			pos++;
 			if (pos === input.length) return pos;
-			pos = eatWhiteLine(input, pos);
+			pos = walkCssTokens.eatWhiteLine(input, pos);
 			return pos;
 		};
 		const eatPropertyName = eatUntil(":{};");
@@ -339,14 +365,13 @@ class CssParser extends Parser {
 					mode !== CSS_MODE_IN_RULE &&
 					mode !== CSS_MODE_IN_LOCAL_RULE &&
 					mode !== CSS_MODE_AT_IMPORT_EXPECT_URL &&
-					mode !== CSS_MODE_AT_IMPORT_EXPECT_LAYER_OR_SUPPORTS_OR_MEDIA
+					mode !== CSS_MODE_AT_IMPORT_EXPECT_LAYER_OR_SUPPORTS_OR_MEDIA &&
+					mode !== CSS_MODE_AT_IMPORT_INVALID &&
+					mode !== CSS_MODE_AT_NAMESPACE_INVALID
 				);
 			},
-			url: (input, start, end, contentStart, contentEnd, isString) => {
-				let value = normalizeUrl(
-					input.slice(contentStart, contentEnd),
-					isString
-				);
+			url: (input, start, end, contentStart, contentEnd) => {
+				let value = normalizeUrl(input.slice(contentStart, contentEnd), false);
 				switch (mode) {
 					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
 						modeData.url = value;
@@ -358,13 +383,14 @@ class CssParser extends Parser {
 					case CSS_MODE_AT_IMPORT_EXPECT_LAYER_OR_SUPPORTS_OR_MEDIA: {
 						break;
 					}
+					// Do not parse URLs in import between rules
+					case CSS_MODE_AT_NAMESPACE_INVALID:
+					case CSS_MODE_AT_IMPORT_INVALID: {
+						break;
+					}
 					default: {
-						if (
-							// Ignore `url(#highlight)` URLs
-							/^#/.test(value) ||
-							// Ignore `url()`, `url('')` and `url("")`, they are valid by spec
-							value.length === 0
-						) {
+						// Ignore `url()`, `url('')` and `url("")`, they are valid by spec
+						if (value.length === 0) {
 							break;
 						}
 
@@ -408,12 +434,8 @@ class CssParser extends Parser {
 						) {
 							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
-							) {
+							// Ignore `url()`, `url('')` and `url("")`, they are valid by spec
+							if (value.length === 0) {
 								break;
 							}
 
@@ -436,14 +458,28 @@ class CssParser extends Parser {
 			atKeyword: (input, start, end) => {
 				const name = input.slice(start, end).toLowerCase();
 				if (name === "@namespace") {
-					throw new Error("@namespace is not supported in bundled CSS");
-				}
-				if (name === "@import") {
-					if (mode !== CSS_MODE_TOP_LEVEL) {
-						throw new Error(
-							`Unexpected @import at ${start} during ${explainMode(mode)}`
+					mode = CSS_MODE_AT_NAMESPACE_INVALID;
+					this._emitWarning(
+						state,
+						"@namespace is not supported in bundled CSS",
+						locConverter,
+						start,
+						end
+					);
+					return end;
+				} else if (name === "@import") {
+					if (!allowImportAtRule) {
+						mode = CSS_MODE_AT_IMPORT_INVALID;
+						this._emitWarning(
+							state,
+							"Any @import rules must precede all other rules",
+							locConverter,
+							start,
+							end
 						);
+						return end;
 					}
+
 					mode = CSS_MODE_AT_IMPORT_EXPECT_URL;
 					modeData = {
 						atRuleStart: start,
@@ -453,37 +489,50 @@ class CssParser extends Parser {
 						supports: undefined,
 						media: undefined
 					};
-				}
-				if (OPTIONALLY_VENDOR_PREFIXED_KEYFRAMES_AT_RULE.test(name)) {
+				} else if (
+					isTopLevelLocal() &&
+					OPTIONALLY_VENDOR_PREFIXED_KEYFRAMES_AT_RULE.test(name)
+				) {
 					let pos = end;
 					pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
 					if (pos === input.length) return pos;
 					const [newPos, name] = eatText(input, pos, eatKeyframes);
+					if (newPos === input.length) return newPos;
+					if (input.charCodeAt(newPos) !== CC_LEFT_CURLY) {
+						this._emitWarning(
+							state,
+							`Unexpected '${input[newPos]}' at ${newPos} during parsing of @keyframes (expected '{')`,
+							locConverter,
+							start,
+							end
+						);
+
+						return newPos;
+					}
 					const { line: sl, column: sc } = locConverter.get(pos);
 					const { line: el, column: ec } = locConverter.get(newPos);
 					const dep = new CssLocalIdentifierDependency(name, [pos, newPos]);
 					dep.setLoc(sl, sc, el, ec);
 					module.addDependency(dep);
 					pos = newPos;
-					if (pos === input.length) return pos;
-					if (input.charCodeAt(pos) !== CC_LEFT_CURLY) {
-						throw new Error(
-							`Unexpected ${input[pos]} at ${pos} during parsing of @keyframes (expected '{')`
-						);
-					}
 					mode = CSS_MODE_IN_LOCAL_RULE;
 					modeNestingLevel = 1;
 					return pos + 1;
-				}
-				if (name === "@media" || name === "@supports") {
+				} else if (name === "@media" || name === "@supports") {
+					// TODO handle nested CSS syntax
 					let pos = end;
 					const [newPos] = eatText(input, pos, eatAtRuleNested);
 					pos = newPos;
 					if (pos === input.length) return pos;
 					if (input.charCodeAt(pos) !== CC_LEFT_CURLY) {
-						throw new Error(
-							`Unexpected ${input[pos]} at ${pos} during parsing of @media or @supports (expected '{')`
+						this._emitWarning(
+							state,
+							`Unexpected ${input[pos]} at ${pos} during parsing of @media or @supports (expected '{')`,
+							locConverter,
+							start,
+							pos
 						);
+						return pos;
 					}
 					return pos + 1;
 				}
@@ -491,15 +540,29 @@ class CssParser extends Parser {
 			},
 			semicolon: (input, start, end) => {
 				switch (mode) {
-					case CSS_MODE_AT_IMPORT_EXPECT_URL:
-						throw new Error(`Expected URL for @import at ${start}`);
+					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
+						this._emitWarning(
+							state,
+							`Expected URL for @import at ${start}`,
+							locConverter,
+							start,
+							end
+						);
+						return end;
+					}
 					case CSS_MODE_AT_IMPORT_EXPECT_LAYER_OR_SUPPORTS_OR_MEDIA: {
 						if (modeData.url === undefined) {
-							throw new Error(
-								`Expected URL for @import at ${modeData.atRuleStart}`
+							this._emitWarning(
+								state,
+								`Expected URL for @import at ${modeData.atRuleStart}`,
+								locConverter,
+								modeData.atRuleStart,
+								modeData.lastPos
 							);
+							return end;
 						}
 						const semicolonPos = end;
+						end = walkCssTokens.eatWhiteLine(input, end + 1);
 						const { line: sl, column: sc } = locConverter.get(
 							modeData.atRuleStart
 						);
@@ -545,6 +608,7 @@ class CssParser extends Parser {
 			leftCurlyBracket: (input, start, end) => {
 				switch (mode) {
 					case CSS_MODE_TOP_LEVEL:
+						allowImportAtRule = false;
 						mode = isTopLevelLocal()
 							? CSS_MODE_IN_LOCAL_RULE
 							: CSS_MODE_IN_RULE;

package/lib/css/walkCssTokens.js

@@ -76,6 +76,10 @@ const CC_HYPHEN_MINUS = "-".charCodeAt(0);
 const CC_LESS_THAN_SIGN = "<".charCodeAt(0);
 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
@@ -84,6 +88,7 @@ const _isNewLine = cc => {
 
 /** @type {CharHandler} */
 const consumeSpace = (input, pos, callbacks) => {
+	/** @type {number} */
 	let cc;
 	do {
 		pos++;
@@ -92,16 +97,36 @@ const consumeSpace = (input, pos, callbacks) => {
 	return pos;
 };
 
-const _isWhiteSpace = cc => {
+/**
+ * @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 ||
-		cc === CC_TAB ||
-		cc === CC_SPACE
+		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;
+};
+
+/**
+ * @param {number} cc char code
+ * @returns {boolean} true, if cc is a whitespace
+ */
+const _isWhiteSpace = cc => {
+	return _isNewline(cc) || _isSpace(cc);
+};
+
+/**
+ * @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) ||
@@ -145,21 +170,27 @@ const consumeComments = (input, pos, callbacks) => {
 };
 
 /** @type {function(number): CharHandler} */
-const consumeString = end => (input, pos, callbacks) => {
+const consumeString = quote_cc => (input, pos, callbacks) => {
 	const start = pos;
-	pos = _consumeString(input, pos, end);
+	pos = _consumeString(input, pos, quote_cc);
 	if (callbacks.string !== undefined) {
 		pos = callbacks.string(input, start, pos);
 	}
 	return pos;
 };
 
-const _consumeString = (input, pos, end) => {
+/**
+ * @param {string} input input
+ * @param {number} pos position
+ * @param {number} quote_cc quote char code
+ * @returns {number} new position
+ */
+const _consumeString = (input, pos, quote_cc) => {
 	pos++;
 	for (;;) {
 		if (pos === input.length) return pos;
 		const cc = input.charCodeAt(pos);
-		if (cc === end) return pos + 1;
+		if (cc === quote_cc) return pos + 1;
 		if (_isNewLine(cc)) {
 			// bad string
 			return pos;
@@ -176,6 +207,10 @@ const _consumeString = (input, pos, end) => {
 	}
 };
 
+/**
+ * @param {number} cc char code
+ * @returns {boolean} is identifier start code
+ */
 const _isIdentifierStartCode = cc => {
 	return (
 		cc === CC_LOW_LINE ||
@@ -185,16 +220,30 @@ const _isIdentifierStartCode = cc => {
 	);
 };
 
+/**
+ * @param {number} first first code point
+ * @param {number} second second code point
+ * @returns {boolean} true if two code points are a valid escape
+ */
 const _isTwoCodePointsAreValidEscape = (first, second) => {
 	if (first !== CC_REVERSE_SOLIDUS) return false;
 	if (_isNewLine(second)) return false;
 	return true;
 };
 
+/**
+ * @param {number} cc char code
+ * @returns {boolean} is digit
+ */
 const _isDigit = cc => {
 	return cc >= CC_0 && cc <= CC_9;
 };
 
+/**
+ * @param {string} input input
+ * @param {number} pos position
+ * @returns {boolean} true, if input at pos starts an identifier
+ */
 const _startsIdentifier = (input, pos) => {
 	const cc = input.charCodeAt(pos);
 	if (cc === CC_HYPHEN_MINUS) {
@@ -220,7 +269,7 @@ const consumeNumberSign = (input, pos, callbacks) => {
 	pos++;
 	if (pos === input.length) return pos;
 	if (callbacks.isSelector(input, pos) && _startsIdentifier(input, pos)) {
-		pos = _consumeIdentifier(input, pos);
+		pos = _consumeIdentifier(input, pos, callbacks);
 		if (callbacks.id !== undefined) {
 			return callbacks.id(input, start, pos);
 		}
@@ -244,7 +293,7 @@ const consumeMinus = (input, pos, callbacks) => {
 		if (cc === CC_GREATER_THAN_SIGN) {
 			return pos + 1;
 		} else {
-			pos = _consumeIdentifier(input, pos);
+			pos = _consumeIdentifier(input, pos, callbacks);
 			if (callbacks.identifier !== undefined) {
 				return callbacks.identifier(input, start, pos);
 			}
@@ -253,7 +302,7 @@ const consumeMinus = (input, pos, callbacks) => {
 		if (pos + 1 === input.length) return pos;
 		const cc = input.charCodeAt(pos + 1);
 		if (_isNewLine(cc)) return pos;
-		pos = _consumeIdentifier(input, pos);
+		pos = _consumeIdentifier(input, pos, callbacks);
 		if (callbacks.identifier !== undefined) {
 			return callbacks.identifier(input, start, pos);
 		}
@@ -272,16 +321,17 @@ const consumeDot = (input, pos, callbacks) => {
 	if (_isDigit(cc)) return consumeNumericToken(input, pos - 2, callbacks);
 	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
 		return pos;
-	pos = _consumeIdentifier(input, pos);
+	pos = _consumeIdentifier(input, pos, callbacks);
 	if (callbacks.class !== undefined) return callbacks.class(input, start, pos);
 	return pos;
 };
 
 /** @type {CharHandler} */
 const consumeNumericToken = (input, pos, callbacks) => {
-	pos = _consumeNumber(input, pos);
+	pos = _consumeNumber(input, pos, callbacks);
 	if (pos === input.length) return pos;
-	if (_startsIdentifier(input, pos)) return _consumeIdentifier(input, pos);
+	if (_startsIdentifier(input, pos))
+		return _consumeIdentifier(input, pos, callbacks);
 	const cc = input.charCodeAt(pos);
 	if (cc === CC_PERCENTAGE) return pos + 1;
 	return pos;
@@ -290,7 +340,7 @@ const consumeNumericToken = (input, pos, callbacks) => {
 /** @type {CharHandler} */
 const consumeOtherIdentifier = (input, pos, callbacks) => {
 	const start = pos;
-	pos = _consumeIdentifier(input, pos);
+	pos = _consumeIdentifier(input, pos, callbacks);
 	if (
 		pos !== input.length &&
 		!callbacks.isSelector(input, pos) &&
@@ -311,7 +361,7 @@ const consumeOtherIdentifier = (input, pos, callbacks) => {
 /** @type {CharHandler} */
 const consumePotentialUrl = (input, pos, callbacks) => {
 	const start = pos;
-	pos = _consumeIdentifier(input, pos);
+	pos = _consumeIdentifier(input, pos, callbacks);
 	const nextPos = pos + 1;
 	if (
 		pos === start + 3 &&
@@ -331,6 +381,7 @@ const consumePotentialUrl = (input, pos, callbacks) => {
 			return nextPos;
 		} else {
 			const contentStart = pos;
+			/** @type {number} */
 			let contentEnd;
 			for (;;) {
 				if (cc === CC_REVERSE_SOLIDUS) {
@@ -380,7 +431,7 @@ const consumePotentialPseudo = (input, pos, callbacks) => {
 	pos++;
 	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
 		return pos;
-	pos = _consumeIdentifier(input, pos);
+	pos = _consumeIdentifier(input, pos, callbacks);
 	let cc = input.charCodeAt(pos);
 	if (cc === CC_LEFT_PARENTHESIS) {
 		pos++;
@@ -449,6 +500,7 @@ const consumeComma = (input, pos, callbacks) => {
 	return pos;
 };
 
+/** @type {CharHandler} */
 const _consumeIdentifier = (input, pos) => {
 	for (;;) {
 		const cc = input.charCodeAt(pos);
@@ -468,6 +520,7 @@ const _consumeIdentifier = (input, pos) => {
 	}
 };
 
+/** @type {CharHandler} */
 const _consumeNumber = (input, pos) => {
 	pos++;
 	if (pos === input.length) return pos;
@@ -526,12 +579,13 @@ const consumeLessThan = (input, pos, callbacks) => {
 	return pos + 1;
 };
 
+/** @type {CharHandler} */
 const consumeAt = (input, pos, callbacks) => {
 	const start = pos;
 	pos++;
 	if (pos === input.length) return pos;
 	if (_startsIdentifier(input, pos)) {
-		pos = _consumeIdentifier(input, pos);
+		pos = _consumeIdentifier(input, pos, callbacks);
 		if (callbacks.atKeyword !== undefined) {
 			pos = callbacks.atKeyword(input, start, pos);
 		}
@@ -697,3 +751,25 @@ module.exports.eatWhitespaceAndComments = (input, pos) => {
 
 	return pos;
 };
+
+/**
+ * @param {string} input input
+ * @param {number} pos position
+ * @returns {number} position after whitespace
+ */
+module.exports.eatWhiteLine = (input, pos) => {
+	for (;;) {
+		const cc = input.charCodeAt(pos);
+		if (_isSpace(cc)) {
+			pos++;
+			continue;
+		}
+		if (_isNewLine(cc)) pos++;
+		// For `\r\n`
+		if (cc === CC_CARRIAGE_RETURN && input.charCodeAt(pos + 1) === CC_LINE_FEED)
+			pos++;
+		break;
+	}
+
+	return pos;
+};

package/lib/debug/ProfilingPlugin.js

@@ -100,6 +100,8 @@ class Profiler {
 		return this.sendCommand("Profiler.stop").then(({ profile }) => {
 			const hrtime = process.hrtime();
 			const endTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
+			// Avoid coverage problems due indirect changes
+			/* istanbul ignore next */
 			if (profile.startTime < this._startTime || profile.endTime > endTime) {
 				// In some cases timestamps mismatch and we need to adjust them
 				// Both process.hrtime and the inspector timestamps claim to be relative

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -159,6 +159,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 
 				const rootInfo = rightPart.rootInfo;
 				if (
+					typeof rootInfo === "string" ||
 					!rootInfo ||
 					!rootInfo.tagInfo ||
 					rootInfo.tagInfo.tag !== harmonySpecifierTag