Function consumeAQualifiedRule

lib/css/syntax.js:2368–2447

(ts, stopToken, nested = false)

 * @returns {QualifiedRule | undefined} parsed qualified rule, or `undefined` on a parse error
 */
const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
	const start = ts.next().start;
	// Let rule be a new qualified rule with its prelude, declarations, and child rules all initially set to empty lists.
	const rule = /** @type {QualifiedRule} */ (
		_mkContainer(T_QUALIFIED_RULE, start, start)
	);
	const prelude = _list();
	_setPrelude(rule, prelude);
	// declarations / childRules / blockStart (-1) / blockEnd (-1) keep their
	// defaults (no block until a `{` is reached).

	// Process input
	for (;;) {
		const t = ts.next();
		// <EOF-token>
		// stop token (if passed)
		// This is a parse error. Return nothing.
		if (t.type === TT_EOF || t.type === stopToken) {
			return undefined;
		}
		// <}-token>
		// This is a parse error. If nested is true, return nothing. Otherwise, consume a token and append the result to rule’s prelude.
		else if (t.type === TT_RIGHT_CURLY_BRACKET) {
			if (nested) return undefined;
			prelude.push(consumeATokenAsNode(ts));
			continue;
		}
		// <{-token>
		// If the first two non-<whitespace-token> values of rule's prelude are an <ident-token> whose value starts with "--" followed by a <colon-token>, then:
		//   - If nested is true, consume the remnants of a bad declaration from input, with nested set to true, and return nothing.
		//   - If nested is false, consume a block from input, and return nothing.
		// (This disambiguates custom-property declarations from nested qualified rules — `--foo: { … }` at top level of a block is a declaration, not a rule.)
		// Otherwise, consume a block from input, and let child rules be the result.
		else if (t.type === TT_LEFT_CURLY_BRACKET) {
			let firstIdx = 0;
			/* istanbul ignore next -- @preserve: leading whitespace is discarded before the rule, so the prelude never starts with it */
			while (
				firstIdx < prelude.length &&
				_nType(prelude[firstIdx]) === T_WHITESPACE
			) {
				firstIdx++;
			}
			let secondIdx = firstIdx + 1;
			while (
				secondIdx < prelude.length &&
				_nType(prelude[secondIdx]) === T_WHITESPACE
			) {
				secondIdx++;
			}
			const first = prelude[firstIdx];
			const second = prelude[secondIdx];
			if (
				first &&
				_nType(first) === T_IDENT &&
				// Test the source bytes directly — avoids forcing the lazy `value`
				// slice just to check the `--` custom-property prefix.
				ts.input.startsWith("--", _nStart(first)) &&
				second &&