@projectwallace/css-parser 0.1.0

package/dist/selector-parser-2b3tGyri.js

@@ -0,0 +1,365 @@
+import { L as Lexer, q as TOKEN_COMMA, y as TOKEN_EOF, l as TOKEN_WHITESPACE, a as TOKEN_FUNCTION, o as TOKEN_COLON, r as TOKEN_LEFT_BRACKET, h as TOKEN_DELIM, c as TOKEN_HASH, T as TOKEN_IDENT, s as TOKEN_RIGHT_BRACKET, t as TOKEN_LEFT_PAREN, u as TOKEN_RIGHT_PAREN } from './lexer-DXablYMZ.js';
+import { d as NODE_SELECTOR, m as NODE_SELECTOR_LIST, J as is_whitespace, o as NODE_SELECTOR_CLASS, q as NODE_SELECTOR_ATTRIBUTE, M as trim_boundaries, s as NODE_SELECTOR_PSEUDO_ELEMENT, r as NODE_SELECTOR_PSEUDO_CLASS, n as NODE_SELECTOR_TYPE, p as NODE_SELECTOR_ID, u as NODE_SELECTOR_UNIVERSAL, v as NODE_SELECTOR_NESTING, t as NODE_SELECTOR_COMBINATOR } from './string-utils-B-rJII-E.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 wrapper with detailed selector nodes as children
+  parse_selector(start, end, line = 1) {
+    this.selector_end = end;
+    this.lexer.pos = start;
+    this.lexer.line = line;
+    let innerSelector = this.parse_selector_list();
+    if (innerSelector === null) {
+      return null;
+    }
+    let selectorWrapper = this.arena.create_node();
+    this.arena.set_type(selectorWrapper, NODE_SELECTOR);
+    this.arena.set_start_offset(selectorWrapper, start);
+    this.arena.set_length(selectorWrapper, end - start);
+    this.arena.set_start_line(selectorWrapper, line);
+    this.arena.set_first_child(selectorWrapper, innerSelector);
+    this.arena.set_last_child(selectorWrapper, innerSelector);
+    return selectorWrapper;
+  }
+  // Parse comma-separated selectors
+  parse_selector_list() {
+    let selectors = [];
+    let list_start = this.lexer.pos;
+    while (this.lexer.pos < this.selector_end) {
+      let selector = this.parse_complex_selector();
+      if (selector !== null) {
+        selectors.push(selector);
+      }
+      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) {
+      return selectors[0];
+    }
+    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, this.lexer.line);
+      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() {
+    let components = [];
+    this.skip_whitespace();
+    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;
+      }
+      let pos_before = this.lexer.pos;
+      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.pos = pos_before;
+        break;
+      }
+      this.lexer.pos = pos_before;
+      break;
+    }
+    if (components.length === 0) return null;
+    for (let i = 0; i < components.length - 1; i++) {
+      this.arena.set_next_sibling(components[i], 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) {
+      let pos_before = this.lexer.pos;
+      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.pos = pos_before;
+        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 === 46) {
+          return this.parse_class_selector(start);
+        } else if (ch === 42) {
+          return this.create_universal_selector(start, end);
+        } else if (ch === 38) {
+          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 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 (ch === 62 || ch === 43 || ch === 126) {
+        return this.create_combinator(start, this.lexer.token_end);
+      }
+    }
+    if (has_whitespace) {
+      this.lexer.pos = 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(start, this.lexer.pos);
+    }
+    this.lexer.pos = start;
+    return null;
+  }
+  // Parse class selector (.classname)
+  parse_class_selector(dot_pos) {
+    this.lexer.next_token_fast(false);
+    if (this.lexer.token_type !== TOKEN_IDENT) {
+      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_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;
+    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) {
+          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);
+    let trimmed = trim_boundaries(this.source, start + 1, end - 1);
+    if (trimmed) {
+      this.arena.set_content_start(node, trimmed[0]);
+      this.arena.set_content_length(node, trimmed[1] - trimmed[0]);
+    }
+    return node;
+  }
+  // Parse pseudo-class or pseudo-element (:hover, ::before)
+  parse_pseudo(start) {
+    let is_pseudo_element = false;
+    if (this.lexer.pos < this.selector_end && this.source.charCodeAt(this.lexer.pos) === 58) {
+      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_content_start(node, this.lexer.token_start);
+      this.arena.set_content_length(node, this.lexer.token_end - this.lexer.token_start);
+      return node;
+    } else if (token_type === TOKEN_FUNCTION) {
+      return this.parse_pseudo_function_after_colon(start, is_pseudo_element);
+    }
+    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 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) {
+        paren_depth++;
+      } else if (token_type === TOKEN_RIGHT_PAREN) {
+        paren_depth--;
+        if (paren_depth === 0) {
+          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_content_start(node, func_name_start);
+    this.arena.set_content_length(node, func_name_end - func_name_start);
+    return node;
+  }
+  // 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_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_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_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_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_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  // Helper to skip whitespace
+  skip_whitespace() {
+    while (this.lexer.pos < this.selector_end) {
+      let ch = this.source.charCodeAt(this.lexer.pos);
+      if (is_whitespace(ch)) {
+        this.lexer.pos++;
+      } else {
+        break;
+      }
+    }
+  }
+}
+
+export { SelectorParser as S };

package/dist/selector-parser.d.ts

@@ -0,0 +1,25 @@
+import type { CSSDataArena } from './arena';
+export declare class SelectorParser {
+    private lexer;
+    private arena;
+    private source;
+    private selector_end;
+    constructor(arena: CSSDataArena, source: string);
+    parse_selector(start: number, end: number, line?: number): number | null;
+    private parse_selector_list;
+    private parse_complex_selector;
+    private parse_compound_selector;
+    private parse_simple_selector;
+    private try_parse_combinator;
+    private parse_class_selector;
+    private parse_attribute_selector;
+    private parse_pseudo;
+    private parse_pseudo_function;
+    private parse_pseudo_function_after_colon;
+    private create_type_selector;
+    private create_id_selector;
+    private create_universal_selector;
+    private create_nesting_selector;
+    private create_combinator;
+    private skip_whitespace;
+}