@projectwallace/css-parser 0.13.1 → 0.13.3

package/dist/char-types.d.ts

@@ -3,6 +3,7 @@ export declare let CHAR_DIGIT: number;
 export declare let CHAR_HEX: number;
 export declare let CHAR_WHITESPACE: number;
 export declare let CHAR_NEWLINE: number;
+export declare let CHAR_IDENT: number;
 export declare let char_types: Uint8Array<ArrayBuffer>;
 export declare function is_digit(ch: number): boolean;
 export declare function is_hex_digit(ch: number): boolean;

package/dist/char-types.js

@@ -3,6 +3,7 @@ let CHAR_DIGIT = 1 << 1;
 let CHAR_HEX = 1 << 2;
 let CHAR_WHITESPACE = 1 << 3;
 let CHAR_NEWLINE = 1 << 4;
+let CHAR_IDENT = 1 << 5;
 let char_types = new Uint8Array(128);
 for (let i = 48; i <= 57; i++) {
   char_types[i] = CHAR_DIGIT;
@@ -27,9 +28,13 @@ char_types[9] = CHAR_WHITESPACE;
 char_types[10] = CHAR_NEWLINE;
 char_types[13] = CHAR_NEWLINE;
 char_types[12] = CHAR_NEWLINE;
-function is_digit(ch) {
-  return ch < 128 && (char_types[ch] & CHAR_DIGIT) !== 0;
+for (let i = 0; i < 128; i++) {
+  if (char_types[i] & (CHAR_ALPHA | CHAR_DIGIT)) {
+    char_types[i] |= CHAR_IDENT;
+  }
 }
+char_types[45] |= CHAR_IDENT;
+char_types[95] |= CHAR_IDENT;
 function is_hex_digit(ch) {
   return ch < 128 && (char_types[ch] & CHAR_HEX) !== 0;
 }
@@ -39,17 +44,10 @@ function is_alpha(ch) {
 function is_whitespace(ch) {
   return ch < 128 && (char_types[ch] & CHAR_WHITESPACE) !== 0;
 }
-function is_newline(ch) {
-  return ch < 128 && (char_types[ch] & CHAR_NEWLINE) !== 0;
-}
 function is_ident_start(ch) {
   if (ch >= 128) return true;
   if (ch === 95) return true;
   return is_alpha(ch);
 }
-function is_ident_char(ch) {
-  if (ch === 45) return true;
-  return is_ident_start(ch) || is_digit(ch);
-}
 
-export { CHAR_ALPHA, CHAR_DIGIT, CHAR_HEX, CHAR_NEWLINE, CHAR_WHITESPACE, char_types, is_alpha, is_digit, is_hex_digit, is_ident_char, is_ident_start, is_newline, is_whitespace };
+export { CHAR_ALPHA, CHAR_DIGIT, CHAR_HEX, CHAR_IDENT, CHAR_NEWLINE, CHAR_WHITESPACE, char_types, is_alpha, is_hex_digit, is_ident_start, is_whitespace };

package/dist/parse-anplusb.js

@@ -2,7 +2,6 @@ import { Lexer } from './tokenize.js';
 import { NTH_SELECTOR, CSSDataArena } from './arena.js';
 import { TOKEN_IDENT, TOKEN_DELIM, TOKEN_DIMENSION, TOKEN_NUMBER } from './token-types.js';
 import { str_equals, CHAR_MINUS_HYPHEN, CHAR_PLUS, str_index_of } from './string-utils.js';
-import { skip_whitespace_and_comments_forward } from './parse-utils.js';
 import { CSSNode } from './css-node.js';
 
 class ANplusBParser {
@@ -22,8 +21,7 @@ class ANplusBParser {
    */
   parse_anplusb(start, end, line = 1) {
     this.expr_end = end;
-    this.lexer.pos = start;
-    this.lexer.line = line;
+    this.lexer.seek(start, line);
     let b = null;
     let a_start = start;
     let a_end = start;
@@ -186,7 +184,7 @@ class ANplusBParser {
     return null;
   }
   skip_whitespace() {
-    this.lexer.pos = skip_whitespace_and_comments_forward(this.source, this.lexer.pos, this.expr_end);
+    this.lexer.skip_whitespace_in_range(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);

package/dist/parse-atrule-prelude.js

@@ -19,9 +19,7 @@ class AtRulePreludeParser {
   // 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;
+    this.lexer.seek(start, line, column);
     return this.parse_prelude_dispatch(at_rule_name);
   }
   // Dispatch to appropriate parser based on at-rule type
@@ -76,15 +74,15 @@ class AtRulePreludeParser {
     let query_start = this.lexer.pos;
     this.skip_whitespace();
     if (this.lexer.pos >= this.prelude_end) return null;
-    let token_start = this.lexer.pos;
+    const saved_token_start = this.lexer.save_position();
     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;
+        this.lexer.restore_position(saved_token_start);
       }
     } else {
-      this.lexer.pos = token_start;
+      this.lexer.restore_position(saved_token_start);
     }
     let components = [];
     while (this.lexer.pos < this.prelude_end) {
@@ -468,7 +466,7 @@ class AtRulePreludeParser {
   }
   // Helper: Skip whitespace and comments
   skip_whitespace() {
-    this.lexer.pos = skip_whitespace_and_comments_forward(this.source, this.lexer.pos, this.prelude_end);
+    this.lexer.skip_whitespace_in_range(this.prelude_end);
   }
   // Helper: Peek at next token type without consuming
   peek_token_type() {
@@ -504,9 +502,11 @@ class AtRulePreludeParser {
   }
   // Helper: Parse feature value portion into typed nodes
   parse_feature_value(start, end) {
-    let saved_pos = this.lexer.save_position();
-    this.lexer.pos = start;
+    let temp_lexer = new Lexer(this.source);
+    temp_lexer.seek(start, this.lexer.line, this.lexer.column);
     let nodes = [];
+    let saved_lexer = this.lexer;
+    this.lexer = temp_lexer;
     while (this.lexer.pos < end) {
       this.lexer.next_token_fast(false);
       if (this.lexer.token_start >= end) break;
@@ -521,7 +521,7 @@ class AtRulePreludeParser {
       let node = this.parse_value_token();
       if (node !== null) nodes.push(node);
     }
-    this.lexer.restore_position(saved_pos);
+    this.lexer = saved_lexer;
     return nodes;
   }
   // Parse media feature range syntax: (50px <= width <= 100px)

package/dist/parse-declaration.js

@@ -18,9 +18,7 @@ class DeclarationParser {
   // Parse a declaration range into a declaration node (standalone use)
   parse_declaration(start, end, line = 1, column = 1) {
     const lexer = new Lexer(this.source);
-    lexer.pos = start;
-    lexer.line = line;
-    lexer.column = column;
+    lexer.seek(start, line, column);
     lexer.next_token_fast(true);
     return this.parse_declaration_with_lexer(lexer, end);
   }

package/dist/parse-selector.js

@@ -21,9 +21,7 @@ class SelectorParser {
   // 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;
-    this.lexer.pos = start;
-    this.lexer.line = line;
-    this.lexer.column = column;
+    this.lexer.seek(start, line, column);
     return this.parse_selector_list(allow_relative);
   }
   // Parse comma-separated selectors
@@ -230,7 +228,7 @@ class SelectorParser {
       this.lexer.pos++;
       let node = this.parse_namespace_local_part(start, start, end - start);
       if (node !== null) return node;
-      this.lexer.pos = end;
+      this.lexer.restore_position(saved);
     } else {
       this.lexer.restore_position(saved);
     }
@@ -245,7 +243,7 @@ class SelectorParser {
       this.lexer.pos++;
       let node = this.parse_namespace_local_part(start, start, end - start);
       if (node !== null) return node;
-      this.lexer.pos = end;
+      this.lexer.restore_position(saved);
     } else {
       this.lexer.restore_position(saved);
     }
@@ -258,16 +256,12 @@ class SelectorParser {
   }
   // Parse combinator (>, +, ~, or descendant space)
   try_parse_combinator() {
-    let whitespace_start = this.lexer.pos;
-    let whitespace_start_line = this.lexer.line;
-    let whitespace_start_column = this.lexer.column;
+    const saved_whitespace_start = this.lexer.save_position();
     let has_whitespace = this.lexer.pos < this.selector_end;
     this.skip_whitespace();
-    has_whitespace = has_whitespace && this.lexer.pos > whitespace_start;
+    has_whitespace = has_whitespace && this.lexer.pos > saved_whitespace_start.pos;
     if (this.lexer.pos >= this.selector_end) {
-      this.lexer.pos = whitespace_start;
-      this.lexer.line = whitespace_start_line;
-      this.lexer.column = whitespace_start_column;
+      this.lexer.restore_position(saved_whitespace_start);
       return null;
     }
     this.lexer.next_token_fast(false);
@@ -278,15 +272,11 @@ class SelectorParser {
       }
     }
     if (has_whitespace) {
-      this.lexer.pos = whitespace_start;
-      this.lexer.line = whitespace_start_line;
-      this.lexer.column = whitespace_start_column;
+      this.lexer.restore_position(saved_whitespace_start);
       this.skip_whitespace();
-      return this.create_node_at(COMBINATOR, whitespace_start, this.lexer.pos, whitespace_start_line, whitespace_start_column);
+      return this.create_node_at(COMBINATOR, saved_whitespace_start.pos, this.lexer.pos, saved_whitespace_start.line, saved_whitespace_start.column);
     }
-    this.lexer.pos = whitespace_start;
-    this.lexer.line = whitespace_start_line;
-    this.lexer.column = whitespace_start_column;
+    this.lexer.restore_position(saved_whitespace_start);
     return null;
   }
   // Parse class selector (.classname)
@@ -512,9 +502,11 @@ class SelectorParser {
   // Parse :lang() content - comma-separated language identifiers
   // Accepts both quoted strings: :lang("en", "fr") and unquoted: :lang(en, fr)
   parse_lang_identifiers(start, end, parent_node) {
+    let temp_lexer = new Lexer(this.source);
+    temp_lexer.seek(start, this.lexer.line, this.lexer.column);
     let saved_selector_end = this.selector_end;
-    const saved = this.lexer.save_position();
-    this.lexer.pos = start;
+    let saved_lexer = this.lexer;
+    this.lexer = temp_lexer;
     this.selector_end = end;
     let first_child = null;
     let last_child = null;
@@ -547,7 +539,7 @@ class SelectorParser {
       this.arena.set_first_child(parent_node, first_child);
     }
     this.selector_end = saved_selector_end;
-    this.lexer.restore_position(saved);
+    this.lexer = saved_lexer;
   }
   // Parse An+B expression for nth-* pseudo-classes
   // Handles both simple An+B and "An+B of S" syntax

package/dist/parse-value.js

@@ -19,9 +19,7 @@ class ValueParser {
   // Returns single VALUE node index
   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;
+    this.lexer.seek(start, start_line, start_column);
     let value_nodes = this.parse_value_tokens();
     if (value_nodes.length === 0) {
       let value_node2 = this.arena.create_node(VALUE, start, 0, start_line, start_column);

package/dist/parse.js

@@ -4,7 +4,7 @@ import { CSSNode } from './css-node.js';
 import { SelectorParser } from './parse-selector.js';
 import { AtRulePreludeParser } from './parse-atrule-prelude.js';
 import { DeclarationParser } from './parse-declaration.js';
-import { TOKEN_EOF, TOKEN_AT_KEYWORD, TOKEN_LEFT_BRACE, TOKEN_RIGHT_BRACE, TOKEN_IDENT, TOKEN_HASH, TOKEN_DELIM, TOKEN_LEFT_PAREN, TOKEN_RIGHT_PAREN, TOKEN_LEFT_BRACKET, TOKEN_RIGHT_BRACKET, TOKEN_COMMA, TOKEN_COLON, TOKEN_SEMICOLON } from './token-types.js';
+import { TOKEN_EOF, TOKEN_AT_KEYWORD, TOKEN_LEFT_BRACE, TOKEN_RIGHT_BRACE, TOKEN_IDENT, TOKEN_HASH, TOKEN_DELIM, TOKEN_LEFT_PAREN, TOKEN_RIGHT_PAREN, TOKEN_LEFT_BRACKET, TOKEN_RIGHT_BRACKET, TOKEN_COMMA, TOKEN_COLON, TOKEN_SEMICOLON, TOKEN_FUNCTION } from './token-types.js';
 import { trim_boundaries } from './parse-utils.js';
 import { CHAR_PERIOD, CHAR_GREATER_THAN, CHAR_PLUS, CHAR_TILDE, CHAR_AMPERSAND } from './string-utils.js';
 
@@ -213,9 +213,16 @@ class Parser {
     this.arena.set_content_length(at_rule, name_length);
     let prelude_start = this.lexer.token_start;
     let prelude_end = prelude_start;
+    let paren_depth = 0;
     while (!this.is_eof()) {
       let token_type = this.peek_type();
-      if (token_type === TOKEN_LEFT_BRACE || token_type === TOKEN_SEMICOLON) break;
+      if (token_type === TOKEN_LEFT_PAREN || token_type === TOKEN_FUNCTION) {
+        paren_depth++;
+      } else if (token_type === TOKEN_RIGHT_PAREN) {
+        paren_depth--;
+      }
+      if (token_type === TOKEN_LEFT_BRACE && paren_depth === 0) break;
+      if (token_type === TOKEN_SEMICOLON && paren_depth === 0) break;
       prelude_end = this.lexer.token_end;
       this.next_token();
     }

package/dist/tokenize.d.ts

@@ -3,6 +3,7 @@ export interface LexerPosition {
     pos: number;
     line: number;
     column: number;
+    _line_offset: number;
     token_type: TokenType;
     token_start: number;
     token_end: number;

package/dist/tokenize.js

@@ -1,6 +1,9 @@
-import { char_types, CHAR_WHITESPACE, CHAR_NEWLINE, CHAR_DIGIT, is_ident_start, is_newline, is_hex_digit, is_whitespace, is_ident_char } from './char-types.js';
+import { char_types, CHAR_WHITESPACE, CHAR_NEWLINE, CHAR_DIGIT, is_ident_start, is_hex_digit, is_whitespace, CHAR_IDENT } from './char-types.js';
 import { TOKEN_EOF, TOKEN_RIGHT_PAREN, TOKEN_LEFT_PAREN, TOKEN_RIGHT_BRACKET, TOKEN_LEFT_BRACKET, TOKEN_COMMA, TOKEN_SEMICOLON, TOKEN_COLON, TOKEN_RIGHT_BRACE, TOKEN_LEFT_BRACE, TOKEN_CDO, TOKEN_CDC, TOKEN_DELIM, TOKEN_WHITESPACE, TOKEN_STRING, TOKEN_BAD_STRING, TOKEN_PERCENTAGE, TOKEN_DIMENSION, TOKEN_NUMBER, TOKEN_FUNCTION, TOKEN_IDENT, TOKEN_UNICODE_RANGE, TOKEN_AT_KEYWORD, TOKEN_HASH } from './token-types.js';
 
+function is_newline(ch) {
+  return ch < 128 && (char_types[ch] & CHAR_NEWLINE) !== 0;
+}
 const CHAR_LEFT_BRACE = 123;
 const CHAR_RIGHT_BRACE = 125;
 const CHAR_COLON = 58;
@@ -34,8 +37,8 @@ const CHAR_LINE_FEED = 10;
 class Lexer {
   source;
   pos;
-  line;
-  column;
+  _line;
+  _line_offset;
   on_comment;
   // Current token properties (avoiding object allocation)
   token_type;
@@ -46,8 +49,8 @@ class Lexer {
   constructor(source, on_comment) {
     this.source = source;
     this.pos = 0;
-    this.line = 1;
-    this.column = 1;
+    this._line = 1;
+    this._line_offset = 0;
     this.on_comment = on_comment;
     this.token_type = TOKEN_EOF;
     this.token_start = 0;
@@ -55,6 +58,17 @@ class Lexer {
     this.token_line = 1;
     this.token_column = 1;
   }
+  get line() {
+    return this._line;
+  }
+  get column() {
+    return this.pos - this._line_offset + 1;
+  }
+  seek(pos, line, column = 1) {
+    this.pos = pos;
+    this._line = line;
+    this._line_offset = pos - column + 1;
+  }
   // Fast token advancing without object allocation (for internal parser use)
   next_token_fast(skip_whitespace = false) {
     if (skip_whitespace) {
@@ -295,7 +309,9 @@ class Lexer {
         return this.make_token(TOKEN_PERCENTAGE, start, this.pos, start_line, start_column);
       }
       if (is_ident_start(ch2) || ch2 === CHAR_HYPHEN && is_ident_start(this.peek())) {
-        while (this.pos < this.source.length && is_ident_char(this.source.charCodeAt(this.pos))) {
+        while (this.pos < this.source.length) {
+          let ch3 = this.source.charCodeAt(this.pos);
+          if (ch3 < 128 && (char_types[ch3] & CHAR_IDENT) === 0) break;
           this.advance();
         }
         return this.make_token(TOKEN_DIMENSION, start, this.pos, start_line, start_column);
@@ -327,7 +343,7 @@ class Lexer {
         } else {
           this.advance();
         }
-      } else if (is_ident_char(ch)) {
+      } else if (ch >= 128 || (char_types[ch] & CHAR_IDENT) !== 0) {
         this.advance();
       } else {
         break;
@@ -388,7 +404,9 @@ class Lexer {
   consume_at_keyword(start_line, start_column) {
     let start = this.pos;
     this.advance();
-    while (this.pos < this.source.length && is_ident_char(this.source.charCodeAt(this.pos))) {
+    while (this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (ch < 128 && (char_types[ch] & CHAR_IDENT) === 0) break;
       this.advance();
     }
     return this.make_token(TOKEN_AT_KEYWORD, start, this.pos, start_line, start_column);
@@ -396,7 +414,9 @@ class Lexer {
   consume_hash(start_line, start_column) {
     let start = this.pos;
     this.advance();
-    while (this.pos < this.source.length && is_ident_char(this.source.charCodeAt(this.pos))) {
+    while (this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (ch < 128 && (char_types[ch] & CHAR_IDENT) === 0) break;
       this.advance();
     }
     return this.make_token(TOKEN_HASH, start, this.pos, start_line, start_column);
@@ -406,14 +426,12 @@ class Lexer {
       if (this.pos >= this.source.length) return;
       let ch = this.source.charCodeAt(this.pos);
       this.pos++;
-      if (is_newline(ch)) {
+      if (ch < 128 && (char_types[ch] & CHAR_NEWLINE) !== 0) {
         if (ch === CHAR_CARRIAGE_RETURN && this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_LINE_FEED) {
           this.pos++;
         }
-        this.line++;
-        this.column = 1;
-      } else {
-        this.column++;
+        this._line++;
+        this._line_offset = this.pos;
       }
       return;
     }
@@ -421,15 +439,13 @@ class Lexer {
       if (this.pos >= this.source.length) break;
       let ch = this.source.charCodeAt(this.pos);
       this.pos++;
-      if (is_newline(ch)) {
+      if (ch < 128 && (char_types[ch] & CHAR_NEWLINE) !== 0) {
         if (ch === CHAR_CARRIAGE_RETURN && this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_LINE_FEED) {
           this.pos++;
           i++;
         }
-        this.line++;
-        this.column = 1;
-      } else {
-        this.column++;
+        this._line++;
+        this._line_offset = this.pos;
       }
     }
   }
@@ -464,8 +480,9 @@ class Lexer {
   save_position() {
     return {
       pos: this.pos,
-      line: this.line,
+      line: this._line,
       column: this.column,
+      _line_offset: this._line_offset,
       token_type: this.token_type,
       token_start: this.token_start,
       token_end: this.token_end,
@@ -479,14 +496,41 @@ class Lexer {
    */
   restore_position(saved) {
     this.pos = saved.pos;
-    this.line = saved.line;
-    this.column = saved.column;
+    this._line = saved.line;
+    this._line_offset = saved._line_offset;
     this.token_type = saved.token_type;
     this.token_start = saved.token_start;
     this.token_end = saved.token_end;
     this.token_line = saved.token_line;
     this.token_column = saved.token_column;
   }
+  /**
+   * Skip whitespace and comments within a range, maintaining line/column tracking
+   * @param end The end boundary (exclusive)
+   */
+  skip_whitespace_in_range(end) {
+    while (this.pos < end) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (is_whitespace(ch)) {
+        this.advance();
+        continue;
+      }
+      if (ch === CHAR_FORWARD_SLASH && this.pos + 1 < end && this.source.charCodeAt(this.pos + 1) === CHAR_ASTERISK) {
+        this.advance();
+        this.advance();
+        while (this.pos < end) {
+          if (this.source.charCodeAt(this.pos) === CHAR_ASTERISK && this.pos + 1 < end && this.source.charCodeAt(this.pos + 1) === CHAR_FORWARD_SLASH) {
+            this.advance();
+            this.advance();
+            break;
+          }
+          this.advance();
+        }
+        continue;
+      }
+      break;
+    }
+  }
 }
 function* tokenize(source, on_comment) {
   const lexer = new Lexer(source, on_comment);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@projectwallace/css-parser",
-	"version": "0.13.1",
+	"version": "0.13.3",
 	"description": "High-performance CSS lexer and parser, optimized for CSS inspection and analysis",
 	"author": "Bart Veneman <bart@projectwallace.com>",
 	"license": "MIT",