webpack 5.107.2 → 5.108.0

package/lib/css/walkCssTokens.js

@@ -1,2020 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const { makeCacheable } = require("../util/identifier");
-
-/**
- * Defines the css token callbacks type used by this module.
- * @typedef {object} CssTokenCallbacks
- * @property {((input: string, start: number, end: number) => number)=} comment
- * @property {((input: string, start: number, end: number) => number)=} whitespace
- * @property {((input: string, start: number, end: number) => number)=} string
- * @property {((input: string, start: number, end: number) => number)=} leftCurlyBracket
- * @property {((input: string, start: number, end: number) => number)=} rightCurlyBracket
- * @property {((input: string, start: number, end: number) => number)=} leftParenthesis
- * @property {((input: string, start: number, end: number) => number)=} rightParenthesis
- * @property {((input: string, start: number, end: number) => number)=} leftSquareBracket
- * @property {((input: string, start: number, end: number) => number)=} rightSquareBracket
- * @property {((input: string, start: number, end: number) => number)=} function
- * @property {((input: string, start: number, end: number, innerStart: number, innerEnd: number) => number)=} url
- * @property {((input: string, start: number, end: number) => number)=} colon
- * @property {((input: string, start: number, end: number) => number)=} atKeyword
- * @property {((input: string, start: number, end: number) => number)=} delim
- * @property {((input: string, start: number, end: number) => number)=} identifier
- * @property {((input: string, start: number, end: number) => number)=} percentage
- * @property {((input: string, start: number, end: number) => number)=} number
- * @property {((input: string, start: number, end: number) => number)=} dimension
- * @property {((input: string, start: number, end: number, isId: boolean) => number)=} hash
- * @property {((input: string, start: number, end: number) => number)=} semicolon
- * @property {((input: string, start: number, end: number) => number)=} comma
- * @property {((input: string, start: number, end: number) => number)=} cdo
- * @property {((input: string, start: number, end: number) => number)=} cdc
- * @property {((input: string, start: number, end: number) => number)=} badStringToken
- * @property {((input: string, start: number, end: number) => number)=} badUrlToken
- * @property {(() => boolean)=} needTerminate
- */
-
-/** @typedef {(input: string, pos: number, callbacks: CssTokenCallbacks) => number} CharHandler */
-
-// spec: https://drafts.csswg.org/css-syntax/
-
-const CC_LINE_FEED = "\n".charCodeAt(0);
-const CC_CARRIAGE_RETURN = "\r".charCodeAt(0);
-const CC_FORM_FEED = "\f".charCodeAt(0);
-
-const CC_TAB = "\t".charCodeAt(0);
-const CC_SPACE = " ".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);
-
-const CC_FULL_STOP = ".".charCodeAt(0);
-const CC_COLON = ":".charCodeAt(0);
-const CC_SEMICOLON = ";".charCodeAt(0);
-const CC_COMMA = ",".charCodeAt(0);
-const CC_PERCENTAGE = "%".charCodeAt(0);
-const CC_AT_SIGN = "@".charCodeAt(0);
-
-const CC_LOW_LINE = "_".charCodeAt(0);
-const CC_LOWER_A = "a".charCodeAt(0);
-const CC_LOWER_F = "f".charCodeAt(0);
-const CC_LOWER_E = "e".charCodeAt(0);
-const CC_LOWER_U = "u".charCodeAt(0);
-const CC_LOWER_Z = "z".charCodeAt(0);
-const CC_UPPER_A = "A".charCodeAt(0);
-const CC_UPPER_F = "F".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);
-
-const CC_NUMBER_SIGN = "#".charCodeAt(0);
-const CC_PLUS_SIGN = "+".charCodeAt(0);
-const CC_HYPHEN_MINUS = "-".charCodeAt(0);
-
-const CC_LESS_THAN_SIGN = "<".charCodeAt(0);
-const CC_GREATER_THAN_SIGN = ">".charCodeAt(0);
-
-/** @type {CharHandler} */
-const consumeSpace = (input, pos, callbacks) => {
-	const start = pos - 1;
-
-	// Consume as much whitespace as possible.
-	while (_isWhiteSpace(input.charCodeAt(pos))) {
-		pos++;
-	}
-
-	// Return a <whitespace-token>.
-	if (callbacks.whitespace !== undefined) {
-		return callbacks.whitespace(input, start, pos);
-	}
-
-	return pos;
-};
-
-// U+000A LINE FEED. Note that U+000D CARRIAGE RETURN and U+000C FORM FEED are not included in this definition,
-// as they are converted to U+000A LINE FEED during preprocessing.
-//
-// Replace any U+000D CARRIAGE RETURN (CR) code points, U+000C FORM FEED (FF) code points, or pairs of U+000D CARRIAGE RETURN (CR) followed by U+000A LINE FEED (LF) in input by a single U+000A LINE FEED (LF) code point.
-
-/**
- * Checks whether newline true, if cc is a newline.
- * @param {number} cc char code
- * @returns {boolean} true, if cc is a newline
- */
-const _isNewline = (cc) =>
-	cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED;
-
-/**
- * Consume extra newline.
- * @param {number} cc char code
- * @param {string} input input
- * @param {number} pos position
- * @returns {number} position
- */
-const consumeExtraNewline = (cc, input, pos) => {
-	if (cc === CC_CARRIAGE_RETURN && input.charCodeAt(pos) === CC_LINE_FEED) {
-		pos++;
-	}
-
-	return pos;
-};
-
-/**
- * Checks whether space true, if cc is a space (U+0009 CHARACTER TABULATION or U+0020 SPACE).
- * @param {number} cc char code
- * @returns {boolean} true, if cc is a space (U+0009 CHARACTER TABULATION or U+0020 SPACE)
- */
-const _isSpace = (cc) => cc === CC_TAB || cc === CC_SPACE;
-
-/**
- * Checks whether white space true, if cc is a whitespace.
- * @param {number} cc char code
- * @returns {boolean} true, if cc is a whitespace
- */
-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) =>
-	(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
-	(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
-	cc === CC_LOW_LINE ||
-	cc >= 0x80;
-
-const REGEX_SINGLE_ESCAPE = /[ -,./:-@[\]^`{-~]/;
-const REGEX_EXCESSIVE_SPACES = /(^|\\+)?(\\[A-F0-9]{1,6}) (?![a-fA-F0-9 ])/g;
-const REGEX_CTRL_WHITESPACE = /[\t\n\f\r\v]/;
-const REGEX_LEADING_HYPHEN_DIGIT = /^-[-\d]/;
-const REGEX_DIGIT = /\d/;
-const CONTAINS_ESCAPE = /\\/;
-
-/**
- * Returns escaped identifier.
- * @param {string} str string
- * @returns {string} escaped identifier
- */
-const _escapeIdentifier = (str) => {
-	let output = "";
-	let counter = 0;
-
-	while (counter < str.length) {
-		const character = str.charAt(counter++);
-
-		/** @type {string} */
-		let value;
-
-		if (REGEX_CTRL_WHITESPACE.test(character)) {
-			const codePoint = character.charCodeAt(0);
-
-			value = `\\${codePoint.toString(16).toUpperCase()} `;
-		} else if (character === "\\" || REGEX_SINGLE_ESCAPE.test(character)) {
-			value = `\\${character}`;
-		} else {
-			value = character;
-		}
-
-		output += value;
-	}
-
-	const firstChar = str.charAt(0);
-
-	if (REGEX_LEADING_HYPHEN_DIGIT.test(output)) {
-		output = `\\-${output.slice(1)}`;
-	} else if (REGEX_DIGIT.test(firstChar)) {
-		output = `\\3${firstChar} ${output.slice(1)}`;
-	}
-
-	// Remove spaces after `\HEX` escapes that are not followed by a hex digit,
-	// since they’re redundant. Note that this is only possible if the escape
-	// sequence isn’t preceded by an odd number of backslashes.
-	output = output.replace(REGEX_EXCESSIVE_SPACES, ($0, $1, $2) => {
-		if ($1 && $1.length % 2) {
-			// It’s not safe to remove the space, so don’t.
-			return $0;
-		}
-
-		// Strip the space.
-		return ($1 || "") + $2;
-	});
-
-	return output;
-};
-
-/**
- * Returns hex.
- * @param {string} str string
- * @returns {[string, number] | undefined} hex
- */
-const gobbleHex = (str) => {
-	const lower = str.toLowerCase();
-	let hex = "";
-	let spaceTerminated = false;
-
-	for (let i = 0; i < 6 && lower[i] !== undefined; i++) {
-		const code = lower.charCodeAt(i);
-		// check to see if we are dealing with a valid hex char [a-f|0-9]
-		const valid = (code >= 97 && code <= 102) || (code >= 48 && code <= 57);
-		// https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
-		spaceTerminated = code === 32;
-		if (!valid) break;
-		hex += lower[i];
-	}
-
-	if (hex.length === 0) return undefined;
-
-	const codePoint = Number.parseInt(hex, 16);
-	const isSurrogate = codePoint >= 0xd800 && codePoint <= 0xdfff;
-
-	// Add special case for
-	// "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point"
-	// https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point
-	if (isSurrogate || codePoint === 0x0000 || codePoint > 0x10ffff) {
-		return ["�", hex.length + (spaceTerminated ? 1 : 0)];
-	}
-
-	return [
-		String.fromCodePoint(codePoint),
-		hex.length + (spaceTerminated ? 1 : 0)
-	];
-};
-
-/**
- * Unescape identifier.
- * @param {string} str string
- * @returns {string} unescaped string
- */
-const _unescapeIdentifier = (str) => {
-	const needToProcess = CONTAINS_ESCAPE.test(str);
-	if (!needToProcess) return str;
-	let ret = "";
-	for (let i = 0; i < str.length; i++) {
-		if (str[i] === "\\") {
-			const gobbled = gobbleHex(str.slice(i + 1, i + 7));
-			if (gobbled !== undefined) {
-				ret += gobbled[0];
-				i += gobbled[1];
-				continue;
-			}
-			// Retain a pair of \\ if double escaped `\\\\`
-			// https://github.com/postcss/postcss-selector-parser/commit/268c9a7656fb53f543dc620aa5b73a30ec3ff20e
-			if (str[i + 1] === "\\") {
-				ret += "\\";
-				i += 1;
-				continue;
-			}
-			// if \\ is at the end of the string retain it
-			// https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb
-			if (str.length === i + 1) {
-				ret += str[i];
-			}
-			continue;
-		}
-		ret += str[i];
-	}
-
-	return ret;
-};
-
-const escapeIdentifier = makeCacheable(_escapeIdentifier);
-const unescapeIdentifier = makeCacheable(_unescapeIdentifier);
-
-/** @type {CharHandler} */
-const consumeDelimToken = (input, pos, callbacks) => {
-	// Return a <delim-token> with its value set to the current input code point.
-	if (callbacks.delim) {
-		pos = callbacks.delim(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeComments = (input, pos, callbacks) => {
-	// This section describes how to consume comments from a stream of code points. It returns nothing.
-	// 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.
-	while (
-		input.charCodeAt(pos) === CC_SOLIDUS &&
-		input.charCodeAt(pos + 1) === CC_ASTERISK
-	) {
-		const start = pos;
-		pos += 2;
-
-		for (;;) {
-			if (pos === input.length) {
-				// If the preceding paragraph ended by consuming an EOF code point, this is a parse error.
-				return pos;
-			}
-
-			if (
-				input.charCodeAt(pos) === CC_ASTERISK &&
-				input.charCodeAt(pos + 1) === CC_SOLIDUS
-			) {
-				pos += 2;
-
-				if (callbacks.comment) {
-					pos = callbacks.comment(input, start, pos);
-				}
-
-				break;
-			}
-
-			pos++;
-		}
-	}
-
-	return pos;
-};
-
-/**
- * Checks whether hex digit true, if cc is a hex digit.
- * @param {number} cc char code
- * @returns {boolean} true, if cc is a hex digit
- */
-const _isHexDigit = (cc) =>
-	_isDigit(cc) ||
-	(cc >= CC_UPPER_A && cc <= CC_UPPER_F) ||
-	(cc >= CC_LOWER_A && cc <= CC_LOWER_F);
-
-/**
- * Consume an escaped code point.
- * @param {string} input input
- * @param {number} pos position
- * @returns {number} position
- */
-const _consumeAnEscapedCodePoint = (input, pos) => {
-	// This section describes how to consume an escaped code point.
-	// It assumes that the U+005C REVERSE SOLIDUS (\) has already been consumed and that the next input code point has already been verified to be part of a valid escape.
-	// It will return a code point.
-
-	// Consume the next input code point.
-	const cc = input.charCodeAt(pos);
-	pos++;
-
-	// EOF
-	// This is a parse error. Return U+FFFD REPLACEMENT CHARACTER (�).
-	if (pos === input.length) {
-		return pos;
-	}
-
-	// hex digit
-	// Consume as many hex digits as possible, but no more than 5.
-	// Note that this means 1-6 hex digits have been consumed in total.
-	// If the next input code point is whitespace, consume it as well.
-	// Interpret the hex digits as a hexadecimal number.
-	// If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point, return U+FFFD REPLACEMENT CHARACTER (�).
-	// Otherwise, return the code point with that value.
-	if (_isHexDigit(cc)) {
-		for (let i = 0; i < 5; i++) {
-			if (_isHexDigit(input.charCodeAt(pos))) {
-				pos++;
-			}
-		}
-
-		const cc = input.charCodeAt(pos);
-
-		if (_isWhiteSpace(cc)) {
-			pos++;
-			pos = consumeExtraNewline(cc, input, pos);
-		}
-
-		return pos;
-	}
-
-	// anything else
-	// Return the current input code point.
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeAStringToken = (input, pos, callbacks) => {
-	// This section describes how to consume a string token from a stream of code points.
-	// It returns either a <string-token> or <bad-string-token>.
-	//
-	// This algorithm may be called with an ending code point, which denotes the code point that ends the string.
-	// If an ending code point is not specified, the current input code point is used.
-	const start = pos - 1;
-	const endingCodePoint = input.charCodeAt(pos - 1);
-
-	// Initially create a <string-token> with its value set to the empty string.
-
-	// Repeatedly consume the next input code point from the stream:
-	for (;;) {
-		// EOF
-		// This is a parse error. Return the <string-token>.
-		if (pos === input.length) {
-			if (callbacks.string !== undefined) {
-				return callbacks.string(input, start, pos);
-			}
-
-			return pos;
-		}
-
-		const cc = input.charCodeAt(pos);
-		pos++;
-
-		// ending code point
-		// Return the <string-token>.
-		if (cc === endingCodePoint) {
-			if (callbacks.string !== undefined) {
-				return callbacks.string(input, start, pos);
-			}
-
-			return pos;
-		}
-		// newline
-		// This is a parse error.
-		// Reconsume the current input code point, create a <bad-string-token>, and return it.
-		else if (_isNewline(cc)) {
-			pos--;
-
-			if (callbacks.badStringToken !== undefined) {
-				return callbacks.badStringToken(input, start, pos);
-			}
-
-			// bad string
-			return pos;
-		}
-		// U+005C REVERSE SOLIDUS (\)
-		else if (cc === CC_REVERSE_SOLIDUS) {
-			// If the next input code point is EOF, do nothing.
-			if (pos === input.length) {
-				return pos;
-			}
-			// Otherwise, if the next input code point is a newline, consume it.
-			else if (_isNewline(input.charCodeAt(pos))) {
-				const cc = input.charCodeAt(pos);
-				pos++;
-				pos = consumeExtraNewline(cc, input, pos);
-			}
-			// Otherwise, (the stream starts with a valid escape) consume an escaped code point and append the returned code point to the <string-token>’s value.
-			else if (_ifTwoCodePointsAreValidEscape(input, pos)) {
-				pos = _consumeAnEscapedCodePoint(input, pos);
-			}
-		}
-		// anything else
-		// Append the current input code point to the <string-token>’s value.
-		else {
-			// Append
-		}
-	}
-};
-
-/**
- * Checks whether this object is non ascii code point.
- * @param {number} cc char code
- * @param {number} q char code
- * @returns {boolean} is non-ASCII code point
- */
-const isNonASCIICodePoint = (cc, q) =>
-	// Simplify
-	cc > 0x80;
-
-/**
- * Checks whether this object is letter.
- * @param {number} cc char code
- * @returns {boolean} is letter
- */
-const isLetter = (cc) =>
-	(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
-	(cc >= CC_UPPER_A && cc <= CC_UPPER_Z);
-
-/**
- * Is ident start code point.
- * @param {number} cc char code
- * @param {number} q char code
- * @returns {boolean} is identifier start code
- */
-const _isIdentStartCodePoint = (cc, q) =>
-	isLetter(cc) || isNonASCIICodePoint(cc, q) || cc === CC_LOW_LINE;
-
-/**
- * Is ident code point.
- * @param {number} cc char code
- * @param {number} q char code
- * @returns {boolean} is identifier code
- */
-const _isIdentCodePoint = (cc, q) =>
-	_isIdentStartCodePoint(cc, q) || _isDigit(cc) || cc === CC_HYPHEN_MINUS;
-/**
- * Checks whether digit is digit.
- * @param {number} cc char code
- * @returns {boolean} is digit
- */
-const _isDigit = (cc) => cc >= CC_0 && cc <= CC_9;
-
-/**
- * If two code points are valid escape.
- * @param {string} input input
- * @param {number} pos position
- * @param {number=} f first code point
- * @param {number=} s second code point
- * @returns {boolean} true if two code points are a valid escape
- */
-const _ifTwoCodePointsAreValidEscape = (input, pos, f, s) => {
-	// This section describes how to check if two code points are a valid escape.
-	// The algorithm described here can be called explicitly with two code points, or can be called with the input stream itself.
-	// In the latter case, the two code points in question are the current input code point and the next input code point, in that order.
-
-	// Note: This algorithm will not consume any additional code point.
-	const first = f || input.charCodeAt(pos - 1);
-	const second = s || input.charCodeAt(pos);
-
-	// If the first code point is not U+005C REVERSE SOLIDUS (\), return false.
-	if (first !== CC_REVERSE_SOLIDUS) return false;
-	// Otherwise, if the second code point is a newline, return false.
-	if (_isNewline(second)) return false;
-	// Otherwise, return true.
-	return true;
-};
-
-/**
- * If three code points would start an ident sequence.
- * @param {string} input input
- * @param {number} pos position
- * @param {number=} f first
- * @param {number=} s second
- * @param {number=} t third
- * @returns {boolean} true, if input at pos starts an identifier
- */
-const _ifThreeCodePointsWouldStartAnIdentSequence = (input, pos, f, s, t) => {
-	// This section describes how to check if three code points would start an ident sequence.
-	// The algorithm described here can be called explicitly with three code points, or can be called with the input stream itself.
-	// In the latter case, the three code points in question are the current input code point and the next two input code points, in that order.
-
-	// Note: This algorithm will not consume any additional code points.
-
-	const first = f || input.charCodeAt(pos - 1);
-	const second = s || input.charCodeAt(pos);
-	const third = t || input.charCodeAt(pos + 1);
-
-	// Look at the first code point:
-
-	// U+002D HYPHEN-MINUS
-	if (first === CC_HYPHEN_MINUS) {
-		// If the second code point is an ident-start code point or a U+002D HYPHEN-MINUS
-		// or a U+002D HYPHEN-MINUS, or the second and third code points are a valid escape, return true.
-		if (
-			_isIdentStartCodePoint(second, pos) ||
-			second === CC_HYPHEN_MINUS ||
-			_ifTwoCodePointsAreValidEscape(input, pos, second, third)
-		) {
-			return true;
-		}
-		return false;
-	}
-	// ident-start code point
-	else if (_isIdentStartCodePoint(first, pos - 1)) {
-		return true;
-	}
-	// U+005C REVERSE SOLIDUS (\)
-	// If the first and second code points are a valid escape, return true. Otherwise, return false.
-	else if (first === CC_REVERSE_SOLIDUS) {
-		if (_ifTwoCodePointsAreValidEscape(input, pos, first, second)) {
-			return true;
-		}
-
-		return false;
-	}
-	// anything else
-	// Return false.
-	return false;
-};
-
-/**
- * If three code points would start a number.
- * @param {string} input input
- * @param {number} pos position
- * @param {number=} f first
- * @param {number=} s second
- * @param {number=} t third
- * @returns {boolean} true, if input at pos starts an identifier
- */
-const _ifThreeCodePointsWouldStartANumber = (input, pos, f, s, t) => {
-	// This section describes how to check if three code points would start a number.
-	// The algorithm described here can be called explicitly with three code points, or can be called with the input stream itself.
-	// In the latter case, the three code points in question are the current input code point and the next two input code points, in that order.
-
-	// Note: This algorithm will not consume any additional code points.
-
-	const first = f || input.charCodeAt(pos - 1);
-	const second = s || input.charCodeAt(pos);
-	const third = t || input.charCodeAt(pos + 1);
-
-	// Look at the first code point:
-
-	// U+002B PLUS SIGN (+)
-	// U+002D HYPHEN-MINUS (-)
-	//
-	// If the second code point is a digit, return true.
-	// Otherwise, if the second code point is a U+002E FULL STOP (.) and the third code point is a digit, return true.
-	// Otherwise, return false.
-	if (first === CC_PLUS_SIGN || first === CC_HYPHEN_MINUS) {
-		if (_isDigit(second)) {
-			return true;
-		} else if (second === CC_FULL_STOP && _isDigit(third)) {
-			return true;
-		}
-
-		return false;
-	}
-	// U+002E FULL STOP (.)
-	// If the second code point is a digit, return true. Otherwise, return false.
-	else if (first === CC_FULL_STOP) {
-		if (_isDigit(second)) {
-			return true;
-		}
-
-		return false;
-	}
-	// digit
-	// Return true.
-	else if (_isDigit(first)) {
-		return true;
-	}
-
-	// anything else
-	// Return false.
-	return false;
-};
-
-/** @type {CharHandler} */
-const consumeNumberSign = (input, pos, callbacks) => {
-	// If the next input code point is an ident code point or the next two input code points are a valid escape, then:
-	// - Create a <hash-token>.
-	// - If the next 3 input code points would start an ident sequence, set the <hash-token>’s type flag to "id".
-	// - Consume an ident sequence, and set the <hash-token>’s value to the returned string.
-	// - Return the <hash-token>.
-	const start = pos - 1;
-	const first = input.charCodeAt(pos);
-	const second = input.charCodeAt(pos + 1);
-
-	if (
-		_isIdentCodePoint(first, pos - 1) ||
-		_ifTwoCodePointsAreValidEscape(input, pos, first, second)
-	) {
-		const third = input.charCodeAt(pos + 2);
-		let isId = false;
-
-		if (
-			_ifThreeCodePointsWouldStartAnIdentSequence(
-				input,
-				pos,
-				first,
-				second,
-				third
-			)
-		) {
-			isId = true;
-		}
-
-		pos = _consumeAnIdentSequence(input, pos, callbacks);
-
-		if (callbacks.hash !== undefined) {
-			return callbacks.hash(input, start, pos, isId);
-		}
-
-		return pos;
-	}
-
-	if (callbacks.delim !== undefined) {
-		return callbacks.delim(input, start, pos);
-	}
-
-	// Otherwise, return a <delim-token> with its value set to the current input code point.
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeHyphenMinus = (input, pos, callbacks) => {
-	// If the input stream starts with a number, reconsume the current input code point, consume a numeric token, and return it.
-	if (_ifThreeCodePointsWouldStartANumber(input, pos)) {
-		pos--;
-		return consumeANumericToken(input, pos, callbacks);
-	}
-	// Otherwise, if the next 2 input code points are U+002D HYPHEN-MINUS U+003E GREATER-THAN SIGN (->), consume them and return a <CDC-token>.
-	else if (
-		input.charCodeAt(pos) === CC_HYPHEN_MINUS &&
-		input.charCodeAt(pos + 1) === CC_GREATER_THAN_SIGN
-	) {
-		if (callbacks.cdc !== undefined) {
-			return callbacks.cdc(input, pos - 1, pos + 2);
-		}
-
-		return pos + 2;
-	}
-	// Otherwise, if the input stream starts with an ident sequence, reconsume the current input code point, consume an ident-like token, and return it.
-	else if (_ifThreeCodePointsWouldStartAnIdentSequence(input, pos)) {
-		pos--;
-		return consumeAnIdentLikeToken(input, pos, callbacks);
-	}
-
-	if (callbacks.delim !== undefined) {
-		return callbacks.delim(input, pos - 1, pos);
-	}
-
-	// Otherwise, return a <delim-token> with its value set to the current input code point.
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeFullStop = (input, pos, callbacks) => {
-	const start = pos - 1;
-
-	// If the input stream starts with a number, reconsume the current input code point, consume a numeric token, and return it.
-	if (_ifThreeCodePointsWouldStartANumber(input, pos)) {
-		pos--;
-		return consumeANumericToken(input, pos, callbacks);
-	}
-
-	// Otherwise, return a <delim-token> with its value set to the current input code point.
-	if (callbacks.delim !== undefined) {
-		return callbacks.delim(input, start, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumePlusSign = (input, pos, callbacks) => {
-	const start = pos - 1;
-
-	// If the input stream starts with a number, reconsume the current input code point, consume a numeric token, and return it.
-	if (_ifThreeCodePointsWouldStartANumber(input, pos)) {
-		pos--;
-		return consumeANumericToken(input, pos, callbacks);
-	}
-
-	// Otherwise, return a <delim-token> with its value set to the current input code point.
-	if (callbacks.delim !== undefined) {
-		return callbacks.delim(input, start, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const _consumeANumber = (input, pos) => {
-	// This section describes how to consume a number from a stream of code points.
-	// It returns a numeric value, and a type which is either "integer" or "number".
-
-	// Execute the following steps in order:
-	// Initially set type to "integer". Let repr be the empty string.
-
-	// If the next input code point is U+002B PLUS SIGN (+) or U+002D HYPHEN-MINUS (-), consume it and append it to repr.
-	if (
-		input.charCodeAt(pos) === CC_HYPHEN_MINUS ||
-		input.charCodeAt(pos) === CC_PLUS_SIGN
-	) {
-		pos++;
-	}
-
-	// While the next input code point is a digit, consume it and append it to repr.
-	while (_isDigit(input.charCodeAt(pos))) {
-		pos++;
-	}
-
-	// If the next 2 input code points are U+002E FULL STOP (.) followed by a digit, then:
-	// 1. Consume the next input code point and append it to number part.
-	// 2. While the next input code point is a digit, consume it and append it to number part.
-	// 3. Set type to "number".
-	if (
-		input.charCodeAt(pos) === CC_FULL_STOP &&
-		_isDigit(input.charCodeAt(pos + 1))
-	) {
-		pos++;
-
-		while (_isDigit(input.charCodeAt(pos))) {
-			pos++;
-		}
-	}
-
-	// If the next 2 or 3 input code points are U+0045 LATIN CAPITAL LETTER E (E) or U+0065 LATIN SMALL LETTER E (e), optionally followed by U+002D HYPHEN-MINUS (-) or U+002B PLUS SIGN (+), followed by a digit, then:
-	// 1. Consume the next input code point.
-	// 2. If the next input code point is "+" or "-", consume it and append it to exponent part.
-	// 3. While the next input code point is a digit, consume it and append it to exponent part.
-	// 4. Set type to "number".
-	if (
-		(input.charCodeAt(pos) === CC_LOWER_E ||
-			input.charCodeAt(pos) === CC_UPPER_E) &&
-		(((input.charCodeAt(pos + 1) === CC_HYPHEN_MINUS ||
-			input.charCodeAt(pos + 1) === CC_PLUS_SIGN) &&
-			_isDigit(input.charCodeAt(pos + 2))) ||
-			_isDigit(input.charCodeAt(pos + 1)))
-	) {
-		pos++;
-
-		if (
-			input.charCodeAt(pos) === CC_PLUS_SIGN ||
-			input.charCodeAt(pos) === CC_HYPHEN_MINUS
-		) {
-			pos++;
-		}
-
-		while (_isDigit(input.charCodeAt(pos))) {
-			pos++;
-		}
-	}
-
-	// Let value be the result of interpreting number part as a base-10 number.
-
-	// If exponent part is non-empty, interpret it as a base-10 integer, then raise 10 to the power of the result, multiply it by value, and set value to that result.
-
-	// Return value and type.
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeANumericToken = (input, pos, callbacks) => {
-	// This section describes how to consume a numeric token from a stream of code points.
-	// It returns either a <number-token>, <percentage-token>, or <dimension-token>.
-
-	const start = pos;
-
-	// Consume a number and let number be the result.
-	pos = _consumeANumber(input, pos, callbacks);
-
-	// If the next 3 input code points would start an ident sequence, then:
-	//
-	// - Create a <dimension-token> with the same value and type flag as number, and a unit set initially to the empty string.
-	// - Consume an ident sequence. Set the <dimension-token>’s unit to the returned value.
-	// - Return the <dimension-token>.
-
-	const first = input.charCodeAt(pos);
-	const second = input.charCodeAt(pos + 1);
-	const third = input.charCodeAt(pos + 2);
-
-	if (
-		_ifThreeCodePointsWouldStartAnIdentSequence(
-			input,
-			pos,
-			first,
-			second,
-			third
-		)
-	) {
-		pos = _consumeAnIdentSequence(input, pos, callbacks);
-
-		if (callbacks.dimension !== undefined) {
-			return callbacks.dimension(input, start, pos);
-		}
-
-		return pos;
-	}
-	// Otherwise, if the next input code point is U+0025 PERCENTAGE SIGN (%), consume it.
-	// Create a <percentage-token> with the same value as number, and return it.
-	else if (first === CC_PERCENTAGE) {
-		if (callbacks.percentage !== undefined) {
-			return callbacks.percentage(input, start, pos + 1);
-		}
-
-		return pos + 1;
-	}
-
-	// Otherwise, create a <number-token> with the same value and type flag as number, and return it.
-	if (callbacks.number !== undefined) {
-		return callbacks.number(input, start, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeColon = (input, pos, callbacks) => {
-	// Return a <colon-token>.
-	if (callbacks.colon !== undefined) {
-		return callbacks.colon(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeLeftParenthesis = (input, pos, callbacks) => {
-	// Return a <(-token>.
-	if (callbacks.leftParenthesis !== undefined) {
-		return callbacks.leftParenthesis(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeRightParenthesis = (input, pos, callbacks) => {
-	// Return a <)-token>.
-	if (callbacks.rightParenthesis !== undefined) {
-		return callbacks.rightParenthesis(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeLeftSquareBracket = (input, pos, callbacks) => {
-	// Return a <]-token>.
-	if (callbacks.leftSquareBracket !== undefined) {
-		return callbacks.leftSquareBracket(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeRightSquareBracket = (input, pos, callbacks) => {
-	// Return a <]-token>.
-	if (callbacks.rightSquareBracket !== undefined) {
-		return callbacks.rightSquareBracket(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeLeftCurlyBracket = (input, pos, callbacks) => {
-	// Return a <{-token>.
-	if (callbacks.leftCurlyBracket !== undefined) {
-		return callbacks.leftCurlyBracket(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeRightCurlyBracket = (input, pos, callbacks) => {
-	// Return a <}-token>.
-	if (callbacks.rightCurlyBracket !== undefined) {
-		return callbacks.rightCurlyBracket(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeSemicolon = (input, pos, callbacks) => {
-	// Return a <semicolon-token>.
-	if (callbacks.semicolon !== undefined) {
-		return callbacks.semicolon(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeComma = (input, pos, callbacks) => {
-	// Return a <comma-token>.
-	if (callbacks.comma !== undefined) {
-		return callbacks.comma(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const _consumeAnIdentSequence = (input, pos) => {
-	// This section describes how to consume an ident sequence from a stream of code points.
-	// It returns a string containing the largest name that can be formed from adjacent code points in the stream, starting from the first.
-
-	// Note: This algorithm does not do the verification of the first few code points that are necessary to ensure the returned code points would constitute an <ident-token>.
-	// If that is the intended use, ensure that the stream starts with an ident sequence before calling this algorithm.
-
-	// Let result initially be an empty string.
-
-	// Repeatedly consume the next input code point from the stream:
-	for (;;) {
-		const cc = input.charCodeAt(pos);
-		pos++;
-
-		// ident code point
-		// Append the code point to result.
-		if (_isIdentCodePoint(cc, pos - 1)) {
-			// Nothing
-		}
-		// the stream starts with a valid escape
-		// Consume an escaped code point. Append the returned code point to result.
-		else if (_ifTwoCodePointsAreValidEscape(input, pos)) {
-			pos = _consumeAnEscapedCodePoint(input, pos);
-		}
-		// anything else
-		// Reconsume the current input code point. Return result.
-		else {
-			return pos - 1;
-		}
-	}
-};
-
-/**
- * Is non printable code point.
- * @param {number} cc char code
- * @returns {boolean} true, when cc is the non-printable code point, otherwise false
- */
-const _isNonPrintableCodePoint = (cc) =>
-	(cc >= 0x00 && cc <= 0x08) ||
-	cc === 0x0b ||
-	(cc >= 0x0e && cc <= 0x1f) ||
-	cc === 0x7f;
-
-/**
- * Consume the remnants of a bad url.
- * @param {string} input input
- * @param {number} pos position
- * @returns {number} position
- */
-const consumeTheRemnantsOfABadUrl = (input, pos) => {
-	// This section describes how to consume the remnants of a bad url from a stream of code points,
-	// "cleaning up" after the tokenizer realizes that it’s in the middle of a <bad-url-token> rather than a <url-token>.
-	// It returns nothing; its sole use is to consume enough of the input stream to reach a recovery point where normal tokenizing can resume.
-
-	// Repeatedly consume the next input code point from the stream:
-	for (;;) {
-		// EOF
-		// Return.
-		if (pos === input.length) {
-			return pos;
-		}
-
-		const cc = input.charCodeAt(pos);
-		pos++;
-
-		// U+0029 RIGHT PARENTHESIS ())
-		// Return.
-		if (cc === CC_RIGHT_PARENTHESIS) {
-			return pos;
-		}
-		// the input stream starts with a valid escape
-		// Consume an escaped code point.
-		// This allows an escaped right parenthesis ("\)") to be encountered without ending the <bad-url-token>.
-		// This is otherwise identical to the "anything else" clause.
-		else if (_ifTwoCodePointsAreValidEscape(input, pos)) {
-			pos = _consumeAnEscapedCodePoint(input, pos);
-		}
-		// anything else
-		// Do nothing.
-		else {
-			// Do nothing.
-		}
-	}
-};
-
-/**
- * Consume a url token.
- * @param {string} input input
- * @param {number} pos position
- * @param {number} fnStart start
- * @param {CssTokenCallbacks} callbacks callbacks
- * @returns {pos} pos
- */
-const consumeAUrlToken = (input, pos, fnStart, callbacks) => {
-	// This section describes how to consume a url token from a stream of code points.
-	// It returns either a <url-token> or a <bad-url-token>.
-
-	// Note: This algorithm assumes that the initial "url(" has already been consumed.
-	// This algorithm also assumes that it’s being called to consume an "unquoted" value, like url(foo).
-	// A quoted value, like url("foo"), is parsed as a <function-token>.
-	// Consume an ident-like token automatically handles this distinction; this algorithm shouldn’t be called directly otherwise.
-
-	// Initially create a <url-token> with its value set to the empty string.
-
-	// Consume as much whitespace as possible.
-	while (_isWhiteSpace(input.charCodeAt(pos))) {
-		pos++;
-	}
-
-	const contentStart = pos;
-
-	// Repeatedly consume the next input code point from the stream:
-	for (;;) {
-		// EOF
-		// This is a parse error. Return the <url-token>.
-		if (pos === input.length) {
-			if (callbacks.url !== undefined) {
-				return callbacks.url(input, fnStart, pos, contentStart, pos - 1);
-			}
-
-			return pos;
-		}
-
-		const cc = input.charCodeAt(pos);
-		pos++;
-
-		// U+0029 RIGHT PARENTHESIS ())
-		// Return the <url-token>.
-		if (cc === CC_RIGHT_PARENTHESIS) {
-			if (callbacks.url !== undefined) {
-				return callbacks.url(input, fnStart, pos, contentStart, pos - 1);
-			}
-
-			return pos;
-		}
-		// whitespace
-		// Consume as much whitespace as possible.
-		// If the next input code point is U+0029 RIGHT PARENTHESIS ()) or EOF, consume it and return the <url-token>
-		// (if EOF was encountered, this is a parse error); otherwise, consume the remnants of a bad url, create a <bad-url-token>, and return it.
-		else if (_isWhiteSpace(cc)) {
-			const end = pos - 1;
-
-			while (_isWhiteSpace(input.charCodeAt(pos))) {
-				pos++;
-			}
-
-			if (pos === input.length) {
-				if (callbacks.url !== undefined) {
-					return callbacks.url(input, fnStart, pos, contentStart, end);
-				}
-
-				return pos;
-			}
-
-			if (input.charCodeAt(pos) === CC_RIGHT_PARENTHESIS) {
-				pos++;
-
-				if (callbacks.url !== undefined) {
-					return callbacks.url(input, fnStart, pos, contentStart, end);
-				}
-
-				return pos;
-			}
-
-			// Don't handle bad urls
-			pos = consumeTheRemnantsOfABadUrl(input, pos);
-
-			if (callbacks.badUrlToken !== undefined) {
-				return callbacks.badUrlToken(input, fnStart, pos);
-			}
-
-			return pos;
-		}
-		// U+0022 QUOTATION MARK (")
-		// U+0027 APOSTROPHE (')
-		// U+0028 LEFT PARENTHESIS (()
-		// non-printable code point
-		// This is a parse error. Consume the remnants of a bad url, create a <bad-url-token>, and return it.
-		else if (
-			cc === CC_QUOTATION_MARK ||
-			cc === CC_APOSTROPHE ||
-			cc === CC_LEFT_PARENTHESIS ||
-			_isNonPrintableCodePoint(cc)
-		) {
-			// Don't handle bad urls
-			pos = consumeTheRemnantsOfABadUrl(input, pos);
-
-			if (callbacks.badUrlToken !== undefined) {
-				return callbacks.badUrlToken(input, fnStart, pos);
-			}
-
-			return pos;
-		}
-		// // U+005C REVERSE SOLIDUS (\)
-		// // If the stream starts with a valid escape, consume an escaped code point and append the returned code point to the <url-token>’s value.
-		// // Otherwise, this is a parse error. Consume the remnants of a bad url, create a <bad-url-token>, and return it.
-		else if (cc === CC_REVERSE_SOLIDUS) {
-			if (_ifTwoCodePointsAreValidEscape(input, pos)) {
-				pos = _consumeAnEscapedCodePoint(input, pos);
-			} else {
-				// Don't handle bad urls
-				pos = consumeTheRemnantsOfABadUrl(input, pos);
-
-				if (callbacks.badUrlToken !== undefined) {
-					return callbacks.badUrlToken(input, fnStart, pos);
-				}
-
-				return pos;
-			}
-		}
-		// anything else
-		// Append the current input code point to the <url-token>’s value.
-		else {
-			// Nothing
-		}
-	}
-};
-
-/** @type {CharHandler} */
-const consumeAnIdentLikeToken = (input, pos, callbacks) => {
-	const start = pos;
-	// This section describes how to consume an ident-like token from a stream of code points.
-	// It returns an <ident-token>, <function-token>, <url-token>, or <bad-url-token>.
-	pos = _consumeAnIdentSequence(input, pos, callbacks);
-
-	// If string’s value is an ASCII case-insensitive match for "url", and the next input code point is U+0028 LEFT PARENTHESIS ((), consume it.
-	// While the next two input code points are whitespace, consume the next input code point.
-	// If the next one or two input code points are U+0022 QUOTATION MARK ("), U+0027 APOSTROPHE ('), or whitespace followed by U+0022 QUOTATION MARK (") or U+0027 APOSTROPHE ('), then create a <function-token> with its value set to string and return it.
-	// Otherwise, consume a url token, and return it.
-	if (
-		input.slice(start, pos).toLowerCase() === "url" &&
-		input.charCodeAt(pos) === CC_LEFT_PARENTHESIS
-	) {
-		pos++;
-		const end = pos;
-
-		while (
-			_isWhiteSpace(input.charCodeAt(pos)) &&
-			_isWhiteSpace(input.charCodeAt(pos + 1))
-		) {
-			pos++;
-		}
-
-		if (
-			input.charCodeAt(pos) === CC_QUOTATION_MARK ||
-			input.charCodeAt(pos) === CC_APOSTROPHE ||
-			(_isWhiteSpace(input.charCodeAt(pos)) &&
-				(input.charCodeAt(pos + 1) === CC_QUOTATION_MARK ||
-					input.charCodeAt(pos + 1) === CC_APOSTROPHE))
-		) {
-			if (callbacks.function !== undefined) {
-				return callbacks.function(input, start, end);
-			}
-
-			return pos;
-		}
-
-		return consumeAUrlToken(input, pos, start, callbacks);
-	}
-
-	// Otherwise, if the next input code point is U+0028 LEFT PARENTHESIS ((), consume it.
-	// Create a <function-token> with its value set to string and return it.
-	if (input.charCodeAt(pos) === CC_LEFT_PARENTHESIS) {
-		pos++;
-
-		if (callbacks.function !== undefined) {
-			return callbacks.function(input, start, pos);
-		}
-
-		return pos;
-	}
-
-	// Otherwise, create an <ident-token> with its value set to string and return it.
-	if (callbacks.identifier !== undefined) {
-		return callbacks.identifier(input, start, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeLessThan = (input, pos, callbacks) => {
-	// If the next 3 input code points are U+0021 EXCLAMATION MARK U+002D HYPHEN-MINUS U+002D HYPHEN-MINUS (!--), consume them and return a <CDO-token>.
-	if (input.slice(pos, pos + 3) === "!--") {
-		if (callbacks.cdo !== undefined) {
-			return callbacks.cdo(input, pos - 1, pos + 3);
-		}
-
-		return pos + 3;
-	}
-
-	if (callbacks.delim !== undefined) {
-		return callbacks.delim(input, pos - 1, pos);
-	}
-
-	// Otherwise, return a <delim-token> with its value set to the current input code point.
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeCommercialAt = (input, pos, callbacks) => {
-	const start = pos - 1;
-
-	// If the next 3 input code points would start an ident sequence, consume an ident sequence, create an <at-keyword-token> with its value set to the returned value, and return it.
-	if (
-		_ifThreeCodePointsWouldStartAnIdentSequence(
-			input,
-			pos,
-			input.charCodeAt(pos),
-			input.charCodeAt(pos + 1),
-			input.charCodeAt(pos + 2)
-		)
-	) {
-		pos = _consumeAnIdentSequence(input, pos, callbacks);
-
-		if (callbacks.atKeyword !== undefined) {
-			pos = callbacks.atKeyword(input, start, pos);
-		}
-
-		return pos;
-	}
-
-	// Otherwise, return a <delim-token> with its value set to the current input code point.
-	if (callbacks.delim !== undefined) {
-		return callbacks.delim(input, start, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeReverseSolidus = (input, pos, callbacks) => {
-	// If the input stream starts with a valid escape, reconsume the current input code point, consume an ident-like token, and return it.
-	if (_ifTwoCodePointsAreValidEscape(input, pos)) {
-		pos--;
-		return consumeAnIdentLikeToken(input, pos, callbacks);
-	}
-
-	// Otherwise, this is a parse error. Return a <delim-token> with its value set to the current input code point.
-	if (callbacks.delim !== undefined) {
-		return callbacks.delim(input, pos - 1, pos);
-	}
-
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeAToken = (input, pos, callbacks) => {
-	const cc = input.charCodeAt(pos - 1);
-
-	// 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(input, pos, callbacks);
-		// U+0022 QUOTATION MARK (")
-		case CC_QUOTATION_MARK:
-			return consumeAStringToken(input, pos, callbacks);
-		// U+0023 NUMBER SIGN (#)
-		case CC_NUMBER_SIGN:
-			return consumeNumberSign(input, pos, callbacks);
-		// U+0027 APOSTROPHE (')
-		case CC_APOSTROPHE:
-			return consumeAStringToken(input, pos, callbacks);
-		// U+0028 LEFT PARENTHESIS (()
-		case CC_LEFT_PARENTHESIS:
-			return consumeLeftParenthesis(input, pos, callbacks);
-		// U+0029 RIGHT PARENTHESIS ())
-		case CC_RIGHT_PARENTHESIS:
-			return consumeRightParenthesis(input, pos, callbacks);
-		// U+002B PLUS SIGN (+)
-		case CC_PLUS_SIGN:
-			return consumePlusSign(input, pos, callbacks);
-		// U+002C COMMA (,)
-		case CC_COMMA:
-			return consumeComma(input, pos, callbacks);
-		// U+002D HYPHEN-MINUS (-)
-		case CC_HYPHEN_MINUS:
-			return consumeHyphenMinus(input, pos, callbacks);
-		// U+002E FULL STOP (.)
-		case CC_FULL_STOP:
-			return consumeFullStop(input, pos, callbacks);
-		// U+003A COLON (:)
-		case CC_COLON:
-			return consumeColon(input, pos, callbacks);
-		// U+003B SEMICOLON (;)
-		case CC_SEMICOLON:
-			return consumeSemicolon(input, pos, callbacks);
-		// U+003C LESS-THAN SIGN (<)
-		case CC_LESS_THAN_SIGN:
-			return consumeLessThan(input, pos, callbacks);
-		// U+0040 COMMERCIAL AT (@)
-		case CC_AT_SIGN:
-			return consumeCommercialAt(input, pos, callbacks);
-		// U+005B LEFT SQUARE BRACKET ([)
-		case CC_LEFT_SQUARE:
-			return consumeLeftSquareBracket(input, pos, callbacks);
-		// U+005C REVERSE SOLIDUS (\)
-		case CC_REVERSE_SOLIDUS:
-			return consumeReverseSolidus(input, pos, callbacks);
-		// U+005D RIGHT SQUARE BRACKET (])
-		case CC_RIGHT_SQUARE:
-			return consumeRightSquareBracket(input, pos, callbacks);
-		// U+007B LEFT CURLY BRACKET ({)
-		case CC_LEFT_CURLY:
-			return consumeLeftCurlyBracket(input, pos, callbacks);
-		// U+007D RIGHT CURLY BRACKET (})
-		case CC_RIGHT_CURLY:
-			return consumeRightCurlyBracket(input, pos, callbacks);
-		default:
-			// digit
-			// Reconsume the current input code point, consume a numeric token, and return it.
-			if (_isDigit(cc)) {
-				pos--;
-				return consumeANumericToken(input, pos, callbacks);
-			} else if (cc === CC_LOWER_U || cc === CC_UPPER_U) {
-				// If unicode ranges allowed is true and the input stream would start a unicode-range,
-				// reconsume the current input code point, consume a unicode-range token, and return it.
-				// Skip now
-				// if (_ifThreeCodePointsWouldStartAUnicodeRange(input, pos)) {
-				// 	pos--;
-				// 	return consumeAUnicodeRangeToken(input, pos, callbacks);
-				// }
-
-				// Otherwise, reconsume the current input code point, consume an ident-like token, and return it.
-				pos--;
-				return consumeAnIdentLikeToken(input, pos, callbacks);
-			}
-			// ident-start code point
-			// Reconsume the current input code point, consume an ident-like token, and return it.
-			else if (isIdentStartCodePoint(cc)) {
-				pos--;
-				return consumeAnIdentLikeToken(input, pos, callbacks);
-			}
-
-			// EOF, but we don't have it
-
-			// anything else
-			// Return a <delim-token> with its value set to the current input code point.
-			return consumeDelimToken(input, pos, callbacks);
-	}
-};
-
-/**
- * Returns pos.
- * @param {string} input input css
- * @param {number=} pos pos
- * @param {CssTokenCallbacks=} callbacks callbacks
- * @returns {number} pos
- */
-module.exports = (input, pos = 0, callbacks = {}) => {
-	// This section describes how to consume a token from a stream of code points. It will return a single token of any type.
-	while (pos < input.length) {
-		// Consume comments.
-		pos = consumeComments(input, pos, callbacks);
-
-		// Consume the next input code point.
-		pos++;
-		pos = consumeAToken(input, pos, callbacks);
-
-		if (callbacks.needTerminate && callbacks.needTerminate()) {
-			break;
-		}
-	}
-
-	return pos;
-};
-
-/**
- * Returns pos.
- * @param {string} input input css
- * @param {number} pos pos
- * @param {CssTokenCallbacks} callbacks callbacks
- * @param {CssTokenCallbacks=} additional additional callbacks
- * @param {{ onlyTopLevel?: boolean, declarationValue?: boolean, atRulePrelude?: boolean, functionValue?: boolean }=} options options
- * @returns {number} pos
- */
-const consumeUntil = (input, pos, callbacks, additional, options = {}) => {
-	let needHandle = true;
-	let needTerminate = false;
-
-	/** @type {CssTokenCallbacks} */
-	const servicedCallbacks = {};
-
-	let balanced = 0;
-
-	if (options.onlyTopLevel) {
-		servicedCallbacks.function = (input, start, end) => {
-			balanced++;
-			if (!options.functionValue) {
-				needHandle = false;
-			}
-
-			if (additional && additional.function !== undefined) {
-				return additional.function(input, start, end);
-			}
-
-			return end;
-		};
-
-		servicedCallbacks.leftParenthesis = (_input, _start, end) => {
-			balanced++;
-			needHandle = false;
-			return end;
-		};
-		servicedCallbacks.rightParenthesis = (_input, _start, end) => {
-			balanced--;
-			if (balanced === 0) {
-				needHandle = true;
-			}
-			return end;
-		};
-	}
-
-	if (options.declarationValue) {
-		servicedCallbacks.semicolon = (_input, _start, end) => {
-			needTerminate = true;
-			return end;
-		};
-
-		servicedCallbacks.rightCurlyBracket = (_input, _start, end) => {
-			needTerminate = true;
-			return end;
-		};
-	} else if (options.functionValue) {
-		servicedCallbacks.rightParenthesis = (_input, _start, end) => {
-			balanced--;
-			if (balanced === 0) {
-				needTerminate = true;
-			}
-			return end;
-		};
-	} else if (options.atRulePrelude) {
-		servicedCallbacks.leftCurlyBracket = (_input, _start, end) => {
-			needTerminate = true;
-			return end;
-		};
-		servicedCallbacks.semicolon = (_input, _start, end) => {
-			needTerminate = true;
-			return end;
-		};
-	}
-
-	const mergedCallbacks = { ...servicedCallbacks, ...callbacks };
-
-	while (pos < input.length) {
-		// Consume comments.
-		pos = consumeComments(
-			input,
-			pos,
-			needHandle ? mergedCallbacks : servicedCallbacks
-		);
-
-		const start = pos;
-
-		// Consume the next input code point.
-		pos++;
-		pos = consumeAToken(
-			input,
-			pos,
-			needHandle ? mergedCallbacks : servicedCallbacks
-		);
-
-		if (needTerminate) {
-			return start;
-		}
-	}
-
-	return pos;
-};
-
-/**
- * Returns position after comments.
- * @param {string} input input
- * @param {number} pos position
- * @returns {number} position after comments
- */
-const eatComments = (input, pos) => {
-	for (;;) {
-		const originalPos = pos;
-		pos = consumeComments(input, pos, {});
-		if (originalPos === pos) {
-			break;
-		}
-	}
-
-	return pos;
-};
-
-/**
- * Returns position after whitespace.
- * @param {string} input input
- * @param {number} pos position
- * @returns {number} position after whitespace
- */
-const eatWhitespace = (input, pos) => {
-	while (_isWhiteSpace(input.charCodeAt(pos))) {
-		pos++;
-	}
-
-	return pos;
-};
-
-/**
- * Eat whitespace and comments.
- * @param {string} input input
- * @param {number} pos position
- * @returns {[number, boolean]} position after whitespace and comments
- */
-const eatWhitespaceAndComments = (input, pos) => {
-	let foundWhitespace = false;
-
-	for (;;) {
-		const originalPos = pos;
-		pos = consumeComments(input, pos, {});
-		while (_isWhiteSpace(input.charCodeAt(pos))) {
-			if (!foundWhitespace) {
-				foundWhitespace = true;
-			}
-			pos++;
-		}
-		if (originalPos === pos) {
-			break;
-		}
-	}
-
-	return [pos, foundWhitespace];
-};
-
-/**
- * Returns position after whitespace.
- * @param {string} input input
- * @param {number} pos position
- * @returns {number} position after whitespace
- */
-const eatWhiteLine = (input, pos) => {
-	for (;;) {
-		const cc = input.charCodeAt(pos);
-		if (_isSpace(cc)) {
-			pos++;
-			continue;
-		}
-		if (_isNewline(cc)) pos++;
-		pos = consumeExtraNewline(cc, input, pos);
-		break;
-	}
-
-	return pos;
-};
-
-/**
- * Skip comments and eat ident sequence.
- * @param {string} input input
- * @param {number} pos position
- * @returns {[number, number] | undefined} positions of ident sequence
- */
-const skipCommentsAndEatIdentSequence = (input, pos) => {
-	pos = eatComments(input, pos);
-
-	const start = pos;
-
-	if (
-		_ifThreeCodePointsWouldStartAnIdentSequence(
-			input,
-			pos,
-			input.charCodeAt(pos),
-			input.charCodeAt(pos + 1),
-			input.charCodeAt(pos + 2)
-		)
-	) {
-		return [start, _consumeAnIdentSequence(input, pos, {})];
-	}
-
-	return undefined;
-};
-
-/**
- * Returns positions of ident sequence.
- * @param {string} input input
- * @param {number} pos position
- * @returns {[number, number] | undefined} positions of ident sequence
- */
-const eatString = (input, pos) => {
-	pos = eatWhitespaceAndComments(input, pos)[0];
-
-	const start = pos;
-
-	if (
-		input.charCodeAt(pos) === CC_QUOTATION_MARK ||
-		input.charCodeAt(pos) === CC_APOSTROPHE
-	) {
-		return [start, consumeAStringToken(input, pos + 1, {})];
-	}
-
-	return undefined;
-};
-
-/**
- * Eat image set strings.
- * @param {string} input input
- * @param {number} pos position
- * @param {CssTokenCallbacks} cbs callbacks
- * @returns {[number, number][]} positions of ident sequence
- */
-const eatImageSetStrings = (input, pos, cbs) => {
-	/** @type {[number, number][]} */
-	const result = [];
-
-	let isFirst = true;
-	let needStop = false;
-	// We already in `func(` token
-	let balanced = 1;
-
-	/** @type {CssTokenCallbacks} */
-	const callbacks = {
-		...cbs,
-		string: (_input, start, end) => {
-			if (isFirst && balanced === 1) {
-				result.push([start, end]);
-				isFirst = false;
-			}
-
-			return end;
-		},
-		comma: (_input, _start, end) => {
-			if (balanced === 1) {
-				isFirst = true;
-			}
-
-			return end;
-		},
-		leftParenthesis: (input, start, end) => {
-			balanced++;
-
-			return end;
-		},
-		function: (_input, start, end) => {
-			balanced++;
-
-			return end;
-		},
-		rightParenthesis: (_input, _start, end) => {
-			balanced--;
-
-			if (balanced === 0) {
-				needStop = true;
-			}
-
-			return end;
-		}
-	};
-
-	while (pos < input.length) {
-		// Consume comments.
-		pos = consumeComments(input, pos, callbacks);
-
-		// Consume the next input code point.
-		pos++;
-		pos = consumeAToken(input, pos, callbacks);
-
-		if (needStop) {
-			break;
-		}
-	}
-
-	return result;
-};
-
-/**
- * Returns positions of top level tokens.
- * @param {string} input input
- * @param {number} pos position
- * @param {CssTokenCallbacks} cbs callbacks
- * @returns {[[number, number, number, number, boolean?] | undefined, [number, number] | undefined, [number, number] | undefined, [number, number] | undefined]} positions of top level tokens — the URL tuple's optional 5th element is `true` when the URL was given as an identifier (CSS Modules `@value` reference)
- */
-const eatImportTokens = (input, pos, cbs) => {
-	const result =
-		/** @type {[[number, number, number, number, boolean?] | undefined, [number, number] | undefined, [number, number] | undefined, [number, number] | undefined]} */
-		(Array.from({ length: 4 }));
-
-	/** @type {0 | 1 | 2 | undefined} */
-	let scope;
-	let needStop = false;
-	let balanced = 0;
-
-	/** @type {CssTokenCallbacks} */
-	const callbacks = {
-		...cbs,
-		url: (_input, start, end, contentStart, contentEnd) => {
-			if (
-				result[0] === undefined &&
-				balanced === 0 &&
-				result[1] === undefined &&
-				result[2] === undefined &&
-				result[3] === undefined
-			) {
-				result[0] = [start, end, contentStart, contentEnd];
-				scope = undefined;
-			}
-
-			return end;
-		},
-		string: (_input, start, end) => {
-			if (
-				balanced === 0 &&
-				result[0] === undefined &&
-				result[1] === undefined &&
-				result[2] === undefined &&
-				result[3] === undefined
-			) {
-				result[0] = [start, end, start + 1, end - 1];
-				scope = undefined;
-			} else if (result[0] !== undefined && scope === 0) {
-				result[0][2] = start + 1;
-				result[0][3] = end - 1;
-			}
-
-			return end;
-		},
-		leftParenthesis: (_input, _start, end) => {
-			balanced++;
-
-			return end;
-		},
-		rightParenthesis: (_input, _start, end) => {
-			balanced--;
-
-			if (balanced === 0 && scope !== undefined) {
-				/** @type {[number, number]} */
-				(result[scope])[1] = end;
-				scope = undefined;
-			}
-
-			return end;
-		},
-		function: (input, start, end) => {
-			if (balanced === 0) {
-				const name = input
-					.slice(start, end - 1)
-					.replace(/\\/g, "")
-					.toLowerCase();
-
-				if (
-					name === "url" &&
-					result[0] === undefined &&
-					result[1] === undefined &&
-					result[2] === undefined &&
-					result[3] === undefined
-				) {
-					scope = 0;
-					result[scope] = [start, end + 1, end + 1, end + 1];
-				} else if (
-					name === "layer" &&
-					result[1] === undefined &&
-					result[2] === undefined
-				) {
-					scope = 1;
-					result[scope] = [start, end];
-				} else if (name === "supports" && result[2] === undefined) {
-					scope = 2;
-					result[scope] = [start, end];
-				} else {
-					scope = undefined;
-				}
-			}
-
-			balanced++;
-
-			return end;
-		},
-		identifier: (input, start, end) => {
-			if (
-				balanced === 0 &&
-				result[1] === undefined &&
-				result[2] === undefined
-			) {
-				const name = input.slice(start, end).replace(/\\/g, "").toLowerCase();
-
-				if (name === "layer") {
-					result[1] = [start, end];
-					scope = undefined;
-				} else if (result[0] === undefined) {
-					// Capture as URL identifier (e.g. `@import myValue;` where
-					// `myValue` is a CSS Modules `@value` definition).
-					result[0] = [start, end, start, end, true];
-					scope = undefined;
-				}
-			}
-
-			return end;
-		},
-		semicolon: (_input, start, end) => {
-			if (balanced === 0) {
-				needStop = true;
-				result[3] = [start, end];
-			}
-
-			return end;
-		}
-	};
-
-	while (pos < input.length) {
-		// Consume comments.
-		pos = consumeComments(input, pos, callbacks);
-
-		// Consume the next input code point.
-		pos++;
-		pos = consumeAToken(input, pos, callbacks);
-
-		if (needStop) {
-			break;
-		}
-	}
-
-	return result;
-};
-
-/**
- * Eat ident sequence.
- * @param {string} input input
- * @param {number} pos position
- * @returns {[number, number] | undefined} positions of ident sequence
- */
-const eatIdentSequence = (input, pos) => {
-	pos = eatWhitespaceAndComments(input, pos)[0];
-
-	const start = pos;
-
-	if (
-		_ifThreeCodePointsWouldStartAnIdentSequence(
-			input,
-			pos,
-			input.charCodeAt(pos),
-			input.charCodeAt(pos + 1),
-			input.charCodeAt(pos + 2)
-		)
-	) {
-		return [start, _consumeAnIdentSequence(input, pos, {})];
-	}
-
-	return undefined;
-};
-
-/**
- * Eat ident sequence or string.
- * @param {string} input input
- * @param {number} pos position
- * @returns {[number, number, boolean] | undefined} positions of ident sequence or string
- */
-const eatIdentSequenceOrString = (input, pos) => {
-	pos = eatWhitespaceAndComments(input, pos)[0];
-
-	const start = pos;
-
-	if (
-		input.charCodeAt(pos) === CC_QUOTATION_MARK ||
-		input.charCodeAt(pos) === CC_APOSTROPHE
-	) {
-		return [start, consumeAStringToken(input, pos + 1, {}), false];
-	} else if (
-		_ifThreeCodePointsWouldStartAnIdentSequence(
-			input,
-			pos,
-			input.charCodeAt(pos),
-			input.charCodeAt(pos + 1),
-			input.charCodeAt(pos + 2)
-		)
-	) {
-		return [start, _consumeAnIdentSequence(input, pos, {}), true];
-	}
-
-	return undefined;
-};
-
-/**
- * Returns function to eat characters.
- * @param {string} chars characters
- * @returns {(input: string, pos: number) => number} function to eat characters
- */
-const eatUntil = (chars) => {
-	const charCodes = Array.from({ length: chars.length }, (_, i) =>
-		chars.charCodeAt(i)
-	);
-	const arr = Array.from(
-		{ length: Math.max(...charCodes, 0) + 1 },
-		() => false
-	);
-	for (const cc of charCodes) {
-		arr[cc] = true;
-	}
-
-	return (input, pos) => {
-		for (;;) {
-			const cc = input.charCodeAt(pos);
-			if (cc < arr.length && arr[cc]) {
-				return pos;
-			}
-			pos++;
-			if (pos === input.length) return pos;
-		}
-	};
-};
-
-module.exports.consumeUntil = consumeUntil;
-module.exports.eatComments = eatComments;
-module.exports.eatIdentSequence = eatIdentSequence;
-module.exports.eatIdentSequenceOrString = eatIdentSequenceOrString;
-module.exports.eatImageSetStrings = eatImageSetStrings;
-module.exports.eatImportTokens = eatImportTokens;
-module.exports.eatString = eatString;
-module.exports.eatUntil = eatUntil;
-module.exports.eatWhiteLine = eatWhiteLine;
-module.exports.eatWhitespace = eatWhitespace;
-module.exports.eatWhitespaceAndComments = eatWhitespaceAndComments;
-module.exports.escapeIdentifier = escapeIdentifier;
-module.exports.isIdentStartCodePoint = isIdentStartCodePoint;
-module.exports.isWhiteSpace = _isWhiteSpace;
-module.exports.skipCommentsAndEatIdentSequence =
-	skipCommentsAndEatIdentSequence;
-module.exports.unescapeIdentifier = unescapeIdentifier;