@projectwallace/css-parser 0.8.2 → 0.8.4

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { parse } from './parse';
 export { parse_selector } from './parse-selector';
 export { parse_atrule_prelude } from './parse-atrule-prelude';
+export { parse_declaration } from './parse-declaration';
 export { parse_value } from './parse-value';
 export { tokenize } from './tokenize';
 export { walk, traverse, SKIP, BREAK } from './walk';

package/dist/index.js

@@ -1,6 +1,7 @@
 export { parse } from './parse.js';
 export { parse_selector } from './parse-selector.js';
 export { parse_atrule_prelude } from './parse-atrule-prelude.js';
+export { parse_declaration } from './parse-declaration.js';
 export { parse_value } from './parse-value.js';
 export { tokenize } from './tokenize.js';
 export { BREAK, SKIP, traverse, walk } from './walk.js';

package/dist/parse-anplusb.js

@@ -189,13 +189,7 @@ class ANplusBParser {
     this.lexer.pos = skip_whitespace_forward(this.source, this.lexer.pos, this.expr_end);
   }
   create_anplusb_node(start, a_start, a_end, b_start, b_end) {
-    const node = this.arena.create_node(
-      NTH_SELECTOR,
-      start,
-      this.lexer.pos - start,
-      this.lexer.line,
-      1
-    );
+    const node = this.arena.create_node(NTH_SELECTOR, start, this.lexer.pos - start, this.lexer.line, 1);
     if (a_end > a_start) {
       this.arena.set_content_start_delta(node, a_start - start);
       this.arena.set_content_length(node, a_end - a_start);

package/dist/parse-atrule-prelude.js

@@ -16,12 +16,16 @@ class AtRulePreludeParser {
     this.lexer = new Lexer(source, false);
     this.prelude_end = 0;
   }
-  // Parse an at-rule prelude into nodes based on the at-rule type
+  // Parse an at-rule prelude into nodes (standalone use)
   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;
+    return this.parse_prelude_dispatch(at_rule_name);
+  }
+  // Dispatch to appropriate parser based on at-rule type
+  parse_prelude_dispatch(at_rule_name) {
     if (str_equals("media", at_rule_name)) {
       return this.parse_media_query_list();
     } else if (str_equals("container", at_rule_name)) {
@@ -59,13 +63,7 @@ class AtRulePreludeParser {
     return nodes;
   }
   create_node(type, start, end) {
-    return this.arena.create_node(
-      type,
-      start,
-      end - start,
-      this.lexer.token_line,
-      this.lexer.token_column
-    );
+    return this.arena.create_node(type, start, end - start, this.lexer.token_line, this.lexer.token_column);
   }
   is_and_or_not(str) {
     return str_equals("and", str) || str_equals("or", str) || str_equals("not", str);

package/dist/parse-declaration.d.ts

@@ -0,0 +1,7 @@
+import { CSSNode } from './css-node';
+/**
+ * Parse a CSS declaration string and return an AST
+ * @param source - The CSS declaration to parse (e.g., "color: red", "margin: 10px !important")
+ * @returns The DECLARATION CSSNode
+ */
+export declare function parse_declaration(source: string): CSSNode;

package/dist/parse-declaration.js

@@ -0,0 +1,114 @@
+import { Lexer } from './lexer.js';
+import { CSSDataArena, DECLARATION, FLAG_IMPORTANT } from './arena.js';
+import { ValueParser } from './parse-value.js';
+import { TOKEN_IDENT, TOKEN_COLON, TOKEN_EOF, TOKEN_SEMICOLON, TOKEN_RIGHT_BRACE, TOKEN_LEFT_BRACE, TOKEN_DELIM } from './token-types.js';
+import { trim_boundaries } from './parse-utils.js';
+import { CSSNode } from './css-node.js';
+
+class DeclarationParser {
+  arena;
+  source;
+  value_parser;
+  constructor(arena, source, parse_values = true) {
+    this.arena = arena;
+    this.source = source;
+    this.value_parser = parse_values ? new ValueParser(arena, source) : null;
+  }
+  // Parse a declaration range into a declaration node (standalone use)
+  parse_declaration(start, end, line = 1, column = 1) {
+    const lexer = new Lexer(this.source, false);
+    lexer.pos = start;
+    lexer.line = line;
+    lexer.column = column;
+    lexer.next_token_fast(true);
+    return this.parse_declaration_with_lexer(lexer, end);
+  }
+  // Parse a declaration using a provided lexer (used by Parser to avoid re-tokenization)
+  parse_declaration_with_lexer(lexer, end) {
+    if (lexer.token_type !== TOKEN_IDENT) {
+      return null;
+    }
+    let prop_start = lexer.token_start;
+    let prop_end = lexer.token_end;
+    let decl_line = lexer.token_line;
+    let decl_column = lexer.token_column;
+    const saved = lexer.save_position();
+    lexer.next_token_fast(true);
+    if (lexer.token_type !== TOKEN_COLON) {
+      lexer.restore_position(saved);
+      return null;
+    }
+    lexer.next_token_fast(true);
+    let declaration = this.arena.create_node(
+      DECLARATION,
+      prop_start,
+      0,
+      // length unknown yet
+      decl_line,
+      decl_column
+    );
+    this.arena.set_content_start_delta(declaration, 0);
+    this.arena.set_content_length(declaration, prop_end - prop_start);
+    let value_start = lexer.token_start;
+    let value_start_line = lexer.token_line;
+    let value_start_column = lexer.token_column;
+    let value_end = value_start;
+    let has_important = false;
+    let last_end = lexer.token_end;
+    while (lexer.token_type !== TOKEN_EOF && lexer.token_start < end) {
+      let token_type = lexer.token_type;
+      if (token_type === TOKEN_SEMICOLON) break;
+      if (token_type === TOKEN_RIGHT_BRACE) break;
+      if (token_type === TOKEN_LEFT_BRACE) {
+        lexer.restore_position(saved);
+        return null;
+      }
+      if (token_type === TOKEN_DELIM && this.source[lexer.token_start] === "!") {
+        value_end = lexer.token_start;
+        let next_type = lexer.next_token_fast(true);
+        if (next_type === TOKEN_IDENT) {
+          has_important = true;
+          last_end = lexer.token_end;
+          lexer.next_token_fast(true);
+          break;
+        }
+      }
+      last_end = lexer.token_end;
+      value_end = last_end;
+      lexer.next_token_fast(true);
+    }
+    let trimmed = trim_boundaries(this.source, value_start, value_end);
+    if (trimmed) {
+      this.arena.set_value_start_delta(declaration, trimmed[0] - prop_start);
+      this.arena.set_value_length(declaration, trimmed[1] - trimmed[0]);
+      if (this.value_parser) {
+        let valueNodes = this.value_parser.parse_value(value_start, trimmed[1], value_start_line, value_start_column);
+        this.arena.append_children(declaration, valueNodes);
+      }
+    } else {
+      this.arena.set_value_start_delta(declaration, value_start - prop_start);
+      this.arena.set_value_length(declaration, 0);
+    }
+    if (has_important) {
+      this.arena.set_flag(declaration, FLAG_IMPORTANT);
+    }
+    if (lexer.token_type === TOKEN_SEMICOLON) {
+      last_end = lexer.token_end;
+      lexer.next_token_fast(true);
+    }
+    this.arena.set_length(declaration, last_end - prop_start);
+    return declaration;
+  }
+}
+function parse_declaration(source) {
+  const arena = new CSSDataArena(CSSDataArena.capacity_for_source(source.length));
+  const decl_parser = new DeclarationParser(arena, source);
+  const decl_index = decl_parser.parse_declaration(0, source.length);
+  if (decl_index === null) {
+    const empty = arena.create_node(DECLARATION, 0, 0, 1, 1);
+    return new CSSNode(arena, source, empty);
+  }
+  return new CSSNode(arena, source, decl_index);
+}
+
+export { DeclarationParser, parse_declaration };

package/dist/parse-selector.js

@@ -17,7 +17,7 @@ class SelectorParser {
     this.lexer = new Lexer(source, false);
     this.selector_end = 0;
   }
-  // Parse a selector range into selector nodes
+  // Parse a selector range into selector nodes (standalone use)
   // Always returns a NODE_SELECTOR_LIST with selector components as children
   parse_selector(start, end, line = 1, column = 1, allow_relative = true) {
     this.selector_end = end;
@@ -58,13 +58,7 @@ class SelectorParser {
       }
     }
     if (selectors.length >= 1) {
-      let list_node = this.arena.create_node(
-        SELECTOR_LIST,
-        list_start,
-        this.lexer.pos - list_start,
-        list_line,
-        list_column
-      );
+      let list_node = this.arena.create_node(SELECTOR_LIST, list_start, this.lexer.pos - list_start, list_line, list_column);
       this.arena.append_children(list_node, selectors);
       return list_node;
     }
@@ -547,13 +541,7 @@ class SelectorParser {
       let selector_list = this.parse_selector_list();
       this.selector_end = saved_selector_end;
       this.lexer.restore_position(saved);
-      let of_node = this.arena.create_node(
-        NTH_OF_SELECTOR,
-        start,
-        end - start,
-        this.lexer.line,
-        1
-      );
+      let of_node = this.arena.create_node(NTH_OF_SELECTOR, start, end - start, this.lexer.line, 1);
       if (anplusb_node !== null && selector_list !== null) {
         this.arena.set_first_child(of_node, anplusb_node);
         this.arena.set_next_sibling(anplusb_node, selector_list);
@@ -580,13 +568,7 @@ class SelectorParser {
     return -1;
   }
   create_node(type, start, end) {
-    let node = this.arena.create_node(
-      type,
-      start,
-      end - start,
-      this.lexer.line,
-      this.lexer.column
-    );
+    let node = this.arena.create_node(type, start, end - start, this.lexer.line, this.lexer.column);
     this.arena.set_content_start_delta(node, 0);
     this.arena.set_content_length(node, end - start);
     return node;

package/dist/parse-value.js

@@ -15,13 +15,17 @@ class ValueParser {
     this.lexer = new Lexer(source, false);
     this.value_end = 0;
   }
-  // Parse a declaration value range into value nodes
+  // Parse a declaration value range into value nodes (standalone use)
   // Returns array of value node indices
   parse_value(start, end, start_line, start_column) {
     this.value_end = end;
     this.lexer.pos = start;
     this.lexer.line = start_line;
     this.lexer.column = start_column;
+    return this.parse_value_tokens();
+  }
+  // Core token parsing logic
+  parse_value_tokens() {
     let nodes = [];
     while (this.lexer.pos < this.value_end) {
       this.lexer.next_token_fast(false);
@@ -77,13 +81,7 @@ class ValueParser {
     }
   }
   create_node(node_type, start, end) {
-    let node = this.arena.create_node(
-      node_type,
-      start,
-      end - start,
-      this.lexer.token_line,
-      this.lexer.token_column
-    );
+    let node = this.arena.create_node(node_type, start, end - start, this.lexer.token_line, this.lexer.token_column);
     this.arena.set_content_length(node, end - start);
     return node;
   }
@@ -154,9 +152,7 @@ class ValueParser {
       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) {
+      if (token_type === TOKEN_RIGHT_PAREN) {
         paren_depth--;
         if (paren_depth === 0) {
           content_end = this.lexer.token_start;

package/dist/parse.js

@@ -1,10 +1,10 @@
 import { Lexer } from './lexer.js';
-import { CSSDataArena, STYLESHEET, STYLE_RULE, FLAG_HAS_BLOCK, BLOCK, FLAG_HAS_DECLARATIONS, SELECTOR_LIST, DECLARATION, FLAG_IMPORTANT, AT_RULE } from './arena.js';
+import { CSSDataArena, STYLESHEET, STYLE_RULE, FLAG_HAS_BLOCK, BLOCK, FLAG_HAS_DECLARATIONS, SELECTOR_LIST, AT_RULE } from './arena.js';
 import { CSSNode } from './css-node.js';
-import { ValueParser } from './parse-value.js';
 import { SelectorParser } from './parse-selector.js';
 import { AtRulePreludeParser } from './parse-atrule-prelude.js';
-import { TOKEN_EOF, TOKEN_AT_KEYWORD, TOKEN_LEFT_BRACE, TOKEN_RIGHT_BRACE, TOKEN_IDENT, TOKEN_COLON, TOKEN_SEMICOLON, TOKEN_DELIM } from './token-types.js';
+import { DeclarationParser } from './parse-declaration.js';
+import { TOKEN_EOF, TOKEN_AT_KEYWORD, TOKEN_LEFT_BRACE, TOKEN_RIGHT_BRACE, TOKEN_IDENT, TOKEN_SEMICOLON } from './token-types.js';
 import { trim_boundaries } from './parse-utils.js';
 
 let DECLARATION_AT_RULES = /* @__PURE__ */ new Set(["font-face", "font-feature-values", "page", "property", "counter-style"]);
@@ -13,9 +13,9 @@ class Parser {
   source;
   lexer;
   arena;
-  value_parser;
   selector_parser;
   prelude_parser;
+  declaration_parser;
   parse_values_enabled;
   parse_selectors_enabled;
   parse_atrule_preludes_enabled;
@@ -29,9 +29,9 @@ class Parser {
     this.lexer = new Lexer(source, skip_comments);
     let capacity = CSSDataArena.capacity_for_source(source.length);
     this.arena = new CSSDataArena(capacity);
-    this.value_parser = this.parse_values_enabled ? new ValueParser(this.arena, source) : null;
     this.selector_parser = this.parse_selectors_enabled ? new SelectorParser(this.arena, source) : null;
     this.prelude_parser = this.parse_atrule_preludes_enabled ? new AtRulePreludeParser(this.arena, source) : null;
+    this.declaration_parser = new DeclarationParser(this.arena, source, this.parse_values_enabled);
   }
   // Get the arena (for internal/advanced use only)
   get_arena() {
@@ -56,13 +56,7 @@ class Parser {
   // Parse the entire stylesheet and return the root CSSNode
   parse() {
     this.next_token();
-    let stylesheet = this.arena.create_node(
-      STYLESHEET,
-      0,
-      this.source.length,
-      1,
-      1
-    );
+    let stylesheet = this.arena.create_node(STYLESHEET, 0, this.source.length, 1, 1);
     let rules = [];
     while (!this.is_eof()) {
       let rule = this.parse_rule();
@@ -177,13 +171,7 @@ class Parser {
         return selectorNode;
       }
     }
-    let selector = this.arena.create_node(
-      SELECTOR_LIST,
-      selector_start,
-      last_end - selector_start,
-      selector_line,
-      selector_column
-    );
+    let selector = this.arena.create_node(SELECTOR_LIST, selector_start, last_end - selector_start, selector_line, selector_column);
     return selector;
   }
   // Parse a declaration: property: value;
@@ -191,72 +179,7 @@ class Parser {
     if (this.peek_type() !== TOKEN_IDENT) {
       return null;
     }
-    let prop_start = this.lexer.token_start;
-    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();
-    let declaration = this.arena.create_node(
-      DECLARATION,
-      prop_start,
-      0,
-      // length unknown yet
-      decl_line,
-      decl_column
-    );
-    this.arena.set_content_start_delta(declaration, 0);
-    this.arena.set_content_length(declaration, prop_end - prop_start);
-    let value_start = this.lexer.token_start;
-    let value_start_line = this.lexer.token_line;
-    let value_start_column = this.lexer.token_column;
-    let value_end = value_start;
-    let has_important = false;
-    let last_end = this.lexer.token_end;
-    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;
-        }
-      }
-      last_end = this.lexer.token_end;
-      value_end = last_end;
-      this.next_token();
-    }
-    let trimmed = trim_boundaries(this.source, value_start, value_end);
-    if (trimmed) {
-      this.arena.set_value_start_delta(declaration, trimmed[0] - prop_start);
-      this.arena.set_value_length(declaration, trimmed[1] - trimmed[0]);
-      if (this.parse_values_enabled && this.value_parser) {
-        let valueNodes = this.value_parser.parse_value(value_start, trimmed[1], value_start_line, value_start_column);
-        this.arena.append_children(declaration, valueNodes);
-      }
-    }
-    if (has_important) {
-      this.arena.set_flag(declaration, FLAG_IMPORTANT);
-    }
-    if (this.peek_type() === TOKEN_SEMICOLON) {
-      last_end = this.lexer.token_end;
-      this.next_token();
-    }
-    this.arena.set_length(declaration, last_end - prop_start);
-    return declaration;
+    return this.declaration_parser.parse_declaration_with_lexer(this.lexer, this.source.length);
   }
   // Parse an at-rule: @media, @import, @font-face, etc.
   parse_atrule() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@projectwallace/css-parser",
-	"version": "0.8.2",
+	"version": "0.8.4",
 	"description": "High-performance CSS lexer and parser, optimized for CSS inspection and analysis",
 	"author": "Bart Veneman <bat@projectwallace.com>",
 	"license": "MIT",
@@ -35,6 +35,10 @@
 			"types": "./dist/parse-atrule-prelude.d.ts",
 			"import": "./dist/parse-atrule-prelude.js"
 		},
+		"./parse-declaration": {
+			"types": "./dist/parse-declaration.d.ts",
+			"import": "./dist/parse-declaration.js"
+		},
 		"./parse-value": {
 			"types": "./dist/parse-value.d.ts",
 			"import": "./dist/parse-value.js"