webpack 5.76.1 → 5.88.0

package/lib/css/walkCssTokens.js

@@ -7,7 +7,7 @@
 
 /**
  * @typedef {Object} CssTokenCallbacks
- * @property {function(string, number): boolean} isSelector
+ * @property {function(string, number): boolean=} isSelector
  * @property {function(string, number, number, number, number): number=} url
  * @property {function(string, number, number): number=} string
  * @property {function(string, number, number): number=} leftParenthesis
@@ -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);
@@ -62,6 +64,7 @@ const CC_LOWER_E = "e".charCodeAt(0);
 const CC_LOWER_Z = "z".charCodeAt(0);
 const CC_UPPER_A = "A".charCodeAt(0);
 const CC_UPPER_E = "E".charCodeAt(0);
+const CC_UPPER_U = "U".charCodeAt(0);
 const CC_UPPER_Z = "Z".charCodeAt(0);
 const CC_0 = "0".charCodeAt(0);
 const CC_9 = "9".charCodeAt(0);
@@ -73,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
@@ -81,6 +88,7 @@ const _isNewLine = cc => {
 
 /** @type {CharHandler} */
 const consumeSpace = (input, pos, callbacks) => {
+	/** @type {number} */
 	let cc;
 	do {
 		pos++;
@@ -89,61 +97,109 @@ const consumeSpace = (input, pos, callbacks) => {
 	return pos;
 };
 
+/**
+ * @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
+	);
+};
+
+/**
+ * @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);
+};
+
+/**
+ * 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_LINE_FEED ||
-		cc === CC_CARRIAGE_RETURN ||
-		cc === CC_FORM_FEED ||
-		cc === CC_TAB ||
-		cc === CC_SPACE
+		(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} */
-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;
 		}
-		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++;
@@ -155,6 +211,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 ||
@@ -164,23 +224,43 @@ 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) {
 		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);
 	}
@@ -193,7 +273,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);
 		}
@@ -207,6 +287,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) {
@@ -216,25 +297,21 @@ 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);
 			}
 		}
-	} 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;
-		pos = _consumeIdentifier(input, pos);
+		pos = _consumeIdentifier(input, pos, callbacks);
 		if (callbacks.identifier !== undefined) {
 			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;
 };
@@ -248,16 +325,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;
@@ -266,12 +344,8 @@ const consumeNumericToken = (input, pos, callbacks) => {
 /** @type {CharHandler} */
 const consumeOtherIdentifier = (input, pos, callbacks) => {
 	const start = pos;
-	pos = _consumeIdentifier(input, pos);
-	if (
-		pos !== input.length &&
-		!callbacks.isSelector(input, pos) &&
-		input.charCodeAt(pos) === CC_LEFT_PARENTHESIS
-	) {
+	pos = _consumeIdentifier(input, pos, callbacks);
+	if (pos !== input.length && input.charCodeAt(pos) === CC_LEFT_PARENTHESIS) {
 		pos++;
 		if (callbacks.function !== undefined) {
 			return callbacks.function(input, start, pos);
@@ -287,8 +361,12 @@ const consumeOtherIdentifier = (input, pos, callbacks) => {
 /** @type {CharHandler} */
 const consumePotentialUrl = (input, pos, callbacks) => {
 	const start = pos;
-	pos = _consumeIdentifier(input, pos);
-	if (pos === start + 3 && input.slice(start, pos + 1) === "url(") {
+	pos = _consumeIdentifier(input, pos, callbacks);
+	const nextPos = pos + 1;
+	if (
+		pos === start + 3 &&
+		input.slice(start, nextPos).toLowerCase() === "url("
+	) {
 		pos++;
 		let cc = input.charCodeAt(pos);
 		while (_isWhiteSpace(cc)) {
@@ -297,26 +375,16 @@ 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;
+			/** @type {number} */
 			let contentEnd;
 			for (;;) {
-				if (cc === CC_BACK_SLASH) {
+				if (cc === CC_REVERSE_SOLIDUS) {
 					pos++;
 					if (pos === input.length) return pos;
 					pos++;
@@ -363,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++;
@@ -432,10 +500,11 @@ const consumeComma = (input, pos, callbacks) => {
 	return pos;
 };
 
+/** @type {CharHandler} */
 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++;
@@ -451,6 +520,7 @@ const _consumeIdentifier = (input, pos) => {
 	}
 };
 
+/** @type {CharHandler} */
 const _consumeNumber = (input, pos) => {
 	pos++;
 	if (pos === input.length) return pos;
@@ -515,7 +585,7 @@ const consumeAt = (input, pos, callbacks) => {
 	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);
 		}
@@ -523,64 +593,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;
 	}
 });
 
@@ -590,9 +698,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 {
@@ -601,59 +715,76 @@ module.exports = (input, callbacks) => {
 	}
 };
 
+module.exports.isIdentStartCodePoint = isIdentStartCodePoint;
+
+/**
+ * @param {string} input input
+ * @param {number} pos position
+ * @returns {number} position after comments
+ */
 module.exports.eatComments = (input, pos) => {
-	loop: for (;;) {
-		const cc = input.charCodeAt(pos);
-		if (cc === CC_SLASH) {
-			if (pos === input.length) return pos;
-			let cc = input.charCodeAt(pos + 1);
-			if (cc !== CC_ASTERISK) return pos;
-			pos++;
-			for (;;) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-				while (cc === CC_ASTERISK) {
-					pos++;
-					if (pos === input.length) return pos;
-					cc = input.charCodeAt(pos);
-					if (cc === CC_SLASH) {
-						pos++;
-						continue loop;
-					}
-				}
-			}
+	for (;;) {
+		let originalPos = pos;
+		pos = consumeComments(input, pos, {});
+		if (originalPos === pos) {
+			break;
 		}
-		return pos;
 	}
+
+	return pos;
+};
+
+/**
+ * @param {string} input input
+ * @param {number} pos position
+ * @returns {number} position after whitespace
+ */
+module.exports.eatWhitespace = (input, pos) => {
+	while (_isWhiteSpace(input.charCodeAt(pos))) {
+		pos++;
+	}
+
+	return pos;
 };
 
+/**
+ * @param {string} input input
+ * @param {number} pos position
+ * @returns {number} position after whitespace and comments
+ */
 module.exports.eatWhitespaceAndComments = (input, pos) => {
-	loop: for (;;) {
-		const cc = input.charCodeAt(pos);
-		if (cc === CC_SLASH) {
-			if (pos === input.length) return pos;
-			let cc = input.charCodeAt(pos + 1);
-			if (cc !== CC_ASTERISK) return pos;
+	for (;;) {
+		let originalPos = pos;
+		pos = consumeComments(input, pos, {});
+		while (_isWhiteSpace(input.charCodeAt(pos))) {
 			pos++;
-			for (;;) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-				while (cc === CC_ASTERISK) {
-					pos++;
-					if (pos === input.length) return pos;
-					cc = input.charCodeAt(pos);
-					if (cc === CC_SLASH) {
-						pos++;
-						continue loop;
-					}
-				}
-			}
-		} else if (_isWhiteSpace(cc)) {
+		}
+		if (originalPos === pos) {
+			break;
+		}
+	}
+
+	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;
 		}
-		return pos;
+		if (_isNewLine(cc)) pos++;
+		// For `\r\n`
+		if (cc === CC_CARRIAGE_RETURN && input.charCodeAt(pos + 1) === CC_LINE_FEED)
+			pos++;
+		break;
 	}
+
+	return pos;
 };