Function consumeAnAtRule

lib/css/syntax.js:2290–2345

(ts, nested = false)

 * @returns {AtRule | undefined} the parsed at-rule
 */
const consumeAnAtRule = (ts, nested = false) => {
	// Assert (spec): the next token is an <at-keyword-token>.
	// Consume a token from input, and let rule be a new at-rule with its name set to the returned token’s value, its prelude initially set to an empty list, and no declarations or child rules.
	const head = ts.consume();
	const rule = /** @type {AtRule} */ (
		_mkContainer(T_AT_RULE, head.start, head.end)
	);
	_setName(
		rule,
		ts.input.slice(head.start + 1, head.end),
		head.start,
		head.end
	);
	const prelude = _list();
	_setPrelude(rule, prelude);
	// declarations / childRules / blockStart (-1) / blockEnd (-1) keep their
	// defaults (no block: the `;` / EOF / nested-`}` at-rule forms).

	// Process input
	for (;;) {
		const t = ts.next();

		// <semicolon-token>
		// <EOF-token>
		// Discard a token from input. If rule is valid in the current context, return it; otherwise return nothing.
		if (t.type === TT_SEMICOLON || t.type === TT_EOF) {
			ts.discard();
			_setEnd(rule, t.start);
			return rule;
		}
		// <}-token>
		// If nested is true: if rule is valid in the current context, return it; otherwise return nothing.
		// Otherwise, consume a token and append the result to rule’s prelude.
		else if (t.type === TT_RIGHT_CURLY_BRACKET) {
			if (nested) {
				_setEnd(rule, t.start);
				return rule;
			}
			prelude.push(consumeATokenAsNode(ts));
			continue;
		}
		// <{-token>
		// Consume a block from input, and assign the result to rule's declarations and child rules.
		else if (t.type === TT_LEFT_CURLY_BRACKET) {
			const block = consumeABlock(ts);
			_setBody(rule, block.decls, block.rules);
			_setBlock(rule, block.blockStart, block.blockEnd);
			_setEnd(rule, block.blockEnd);
			return rule;
		}

		// anything else
		// Consume a component value from input and append the returned value to rule’s prelude.
		prelude.push(consumeAComponentValue(ts, t));
	}
};

/**