@projectwallace/css-parser 0.5.0 → 0.6.0

package/dist/parse-value.d.ts

@@ -0,0 +1,22 @@
+import { CSSDataArena } from './arena';
+import { CSSNode } from './css-node';
+export declare class ValueParser {
+    private lexer;
+    private arena;
+    private source;
+    private value_end;
+    constructor(arena: CSSDataArena, source: string);
+    parse_value(start: number, end: number): number[];
+    private is_whitespace_token;
+    private parse_value_node;
+    private create_node;
+    private create_operator_node;
+    private parse_operator_node;
+    private parse_function_node;
+}
+/**
+ * Parse a CSS declaration value string and return an array of value AST nodes
+ * @param value_string - The CSS value to parse (e.g., "1px solid red")
+ * @returns An array of CSSNode objects representing the parsed value
+ */
+export declare function parse_value(value_string: string): CSSNode[];

package/dist/parse-value.js

@@ -0,0 +1,142 @@
+import { L as Lexer, y as TOKEN_EOF, q as TOKEN_COMMA, h as TOKEN_DELIM, a as TOKEN_FUNCTION, c as TOKEN_HASH, d as TOKEN_STRING, k as TOKEN_DIMENSION, j as TOKEN_PERCENTAGE, i as TOKEN_NUMBER, T as TOKEN_IDENT, t as TOKEN_LEFT_PAREN, u as TOKEN_RIGHT_PAREN } from './lexer-CtBKgfVv.js';
+import { T as CSSDataArena, C as CSSNode, a5 as is_whitespace, r as NODE_VALUE_OPERATOR, p as NODE_VALUE_COLOR, o as NODE_VALUE_STRING, n as NODE_VALUE_DIMENSION, m as NODE_VALUE_NUMBER, l as NODE_VALUE_KEYWORD, a0 as CHAR_PLUS, ai as CHAR_MINUS_HYPHEN, a3 as CHAR_ASTERISK, aj as CHAR_FORWARD_SLASH, q as NODE_VALUE_FUNCTION } from './css-node-BzCSxoLM.js';
+
+class ValueParser {
+  lexer;
+  arena;
+  source;
+  value_end;
+  constructor(arena, source) {
+    this.arena = arena;
+    this.source = source;
+    this.lexer = new Lexer(source, false);
+    this.value_end = 0;
+  }
+  // Parse a declaration value range into value nodes
+  // Returns array of value node indices
+  parse_value(start, end) {
+    this.value_end = end;
+    this.lexer.pos = start;
+    this.lexer.line = 1;
+    let nodes = [];
+    while (this.lexer.pos < this.value_end) {
+      this.lexer.next_token_fast(false);
+      if (this.lexer.token_start >= this.value_end) break;
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_EOF) break;
+      if (this.is_whitespace_token()) {
+        continue;
+      }
+      let node = this.parse_value_node();
+      if (node !== null) {
+        nodes.push(node);
+      }
+    }
+    return nodes;
+  }
+  is_whitespace_token() {
+    let start = this.lexer.token_start;
+    let end = this.lexer.token_end;
+    if (start >= end) return false;
+    for (let i = start; i < end; i++) {
+      let ch = this.source.charCodeAt(i);
+      if (!is_whitespace(ch)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  parse_value_node() {
+    let token_type = this.lexer.token_type;
+    let start = this.lexer.token_start;
+    let end = this.lexer.token_end;
+    switch (token_type) {
+      case TOKEN_IDENT:
+        return this.create_node(NODE_VALUE_KEYWORD, start, end);
+      case TOKEN_NUMBER:
+        return this.create_node(NODE_VALUE_NUMBER, start, end);
+      case TOKEN_PERCENTAGE:
+      case TOKEN_DIMENSION:
+        return this.create_node(NODE_VALUE_DIMENSION, start, end);
+      case TOKEN_STRING:
+        return this.create_node(NODE_VALUE_STRING, start, end);
+      case TOKEN_HASH:
+        return this.create_node(NODE_VALUE_COLOR, start, end);
+      case TOKEN_FUNCTION:
+        return this.parse_function_node(start, end);
+      case TOKEN_DELIM:
+        return this.parse_operator_node(start, end);
+      case TOKEN_COMMA:
+        return this.create_node(NODE_VALUE_OPERATOR, start, end);
+      default:
+        return null;
+    }
+  }
+  create_node(node_type, start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, node_type);
+    this.arena.set_start_offset(node, start);
+    this.arena.set_length(node, end - start);
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, end - start);
+    return node;
+  }
+  create_operator_node(start, end) {
+    return this.create_node(NODE_VALUE_OPERATOR, start, end);
+  }
+  parse_operator_node(start, end) {
+    let ch = this.source.charCodeAt(start);
+    if (ch === CHAR_PLUS || ch === CHAR_MINUS_HYPHEN || ch === CHAR_ASTERISK || ch === CHAR_FORWARD_SLASH) {
+      return this.create_operator_node(start, end);
+    }
+    return null;
+  }
+  parse_function_node(start, end) {
+    let node = this.arena.create_node();
+    this.arena.set_type(node, NODE_VALUE_FUNCTION);
+    this.arena.set_start_offset(node, start);
+    let name_end = end - 1;
+    this.arena.set_content_start(node, start);
+    this.arena.set_content_length(node, name_end - start);
+    let args = [];
+    let paren_depth = 1;
+    let func_end = end;
+    while (this.lexer.pos < this.value_end && paren_depth > 0) {
+      this.lexer.next_token_fast(false);
+      let token_type = this.lexer.token_type;
+      if (token_type === TOKEN_EOF) break;
+      if (this.lexer.token_start >= this.value_end) break;
+      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) {
+          func_end = this.lexer.token_end;
+          break;
+        }
+      }
+      if (this.is_whitespace_token()) continue;
+      let arg_node = this.parse_value_node();
+      if (arg_node !== null) {
+        args.push(arg_node);
+      }
+    }
+    this.arena.set_length(node, func_end - start);
+    if (args.length > 0) {
+      this.arena.set_first_child(node, args[0]);
+      this.arena.set_last_child(node, args[args.length - 1]);
+      for (let i = 0; i < args.length - 1; i++) {
+        this.arena.set_next_sibling(args[i], args[i + 1]);
+      }
+    }
+    return node;
+  }
+}
+function parse_value(value_string) {
+  const arena = new CSSDataArena(CSSDataArena.capacity_for_source(value_string.length));
+  const value_parser = new ValueParser(arena, value_string);
+  const node_indices = value_parser.parse_value(0, value_string.length);
+  return node_indices.map((index) => new CSSNode(arena, value_string, index));
+}
+
+export { ValueParser, parse_value };

package/dist/parse.d.ts

@@ -1,5 +1,36 @@
-import type { ParserOptions } from './parser';
-import type { CSSNode } from './css-node';
+import { CSSDataArena } from './arena';
+import { CSSNode } from './css-node';
+export interface ParserOptions {
+    skip_comments?: boolean;
+    parse_values?: boolean;
+    parse_selectors?: boolean;
+    parse_atrule_preludes?: boolean;
+}
+export declare class Parser {
+    private source;
+    private lexer;
+    private arena;
+    private value_parser;
+    private selector_parser;
+    private prelude_parser;
+    private parse_values_enabled;
+    private parse_selectors_enabled;
+    private parse_atrule_preludes_enabled;
+    constructor(source: string, options?: ParserOptions);
+    get_arena(): CSSDataArena;
+    get_source(): string;
+    private next_token;
+    private peek_type;
+    private is_eof;
+    parse(): CSSNode;
+    private parse_rule;
+    private parse_style_rule;
+    private parse_selector;
+    private parse_declaration;
+    private parse_atrule;
+    private atrule_has_declarations;
+    private atrule_is_conditional;
+}
 /**
  * Parse CSS and return an AST
  * @param source - The CSS source code to parse
@@ -7,3 +38,4 @@ import type { CSSNode } from './css-node';
  * @returns The root CSSNode of the AST
  */
 export declare function parse(source: string, options?: ParserOptions): CSSNode;
+export { NODE_STYLESHEET, NODE_STYLE_RULE, NODE_AT_RULE, NODE_DECLARATION, NODE_SELECTOR, NODE_COMMENT, NODE_BLOCK, 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_SELECTOR_NTH, NODE_SELECTOR_NTH_OF, NODE_SELECTOR_LANG, 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, FLAG_IMPORTANT, } from './arena';

package/dist/parse.js

@@ -1,185 +1,9 @@
-import { L as Lexer, y as TOKEN_EOF, q as TOKEN_COMMA, h as TOKEN_DELIM, a as TOKEN_FUNCTION, c as TOKEN_HASH, d as TOKEN_STRING, k as TOKEN_DIMENSION, j as TOKEN_PERCENTAGE, i as TOKEN_NUMBER, T as TOKEN_IDENT, t as TOKEN_LEFT_PAREN, u as TOKEN_RIGHT_PAREN, b as TOKEN_AT_KEYWORD, v as TOKEN_LEFT_BRACE, w as TOKEN_RIGHT_BRACE, o as TOKEN_COLON, p as TOKEN_SEMICOLON } from './lexer-DXablYMZ.js';
-import { J as is_whitespace, f as NODE_VALUE_KEYWORD, g as NODE_VALUE_NUMBER, h as NODE_VALUE_DIMENSION, i as NODE_VALUE_STRING, j as NODE_VALUE_COLOR, l as NODE_VALUE_OPERATOR, k as NODE_VALUE_FUNCTION, K as CSSDataArena, e as NODE_STYLESHEET, C as CSSNode, N as NODE_STYLE_RULE, L as FLAG_HAS_BLOCK, M as FLAG_HAS_DECLARATIONS, m as NODE_SELECTOR_LIST, c as NODE_DECLARATION, O as is_vendor_prefixed, P as FLAG_VENDOR_PREFIXED, Q as trim_boundaries, I as FLAG_IMPORTANT, a as NODE_AT_RULE } from './string-utils-tMt2O9RW.js';
-import { S as SelectorParser } from './selector-parser-C-u1epDB.js';
-import { A as AtRulePreludeParser } from './at-rule-prelude-parser-Cj8ecgQp.js';
-
-const CH_PLUS = 43;
-const CH_MINUS = 45;
-const CH_ASTERISK = 42;
-const CH_SLASH = 47;
-class ValueParser {
-  lexer;
-  arena;
-  source;
-  value_end;
-  constructor(arena, source) {
-    this.arena = arena;
-    this.source = source;
-    this.lexer = new Lexer(source, false);
-    this.value_end = 0;
-  }
-  // Parse a declaration value range into value nodes
-  // Returns array of value node indices
-  parse_value(start, end) {
-    this.value_end = end;
-    this.lexer.pos = start;
-    this.lexer.line = 1;
-    let nodes = [];
-    while (this.lexer.pos < this.value_end) {
-      this.lexer.next_token_fast(false);
-      if (this.lexer.token_start >= this.value_end) break;
-      let token_type = this.lexer.token_type;
-      if (token_type === TOKEN_EOF) break;
-      if (this.is_whitespace_token()) {
-        continue;
-      }
-      let node = this.parse_value_node();
-      if (node !== null) {
-        nodes.push(node);
-      }
-    }
-    return nodes;
-  }
-  is_whitespace_token() {
-    let start = this.lexer.token_start;
-    let end = this.lexer.token_end;
-    if (start >= end) return false;
-    for (let i = start; i < end; i++) {
-      let ch = this.source.charCodeAt(i);
-      if (!is_whitespace(ch)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  parse_value_node() {
-    let token_type = this.lexer.token_type;
-    let start = this.lexer.token_start;
-    let end = this.lexer.token_end;
-    switch (token_type) {
-      case TOKEN_IDENT:
-        return this.create_keyword_node(start, end);
-      case TOKEN_NUMBER:
-        return this.create_number_node(start, end);
-      case TOKEN_PERCENTAGE:
-      case TOKEN_DIMENSION:
-        return this.create_dimension_node(start, end);
-      case TOKEN_STRING:
-        return this.create_string_node(start, end);
-      case TOKEN_HASH:
-        return this.create_color_node(start, end);
-      case TOKEN_FUNCTION:
-        return this.parse_function_node(start, end);
-      case TOKEN_DELIM:
-        return this.parse_operator_node(start, end);
-      case TOKEN_COMMA:
-        return this.create_operator_node(start, end);
-      default:
-        return null;
-    }
-  }
-  create_keyword_node(start, end) {
-    let node = this.arena.create_node();
-    this.arena.set_type(node, NODE_VALUE_KEYWORD);
-    this.arena.set_start_offset(node, start);
-    this.arena.set_length(node, end - start);
-    this.arena.set_content_start(node, start);
-    this.arena.set_content_length(node, end - start);
-    return node;
-  }
-  create_number_node(start, end) {
-    let node = this.arena.create_node();
-    this.arena.set_type(node, NODE_VALUE_NUMBER);
-    this.arena.set_start_offset(node, start);
-    this.arena.set_length(node, end - start);
-    this.arena.set_content_start(node, start);
-    this.arena.set_content_length(node, end - start);
-    return node;
-  }
-  create_dimension_node(start, end) {
-    let node = this.arena.create_node();
-    this.arena.set_type(node, NODE_VALUE_DIMENSION);
-    this.arena.set_start_offset(node, start);
-    this.arena.set_length(node, end - start);
-    this.arena.set_content_start(node, start);
-    this.arena.set_content_length(node, end - start);
-    return node;
-  }
-  create_string_node(start, end) {
-    let node = this.arena.create_node();
-    this.arena.set_type(node, NODE_VALUE_STRING);
-    this.arena.set_start_offset(node, start);
-    this.arena.set_length(node, end - start);
-    this.arena.set_content_start(node, start);
-    this.arena.set_content_length(node, end - start);
-    return node;
-  }
-  create_color_node(start, end) {
-    let node = this.arena.create_node();
-    this.arena.set_type(node, NODE_VALUE_COLOR);
-    this.arena.set_start_offset(node, start);
-    this.arena.set_length(node, end - start);
-    this.arena.set_content_start(node, start);
-    this.arena.set_content_length(node, end - start);
-    return node;
-  }
-  create_operator_node(start, end) {
-    let node = this.arena.create_node();
-    this.arena.set_type(node, NODE_VALUE_OPERATOR);
-    this.arena.set_start_offset(node, start);
-    this.arena.set_length(node, end - start);
-    this.arena.set_content_start(node, start);
-    this.arena.set_content_length(node, end - start);
-    return node;
-  }
-  parse_operator_node(start, end) {
-    let ch = this.source.charCodeAt(start);
-    if (ch === CH_PLUS || ch === CH_MINUS || ch === CH_ASTERISK || ch === CH_SLASH) {
-      return this.create_operator_node(start, end);
-    }
-    return null;
-  }
-  parse_function_node(start, end) {
-    let node = this.arena.create_node();
-    this.arena.set_type(node, NODE_VALUE_FUNCTION);
-    this.arena.set_start_offset(node, start);
-    let name_end = end - 1;
-    this.arena.set_content_start(node, start);
-    this.arena.set_content_length(node, name_end - start);
-    let args = [];
-    let paren_depth = 1;
-    let func_end = end;
-    while (this.lexer.pos < this.value_end && paren_depth > 0) {
-      this.lexer.next_token_fast(false);
-      let token_type = this.lexer.token_type;
-      if (token_type === TOKEN_EOF) break;
-      if (this.lexer.token_start >= this.value_end) break;
-      if (token_type === TOKEN_LEFT_PAREN) {
-        paren_depth++;
-      } else if (token_type === TOKEN_RIGHT_PAREN) {
-        paren_depth--;
-        if (paren_depth === 0) {
-          func_end = this.lexer.token_end;
-          break;
-        }
-      }
-      if (this.is_whitespace_token()) continue;
-      let arg_node = this.parse_value_node();
-      if (arg_node !== null) {
-        args.push(arg_node);
-      }
-    }
-    this.arena.set_length(node, func_end - start);
-    if (args.length > 0) {
-      this.arena.set_first_child(node, args[0]);
-      this.arena.set_last_child(node, args[args.length - 1]);
-      for (let i = 0; i < args.length - 1; i++) {
-        this.arena.set_next_sibling(args[i], args[i + 1]);
-      }
-    }
-    return node;
-  }
-}
+import { L as Lexer, y as TOKEN_EOF, b as TOKEN_AT_KEYWORD, v as TOKEN_LEFT_BRACE, w as TOKEN_RIGHT_BRACE, T as TOKEN_IDENT, o as TOKEN_COLON, p as TOKEN_SEMICOLON, h as TOKEN_DELIM } from './lexer-CtBKgfVv.js';
+import { T as CSSDataArena, k as NODE_STYLESHEET, C as CSSNode, N as NODE_STYLE_RULE, U as FLAG_HAS_BLOCK, V as NODE_BLOCK, W as FLAG_HAS_DECLARATIONS, s as NODE_SELECTOR_LIST, i as NODE_DECLARATION, X as is_vendor_prefixed, Y as FLAG_VENDOR_PREFIXED, Z as trim_boundaries, S as FLAG_IMPORTANT, g as NODE_AT_RULE } from './css-node-BzCSxoLM.js';
+export { h as NODE_COMMENT, J as NODE_PRELUDE_CONTAINER_QUERY, M as NODE_PRELUDE_IDENTIFIER, Q as NODE_PRELUDE_IMPORT_LAYER, R as NODE_PRELUDE_IMPORT_SUPPORTS, P as NODE_PRELUDE_IMPORT_URL, L as NODE_PRELUDE_LAYER_NAME, H as NODE_PRELUDE_MEDIA_FEATURE, G as NODE_PRELUDE_MEDIA_QUERY, I as NODE_PRELUDE_MEDIA_TYPE, O as NODE_PRELUDE_OPERATOR, K as NODE_PRELUDE_SUPPORTS_QUERY, j as NODE_SELECTOR, w as NODE_SELECTOR_ATTRIBUTE, u as NODE_SELECTOR_CLASS, z as NODE_SELECTOR_COMBINATOR, v as NODE_SELECTOR_ID, _ as NODE_SELECTOR_LANG, D as NODE_SELECTOR_NESTING, E as NODE_SELECTOR_NTH, F as NODE_SELECTOR_NTH_OF, x as NODE_SELECTOR_PSEUDO_CLASS, y as NODE_SELECTOR_PSEUDO_ELEMENT, t as NODE_SELECTOR_TYPE, B as NODE_SELECTOR_UNIVERSAL, p as NODE_VALUE_COLOR, n as NODE_VALUE_DIMENSION, q as NODE_VALUE_FUNCTION, l as NODE_VALUE_KEYWORD, m as NODE_VALUE_NUMBER, r as NODE_VALUE_OPERATOR, o as NODE_VALUE_STRING } from './css-node-BzCSxoLM.js';
+import { ValueParser } from './parse-value.js';
+import { SelectorParser } from './parse-selector.js';
+import { AtRulePreludeParser } from './parse-atrule-prelude.js';
 
 let DECLARATION_AT_RULES = /* @__PURE__ */ new Set(["font-face", "font-feature-values", "page", "property", "counter-style"]);
 let CONDITIONAL_AT_RULES = /* @__PURE__ */ new Set(["media", "supports", "container", "layer", "nest"]);
@@ -273,15 +97,23 @@ class Parser {
     if (this.peek_type() !== TOKEN_LEFT_BRACE) {
       return null;
     }
+    let block_start = this.lexer.token_end;
     this.next_token();
     this.arena.set_flag(style_rule, FLAG_HAS_BLOCK);
+    let block_line = this.lexer.token_line;
+    let block_column = this.lexer.token_column;
+    let block_node = this.arena.create_node();
+    this.arena.set_type(block_node, NODE_BLOCK);
+    this.arena.set_start_offset(block_node, block_start);
+    this.arena.set_start_line(block_node, block_line);
+    this.arena.set_start_column(block_node, block_column);
     while (!this.is_eof()) {
       let token_type = this.peek_type();
       if (token_type === TOKEN_RIGHT_BRACE) break;
       if (token_type === TOKEN_AT_KEYWORD) {
         let nested_at_rule = this.parse_atrule();
         if (nested_at_rule !== null) {
-          this.arena.append_child(style_rule, nested_at_rule);
+          this.arena.append_child(block_node, nested_at_rule);
         } else {
           this.next_token();
         }
@@ -290,21 +122,27 @@ class Parser {
       let declaration = this.parse_declaration();
       if (declaration !== null) {
         this.arena.set_flag(style_rule, FLAG_HAS_DECLARATIONS);
-        this.arena.append_child(style_rule, declaration);
+        this.arena.append_child(block_node, declaration);
         continue;
       }
       let nested_rule = this.parse_style_rule();
       if (nested_rule !== null) {
-        this.arena.append_child(style_rule, nested_rule);
+        this.arena.append_child(block_node, nested_rule);
       } else {
         this.next_token();
       }
     }
+    let block_end = this.lexer.token_start;
+    let rule_end = this.lexer.token_end;
     if (this.peek_type() === TOKEN_RIGHT_BRACE) {
+      block_end = this.lexer.token_start;
+      rule_end = this.lexer.token_end;
       this.next_token();
     }
+    this.arena.set_length(block_node, block_end - block_start);
+    this.arena.append_child(style_rule, block_node);
     this.arena.set_start_offset(style_rule, rule_start);
-    this.arena.set_length(style_rule, this.lexer.token_end - rule_start);
+    this.arena.set_length(style_rule, rule_end - rule_start);
     return style_rule;
   }
   // Parse a selector (everything before '{')
@@ -341,8 +179,10 @@ class Parser {
     let prop_end = this.lexer.token_end;
     let decl_line = this.lexer.token_line;
     let decl_column = this.lexer.token_column;
+    const saved = this.lexer.save_position();
     this.next_token();
     if (this.peek_type() !== TOKEN_COLON) {
+      this.lexer.restore_position(saved);
       return null;
     }
     this.next_token();
@@ -363,12 +203,17 @@ class Parser {
     while (!this.is_eof()) {
       let token_type = this.peek_type();
       if (token_type === TOKEN_SEMICOLON || token_type === TOKEN_RIGHT_BRACE) break;
+      if (token_type === TOKEN_LEFT_BRACE) {
+        this.lexer.restore_position(saved);
+        return null;
+      }
       if (token_type === TOKEN_DELIM && this.source[this.lexer.token_start] === "!") {
         value_end = this.lexer.token_start;
         let next_type = this.lexer.next_token_fast();
         if (next_type === TOKEN_IDENT) {
           has_important = true;
           last_end = this.lexer.token_end;
+          this.next_token();
           break;
         }
       }
@@ -439,8 +284,16 @@ class Parser {
     }
     let last_end = this.lexer.token_end;
     if (this.peek_type() === TOKEN_LEFT_BRACE) {
+      let block_start = this.lexer.token_end;
       this.next_token();
       this.arena.set_flag(at_rule, FLAG_HAS_BLOCK);
+      let block_line = this.lexer.token_line;
+      let block_column = this.lexer.token_column;
+      let block_node = this.arena.create_node();
+      this.arena.set_type(block_node, NODE_BLOCK);
+      this.arena.set_start_offset(block_node, block_start);
+      this.arena.set_start_line(block_node, block_line);
+      this.arena.set_start_column(block_node, block_column);
       let has_declarations = this.atrule_has_declarations(at_rule_name);
       let is_conditional = this.atrule_is_conditional(at_rule_name);
       if (has_declarations) {
@@ -449,7 +302,7 @@ class Parser {
           if (token_type === TOKEN_RIGHT_BRACE) break;
           let declaration = this.parse_declaration();
           if (declaration !== null) {
-            this.arena.append_child(at_rule, declaration);
+            this.arena.append_child(block_node, declaration);
           } else {
             this.next_token();
           }
@@ -461,7 +314,7 @@ class Parser {
           if (token_type === TOKEN_AT_KEYWORD) {
             let nested_at_rule = this.parse_atrule();
             if (nested_at_rule !== null) {
-              this.arena.append_child(at_rule, nested_at_rule);
+              this.arena.append_child(block_node, nested_at_rule);
             } else {
               this.next_token();
             }
@@ -469,12 +322,12 @@ class Parser {
           }
           let declaration = this.parse_declaration();
           if (declaration !== null) {
-            this.arena.append_child(at_rule, declaration);
+            this.arena.append_child(block_node, declaration);
             continue;
           }
           let nested_rule = this.parse_style_rule();
           if (nested_rule !== null) {
-            this.arena.append_child(at_rule, nested_rule);
+            this.arena.append_child(block_node, nested_rule);
           } else {
             this.next_token();
           }
@@ -485,16 +338,21 @@ class Parser {
           if (token_type === TOKEN_RIGHT_BRACE) break;
           let rule = this.parse_rule();
           if (rule !== null) {
-            this.arena.append_child(at_rule, rule);
+            this.arena.append_child(block_node, rule);
           } else {
             this.next_token();
           }
         }
       }
       if (this.peek_type() === TOKEN_RIGHT_BRACE) {
-        last_end = this.lexer.token_end;
+        let block_end = this.lexer.token_start;
         this.next_token();
+        last_end = this.lexer.token_end;
+        this.arena.set_length(block_node, block_end - block_start);
+      } else {
+        this.arena.set_length(block_node, last_end - block_start);
       }
+      this.arena.append_child(at_rule, block_node);
     } else if (this.peek_type() === TOKEN_SEMICOLON) {
       last_end = this.lexer.token_end;
       this.next_token();
@@ -511,10 +369,9 @@ class Parser {
     return CONDITIONAL_AT_RULES.has(name.toLowerCase());
   }
 }
-
 function parse(source, options) {
   const parser = new Parser(source, options);
   return parser.parse();
 }
 
-export { parse };
+export { FLAG_IMPORTANT, NODE_AT_RULE, NODE_BLOCK, NODE_DECLARATION, NODE_SELECTOR_LIST, NODE_STYLESHEET, NODE_STYLE_RULE, Parser, parse };

package/dist/string-utils.d.ts

@@ -6,23 +6,24 @@ export declare const CHAR_FORM_FEED = 12;
 export declare const CHAR_FORWARD_SLASH = 47;
 export declare const CHAR_ASTERISK = 42;
 export declare const CHAR_MINUS_HYPHEN = 45;
+export declare const CHAR_SINGLE_QUOTE = 39;
+export declare const CHAR_DOUBLE_QUOTE = 34;
+export declare const CHAR_PLUS = 43;
+export declare const CHAR_PERIOD = 46;
+export declare const CHAR_TILDE = 126;
+export declare const CHAR_GREATER_THAN = 62;
+export declare const CHAR_AMPERSAND = 38;
+export declare const CHAR_EQUALS = 61;
+export declare const CHAR_PIPE = 124;
+export declare const CHAR_DOLLAR = 36;
+export declare const CHAR_CARET = 94;
+export declare const CHAR_COLON = 58;
 /**
  * Check if a character code is whitespace (space, tab, newline, CR, or FF)
  */
 export declare function is_whitespace(ch: number): boolean;
-/**
- * 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;
+export declare function is_combinator(ch: number): boolean;
+export declare function is_digit(ch: number): boolean;
 /**
  * @param a Base string, MUST be lowercase!
  * @param b Compare string

package/dist/tokenize.js

@@ -1,4 +1,4 @@
-import { L as Lexer, y as TOKEN_EOF } from './lexer-DXablYMZ.js';
+import { L as Lexer, y as TOKEN_EOF } from './lexer-CtBKgfVv.js';
 
 function* tokenize(source, skip_comments = true) {
   const lexer = new Lexer(source, skip_comments);

package/dist/walk.d.ts

@@ -16,5 +16,5 @@ interface WalkEnterLeaveOptions {
  * @param node - The root node to start walking from
  * @param options - Object with optional enter and leave callback functions
  */
-export declare function walk_enter_leave(node: CSSNode, { enter, leave }?: WalkEnterLeaveOptions): void;
+export declare function traverse(node: CSSNode, { enter, leave }?: WalkEnterLeaveOptions): void;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@projectwallace/css-parser",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"description": "High-performance CSS lexer and parser, optimized for CSS inspection and analysis",
 	"author": "Bart Veneman <bat@projectwallace.com>",
 	"license": "MIT",
@@ -34,6 +34,14 @@
 		"./parse-atrule-prelude": {
 			"types": "./dist/parse-atrule-prelude.d.ts",
 			"import": "./dist/parse-atrule-prelude.js"
+		},
+		"./parse-value": {
+			"types": "./dist/parse-value.d.ts",
+			"import": "./dist/parse-value.js"
+		},
+		"./parse-anplusb": {
+			"types": "./dist/parse-anplusb.d.ts",
+			"import": "./dist/parse-anplusb.js"
 		}
 	},
 	"files": [