@projectwallace/css-parser 0.18.2 → 0.18.5

package/dist/value-node-parser-JFFFJVX-.js

@@ -0,0 +1,661 @@
+import { t as Lexer } from "./tokenize-DK24ACbY.js";
+import "./arena-DKhfTFT5.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-DBdUc04T.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;
+			if (tt === 2) condition_node = this.parse_if_condition_function(this.lexer.token_start, this.lexer.token_end);
+			else condition_node = this.parse_value_node();
+			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;
+	}
+	/**
+	* 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 = [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 };

package/dist/walk.d.ts

@@ -1,4 +1,4 @@
-import { o as CSSNode, t as AnyNode } from "./node-types-D41wr72y.js";
+import { o as CSSNode, t as AnyNode } from "./node-types-u3Sbl3_p.js";
 //#region src/walk.d.ts
 declare const SKIP: unique symbol;
 declare const BREAK: unique symbol;

package/dist/walk.js

@@ -1,5 +1,5 @@
-import "./arena-CFwM4uQs.js";
-import { t as CSSNode } from "./css-node-Cf8K9nWd.js";
+import "./arena-DKhfTFT5.js";
+import { t as CSSNode } from "./css-node-DKr6cufe.js";
 import "./constants.js";
 //#region src/walk.ts
 const SKIP = Symbol("SKIP");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectwallace/css-parser",
-  "version": "0.18.2",
+  "version": "0.18.5",
   "description": "High-performance CSS lexer and parser, optimized for CSS inspection and analysis",
   "keywords": [
     "ast",
@@ -84,6 +84,7 @@
     "knip": "^6.18.0",
     "oxfmt": "^0.60.0",
     "oxlint": "^1.71.0",
+    "pkg-pr-new": "^0.0.88",
     "postcss": "^8.5.15",
     "publint": "^0.3.21",
     "tailwindcss": "^2.2.8",
@@ -103,7 +104,7 @@
     "test-build": "pnpm run build && vitest run --config vitest.config.build.ts",
     "build": "tsdown",
     "benchmark": "pnpm run build && node --expose-gc benchmark/index.ts",
-    "lint": "oxlint --config .oxlintrc.json; oxfmt --check",
+    "lint": "oxlint --config .oxlintrc.json && oxfmt --check",
     "check": "tsc --noEmit",
     "knip": "knip",
     "precommit": "pnpm run test --run; pnpm run lint; pnpm run check"