@projectwallace/css-parser 0.5.0 → 0.6.0

package/dist/parse-selector.js

@@ -1,6 +1,617 @@
-import { K as CSSDataArena, m as NODE_SELECTOR_LIST, C as CSSNode } from './string-utils-tMt2O9RW.js';
-import { S as SelectorParser } from './selector-parser-C-u1epDB.js';
+import { L as Lexer, q as TOKEN_COMMA, h as TOKEN_DELIM, y as TOKEN_EOF, l as TOKEN_WHITESPACE, a as TOKEN_FUNCTION, o as TOKEN_COLON, r as TOKEN_LEFT_BRACKET, c as TOKEN_HASH, T as TOKEN_IDENT, s as TOKEN_RIGHT_BRACKET, t as TOKEN_LEFT_PAREN, u as TOKEN_RIGHT_PAREN, d as TOKEN_STRING } from './lexer-CtBKgfVv.js';
+import { T as CSSDataArena, s as NODE_SELECTOR_LIST, C as CSSNode, j as NODE_SELECTOR, $ as CHAR_GREATER_THAN, a0 as CHAR_PLUS, a1 as CHAR_TILDE, a2 as CHAR_PERIOD, a3 as CHAR_ASTERISK, a4 as CHAR_AMPERSAND, a5 as is_whitespace, a6 as is_combinator, u as NODE_SELECTOR_CLASS, w as NODE_SELECTOR_ATTRIBUTE, a7 as skip_whitespace_and_comments_forward, a8 as skip_whitespace_and_comments_backward, a9 as CHAR_EQUALS, aa as CHAR_PIPE, ab as CHAR_CARET, ac as CHAR_DOLLAR, A as ATTR_OPERATOR_NONE, a as ATTR_OPERATOR_EQUAL, b as ATTR_OPERATOR_TILDE_EQUAL, c as ATTR_OPERATOR_PIPE_EQUAL, d as ATTR_OPERATOR_CARET_EQUAL, e as ATTR_OPERATOR_DOLLAR_EQUAL, f as ATTR_OPERATOR_STAR_EQUAL, ad as CHAR_SINGLE_QUOTE, ae as CHAR_DOUBLE_QUOTE, af as CHAR_COLON, y as NODE_SELECTOR_PSEUDO_ELEMENT, x as NODE_SELECTOR_PSEUDO_CLASS, X as is_vendor_prefixed, Y as FLAG_VENDOR_PREFIXED, _ as NODE_SELECTOR_LANG, ag as skip_whitespace_forward, F as NODE_SELECTOR_NTH_OF, t as NODE_SELECTOR_TYPE, v as NODE_SELECTOR_ID, B as NODE_SELECTOR_UNIVERSAL, D as NODE_SELECTOR_NESTING, z as NODE_SELECTOR_COMBINATOR } from './css-node-BzCSxoLM.js';
+import { ANplusBParser } from './parse-anplusb.js';
 
+class SelectorParser {
+  lexer;
+  arena;
+  source;
+  selector_end;
+  constructor(arena, source) {
+    this.arena = arena;
+    this.source = source;
+    this.lexer = new Lexer(source, false);
+    this.selector_end = 0;
+  }
+  // Parse a selector range into selector nodes
+  // Always returns a NODE_SELECTOR_LIST with selector components as children
+  parse_selector(start, end, line = 1, column = 1, allow_relative = false) {
+    this.selector_end = end;
+    this.lexer.pos = start;
+    this.lexer.line = line;
+    this.lexer.column = column;
+    return this.parse_selector_list(allow_relative);
+  }
+  // Parse comma-separated selectors
+  parse_selector_list(allow_relative = false) {
+    let selectors = [];
+    let list_start = this.lexer.pos;
+    let list_line = this.lexer.line;
+    let list_column = this.lexer.column;
+    while (this.lexer.pos < this.selector_end) {
+      let selector_start = this.lexer.pos;
+      let selector_line = this.lexer.line;
+      let selector_column = this.lexer.column;
+      let complex_selector = this.parse_complex_selector(allow_relative);
+      if (complex_selector !== null) {
+        let selector_wrapper = this.arena.create_node();
+        this.arena.set_type(selector_wrapper, NODE_SELECTOR);
+        this.arena.set_start_offset(selector_wrapper, selector_start);
+        this.arena.set_length(selector_wrapper, this.lexer.pos - selector_start);
+        this.arena.set_start_line(selector_wrapper, selector_line);
+        this.arena.set_start_column(selector_wrapper, selector_column);
+        let last_component = complex_selector;
+        while (this.arena.get_next_sibling(last_component) !== 0) {
+          last_component = this.arena.get_next_sibling(last_component);
+        }
+        this.arena.set_first_child(selector_wrapper, complex_selector);
+        this.arena.set_last_child(selector_wrapper, last_component);
+        selectors.push(selector_wrapper);
+      }
+      this.skip_whitespace();
+      if (this.lexer.pos >= this.selector_end) break;
+      this.lexer.next_token_fast(false);
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_COMMA) {
+        this.skip_whitespace();
+        continue;
+      } else {
+        break;
+      }
+    }
+    if (selectors.length >= 1) {
+      let list_node = this.arena.create_node();
+      this.arena.set_type(list_node, NODE_SELECTOR_LIST);
+      this.arena.set_start_offset(list_node, list_start);
+      this.arena.set_length(list_node, this.lexer.pos - list_start);
+      this.arena.set_start_line(list_node, list_line);
+      this.arena.set_start_column(list_node, list_column);
+      this.arena.set_first_child(list_node, selectors[0]);
+      this.arena.set_last_child(list_node, selectors[selectors.length - 1]);
+      for (let i = 0; i < selectors.length - 1; i++) {
+        this.arena.set_next_sibling(selectors[i], selectors[i + 1]);
+      }
+      return list_node;
+    }
+    return null;
+  }
+  // Parse a complex selector (with combinators)
+  // e.g., "div.class > p + span"
+  parse_complex_selector(allow_relative = false) {
+    let components = [];
+    this.skip_whitespace();
+    if (allow_relative && this.lexer.pos < this.selector_end) {
+      const saved = this.lexer.save_position();
+      this.lexer.next_token_fast(false);
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_DELIM) {
+        let ch = this.source.charCodeAt(this.lexer.token_start);
+        if (ch === CHAR_GREATER_THAN || ch === CHAR_PLUS || ch === CHAR_TILDE) {
+          let combinator = this.create_combinator(this.lexer.token_start, this.lexer.token_end);
+          components.push(combinator);
+          this.skip_whitespace();
+        } else {
+          this.lexer.restore_position(saved);
+        }
+      } else {
+        this.lexer.restore_position(saved);
+      }
+    }
+    while (this.lexer.pos < this.selector_end) {
+      if (this.lexer.pos >= this.selector_end) break;
+      let compound = this.parse_compound_selector();
+      if (compound !== null) {
+        components.push(compound);
+      } else {
+        break;
+      }
+      let combinator = this.try_parse_combinator();
+      if (combinator !== null) {
+        components.push(combinator);
+        this.skip_whitespace();
+        continue;
+      }
+      const saved = this.lexer.save_position();
+      this.skip_whitespace();
+      if (this.lexer.pos >= this.selector_end) break;
+      this.lexer.next_token_fast(false);
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_COMMA || this.lexer.pos >= this.selector_end) {
+        this.lexer.restore_position(saved);
+        break;
+      }
+      this.lexer.restore_position(saved);
+      break;
+    }
+    if (components.length === 0) return null;
+    for (let i = 0; i < components.length - 1; i++) {
+      let last_node = components[i];
+      while (this.arena.get_next_sibling(last_node) !== 0) {
+        last_node = this.arena.get_next_sibling(last_node);
+      }
+      this.arena.set_next_sibling(last_node, components[i + 1]);
+    }
+    return components[0];
+  }
+  // Parse a compound selector (no combinators)
+  // e.g., "div.class#id[attr]:hover"
+  parse_compound_selector() {
+    let parts = [];
+    while (this.lexer.pos < this.selector_end) {
+      const saved = this.lexer.save_position();
+      this.lexer.next_token_fast(false);
+      if (this.lexer.token_start >= this.selector_end) break;
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_EOF) break;
+      let part = this.parse_simple_selector();
+      if (part !== null) {
+        parts.push(part);
+      } else {
+        this.lexer.restore_position(saved);
+        break;
+      }
+    }
+    if (parts.length === 0) return null;
+    for (let i = 0; i < parts.length - 1; i++) {
+      this.arena.set_next_sibling(parts[i], parts[i + 1]);
+    }
+    return parts[0];
+  }
+  // Parse a simple selector (single component)
+  parse_simple_selector() {
+    let token_type = this.lexer.token_type;
+    let start = this.lexer.token_start;
+    let end = this.lexer.token_end;
+    switch (token_type) {
+      case TOKEN_IDENT:
+        return this.create_type_selector(start, end);
+      case TOKEN_HASH:
+        return this.create_id_selector(start, end);
+      case TOKEN_DELIM:
+        let ch = this.source.charCodeAt(start);
+        if (ch === CHAR_PERIOD) {
+          return this.parse_class_selector(start);
+        } else if (ch === CHAR_ASTERISK) {
+          return this.create_universal_selector(start, end);
+        } else if (ch === CHAR_AMPERSAND) {
+          return this.create_nesting_selector(start, end);
+        }
+        return null;
+      case TOKEN_LEFT_BRACKET:
+        return this.parse_attribute_selector(start);
+      case TOKEN_COLON:
+        return this.parse_pseudo(start);
+      case TOKEN_FUNCTION:
+        return this.parse_pseudo_function(start, end);
+      case TOKEN_WHITESPACE:
+      case TOKEN_COMMA:
+        return null;
+      default:
+        return null;
+    }
+  }
+  // Parse combinator (>, +, ~, or descendant space)
+  try_parse_combinator() {
+    let whitespace_start = this.lexer.pos;
+    let has_whitespace = false;
+    while (this.lexer.pos < this.selector_end) {
+      let ch = this.source.charCodeAt(this.lexer.pos);
+      if (is_whitespace(ch)) {
+        has_whitespace = true;
+        this.lexer.pos++;
+      } else {
+        break;
+      }
+    }
+    if (this.lexer.pos >= this.selector_end) return null;
+    this.lexer.next_token_fast(false);
+    if (this.lexer.token_type === TOKEN_DELIM) {
+      let ch = this.source.charCodeAt(this.lexer.token_start);
+      if (is_combinator(ch)) {
+        return this.create_combinator(this.lexer.token_start, this.lexer.token_end);
+      }
+    }
+    if (has_whitespace) {
+      this.lexer.pos = whitespace_start;
+      while (this.lexer.pos < this.selector_end) {
+        let ch = this.source.charCodeAt(this.lexer.pos);
+        if (is_whitespace(ch)) {
+          this.lexer.pos++;
+        } else {
+          break;
+        }
+      }
+      return this.create_combinator(whitespace_start, this.lexer.pos);
+    }
+    this.lexer.pos = whitespace_start;
+    return null;
+  }
+  // Parse class selector (.classname)
+  parse_class_selector(dot_pos) {
+    const saved = this.lexer.save_position();
+    this.lexer.next_token_fast(false);
+    if (this.lexer.token_type !== TOKEN_IDENT) {
+      this.lexer.restore_position(saved);
+      return null;
+    }
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_SELECTOR_CLASS);
+    this.arena.set_start_offset(node, dot_pos);
+    this.arena.set_length(node, this.lexer.token_end - dot_pos);
+    this.arena.set_start_line(node, this.lexer.line);
+    this.arena.set_start_column(node, this.lexer.column);
+    this.arena.set_content_start(node, this.lexer.token_start);
+    this.arena.set_content_length(node, this.lexer.token_end - this.lexer.token_start);
+    return node;
+  }
+  // Parse attribute selector ([attr], [attr=value], etc.)
+  parse_attribute_selector(start) {
+    let bracket_depth = 1;
+    let end = this.lexer.token_end;
+    let content_start = start + 1;
+    let content_end = content_start;
+    while (this.lexer.pos < this.selector_end && bracket_depth > 0) {
+      this.lexer.next_token_fast(false);
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_LEFT_BRACKET) {
+        bracket_depth++;
+      } else if (token_type === TOKEN_RIGHT_BRACKET) {
+        bracket_depth--;
+        if (bracket_depth === 0) {
+          content_end = this.lexer.token_start;
+          end = this.lexer.token_end;
+          break;
+        }
+      }
+    }
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_SELECTOR_ATTRIBUTE);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_start_line(node, this.lexer.line);
+    this.arena.set_start_column(node, this.lexer.column);
+    this.parse_attribute_content(node, content_start, content_end);
+    return node;
+  }
+  // Parse attribute content to extract name, operator, and value
+  parse_attribute_content(node, start, end) {
+    start = skip_whitespace_and_comments_forward(this.source, start, end);
+    end = skip_whitespace_and_comments_backward(this.source, end, start);
+    if (start >= end) return;
+    let name_start = start;
+    let name_end = start;
+    let operator_end = -1;
+    let value_start = -1;
+    let value_end = -1;
+    while (name_end < end) {
+      let ch2 = this.source.charCodeAt(name_end);
+      if (is_whitespace(ch2) || ch2 === CHAR_EQUALS || ch2 === CHAR_TILDE || ch2 === CHAR_PIPE || ch2 === CHAR_CARET || ch2 === CHAR_DOLLAR || ch2 === CHAR_ASTERISK) {
+        break;
+      }
+      name_end++;
+    }
+    if (name_end > name_start) {
+      this.arena.set_content_start(node, name_start);
+      this.arena.set_content_length(node, name_end - name_start);
+    }
+    let pos = skip_whitespace_and_comments_forward(this.source, name_end, end);
+    if (pos >= end) {
+      this.arena.set_attr_operator(node, ATTR_OPERATOR_NONE);
+      return;
+    }
+    let ch1 = this.source.charCodeAt(pos);
+    if (ch1 === CHAR_EQUALS) {
+      operator_end = pos + 1;
+      this.arena.set_attr_operator(node, ATTR_OPERATOR_EQUAL);
+    } else if (ch1 === CHAR_TILDE && pos + 1 < end && this.source.charCodeAt(pos + 1) === CHAR_EQUALS) {
+      operator_end = pos + 2;
+      this.arena.set_attr_operator(node, ATTR_OPERATOR_TILDE_EQUAL);
+    } else if (ch1 === CHAR_PIPE && pos + 1 < end && this.source.charCodeAt(pos + 1) === CHAR_EQUALS) {
+      operator_end = pos + 2;
+      this.arena.set_attr_operator(node, ATTR_OPERATOR_PIPE_EQUAL);
+    } else if (ch1 === CHAR_CARET && pos + 1 < end && this.source.charCodeAt(pos + 1) === CHAR_EQUALS) {
+      operator_end = pos + 2;
+      this.arena.set_attr_operator(node, ATTR_OPERATOR_CARET_EQUAL);
+    } else if (ch1 === CHAR_DOLLAR && pos + 1 < end && this.source.charCodeAt(pos + 1) === CHAR_EQUALS) {
+      operator_end = pos + 2;
+      this.arena.set_attr_operator(node, ATTR_OPERATOR_DOLLAR_EQUAL);
+    } else if (ch1 === CHAR_ASTERISK && pos + 1 < end && this.source.charCodeAt(pos + 1) === CHAR_EQUALS) {
+      operator_end = pos + 2;
+      this.arena.set_attr_operator(node, ATTR_OPERATOR_STAR_EQUAL);
+    } else {
+      this.arena.set_attr_operator(node, ATTR_OPERATOR_NONE);
+      return;
+    }
+    pos = skip_whitespace_and_comments_forward(this.source, operator_end, end);
+    if (pos >= end) {
+      return;
+    }
+    value_start = pos;
+    let ch = this.source.charCodeAt(pos);
+    if (ch === CHAR_SINGLE_QUOTE || ch === CHAR_DOUBLE_QUOTE) {
+      let quote = ch;
+      value_start = pos;
+      pos++;
+      while (pos < end) {
+        let c = this.source.charCodeAt(pos);
+        if (c === quote) {
+          pos++;
+          break;
+        }
+        if (c === 92) {
+          pos += 2;
+        } else {
+          pos++;
+        }
+      }
+      value_end = pos;
+    } else {
+      while (pos < end) {
+        let c = this.source.charCodeAt(pos);
+        if (is_whitespace(c)) {
+          break;
+        }
+        pos++;
+      }
+      value_end = pos;
+    }
+    if (value_end > value_start) {
+      this.arena.set_value_start(node, value_start);
+      this.arena.set_value_length(node, value_end - value_start);
+    }
+  }
+  // Parse pseudo-class or pseudo-element (:hover, ::before)
+  parse_pseudo(start) {
+    const saved = this.lexer.save_position();
+    let is_pseudo_element = false;
+    if (this.lexer.pos < this.selector_end && this.source.charCodeAt(this.lexer.pos) === CHAR_COLON) {
+      is_pseudo_element = true;
+      this.lexer.pos++;
+    }
+    this.lexer.next_token_fast(false);
+    let token_type = this.lexer.token_type;
+    if (token_type === TOKEN_IDENT) {
+      let node = this.arena.create_node();
+      this.arena.set_type(node, is_pseudo_element ? NODE_SELECTOR_PSEUDO_ELEMENT : NODE_SELECTOR_PSEUDO_CLASS);
+      this.arena.set_start_offset(node, start);
+      this.arena.set_length(node, this.lexer.token_end - start);
+      this.arena.set_start_line(node, this.lexer.line);
+      this.arena.set_start_column(node, this.lexer.column);
+      this.arena.set_content_start(node, this.lexer.token_start);
+      this.arena.set_content_length(node, this.lexer.token_end - this.lexer.token_start);
+      if (is_vendor_prefixed(this.source, this.lexer.token_start, this.lexer.token_end)) {
+        this.arena.set_flag(node, FLAG_VENDOR_PREFIXED);
+      }
+      return node;
+    } else if (token_type === TOKEN_FUNCTION) {
+      return this.parse_pseudo_function_after_colon(start, is_pseudo_element);
+    }
+    this.lexer.restore_position(saved);
+    return null;
+  }
+  // Parse pseudo-class function (:nth-child(), :is(), etc.)
+  parse_pseudo_function(_start, _end) {
+    return null;
+  }
+  // Parse pseudo-class function after we've seen the colon
+  parse_pseudo_function_after_colon(start, is_pseudo_element) {
+    let func_name_start = this.lexer.token_start;
+    let func_name_end = this.lexer.token_end - 1;
+    let content_start = this.lexer.pos;
+    let content_end = content_start;
+    let paren_depth = 1;
+    let end = this.lexer.token_end;
+    while (this.lexer.pos < this.selector_end && paren_depth > 0) {
+      this.lexer.next_token_fast(false);
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_LEFT_PAREN || token_type === TOKEN_FUNCTION) {
+        paren_depth++;
+      } else if (token_type === TOKEN_RIGHT_PAREN) {
+        paren_depth--;
+        if (paren_depth === 0) {
+          content_end = this.lexer.token_start;
+          end = this.lexer.token_end;
+          break;
+        }
+      }
+    }
+    let node = this.arena.create_node();
+    this.arena.set_type(node, is_pseudo_element ? NODE_SELECTOR_PSEUDO_ELEMENT : NODE_SELECTOR_PSEUDO_CLASS);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_start_line(node, this.lexer.line);
+    this.arena.set_start_column(node, this.lexer.column);
+    this.arena.set_content_start(node, func_name_start);
+    this.arena.set_content_length(node, func_name_end - func_name_start);
+    if (is_vendor_prefixed(this.source, func_name_start, func_name_end)) {
+      this.arena.set_flag(node, FLAG_VENDOR_PREFIXED);
+    }
+    if (content_end > content_start) {
+      let func_name = this.source.substring(func_name_start, func_name_end).toLowerCase();
+      if (this.is_nth_pseudo(func_name)) {
+        let child = this.parse_nth_expression(content_start, content_end);
+        if (child !== null) {
+          this.arena.set_first_child(node, child);
+          this.arena.set_last_child(node, child);
+        }
+      } else if (func_name === "lang") {
+        this.parse_lang_identifiers(content_start, content_end, node);
+      } else {
+        let saved_selector_end = this.selector_end;
+        const saved = this.lexer.save_position();
+        let allow_relative = func_name === "has";
+        let child_selector = this.parse_selector(content_start, content_end, this.lexer.line, this.lexer.column, allow_relative);
+        this.selector_end = saved_selector_end;
+        this.lexer.restore_position(saved);
+        if (child_selector !== null) {
+          this.arena.set_first_child(node, child_selector);
+          this.arena.set_last_child(node, child_selector);
+        }
+      }
+    }
+    return node;
+  }
+  // Check if pseudo-class name is an nth-* pseudo
+  is_nth_pseudo(name) {
+    return name === "nth-child" || name === "nth-last-child" || name === "nth-of-type" || name === "nth-last-of-type" || name === "nth-col" || name === "nth-last-col";
+  }
+  // Parse :lang() content - comma-separated language identifiers
+  // Accepts both quoted strings: :lang("en", "fr") and unquoted: :lang(en, fr)
+  parse_lang_identifiers(start, end, parent_node) {
+    let saved_selector_end = this.selector_end;
+    const saved = this.lexer.save_position();
+    this.lexer.pos = start;
+    this.selector_end = end;
+    let first_child = null;
+    let last_child = null;
+    while (this.lexer.pos < end) {
+      this.lexer.next_token_fast(false);
+      let token_type = this.lexer.token_type;
+      let token_start = this.lexer.token_start;
+      let token_end = this.lexer.token_end;
+      if (token_type === TOKEN_WHITESPACE) {
+        continue;
+      }
+      if (token_type === TOKEN_COMMA) {
+        continue;
+      }
+      if (token_type === TOKEN_STRING || token_type === TOKEN_IDENT) {
+        let lang_node = this.arena.create_node();
+        this.arena.set_type(lang_node, NODE_SELECTOR_LANG);
+        this.arena.set_start_offset(lang_node, token_start);
+        this.arena.set_length(lang_node, token_end - token_start);
+        this.arena.set_start_line(lang_node, this.lexer.line);
+        this.arena.set_start_column(lang_node, this.lexer.column);
+        if (first_child === null) {
+          first_child = lang_node;
+        }
+        if (last_child !== null) {
+          this.arena.set_next_sibling(last_child, lang_node);
+        }
+        last_child = lang_node;
+      }
+      if (this.lexer.pos >= end) {
+        break;
+      }
+    }
+    if (first_child !== null) {
+      this.arena.set_first_child(parent_node, first_child);
+    }
+    if (last_child !== null) {
+      this.arena.set_last_child(parent_node, last_child);
+    }
+    this.selector_end = saved_selector_end;
+    this.lexer.restore_position(saved);
+  }
+  // Parse An+B expression for nth-* pseudo-classes
+  // Handles both simple An+B and "An+B of S" syntax
+  parse_nth_expression(start, end) {
+    let of_index = this.find_of_keyword(start, end);
+    if (of_index !== -1) {
+      let anplusb_parser = new ANplusBParser(this.arena, this.source);
+      let anplusb_node = anplusb_parser.parse_anplusb(start, of_index, this.lexer.line);
+      let selector_start = of_index + 2;
+      selector_start = skip_whitespace_forward(this.source, selector_start, end);
+      let saved_selector_end = this.selector_end;
+      const saved = this.lexer.save_position();
+      this.selector_end = end;
+      this.lexer.pos = selector_start;
+      let selector_list = this.parse_selector_list();
+      this.selector_end = saved_selector_end;
+      this.lexer.restore_position(saved);
+      let of_node = this.arena.create_node();
+      this.arena.set_type(of_node, NODE_SELECTOR_NTH_OF);
+      this.arena.set_start_offset(of_node, start);
+      this.arena.set_length(of_node, end - start);
+      this.arena.set_start_line(of_node, this.lexer.line);
+      if (anplusb_node !== null && selector_list !== null) {
+        this.arena.set_first_child(of_node, anplusb_node);
+        this.arena.set_last_child(of_node, selector_list);
+        this.arena.set_next_sibling(anplusb_node, selector_list);
+      } else if (anplusb_node !== null) {
+        this.arena.set_first_child(of_node, anplusb_node);
+        this.arena.set_last_child(of_node, anplusb_node);
+      }
+      return of_node;
+    } else {
+      let anplusb_parser = new ANplusBParser(this.arena, this.source);
+      return anplusb_parser.parse_anplusb(start, end, this.lexer.line);
+    }
+  }
+  // Find the position of standalone "of" keyword
+  find_of_keyword(start, end) {
+    for (let i = start; i < end - 1; i++) {
+      if (this.source.charCodeAt(i) === 111 && this.source.charCodeAt(i + 1) === 102) {
+        let before_ok = i === start || is_whitespace(this.source.charCodeAt(i - 1));
+        let after_ok = i + 2 >= end || is_whitespace(this.source.charCodeAt(i + 2));
+        if (before_ok && after_ok) {
+          return i;
+        }
+      }
+    }
+    return -1;
+  }
+  // Create simple selector nodes
+  create_type_selector(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_SELECTOR_TYPE);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_start_line(node, this.lexer.line);
+    this.arena.set_start_column(node, this.lexer.column);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  create_id_selector(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_SELECTOR_ID);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_start_line(node, this.lexer.line);
+    this.arena.set_start_column(node, this.lexer.column);
+    this.arena.set_content_start(node, start + 1);
+    this.arena.set_content_length(node, end - start - 1);
+    return node;
+  }
+  create_universal_selector(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_SELECTOR_UNIVERSAL);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_start_line(node, this.lexer.line);
+    this.arena.set_start_column(node, this.lexer.column);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  create_nesting_selector(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_SELECTOR_NESTING);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_start_line(node, this.lexer.line);
+    this.arena.set_start_column(node, this.lexer.column);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  create_combinator(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_SELECTOR_COMBINATOR);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_start_line(node, this.lexer.line);
+    this.arena.set_start_column(node, this.lexer.column);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  // Helper to skip whitespace
+  skip_whitespace() {
+    this.lexer.pos = skip_whitespace_forward(this.source, this.lexer.pos, this.selector_end);
+  }
+}
 function parse_selector(source) {
   const arena = new CSSDataArena(CSSDataArena.capacity_for_source(source.length));
   const selector_parser = new SelectorParser(arena, source);
@@ -16,4 +627,4 @@ function parse_selector(source) {
   return new CSSNode(arena, source, selector_index);
 }
 
-export { parse_selector };
+export { SelectorParser, parse_selector };

package/dist/parse-utils.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Parse a dimension string into numeric value and unit
+ *
+ * @param text - Dimension text like "100px", "50%", "1.5em"
+ * @returns Object with value (number) and unit (string)
+ *
+ * Examples:
+ * - "100px" → { value: 100, unit: "px" }
+ * - "50%" → { value: 50, unit: "%" }
+ * - "1.5em" → { value: 1.5, unit: "em" }
+ * - "-10rem" → { value: -10, unit: "rem" }
+ */
+export declare function parse_dimension(text: string): {
+    value: number;
+    unit: string;
+};
+/**
+ * Skip whitespace forward from a position
+ *
+ * @param source - The source string
+ * @param pos - Starting position
+ * @param end - End boundary (exclusive)
+ * @returns New position after skipping whitespace
+ */
+export declare function skip_whitespace_forward(source: string, pos: number, end: number): number;
+/**
+ * Skip whitespace and comments forward from a position
+ *
+ * @param source - The source string
+ * @param pos - Starting position
+ * @param end - End boundary (exclusive)
+ * @returns New position after skipping whitespace/comments
+ */
+export declare function skip_whitespace_and_comments_forward(source: string, pos: number, end: number): number;
+/**
+ * Skip whitespace and comments backward from a position
+ *
+ * @param source - The source string
+ * @param pos - Starting position (exclusive, scanning backward from pos-1)
+ * @param start - Start boundary (inclusive, won't go before this)
+ * @returns New position after skipping whitespace/comments backward
+ */
+export declare function skip_whitespace_and_comments_backward(source: string, pos: number, start: number): number;
+/**
+ * Trim whitespace and comments from both ends of a string range
+ *
+ * @param source - The source string
+ * @param start - Start offset in source
+ * @param end - End offset in source
+ * @returns [trimmed_start, trimmed_end] or null if all whitespace/comments
+ *
+ * Skips whitespace (space, tab, newline, CR, FF) and CSS comments from both ends
+ * of the specified range. Returns the trimmed boundaries or null if the range
+ * contains only whitespace and comments.
+ */
+export declare function trim_boundaries(source: string, start: number, end: number): [number, number] | null;