@projectwallace/css-parser 0.18.4 → 0.18.6

package/dist/value-node-parser-3ET5Z4Rf.js

@@ -0,0 +1,737 @@
+import { t as Lexer } from "./tokenize-DK24ACbY.js";
+import "./arena-e9O_g2AN.js";
+import { a as is_whitespace, o as str_equals } from "./parse-dimension-ouWXNHdx.js";
+import { i as find_colon_at_depth_zero, o as skip_whitespace_and_comments_forward, s as trim_boundaries, t as SelectorParser } from "./parse-selector-DMduLN4o.js";
+//#region src/parse-condition.ts
+/** @internal */
+var ConditionParser = class {
+	lexer;
+	arena;
+	source;
+	end = 0;
+	value_node_parser;
+	selector_parser;
+	constructor(arena, source, value_node_parser) {
+		this.arena = arena;
+		this.source = source;
+		this.lexer = new Lexer(source);
+		this.value_node_parser = value_node_parser;
+		this.selector_parser = new SelectorParser(arena, source);
+	}
+	get end_position() {
+		return [
+			this.lexer.pos,
+			this.lexer.line,
+			this.lexer.column
+		];
+	}
+	create_node(type, start, end) {
+		return this.arena.create_node(type, start, end - start, this.lexer.token_line, this.lexer.token_column);
+	}
+	next_token() {
+		if (this.lexer.pos >= this.end) {
+			this.lexer.token_type = 26;
+			return 26;
+		}
+		return this.lexer.next_token_fast(false);
+	}
+	is_and_or_not(str) {
+		return str_equals("and", str) || str_equals("or", str) || str_equals("not", str);
+	}
+	scan_matching_paren() {
+		let depth = 1;
+		let content_end = this.lexer.pos;
+		let close_end = this.lexer.token_end;
+		while (this.lexer.pos < this.end && depth > 0) {
+			let token_type = this.next_token();
+			if (token_type === 21 || token_type === 2) depth++;
+			else if (token_type === 22) {
+				depth--;
+				if (depth === 0) {
+					content_end = this.lexer.token_start;
+					close_end = this.lexer.token_end;
+				}
+			} else if (token_type === 26) break;
+		}
+		return [
+			content_end,
+			close_end,
+			depth === 0
+		];
+	}
+	parse_feature_value(start, end) {
+		return this.value_node_parser.parse_chain(start, end, this.lexer.line, this.lexer.column);
+	}
+	wrap_ratio_value(first_node) {
+		if (this.arena.get_type(first_node) !== 11) return first_node;
+		let op_node = this.arena.get_next_sibling(first_node);
+		if (op_node === 0 || this.arena.get_type(op_node) !== 16) return first_node;
+		if (this.arena.get_length(op_node) !== 1) return first_node;
+		if (this.source.charCodeAt(this.arena.get_start_offset(op_node)) !== 47) return first_node;
+		let second_node = this.arena.get_next_sibling(op_node);
+		if (second_node === 0 || this.arena.get_type(second_node) !== 11) return first_node;
+		if (this.arena.get_next_sibling(second_node) !== 0) return first_node;
+		let start = this.arena.get_start_offset(first_node);
+		let end = this.arena.get_start_offset(second_node) + this.arena.get_length(second_node);
+		let ratio_node = this.arena.create_node(58, start, end - start, this.arena.get_start_line(first_node), this.arena.get_start_column(first_node));
+		this.arena.set_first_child(ratio_node, first_node);
+		this.arena.set_next_sibling(first_node, second_node);
+		return ratio_node;
+	}
+	create_supports_declaration(content_start, content_end, colon_pos) {
+		let prop_trimmed = trim_boundaries(this.source, content_start, colon_pos);
+		let val_trimmed = trim_boundaries(this.source, colon_pos + 1, content_end);
+		if (!prop_trimmed) return this.create_node(57, content_start, content_end);
+		let decl_start = prop_trimmed[0];
+		let decl_end = val_trimmed ? val_trimmed[1] : colon_pos + 1;
+		let decl = this.create_node(4, decl_start, decl_end);
+		this.arena.set_content_start_delta(decl, 0);
+		this.arena.set_content_length(decl, prop_trimmed[1] - prop_trimmed[0]);
+		if (val_trimmed) {
+			let value_first = this.parse_feature_value(val_trimmed[0], val_trimmed[1]);
+			let value_node;
+			if (value_first === 0) value_node = this.arena.create_node(50, val_trimmed[0], 0, this.lexer.token_line, this.lexer.token_column);
+			else {
+				value_node = this.arena.create_node(50, val_trimmed[0], val_trimmed[1] - val_trimmed[0], this.lexer.token_line, this.lexer.token_column);
+				this.arena.set_first_child(value_node, value_first);
+			}
+			this.arena.set_first_child(decl, value_node);
+		}
+		let supports_decl = this.create_node(57, content_start, content_end);
+		this.arena.set_content_start_delta(supports_decl, prop_trimmed[0] - content_start);
+		this.arena.set_content_length(supports_decl, prop_trimmed[1] - prop_trimmed[0]);
+		this.arena.set_first_child(supports_decl, decl);
+		return supports_decl;
+	}
+	parse_feature_range(feature_start, feature_end, content_start, content_end) {
+		let range_node = this.create_node(39, feature_start, feature_end);
+		let first_child = 0;
+		let last_child = 0;
+		let feature_name_start = -1;
+		let feature_name_end = -1;
+		let pos = content_start;
+		while (pos < content_end) {
+			pos = skip_whitespace_and_comments_forward(this.source, pos, content_end);
+			if (pos >= content_end) break;
+			let ch = this.source.charCodeAt(pos);
+			if (ch === 60 || ch === 62 || ch === 61) {
+				let op_start = pos++;
+				if (pos < content_end && this.source.charCodeAt(pos) === 61) pos++;
+				let op = this.create_node(38, op_start, pos);
+				if (first_child === 0) first_child = op;
+				else this.arena.set_next_sibling(last_child, op);
+				last_child = op;
+			} else {
+				let saved = this.lexer.save_position();
+				this.lexer.pos = pos;
+				this.next_token();
+				if (this.lexer.token_type === 1) {
+					feature_name_start = this.lexer.token_start;
+					feature_name_end = this.lexer.token_end;
+				} else {
+					let value_first = this.parse_feature_value(this.lexer.token_start, this.lexer.token_end);
+					if (value_first !== 0) {
+						if (first_child === 0) first_child = value_first;
+						else this.arena.set_next_sibling(last_child, value_first);
+						last_child = this.arena.get_last_sibling(value_first);
+					}
+				}
+				pos = this.lexer.pos;
+				this.lexer.restore_position(saved);
+			}
+		}
+		if (feature_name_start !== -1) {
+			this.arena.set_content_start_delta(range_node, feature_name_start - feature_start);
+			this.arena.set_content_length(range_node, feature_name_end - feature_name_start);
+		}
+		if (first_child !== 0) this.arena.set_first_child(range_node, first_child);
+		return range_node;
+	}
+	/**
+	* Parse the content of a media feature — everything between its parentheses, already
+	* known by the caller as `[content_start, content_end)`. `feature_start`/`feature_end`
+	* are the span of the feature node itself: for a real `@media (min-width: 768px)` feature
+	* this includes the surrounding parens (`feature_start < content_start`); for if()'s
+	* `media(min-width: 768px)`, media()'s own parens already delimit the content, so callers
+	* pass `feature_start === content_start` and `feature_end === content_end`.
+	* Returns a MEDIA_FEATURE (name/boolean/name:value) or FEATURE_RANGE (comparison syntax) node.
+	*/
+	parse_media_feature_content(feature_start, feature_end, content_start, content_end) {
+		this.end = content_end;
+		let has_comparison = false;
+		let i = content_start;
+		while (i < content_end) {
+			i = skip_whitespace_and_comments_forward(this.source, i, content_end);
+			if (i >= content_end) break;
+			let ch = this.source.charCodeAt(i);
+			if (ch === 60 || ch === 62 || ch === 61) {
+				has_comparison = true;
+				break;
+			}
+			i++;
+		}
+		if (has_comparison) return this.parse_feature_range(feature_start, feature_end, content_start, content_end);
+		let feature = this.create_node(33, feature_start, feature_end);
+		let colon_pos = -1;
+		let j = content_start;
+		while (j < content_end) {
+			j = skip_whitespace_and_comments_forward(this.source, j, content_end);
+			if (j >= content_end) break;
+			if (this.source.charCodeAt(j) === 58) {
+				colon_pos = j;
+				break;
+			}
+			j++;
+		}
+		if (colon_pos === -1) {
+			let trimmed = trim_boundaries(this.source, content_start, content_end);
+			if (trimmed) {
+				this.arena.set_content_start_delta(feature, trimmed[0] - feature_start);
+				this.arena.set_content_length(feature, trimmed[1] - trimmed[0]);
+			}
+		} else {
+			let name_trimmed = trim_boundaries(this.source, content_start, colon_pos);
+			if (name_trimmed) {
+				this.arena.set_content_start_delta(feature, name_trimmed[0] - feature_start);
+				this.arena.set_content_length(feature, name_trimmed[1] - name_trimmed[0]);
+			}
+			let value_trimmed = trim_boundaries(this.source, colon_pos + 1, content_end);
+			if (value_trimmed) {
+				let value_first = this.parse_feature_value(value_trimmed[0], value_trimmed[1]);
+				if (value_first !== 0) this.arena.set_first_child(feature, this.wrap_ratio_value(value_first));
+			}
+		}
+		return feature;
+	}
+	parse_media_feature(open_paren_start, end, line, column) {
+		this.end = end;
+		this.lexer.seek(open_paren_start, line, column);
+		this.next_token();
+		let feature_start = this.lexer.token_start;
+		let content_start = this.lexer.pos;
+		let [content_end, feature_end, matched] = this.scan_matching_paren();
+		if (!matched) return null;
+		return this.parse_media_feature_content(feature_start, feature_end, content_start, content_end);
+	}
+	parse_function_condition(func_start, end, line, column) {
+		this.end = end;
+		this.lexer.seek(func_start, line, column);
+		this.next_token();
+		let func_name = this.source.substring(this.lexer.token_start, this.lexer.token_end - 1);
+		let content_start = this.lexer.token_end;
+		let [content_end, func_end] = this.scan_matching_paren();
+		let func_node = this.create_node(15, func_start, func_end);
+		this.arena.set_content_start_delta(func_node, 0);
+		this.arena.set_content_length(func_node, func_name.length);
+		this.arena.set_value_start_delta(func_node, content_start - func_start);
+		this.arena.set_value_length(func_node, content_end - content_start);
+		if (str_equals("selector", func_name)) {
+			let selector_list = this.selector_parser.parse_selector(content_start, content_end, this.lexer.line, this.lexer.column);
+			if (selector_list !== null) this.arena.set_first_child(func_node, selector_list);
+		} else if (str_equals("style", func_name)) {
+			let decl_child = this.parse_supports_declaration_content(content_start, content_end);
+			if (decl_child !== null) this.arena.set_first_child(func_node, decl_child);
+		}
+		return func_node;
+	}
+	/**
+	* Parse a single `(property: value)` supports declaration from a content range — the
+	* `<style-feature>`/`<supports-feature>` grammar shared by `style()`, `@supports (…)`, and
+	* `@import … supports(…)`. Returns null if no top-level ':' is found.
+	*/
+	parse_supports_declaration_content(content_start, content_end) {
+		let colon_pos = find_colon_at_depth_zero(this.source, content_start, content_end);
+		if (colon_pos === -1) return null;
+		return this.create_supports_declaration(content_start, content_end, colon_pos);
+	}
+	/**
+	* Parse a `<supports-condition>` — the compound and/or/not grammar shared by `@supports`
+	* preludes and if()'s `supports(...)` condition function: parenthesized `(property: value)`
+	* declarations, `and`/`or`/`not` logical operators, and nested function conditions
+	* (`selector()`, `style()`, etc.), chained as flat siblings.
+	* `start`/`end` bound the range to scan; the caller has already positioned nothing — this
+	* seeks its own lexer, so it's safe to call with any sub-range of the source.
+	*/
+	parse_supports_condition(start, end, line, column) {
+		let saved_end = this.end;
+		this.end = end;
+		this.lexer.seek(start, line, column);
+		let nodes = [];
+		while (this.lexer.pos < this.end) {
+			this.lexer.skip_whitespace_in_range(this.end);
+			if (this.lexer.pos >= this.end) break;
+			this.next_token();
+			let token_type = this.lexer.token_type;
+			if (token_type === 21) {
+				let feature_start = this.lexer.token_start;
+				let content_start = this.lexer.pos;
+				let [content_end, feature_end, matched] = this.scan_matching_paren();
+				if (matched) {
+					let query = this.create_node(36, feature_start, feature_end);
+					let trimmed = trim_boundaries(this.source, content_start, content_end);
+					if (trimmed) {
+						this.arena.set_value_start_delta(query, trimmed[0] - feature_start);
+						this.arena.set_value_length(query, trimmed[1] - trimmed[0]);
+						let decl_child = this.parse_supports_declaration_content(trimmed[0], trimmed[1]);
+						if (decl_child !== null) this.arena.set_first_child(query, decl_child);
+					}
+					nodes.push(query);
+				}
+			} else if (token_type === 1) {
+				let text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+				if (this.is_and_or_not(text)) {
+					let op = this.create_node(38, this.lexer.token_start, this.lexer.token_end);
+					nodes.push(op);
+				}
+			} else if (token_type === 2) nodes.push(this.parse_function_condition(this.lexer.token_start, this.end, this.lexer.token_line, this.lexer.token_column));
+		}
+		this.end = saved_end;
+		return nodes;
+	}
+};
+//#endregion
+//#region src/value-node-parser.ts
+/** @internal */
+var ValueNodeParser = class ValueNodeParser {
+	lexer;
+	arena;
+	source;
+	end = 0;
+	last_chain_node = 0;
+	_condition_parser = null;
+	get condition_parser() {
+		if (this._condition_parser === null) this._condition_parser = new ConditionParser(this.arena, this.source, new ValueNodeParser(this.arena, this.source));
+		return this._condition_parser;
+	}
+	constructor(arena, source) {
+		this.arena = arena;
+		this.source = source;
+		this.lexer = new Lexer(source);
+	}
+	parse_chain(start, end, start_line, start_column) {
+		this.end = end;
+		this.lexer.seek(start, start_line, start_column);
+		let first_node = 0;
+		let last_node = 0;
+		while (this.lexer.pos < this.end) {
+			this.lexer.next_token_fast(false);
+			if (this.lexer.token_start >= this.end) break;
+			if (this.lexer.token_type === 26) break;
+			if (this.is_whitespace_inline()) continue;
+			let node = this.parse_value_node();
+			if (node !== null) {
+				if (first_node === 0) first_node = node;
+				else this.arena.set_next_sibling(last_node, node);
+				last_node = node;
+			}
+		}
+		this.last_chain_node = last_node;
+		return first_node;
+	}
+	is_whitespace_inline() {
+		if (this.lexer.token_start >= this.lexer.token_end) return false;
+		for (let i = this.lexer.token_start; i < this.lexer.token_end; i++) if (!is_whitespace(this.source.charCodeAt(i))) return false;
+		return true;
+	}
+	parse_value_node() {
+		let token_type = this.lexer.token_type;
+		let start = this.lexer.token_start;
+		let end = this.lexer.token_end;
+		switch (token_type) {
+			case 1: return this.create_node(10, start, end);
+			case 10: return this.create_node(11, start, end);
+			case 11:
+			case 12: return this.create_node(12, start, end);
+			case 5: return this.create_node(13, start, end);
+			case 4: return this.create_node(14, start, end);
+			case 27: return this.create_node(19, start, end);
+			case 2: return this.parse_function_node(start, end);
+			case 9: return this.parse_operator_node(start, end);
+			case 18:
+			case 16:
+			case 17: return this.create_node(16, start, end);
+			case 21: return this.parse_parenthesis_node(start, end);
+			default: return null;
+		}
+	}
+	create_node(node_type, start, end) {
+		let node = this.arena.create_node(node_type, start, end - start, this.lexer.token_line, this.lexer.token_column);
+		this.arena.set_content_length(node, end - start);
+		return node;
+	}
+	parse_operator_node(start, end) {
+		let ch = this.source.charCodeAt(start);
+		if (ch === 43 || ch === 45 || ch === 42 || ch === 47) return this.create_node(16, start, end);
+		return null;
+	}
+	scan_matching_paren(bounded) {
+		let depth = 1;
+		let content_end = this.lexer.pos;
+		let close_end = this.lexer.token_end;
+		while ((!bounded || this.lexer.pos < this.end) && depth > 0) {
+			this.lexer.next_token_fast(false);
+			let token_type = this.lexer.token_type;
+			if (token_type === 26) break;
+			if (bounded && this.lexer.token_start >= this.end) break;
+			if (token_type === 21 || token_type === 2) depth++;
+			else if (token_type === 22) {
+				depth--;
+				if (depth === 0) {
+					content_end = this.lexer.token_start;
+					close_end = this.lexer.token_end;
+				}
+			}
+		}
+		return [
+			content_end,
+			close_end,
+			depth === 0
+		];
+	}
+	parse_function_node(start, end) {
+		let name_end = end - 1;
+		let func_name_substr = this.source.substring(start, name_end);
+		if (str_equals("if", func_name_substr)) return this.parse_if_function_node(start, end);
+		let node = this.arena.create_node(str_equals("url", func_name_substr) ? 18 : 15, start, 0, this.lexer.token_line, this.lexer.token_column);
+		this.arena.set_content_start_delta(node, 0);
+		this.arena.set_content_length(node, name_end - start);
+		if (str_equals("url", func_name_substr) || str_equals("src", func_name_substr)) {
+			let save_pos = this.lexer.save_position();
+			this.lexer.next_token_fast(false);
+			while (this.is_whitespace_inline() && this.lexer.pos < this.end) this.lexer.next_token_fast(false);
+			let first_token_type = this.lexer.token_type;
+			this.lexer.restore_position(save_pos);
+			if (first_token_type === 5) {} else {
+				let func_end = end;
+				let content_start = end;
+				let content_end = end;
+				let [scanned_content_end, scanned_func_end, matched] = this.scan_matching_paren(false);
+				if (matched) {
+					content_end = scanned_content_end;
+					func_end = scanned_func_end;
+				}
+				this.arena.set_length(node, func_end - start);
+				this.arena.set_value_start_delta(node, content_start - start);
+				this.arena.set_value_length(node, content_end - content_start);
+				return node;
+			}
+		}
+		let first_arg = 0;
+		let last_arg = 0;
+		let paren_depth = 1;
+		let func_end = end;
+		let content_start = end;
+		let content_end = end;
+		while (this.lexer.pos < this.end && paren_depth > 0) {
+			this.lexer.next_token_fast(false);
+			let token_type = this.lexer.token_type;
+			if (token_type === 26) break;
+			if (this.lexer.token_start >= this.end) break;
+			if (token_type === 22) {
+				paren_depth--;
+				if (paren_depth === 0) {
+					content_end = this.lexer.token_start;
+					func_end = this.lexer.token_end;
+					break;
+				}
+			}
+			if (this.is_whitespace_inline()) continue;
+			let arg_node = this.parse_value_node();
+			if (arg_node !== null) {
+				if (first_arg === 0) first_arg = arg_node;
+				else this.arena.set_next_sibling(last_arg, arg_node);
+				last_arg = arg_node;
+			}
+		}
+		this.arena.set_length(node, func_end - start);
+		this.arena.set_value_start_delta(node, content_start - start);
+		this.arena.set_value_length(node, content_end - content_start);
+		if (first_arg !== 0) this.arena.set_first_child(node, first_arg);
+		return node;
+	}
+	/**
+	* Parse an if() inline conditional function.
+	*
+	* Spec grammar (CSS Values Level 5):
+	*   if( <if-branch>+ )
+	*   <if-branch>    = <if-condition> : <declaration-value>? ;?
+	*   <if-condition> = style(…) | media(…) | supports(…) | else
+	*
+	* Each branch becomes an IF_BRANCH child (see the `IfBranch` type in node-types.ts
+	* for its shape). Colons/semicolons here are structural separators, not OPERATOR nodes.
+	*/
+	parse_if_function_node(start, end) {
+		let name_end = end - 1;
+		let save_line = this.lexer.token_line;
+		let save_col = this.lexer.token_column;
+		let node = this.arena.create_node(15, start, 0, save_line, save_col);
+		this.arena.set_content_start_delta(node, 0);
+		this.arena.set_content_length(node, name_end - start);
+		let branches = [];
+		let func_end = end;
+		let content_start = end;
+		let content_end = end;
+		let if_closed = false;
+		while (this.lexer.pos < this.end && !if_closed) {
+			this.lexer.next_token_fast(false);
+			let tt = this.lexer.token_type;
+			if (tt === 26) break;
+			if (this.lexer.token_start >= this.end) break;
+			if (tt === 22) {
+				content_end = this.lexer.token_start;
+				func_end = this.lexer.token_end;
+				break;
+			}
+			if (this.is_whitespace_inline() || tt === 17 || tt === 16) continue;
+			let branch_start = this.lexer.token_start;
+			let branch_line = this.lexer.token_line;
+			let branch_col = this.lexer.token_column;
+			let condition_node = this.parse_if_condition();
+			if (condition_node === null) continue;
+			let condition_end_pos = this.arena.get_start_offset(condition_node) + this.arena.get_length(condition_node);
+			let colon_found = false;
+			while (this.lexer.pos < this.end) {
+				this.lexer.next_token_fast(false);
+				let t = this.lexer.token_type;
+				if (t === 26) break;
+				if (this.lexer.token_start >= this.end) break;
+				if (this.is_whitespace_inline()) continue;
+				if (t === 16) {
+					colon_found = true;
+					break;
+				}
+				if (t === 22) {
+					content_end = this.lexer.token_start;
+					func_end = this.lexer.token_end;
+					if_closed = true;
+					break;
+				}
+			}
+			let value_tokens = [];
+			let value_start = -1;
+			let value_last_end = condition_end_pos;
+			let value_line = 0;
+			let value_col = 0;
+			if (colon_found && !if_closed) while (this.lexer.pos < this.end) {
+				this.lexer.next_token_fast(false);
+				let t = this.lexer.token_type;
+				if (t === 26) break;
+				if (this.lexer.token_start >= this.end) break;
+				if (this.is_whitespace_inline()) continue;
+				if (t === 17) break;
+				if (t === 22) {
+					content_end = this.lexer.token_start;
+					func_end = this.lexer.token_end;
+					if_closed = true;
+					break;
+				}
+				let vnode = this.parse_value_node();
+				if (vnode !== null) {
+					let ns = this.arena.get_start_offset(vnode);
+					if (value_start === -1) {
+						value_start = ns;
+						value_line = this.arena.get_start_line(vnode);
+						value_col = this.arena.get_start_column(vnode);
+					}
+					value_tokens.push(vnode);
+					value_last_end = ns + this.arena.get_length(vnode);
+				}
+			}
+			let value_node = null;
+			if (value_tokens.length > 0) {
+				value_node = this.arena.create_node(50, value_start, value_last_end - value_start, value_line, value_col);
+				this.arena.append_children(value_node, value_tokens);
+			}
+			let branch_end = value_node === null ? condition_end_pos : value_last_end;
+			let branch_node = this.arena.create_node(59, branch_start, branch_end - branch_start, branch_line, branch_col);
+			this.arena.set_content_start_delta(branch_node, 0);
+			this.arena.set_content_length(branch_node, condition_end_pos - branch_start);
+			if (value_start !== -1) {
+				this.arena.set_value_start_delta(branch_node, value_start - branch_start);
+				this.arena.set_value_length(branch_node, value_last_end - value_start);
+			}
+			let branch_children = [condition_node];
+			if (value_node !== null) branch_children.push(value_node);
+			this.arena.append_children(branch_node, branch_children);
+			branches.push(branch_node);
+		}
+		this.arena.set_length(node, func_end - start);
+		this.arena.set_value_start_delta(node, content_start - start);
+		this.arena.set_value_length(node, content_end - content_start);
+		this.arena.append_children(node, branches);
+		return node;
+	}
+	is_and_or_not(str) {
+		return str_equals("and", str) || str_equals("or", str) || str_equals("not", str);
+	}
+	next_significant_token() {
+		while (this.lexer.pos < this.end) {
+			this.lexer.next_token_fast(false);
+			if (this.lexer.token_start >= this.end) return 26;
+			if (this.is_whitespace_inline()) continue;
+			return this.lexer.token_type;
+		}
+		return 26;
+	}
+	/**
+	* Parse an if()-branch condition:
+	*   <if-condition> = <boolean-expr[ <if-test> ]> | else
+	*   <if-test>      = style(…) | media(…) | supports(…)
+	* i.e. a single test function, the bare "else" identifier, or those test functions
+	* combined with not/and/or (e.g. "not style(--x: 1)", "style(--a: 1) and media(width > 600px)").
+	* Called with the lexer's current token already positioned at the condition's first token.
+	* A simple single-function/"else" condition returns that node directly, unwrapped (matching
+	* prior behavior); a compound not/and/or condition wraps the flat operator/function chain in
+	* an IF_CONDITION node so IfBranch.condition/.value (single first_child/next_sibling hops)
+	* still see exactly one node for "the condition".
+	*/
+	parse_if_condition() {
+		if (this.lexer.token_type === 1) {
+			let text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+			if (str_equals("else", text)) return this.parse_value_node();
+		}
+		let first = 0;
+		let last = 0;
+		let component_count = 0;
+		let compound = false;
+		for (;;) {
+			let tt = this.lexer.token_type;
+			let component = null;
+			let is_operator = false;
+			if (tt === 2) component = this.parse_if_condition_function(this.lexer.token_start, this.lexer.token_end);
+			else if (tt === 1) {
+				let text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+				if (this.is_and_or_not(text)) {
+					is_operator = true;
+					component = this.arena.create_node(38, this.lexer.token_start, this.lexer.token_end - this.lexer.token_start, this.lexer.token_line, this.lexer.token_column);
+				} else component = this.parse_value_node();
+			} else component = this.parse_value_node();
+			if (component !== null) {
+				component_count++;
+				if (first === 0) first = component;
+				else this.arena.set_next_sibling(last, component);
+				last = component;
+			}
+			if (tt !== 2 && !is_operator) break;
+			let saved = this.lexer.save_position();
+			let next_tt = this.next_significant_token();
+			if (next_tt === 2) {
+				compound = true;
+				continue;
+			}
+			if (next_tt === 1) {
+				let text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+				if (this.is_and_or_not(text)) {
+					compound = true;
+					continue;
+				}
+			}
+			this.lexer.restore_position(saved);
+			break;
+		}
+		if (first === 0) return null;
+		if (component_count === 1 && !compound) return first;
+		let wrapper_start = this.arena.get_start_offset(first);
+		let last_sibling = this.arena.get_last_sibling(first);
+		let wrapper_end = this.arena.get_start_offset(last_sibling) + this.arena.get_length(last_sibling);
+		let wrapper = this.arena.create_node(60, wrapper_start, wrapper_end - wrapper_start, this.arena.get_start_line(first), this.arena.get_start_column(first));
+		this.arena.set_first_child(wrapper, first);
+		return wrapper;
+	}
+	/**
+	* Parse a condition function inside if() — style(), supports(), or media(). Content parsing
+	* is delegated to the shared ConditionParser (see parse-condition.ts), so these produce the
+	* same node shapes real `@supports`/`@media` conditions do:
+	*   style()/supports() → SUPPORTS_DECLARATION(s) — supports() gets the full compound
+	*     <supports-condition> grammar (and/or/not, nested conditions), same as `@supports`.
+	*   media()  → a single MEDIA_FEATURE or FEATURE_RANGE (comparison syntax), same as `@media`.
+	*   anything else → generic value nodes, as before.
+	*
+	* Called with the current token at TOKEN_FUNCTION (the '(' already consumed).
+	* @param func_start  Offset of the function name's first char.
+	* @param token_end   Offset right after '(' (== lexer.token_end here).
+	*/
+	parse_if_condition_function(func_start, token_end) {
+		let func_name_end = token_end - 1;
+		let func_name = this.source.substring(func_start, func_name_end);
+		let func_line = this.lexer.token_line;
+		let func_col = this.lexer.token_column;
+		let content_start = token_end;
+		let content_end = content_start;
+		let func_end = content_start;
+		let [scanned_content_end, scanned_func_end, matched] = this.scan_matching_paren(true);
+		if (matched) {
+			content_end = scanned_content_end;
+			func_end = scanned_func_end;
+		}
+		let func_node = this.arena.create_node(15, func_start, func_end - func_start, func_line, func_col);
+		this.arena.set_content_start_delta(func_node, 0);
+		this.arena.set_content_length(func_node, func_name_end - func_start);
+		this.arena.set_value_start_delta(func_node, content_start - func_start);
+		this.arena.set_value_length(func_node, content_end - content_start);
+		let child_nodes = [];
+		if (str_equals("style", func_name)) {
+			let decl = this.condition_parser.parse_supports_declaration_content(content_start, content_end);
+			if (decl === null) child_nodes = this.condition_parser.parse_supports_condition(content_start, content_end, func_line, func_col);
+			else child_nodes = [decl];
+		} else if (str_equals("supports", func_name)) {
+			let decl = this.condition_parser.parse_supports_declaration_content(content_start, content_end);
+			if (decl === null) child_nodes = this.condition_parser.parse_supports_condition(content_start, content_end, func_line, func_col);
+			else child_nodes = [decl];
+		} else if (str_equals("media", func_name)) child_nodes = [this.condition_parser.parse_media_feature_content(content_start, content_end, content_start, content_end)];
+		else child_nodes = this.parse_value_nodes_in_range(content_start, content_end);
+		this.arena.append_children(func_node, child_nodes);
+		return func_node;
+	}
+	/** Parse value tokens in a source sub-range using save/restore to protect lexer state. */
+	parse_value_nodes_in_range(start, end) {
+		let saved_end = this.end;
+		let saved_pos = this.lexer.save_position();
+		this.end = end;
+		this.lexer.seek(start, this.lexer.line, this.lexer.column);
+		let nodes = [];
+		while (this.lexer.pos < this.end) {
+			this.lexer.next_token_fast(false);
+			if (this.lexer.token_start >= this.end) break;
+			if (this.lexer.token_type === 26) break;
+			if (this.is_whitespace_inline()) continue;
+			let node = this.parse_value_node();
+			if (node !== null) nodes.push(node);
+		}
+		this.lexer.restore_position(saved_pos);
+		this.end = saved_end;
+		return nodes;
+	}
+	parse_parenthesis_node(start, end) {
+		let node = this.arena.create_node(17, start, 0, this.lexer.token_line, this.lexer.token_column);
+		let first_child = 0;
+		let last_child = 0;
+		let paren_depth = 1;
+		let paren_end = end;
+		while (this.lexer.pos < this.end && paren_depth > 0) {
+			this.lexer.next_token_fast(false);
+			let token_type = this.lexer.token_type;
+			if (token_type === 26) break;
+			if (this.lexer.token_start >= this.end) break;
+			if (token_type === 22) {
+				paren_depth--;
+				if (paren_depth === 0) {
+					paren_end = this.lexer.token_end;
+					break;
+				}
+			}
+			if (this.is_whitespace_inline()) continue;
+			let child_node = this.parse_value_node();
+			if (child_node !== null) {
+				if (first_child === 0) first_child = child_node;
+				else this.arena.set_next_sibling(last_child, child_node);
+				last_child = child_node;
+			}
+		}
+		this.arena.set_length(node, paren_end - start);
+		if (first_child !== 0) this.arena.set_first_child(node, first_child);
+		return node;
+	}
+};
+//#endregion
+export { ConditionParser as n, ValueNodeParser as t };