@projectwallace/css-parser 0.4.0 → 0.6.0

package/dist/parse-atrule-prelude.js

@@ -1,6 +1,455 @@
-import { K as CSSDataArena, C as CSSNode } from './string-utils-tMt2O9RW.js';
-import { A as AtRulePreludeParser } from './at-rule-prelude-parser-Cj8ecgQp.js';
+import { L as Lexer, q as TOKEN_COMMA, T as TOKEN_IDENT, t as TOKEN_LEFT_PAREN, u as TOKEN_RIGHT_PAREN, l as TOKEN_WHITESPACE, f as TOKEN_URL, a as TOKEN_FUNCTION, d as TOKEN_STRING, y as TOKEN_EOF } from './lexer-CtBKgfVv.js';
+import { T as CSSDataArena, C as CSSNode, ah as str_equals, O as NODE_PRELUDE_OPERATOR, I as NODE_PRELUDE_MEDIA_TYPE, G as NODE_PRELUDE_MEDIA_QUERY, H as NODE_PRELUDE_MEDIA_FEATURE, Z as trim_boundaries, M as NODE_PRELUDE_IDENTIFIER, J as NODE_PRELUDE_CONTAINER_QUERY, K as NODE_PRELUDE_SUPPORTS_QUERY, L as NODE_PRELUDE_LAYER_NAME, P as NODE_PRELUDE_IMPORT_URL, Q as NODE_PRELUDE_IMPORT_LAYER, R as NODE_PRELUDE_IMPORT_SUPPORTS, ag as skip_whitespace_forward } from './css-node-BzCSxoLM.js';
 
+class AtRulePreludeParser {
+  lexer;
+  arena;
+  source;
+  prelude_end;
+  constructor(arena, source) {
+    this.arena = arena;
+    this.source = source;
+    this.lexer = new Lexer(source, false);
+    this.prelude_end = 0;
+  }
+  // Parse an at-rule prelude into nodes based on the at-rule type
+  parse_prelude(at_rule_name, start, end, line = 1, column = 1) {
+    this.prelude_end = end;
+    this.lexer.pos = start;
+    this.lexer.line = line;
+    this.lexer.column = column;
+    if (str_equals("media", at_rule_name)) {
+      return this.parse_media_query_list();
+    } else if (str_equals("container", at_rule_name)) {
+      return this.parse_container_query();
+    } else if (str_equals("supports", at_rule_name)) {
+      return this.parse_supports_query();
+    } else if (str_equals("layer", at_rule_name)) {
+      return this.parse_layer_names();
+    } else if (str_equals("keyframes", at_rule_name)) {
+      return this.parse_identifier();
+    } else if (str_equals("property", at_rule_name)) {
+      return this.parse_identifier();
+    } else if (str_equals("import", at_rule_name)) {
+      return this.parse_import_prelude();
+    }
+    return [];
+  }
+  // Parse media query list: screen, (min-width: 768px), ...
+  parse_media_query_list() {
+    let nodes = [];
+    while (this.lexer.pos < this.prelude_end) {
+      this.skip_whitespace();
+      if (this.lexer.pos >= this.prelude_end) break;
+      let query = this.parse_single_media_query();
+      if (query !== null) {
+        nodes.push(query);
+      }
+      this.skip_whitespace();
+      if (this.peek_token_type() === TOKEN_COMMA) {
+        this.next_token();
+      }
+    }
+    return nodes;
+  }
+  is_and_or_not(str) {
+    if (str.length > 3 || str.length < 2) return false;
+    return str_equals("and", str) || str_equals("or", str) || str_equals("not", str);
+  }
+  // Parse a single media query: screen and (min-width: 768px)
+  parse_single_media_query() {
+    let query_start = this.lexer.pos;
+    let query_line = this.lexer.line;
+    this.skip_whitespace();
+    if (this.lexer.pos >= this.prelude_end) return null;
+    let token_start = this.lexer.pos;
+    this.next_token();
+    if (this.lexer.token_type === TOKEN_IDENT) {
+      let text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+      if (!str_equals("only", text) && !str_equals("not", text)) {
+        this.lexer.pos = token_start;
+      }
+    } else {
+      this.lexer.pos = token_start;
+    }
+    let components = [];
+    while (this.lexer.pos < this.prelude_end) {
+      this.skip_whitespace();
+      if (this.lexer.pos >= this.prelude_end) break;
+      if (this.peek_token_type() === TOKEN_COMMA) break;
+      this.next_token();
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_LEFT_PAREN) {
+        let feature = this.parse_media_feature();
+        if (feature !== null) {
+          components.push(feature);
+        }
+      } else if (token_type === TOKEN_IDENT) {
+        let text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+        if (this.is_and_or_not(text)) {
+          let op = this.arena.create_node();
+          this.arena.set_type(op, NODE_PRELUDE_OPERATOR);
+          this.arena.set_start_offset(op, this.lexer.token_start);
+          this.arena.set_length(op, this.lexer.token_end - this.lexer.token_start);
+          this.arena.set_start_line(op, this.lexer.token_line);
+          components.push(op);
+        } else {
+          let media_type = this.arena.create_node();
+          this.arena.set_type(media_type, NODE_PRELUDE_MEDIA_TYPE);
+          this.arena.set_start_offset(media_type, this.lexer.token_start);
+          this.arena.set_length(media_type, this.lexer.token_end - this.lexer.token_start);
+          this.arena.set_start_line(media_type, this.lexer.token_line);
+          this.arena.set_start_column(media_type, this.lexer.token_column);
+          components.push(media_type);
+        }
+      } else {
+        break;
+      }
+    }
+    if (components.length === 0) return null;
+    let query_node = this.arena.create_node();
+    this.arena.set_type(query_node, NODE_PRELUDE_MEDIA_QUERY);
+    this.arena.set_start_offset(query_node, query_start);
+    this.arena.set_length(query_node, this.lexer.pos - query_start);
+    this.arena.set_start_line(query_node, query_line);
+    for (let component of components) {
+      this.arena.append_child(query_node, component);
+    }
+    return query_node;
+  }
+  // Parse media feature: (min-width: 768px)
+  parse_media_feature() {
+    let feature_start = this.lexer.token_start;
+    let feature_line = this.lexer.token_line;
+    let depth = 1;
+    let content_start = this.lexer.pos;
+    while (this.lexer.pos < this.prelude_end && depth > 0) {
+      this.next_token();
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_LEFT_PAREN) {
+        depth++;
+      } else if (token_type === TOKEN_RIGHT_PAREN) {
+        depth--;
+      }
+    }
+    if (depth !== 0) return null;
+    let content_end = this.lexer.token_start;
+    let feature_end = this.lexer.token_end;
+    let feature = this.arena.create_node();
+    this.arena.set_type(feature, NODE_PRELUDE_MEDIA_FEATURE);
+    this.arena.set_start_offset(feature, feature_start);
+    this.arena.set_length(feature, feature_end - feature_start);
+    this.arena.set_start_line(feature, feature_line);
+    let trimmed = trim_boundaries(this.source, content_start, content_end);
+    if (trimmed) {
+      this.arena.set_value_start(feature, trimmed[0]);
+      this.arena.set_value_length(feature, trimmed[1] - trimmed[0]);
+    }
+    return feature;
+  }
+  // Parse container query: [name] and (min-width: 400px)
+  parse_container_query() {
+    let nodes = [];
+    let query_start = this.lexer.pos;
+    let query_line = this.lexer.line;
+    let components = [];
+    while (this.lexer.pos < this.prelude_end) {
+      this.skip_whitespace();
+      if (this.lexer.pos >= this.prelude_end) break;
+      this.next_token();
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_LEFT_PAREN) {
+        let feature = this.parse_media_feature();
+        if (feature !== null) {
+          components.push(feature);
+        }
+      } else if (token_type === TOKEN_IDENT) {
+        let text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+        if (this.is_and_or_not(text)) {
+          let op = this.arena.create_node();
+          this.arena.set_type(op, NODE_PRELUDE_OPERATOR);
+          this.arena.set_start_offset(op, this.lexer.token_start);
+          this.arena.set_length(op, this.lexer.token_end - this.lexer.token_start);
+          this.arena.set_start_line(op, this.lexer.token_line);
+          components.push(op);
+        } else {
+          let name = this.arena.create_node();
+          this.arena.set_type(name, NODE_PRELUDE_IDENTIFIER);
+          this.arena.set_start_offset(name, this.lexer.token_start);
+          this.arena.set_length(name, this.lexer.token_end - this.lexer.token_start);
+          this.arena.set_start_line(name, this.lexer.token_line);
+          components.push(name);
+        }
+      }
+    }
+    if (components.length === 0) return [];
+    let query_node = this.arena.create_node();
+    this.arena.set_type(query_node, NODE_PRELUDE_CONTAINER_QUERY);
+    this.arena.set_start_offset(query_node, query_start);
+    this.arena.set_length(query_node, this.lexer.pos - query_start);
+    this.arena.set_start_line(query_node, query_line);
+    for (let component of components) {
+      this.arena.append_child(query_node, component);
+    }
+    nodes.push(query_node);
+    return nodes;
+  }
+  // Parse supports query: (display: flex) and (gap: 1rem)
+  parse_supports_query() {
+    let nodes = [];
+    while (this.lexer.pos < this.prelude_end) {
+      this.skip_whitespace();
+      if (this.lexer.pos >= this.prelude_end) break;
+      this.next_token();
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_LEFT_PAREN) {
+        let feature_start = this.lexer.token_start;
+        let feature_line = this.lexer.token_line;
+        let depth = 1;
+        let content_start = this.lexer.pos;
+        while (this.lexer.pos < this.prelude_end && depth > 0) {
+          this.next_token();
+          let inner_token_type = this.lexer.token_type;
+          if (inner_token_type === TOKEN_LEFT_PAREN) {
+            depth++;
+          } else if (inner_token_type === TOKEN_RIGHT_PAREN) {
+            depth--;
+          }
+        }
+        if (depth === 0) {
+          let content_end = this.lexer.token_start;
+          let feature_end = this.lexer.token_end;
+          let query = this.arena.create_node();
+          this.arena.set_type(query, NODE_PRELUDE_SUPPORTS_QUERY);
+          this.arena.set_start_offset(query, feature_start);
+          this.arena.set_length(query, feature_end - feature_start);
+          this.arena.set_start_line(query, feature_line);
+          let trimmed = trim_boundaries(this.source, content_start, content_end);
+          if (trimmed) {
+            this.arena.set_value_start(query, trimmed[0]);
+            this.arena.set_value_length(query, trimmed[1] - trimmed[0]);
+          }
+          nodes.push(query);
+        }
+      } else if (token_type === TOKEN_IDENT) {
+        let text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+        if (this.is_and_or_not(text)) {
+          let op = this.arena.create_node();
+          this.arena.set_type(op, NODE_PRELUDE_OPERATOR);
+          this.arena.set_start_offset(op, this.lexer.token_start);
+          this.arena.set_length(op, this.lexer.token_end - this.lexer.token_start);
+          this.arena.set_start_line(op, this.lexer.token_line);
+          nodes.push(op);
+        }
+      }
+    }
+    return nodes;
+  }
+  // Parse layer names: base, components, utilities
+  parse_layer_names() {
+    let nodes = [];
+    while (this.lexer.pos < this.prelude_end) {
+      this.skip_whitespace();
+      if (this.lexer.pos >= this.prelude_end) break;
+      this.next_token();
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_IDENT) {
+        let layer = this.arena.create_node();
+        this.arena.set_type(layer, NODE_PRELUDE_LAYER_NAME);
+        this.arena.set_start_offset(layer, this.lexer.token_start);
+        this.arena.set_length(layer, this.lexer.token_end - this.lexer.token_start);
+        this.arena.set_start_line(layer, this.lexer.token_line);
+        nodes.push(layer);
+      } else if (token_type === TOKEN_COMMA) {
+        continue;
+      } else if (token_type === TOKEN_WHITESPACE) {
+        continue;
+      }
+    }
+    return nodes;
+  }
+  // Parse single identifier: keyframe name, property name
+  parse_identifier() {
+    this.skip_whitespace();
+    if (this.lexer.pos >= this.prelude_end) return [];
+    this.next_token();
+    if (this.lexer.token_type !== TOKEN_IDENT) return [];
+    let ident = this.arena.create_node();
+    this.arena.set_type(ident, NODE_PRELUDE_IDENTIFIER);
+    this.arena.set_start_offset(ident, this.lexer.token_start);
+    this.arena.set_length(ident, this.lexer.token_end - this.lexer.token_start);
+    this.arena.set_start_line(ident, this.lexer.token_line);
+    return [ident];
+  }
+  // Parse @import prelude: url() [layer] [supports()] [media-query-list]
+  // @import url("styles.css") layer(base) supports(display: grid) screen and (min-width: 768px);
+  parse_import_prelude() {
+    let nodes = [];
+    this.skip_whitespace();
+    if (this.lexer.pos >= this.prelude_end) return [];
+    let url_node = this.parse_import_url();
+    if (url_node !== null) {
+      nodes.push(url_node);
+    } else {
+      return [];
+    }
+    this.skip_whitespace();
+    if (this.lexer.pos >= this.prelude_end) return nodes;
+    let layer_node = this.parse_import_layer();
+    if (layer_node !== null) {
+      nodes.push(layer_node);
+    }
+    this.skip_whitespace();
+    if (this.lexer.pos >= this.prelude_end) return nodes;
+    let supports_node = this.parse_import_supports();
+    if (supports_node !== null) {
+      nodes.push(supports_node);
+    }
+    this.skip_whitespace();
+    if (this.lexer.pos >= this.prelude_end) return nodes;
+    let media_nodes = this.parse_media_query_list();
+    nodes.push(...media_nodes);
+    return nodes;
+  }
+  // Parse import URL: url("file.css") or "file.css"
+  parse_import_url() {
+    this.next_token();
+    if (this.lexer.token_type !== TOKEN_URL && this.lexer.token_type !== TOKEN_FUNCTION && this.lexer.token_type !== TOKEN_STRING) {
+      return null;
+    }
+    let url_start = this.lexer.token_start;
+    let url_end = this.lexer.token_end;
+    let url_line = this.lexer.token_line;
+    if (this.lexer.token_type === TOKEN_FUNCTION) {
+      let paren_depth = 1;
+      while (this.lexer.pos < this.prelude_end && paren_depth > 0) {
+        let tokenType = this.next_token();
+        if (tokenType === TOKEN_LEFT_PAREN || tokenType === TOKEN_FUNCTION) {
+          paren_depth++;
+        } else if (tokenType === TOKEN_RIGHT_PAREN) {
+          paren_depth--;
+          if (paren_depth === 0) {
+            url_end = this.lexer.token_end;
+          }
+        } else if (tokenType === TOKEN_EOF) {
+          break;
+        }
+      }
+    }
+    let url_node = this.arena.create_node();
+    this.arena.set_type(url_node, NODE_PRELUDE_IMPORT_URL);
+    this.arena.set_start_offset(url_node, url_start);
+    this.arena.set_length(url_node, url_end - url_start);
+    this.arena.set_start_line(url_node, url_line);
+    return url_node;
+  }
+  // Parse import layer: layer or layer(name)
+  parse_import_layer() {
+    const saved = this.lexer.save_position();
+    this.next_token();
+    if (this.lexer.token_type === TOKEN_IDENT || this.lexer.token_type === TOKEN_FUNCTION) {
+      let text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+      if (this.lexer.token_type === TOKEN_FUNCTION && text.endsWith("(")) {
+        text = text.slice(0, -1);
+      }
+      if (str_equals("layer", text)) {
+        let layer_start = this.lexer.token_start;
+        let layer_end = this.lexer.token_end;
+        let layer_line = this.lexer.token_line;
+        let content_start = 0;
+        let content_length = 0;
+        if (this.lexer.token_type === TOKEN_FUNCTION) {
+          content_start = this.lexer.pos;
+          let paren_depth = 1;
+          while (this.lexer.pos < this.prelude_end && paren_depth > 0) {
+            let tokenType = this.next_token();
+            if (tokenType === TOKEN_LEFT_PAREN || tokenType === TOKEN_FUNCTION) {
+              paren_depth++;
+            } else if (tokenType === TOKEN_RIGHT_PAREN) {
+              paren_depth--;
+              if (paren_depth === 0) {
+                content_length = this.lexer.token_start - content_start;
+                layer_end = this.lexer.token_end;
+              }
+            } else if (tokenType === TOKEN_EOF) {
+              break;
+            }
+          }
+        }
+        let layer_node = this.arena.create_node();
+        this.arena.set_type(layer_node, NODE_PRELUDE_IMPORT_LAYER);
+        this.arena.set_start_offset(layer_node, layer_start);
+        this.arena.set_length(layer_node, layer_end - layer_start);
+        this.arena.set_start_line(layer_node, layer_line);
+        if (content_length > 0) {
+          let trimmed = trim_boundaries(this.source, content_start, content_start + content_length);
+          if (trimmed) {
+            this.arena.set_content_start(layer_node, trimmed[0]);
+            this.arena.set_content_length(layer_node, trimmed[1] - trimmed[0]);
+          }
+        }
+        return layer_node;
+      }
+    }
+    this.lexer.restore_position(saved);
+    return null;
+  }
+  // Parse import supports: supports(condition)
+  parse_import_supports() {
+    const saved = this.lexer.save_position();
+    this.next_token();
+    if (this.lexer.token_type === TOKEN_FUNCTION) {
+      let text = this.source.substring(this.lexer.token_start, this.lexer.token_end - 1);
+      if (str_equals("supports", text)) {
+        let supports_start = this.lexer.token_start;
+        let supports_line = this.lexer.token_line;
+        let paren_depth = 1;
+        let supports_end = this.lexer.token_end;
+        while (this.lexer.pos < this.prelude_end && paren_depth > 0) {
+          let tokenType = this.next_token();
+          if (tokenType === TOKEN_LEFT_PAREN || tokenType === TOKEN_FUNCTION) {
+            paren_depth++;
+          } else if (tokenType === TOKEN_RIGHT_PAREN) {
+            paren_depth--;
+            if (paren_depth === 0) {
+              supports_end = this.lexer.token_end;
+            }
+          } else if (tokenType === TOKEN_EOF) {
+            break;
+          }
+        }
+        let supports_node = this.arena.create_node();
+        this.arena.set_type(supports_node, NODE_PRELUDE_IMPORT_SUPPORTS);
+        this.arena.set_start_offset(supports_node, supports_start);
+        this.arena.set_length(supports_node, supports_end - supports_start);
+        this.arena.set_start_line(supports_node, supports_line);
+        return supports_node;
+      }
+    }
+    this.lexer.restore_position(saved);
+    return null;
+  }
+  // Helper: Skip whitespace
+  skip_whitespace() {
+    this.lexer.pos = skip_whitespace_forward(this.source, this.lexer.pos, this.prelude_end);
+  }
+  // Helper: Peek at next token type without consuming
+  peek_token_type() {
+    const saved = this.lexer.save_position();
+    this.next_token();
+    let type = this.lexer.token_type;
+    this.lexer.restore_position(saved);
+    return type;
+  }
+  // Helper: Get next token
+  next_token() {
+    if (this.lexer.pos >= this.prelude_end) {
+      this.lexer.token_type = TOKEN_EOF;
+      return TOKEN_EOF;
+    }
+    return this.lexer.next_token_fast(false);
+  }
+}
 function parse_atrule_prelude(at_rule_name, prelude) {
   const arena = new CSSDataArena(CSSDataArena.capacity_for_source(prelude.length));
   const prelude_parser = new AtRulePreludeParser(arena, prelude);
@@ -8,4 +457,4 @@ function parse_atrule_prelude(at_rule_name, prelude) {
   return node_indices.map((index) => new CSSNode(arena, prelude, index));
 }
 
-export { parse_atrule_prelude };
+export { AtRulePreludeParser, parse_atrule_prelude };

package/dist/parse-selector.d.ts

@@ -1,4 +1,34 @@
+import { CSSDataArena } from './arena';
 import { CSSNode } from './css-node';
+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, column?: number, allow_relative?: boolean): 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_attribute_content;
+    private parse_pseudo;
+    private parse_pseudo_function;
+    private parse_pseudo_function_after_colon;
+    private is_nth_pseudo;
+    private parse_lang_identifiers;
+    private parse_nth_expression;
+    private find_of_keyword;
+    private create_type_selector;
+    private create_id_selector;
+    private create_universal_selector;
+    private create_nesting_selector;
+    private create_combinator;
+    private skip_whitespace;
+}
 /**
  * Parse a CSS selector string and return an AST
  * @param source - The CSS selector to parse (e.g., "div.class > p#id")