@projectwallace/css-parser 0.1.0

package/README.md

@@ -0,0 +1,72 @@
+# CSS Parser
+
+**High-performance CSS parser optimized for static analysis and formatting**
+
+Built for speed and efficiency, this parser handles large CSS files with minimal memory overhead and blazing-fast parse times. Designed with a data-oriented architecture using a single contiguous memory arena for zero allocations during parsing.
+
+## Features
+
+- **Modern CSS support** - CSS Nesting, `:is()`, `:where()`, `:has()`, `@layer`, `@container`
+- **Error recovery** - Continues parsing on malformed CSS
+- **Comment preservation** - Comments stored as first-class AST nodes
+- **Location tracking** - Line, column, offset, and length for all nodes
+- **Vendor prefix detection** - Automatic detection of `-webkit-`, `-moz-`, etc.
+- **Structured parsing** - Deep parsing of selectors, values, and at-rule preludes
+
+## Performance
+
+- **Tiny install size**
+- **Zero allocations during parsing** - all memory allocated upfront based on real world heuristics, which also helps prevent garbage collection running often
+- **Cache-friendly data layout** - contiguous memory for sequential access
+- **First-class comment and location support** - while still being performant because analysis requires constant access to lines and columns
+- **No syntax validation** - focusing only on the raw data we can skip expensive syntax files and MDN data syncs
+
+This parser was heavily influenced by [CSSTree](https://github.com/csstree/csstree), one of the most robust CSS parsers available.
+
+## Installation
+
+```bash
+npm install @projectwallace/css-parser
+```
+
+## Usage
+
+```typescript
+import { parse, NODE_STYLE_RULE, NODE_DECLARATION } from '@projectwallace/css-parser'
+
+const ast = parse(`
+  body {
+    color: red;
+    margin: 0;
+  }
+
+  @media (min-width: 768px) {
+    .container {
+      max-width: 1200px;
+    }
+  }
+`)
+
+// Iterate over top-level rules
+for (const rule of ast) {
+	if (rule.type === NODE_STYLE_RULE) {
+		const selector = rule.first_child
+		console.log(`Selector: ${selector.text}`)
+
+		// Iterate over declarations
+		for (const node of rule) {
+			if (node.type === NODE_DECLARATION) {
+				console.log(`  ${node.property}: ${node.value}`)
+			}
+		}
+	}
+}
+```
+
+## Documentation
+
+See [API.md](./API.md) for complete documentation of all parser functions and options.
+
+## License
+
+MIT

package/dist/arena.d.ts

@@ -0,0 +1,84 @@
+export declare const NODE_STYLESHEET = 1;
+export declare const NODE_STYLE_RULE = 2;
+export declare const NODE_AT_RULE = 3;
+export declare const NODE_DECLARATION = 4;
+export declare const NODE_SELECTOR = 5;
+export declare const NODE_COMMENT = 6;
+export declare const NODE_VALUE_KEYWORD = 10;
+export declare const NODE_VALUE_NUMBER = 11;
+export declare const NODE_VALUE_DIMENSION = 12;
+export declare const NODE_VALUE_STRING = 13;
+export declare const NODE_VALUE_COLOR = 14;
+export declare const NODE_VALUE_FUNCTION = 15;
+export declare const NODE_VALUE_OPERATOR = 16;
+export declare const NODE_SELECTOR_LIST = 20;
+export declare const NODE_SELECTOR_TYPE = 21;
+export declare const NODE_SELECTOR_CLASS = 22;
+export declare const NODE_SELECTOR_ID = 23;
+export declare const NODE_SELECTOR_ATTRIBUTE = 24;
+export declare const NODE_SELECTOR_PSEUDO_CLASS = 25;
+export declare const NODE_SELECTOR_PSEUDO_ELEMENT = 26;
+export declare const NODE_SELECTOR_COMBINATOR = 27;
+export declare const NODE_SELECTOR_UNIVERSAL = 28;
+export declare const NODE_SELECTOR_NESTING = 29;
+export declare const NODE_PRELUDE_MEDIA_QUERY = 30;
+export declare const NODE_PRELUDE_MEDIA_FEATURE = 31;
+export declare const NODE_PRELUDE_MEDIA_TYPE = 32;
+export declare const NODE_PRELUDE_CONTAINER_QUERY = 33;
+export declare const NODE_PRELUDE_SUPPORTS_QUERY = 34;
+export declare const NODE_PRELUDE_LAYER_NAME = 35;
+export declare const NODE_PRELUDE_IDENTIFIER = 36;
+export declare const NODE_PRELUDE_OPERATOR = 37;
+export declare const NODE_PRELUDE_IMPORT_URL = 38;
+export declare const NODE_PRELUDE_IMPORT_LAYER = 39;
+export declare const NODE_PRELUDE_IMPORT_SUPPORTS = 40;
+export declare const FLAG_IMPORTANT: number;
+export declare const FLAG_HAS_ERROR: number;
+export declare const FLAG_LENGTH_OVERFLOW: number;
+export declare const FLAG_HAS_BLOCK: number;
+export declare class CSSDataArena {
+    private buffer;
+    private view;
+    private capacity;
+    private count;
+    private static readonly GROWTH_FACTOR;
+    private static readonly NODES_PER_KB;
+    private static readonly CAPACITY_BUFFER;
+    constructor(initial_capacity?: number);
+    static capacity_for_source(source_length: number): number;
+    get_count(): number;
+    get_capacity(): number;
+    private node_offset;
+    get_type(node_index: number): number;
+    get_flags(node_index: number): number;
+    get_start_offset(node_index: number): number;
+    get_length(node_index: number): number;
+    get_content_start(node_index: number): number;
+    get_content_length(node_index: number): number;
+    get_first_child(node_index: number): number;
+    get_last_child(node_index: number): number;
+    get_next_sibling(node_index: number): number;
+    get_start_line(node_index: number): number;
+    get_value_start(node_index: number): number;
+    get_value_length(node_index: number): number;
+    set_type(node_index: number, type: number): void;
+    set_flags(node_index: number, flags: number): void;
+    set_start_offset(node_index: number, offset: number): void;
+    set_length(node_index: number, length: number): void;
+    set_content_start(node_index: number, offset: number): void;
+    set_content_length(node_index: number, length: number): void;
+    set_first_child(node_index: number, childIndex: number): void;
+    set_last_child(node_index: number, childIndex: number): void;
+    set_next_sibling(node_index: number, siblingIndex: number): void;
+    set_start_line(node_index: number, line: number): void;
+    set_value_start(node_index: number, offset: number): void;
+    set_value_length(node_index: number, length: number): void;
+    private grow;
+    create_node(): number;
+    append_child(parentIndex: number, childIndex: number): void;
+    has_children(node_index: number): boolean;
+    has_next_sibling(node_index: number): boolean;
+    set_flag(node_index: number, flag: number): void;
+    clear_flag(node_index: number, flag: number): void;
+    has_flag(node_index: number, flag: number): boolean;
+}

package/dist/at-rule-prelude-parser-DlqYQAYH.js

@@ -0,0 +1,464 @@
+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-DXablYMZ.js';
+import { O as str_equals, E as NODE_PRELUDE_OPERATOR, y as NODE_PRELUDE_MEDIA_TYPE, w as NODE_PRELUDE_MEDIA_QUERY, x as NODE_PRELUDE_MEDIA_FEATURE, M as trim_boundaries, D as NODE_PRELUDE_IDENTIFIER, z as NODE_PRELUDE_CONTAINER_QUERY, A as NODE_PRELUDE_SUPPORTS_QUERY, B as NODE_PRELUDE_LAYER_NAME, F as NODE_PRELUDE_IMPORT_URL, G as NODE_PRELUDE_IMPORT_LAYER, H as NODE_PRELUDE_IMPORT_SUPPORTS, P as CHAR_SPACE, Q as CHAR_TAB, R as CHAR_NEWLINE, S as CHAR_CARRIAGE_RETURN, T as CHAR_FORM_FEED } from './string-utils-B-rJII-E.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) {
+    this.prelude_end = end;
+    this.lexer.pos = start;
+    this.lexer.line = line;
+    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);
+          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) {
+          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() {
+    let saved_pos = this.lexer.pos;
+    let saved_line = this.lexer.line;
+    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) {
+              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.pos = saved_pos;
+    this.lexer.line = saved_line;
+    return null;
+  }
+  // Parse import supports: supports(condition)
+  parse_import_supports() {
+    let saved_pos = this.lexer.pos;
+    let saved_line = this.lexer.line;
+    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) {
+            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.pos = saved_pos;
+    this.lexer.line = saved_line;
+    return null;
+  }
+  // Helper: Skip whitespace
+  skip_whitespace() {
+    while (this.lexer.pos < this.prelude_end) {
+      let ch = this.source.charCodeAt(this.lexer.pos);
+      if (ch !== CHAR_SPACE && ch !== CHAR_TAB && ch !== CHAR_NEWLINE && ch !== CHAR_CARRIAGE_RETURN && ch !== CHAR_FORM_FEED) {
+        break;
+      }
+      this.lexer.pos++;
+    }
+  }
+  // Helper: Peek at next token type without consuming
+  peek_token_type() {
+    let saved_pos = this.lexer.pos;
+    let saved_line = this.lexer.line;
+    this.next_token();
+    let type = this.lexer.token_type;
+    this.lexer.pos = saved_pos;
+    this.lexer.line = saved_line;
+    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);
+  }
+}
+
+export { AtRulePreludeParser as A };

package/dist/at-rule-prelude-parser.d.ts

@@ -0,0 +1,24 @@
+import type { CSSDataArena } from './arena';
+export declare class AtRulePreludeParser {
+    private lexer;
+    private arena;
+    private source;
+    private prelude_end;
+    constructor(arena: CSSDataArena, source: string);
+    parse_prelude(at_rule_name: string, start: number, end: number, line?: number): number[];
+    private parse_media_query_list;
+    private is_and_or_not;
+    private parse_single_media_query;
+    private parse_media_feature;
+    private parse_container_query;
+    private parse_supports_query;
+    private parse_layer_names;
+    private parse_identifier;
+    private parse_import_prelude;
+    private parse_import_url;
+    private parse_import_layer;
+    private parse_import_supports;
+    private skip_whitespace;
+    private peek_token_type;
+    private next_token;
+}

package/dist/char-types.d.ts

@@ -0,0 +1,7 @@
+export declare function is_digit(ch: number): boolean;
+export declare function is_hex_digit(ch: number): boolean;
+export declare function is_alpha(ch: number): boolean;
+export declare function is_whitespace(ch: number): boolean;
+export declare function is_newline(ch: number): boolean;
+export declare function is_ident_start(ch: number): boolean;
+export declare function is_ident_char(ch: number): boolean;

package/dist/css-node.d.ts

@@ -0,0 +1,31 @@
+import type { CSSDataArena } from './arena';
+import { NODE_STYLESHEET, NODE_STYLE_RULE, NODE_AT_RULE, NODE_DECLARATION, NODE_SELECTOR, NODE_COMMENT, NODE_VALUE_KEYWORD, NODE_VALUE_NUMBER, NODE_VALUE_DIMENSION, NODE_VALUE_STRING, NODE_VALUE_COLOR, NODE_VALUE_FUNCTION, NODE_VALUE_OPERATOR, NODE_SELECTOR_LIST, NODE_SELECTOR_TYPE, NODE_SELECTOR_CLASS, NODE_SELECTOR_ID, NODE_SELECTOR_ATTRIBUTE, NODE_SELECTOR_PSEUDO_CLASS, NODE_SELECTOR_PSEUDO_ELEMENT, NODE_SELECTOR_COMBINATOR, NODE_SELECTOR_UNIVERSAL, NODE_SELECTOR_NESTING, NODE_PRELUDE_MEDIA_QUERY, NODE_PRELUDE_MEDIA_FEATURE, NODE_PRELUDE_MEDIA_TYPE, NODE_PRELUDE_CONTAINER_QUERY, NODE_PRELUDE_SUPPORTS_QUERY, NODE_PRELUDE_LAYER_NAME, NODE_PRELUDE_IDENTIFIER, NODE_PRELUDE_OPERATOR, NODE_PRELUDE_IMPORT_URL, NODE_PRELUDE_IMPORT_LAYER, NODE_PRELUDE_IMPORT_SUPPORTS } from './arena';
+export type CSSNodeType = typeof NODE_STYLESHEET | typeof NODE_STYLE_RULE | typeof NODE_AT_RULE | typeof NODE_DECLARATION | typeof NODE_SELECTOR | typeof NODE_COMMENT | typeof NODE_VALUE_KEYWORD | typeof NODE_VALUE_NUMBER | typeof NODE_VALUE_DIMENSION | typeof NODE_VALUE_STRING | typeof NODE_VALUE_COLOR | typeof NODE_VALUE_FUNCTION | typeof NODE_VALUE_OPERATOR | typeof NODE_SELECTOR_LIST | typeof NODE_SELECTOR_TYPE | typeof NODE_SELECTOR_CLASS | typeof NODE_SELECTOR_ID | typeof NODE_SELECTOR_ATTRIBUTE | typeof NODE_SELECTOR_PSEUDO_CLASS | typeof NODE_SELECTOR_PSEUDO_ELEMENT | typeof NODE_SELECTOR_COMBINATOR | typeof NODE_SELECTOR_UNIVERSAL | typeof NODE_SELECTOR_NESTING | typeof NODE_PRELUDE_MEDIA_QUERY | typeof NODE_PRELUDE_MEDIA_FEATURE | typeof NODE_PRELUDE_MEDIA_TYPE | typeof NODE_PRELUDE_CONTAINER_QUERY | typeof NODE_PRELUDE_SUPPORTS_QUERY | typeof NODE_PRELUDE_LAYER_NAME | typeof NODE_PRELUDE_IDENTIFIER | typeof NODE_PRELUDE_OPERATOR | typeof NODE_PRELUDE_IMPORT_URL | typeof NODE_PRELUDE_IMPORT_LAYER | typeof NODE_PRELUDE_IMPORT_SUPPORTS;
+export declare class CSSNode {
+    private arena;
+    private source;
+    private index;
+    constructor(arena: CSSDataArena, source: string, index: number);
+    get_index(): number;
+    get type(): CSSNodeType;
+    get text(): string;
+    get name(): string;
+    get property(): string;
+    get value(): string | null;
+    get prelude(): string | null;
+    get is_important(): boolean;
+    get is_vendor_prefixed(): boolean;
+    get has_error(): boolean;
+    get has_prelude(): boolean;
+    get has_block(): boolean;
+    get values(): CSSNode[];
+    get value_count(): number;
+    get line(): number;
+    get offset(): number;
+    get length(): number;
+    get first_child(): CSSNode | null;
+    get next_sibling(): CSSNode | null;
+    get has_children(): boolean;
+    get children(): CSSNode[];
+    [Symbol.iterator](): Iterator<CSSNode>;
+}