@projectwallace/css-parser 0.13.2 → 0.13.4

package/dist/arena.d.ts

@@ -37,6 +37,7 @@ export declare const LAYER_NAME = 37;
 export declare const PRELUDE_OPERATOR = 38;
 export declare const FEATURE_RANGE = 39;
 export declare const AT_RULE_PRELUDE = 40;
+export declare const PRELUDE_SELECTORLIST = 41;
 export declare const VALUE = 50;
 export declare const FLAG_IMPORTANT: number;
 export declare const FLAG_HAS_ERROR: number;

package/dist/arena.js

@@ -38,6 +38,7 @@ const LAYER_NAME = 37;
 const PRELUDE_OPERATOR = 38;
 const FEATURE_RANGE = 39;
 const AT_RULE_PRELUDE = 40;
+const PRELUDE_SELECTORLIST = 41;
 const VALUE = 50;
 const FLAG_IMPORTANT = 1 << 0;
 const FLAG_HAS_ERROR = 1 << 1;
@@ -286,4 +287,4 @@ class CSSDataArena {
   }
 }
 
-export { ATTRIBUTE_SELECTOR, ATTR_FLAG_CASE_INSENSITIVE, ATTR_FLAG_CASE_SENSITIVE, ATTR_FLAG_NONE, ATTR_OPERATOR_CARET_EQUAL, ATTR_OPERATOR_DOLLAR_EQUAL, ATTR_OPERATOR_EQUAL, ATTR_OPERATOR_NONE, ATTR_OPERATOR_PIPE_EQUAL, ATTR_OPERATOR_STAR_EQUAL, ATTR_OPERATOR_TILDE_EQUAL, AT_RULE, AT_RULE_PRELUDE, BLOCK, CLASS_SELECTOR, COMBINATOR, COMMENT, CONTAINER_QUERY, CSSDataArena, DECLARATION, DIMENSION, FEATURE_RANGE, FLAG_BROWSERHACK, FLAG_HAS_BLOCK, FLAG_HAS_DECLARATIONS, FLAG_HAS_ERROR, FLAG_HAS_PARENS, FLAG_IMPORTANT, FLAG_LENGTH_OVERFLOW, FUNCTION, HASH, IDENTIFIER, ID_SELECTOR, LANG_SELECTOR, LAYER_NAME, MEDIA_FEATURE, MEDIA_QUERY, MEDIA_TYPE, NESTING_SELECTOR, NTH_OF_SELECTOR, NTH_SELECTOR, NUMBER, OPERATOR, PARENTHESIS, PRELUDE_OPERATOR, PSEUDO_CLASS_SELECTOR, PSEUDO_ELEMENT_SELECTOR, SELECTOR, SELECTOR_LIST, STRING, STYLESHEET, STYLE_RULE, SUPPORTS_QUERY, TYPE_SELECTOR, UNICODE_RANGE, UNIVERSAL_SELECTOR, URL, VALUE };
+export { ATTRIBUTE_SELECTOR, ATTR_FLAG_CASE_INSENSITIVE, ATTR_FLAG_CASE_SENSITIVE, ATTR_FLAG_NONE, ATTR_OPERATOR_CARET_EQUAL, ATTR_OPERATOR_DOLLAR_EQUAL, ATTR_OPERATOR_EQUAL, ATTR_OPERATOR_NONE, ATTR_OPERATOR_PIPE_EQUAL, ATTR_OPERATOR_STAR_EQUAL, ATTR_OPERATOR_TILDE_EQUAL, AT_RULE, AT_RULE_PRELUDE, BLOCK, CLASS_SELECTOR, COMBINATOR, COMMENT, CONTAINER_QUERY, CSSDataArena, DECLARATION, DIMENSION, FEATURE_RANGE, FLAG_BROWSERHACK, FLAG_HAS_BLOCK, FLAG_HAS_DECLARATIONS, FLAG_HAS_ERROR, FLAG_HAS_PARENS, FLAG_IMPORTANT, FLAG_LENGTH_OVERFLOW, FUNCTION, HASH, IDENTIFIER, ID_SELECTOR, LANG_SELECTOR, LAYER_NAME, MEDIA_FEATURE, MEDIA_QUERY, MEDIA_TYPE, NESTING_SELECTOR, NTH_OF_SELECTOR, NTH_SELECTOR, NUMBER, OPERATOR, PARENTHESIS, PRELUDE_OPERATOR, PRELUDE_SELECTORLIST, PSEUDO_CLASS_SELECTOR, PSEUDO_ELEMENT_SELECTOR, SELECTOR, SELECTOR_LIST, STRING, STYLESHEET, STYLE_RULE, SUPPORTS_QUERY, TYPE_SELECTOR, UNICODE_RANGE, UNIVERSAL_SELECTOR, URL, VALUE };

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

@@ -1,5 +1,5 @@
 import { Lexer } from './tokenize.js';
-import { CSSDataArena, PRELUDE_OPERATOR, MEDIA_TYPE, MEDIA_QUERY, MEDIA_FEATURE, FUNCTION, IDENTIFIER, CONTAINER_QUERY, SUPPORTS_QUERY, LAYER_NAME, STRING, URL, DIMENSION, NUMBER, FEATURE_RANGE } from './arena.js';
+import { CSSDataArena, PRELUDE_OPERATOR, MEDIA_TYPE, MEDIA_QUERY, MEDIA_FEATURE, FUNCTION, IDENTIFIER, CONTAINER_QUERY, SUPPORTS_QUERY, LAYER_NAME, STRING, URL, DIMENSION, NUMBER, PRELUDE_SELECTORLIST, FEATURE_RANGE } from './arena.js';
 import { TOKEN_COMMA, TOKEN_IDENT, TOKEN_LEFT_PAREN, TOKEN_RIGHT_PAREN, TOKEN_FUNCTION, TOKEN_EOF, TOKEN_WHITESPACE, TOKEN_STRING, TOKEN_URL, TOKEN_DIMENSION, TOKEN_PERCENTAGE, TOKEN_NUMBER } from './token-types.js';
 import { strip_vendor_prefix, str_equals, CHAR_LESS_THAN, CHAR_GREATER_THAN, CHAR_EQUALS, CHAR_COLON, is_whitespace } from './string-utils.js';
 import { skip_whitespace_and_comments_forward, trim_boundaries } from './parse-utils.js';
@@ -19,30 +19,40 @@ 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
   parse_prelude_dispatch(at_rule_name) {
-    let normalized_name = strip_vendor_prefix(at_rule_name);
-    if (str_equals("media", normalized_name)) {
-      return this.parse_media_query_list();
-    } else if (str_equals("container", normalized_name)) {
-      return this.parse_container_query();
-    } else if (str_equals("supports", normalized_name)) {
-      return this.parse_supports_query();
-    } else if (str_equals("layer", normalized_name)) {
-      return this.parse_layer_names();
-    } else if (str_equals("keyframes", normalized_name)) {
-      return this.parse_identifier();
-    } else if (str_equals("property", normalized_name)) {
-      return this.parse_identifier();
-    } else if (str_equals("import", normalized_name)) {
-      return this.parse_import_prelude();
-    } else if (str_equals("charset", normalized_name)) {
-      return this.parse_charset_prelude();
+    let normalized_name = strip_vendor_prefix(at_rule_name).toLowerCase();
+    switch (normalized_name) {
+      case "media":
+        return this.parse_media_query_list();
+      case "container":
+        return this.parse_container_query();
+      case "supports":
+        return this.parse_supports_query();
+      case "layer":
+        return this.parse_layer_names();
+      case "keyframes":
+      case "property":
+      case "counter-style":
+      case "color-profile":
+      case "font-palette-values":
+      case "position-try":
+      case "font-feature-values":
+      case "page":
+        return this.parse_identifier();
+      case "import":
+        return this.parse_import_prelude();
+      case "charset":
+        return this.parse_charset_prelude();
+      case "namespace":
+        return this.parse_namespace_prelude();
+      case "scope":
+        return this.parse_scope_prelude();
+      case "custom-media":
+        return this.parse_custom_media_prelude();
     }
     return [];
   }
@@ -76,15 +86,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 +478,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 +514,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 +533,77 @@ 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 @namespace prelude: [prefix] url("...") | "..."
+  // e.g. @namespace url("http://www.w3.org/1999/xhtml");
+  // e.g. @namespace svg url("http://www.w3.org/2000/svg");
+  parse_namespace_prelude() {
+    let nodes = [];
+    this.skip_whitespace();
+    if (this.lexer.pos >= this.prelude_end) return [];
+    const saved = this.lexer.save_position();
+    this.next_token();
+    if (this.lexer.token_type === TOKEN_IDENT) {
+      nodes.push(this.create_node(IDENTIFIER, this.lexer.token_start, this.lexer.token_end));
+      this.skip_whitespace();
+    } else {
+      this.lexer.restore_position(saved);
+    }
+    const url_node = this.parse_import_url();
+    if (url_node !== null) nodes.push(url_node);
+    return nodes;
+  }
+  // Parse @scope prelude: [(<scope-start>)] [to (<scope-end>)]
+  // e.g. @scope (.parent) to (.child) { }
+  parse_scope_prelude() {
+    let nodes = [];
+    while (this.lexer.pos < this.prelude_end) {
+      this.skip_whitespace();
+      if (this.lexer.pos >= this.prelude_end) break;
+      const token_type = this.peek_token_type();
+      if (token_type === TOKEN_LEFT_PAREN) {
+        this.next_token();
+        let paren_start = this.lexer.token_start;
+        let content_start = this.lexer.pos;
+        let depth = 1;
+        while (this.lexer.pos < this.prelude_end && depth > 0) {
+          this.next_token();
+          if (this.lexer.token_type === TOKEN_LEFT_PAREN) depth++;
+          else if (this.lexer.token_type === TOKEN_RIGHT_PAREN) depth--;
+        }
+        let content_end = this.lexer.token_start;
+        let paren_end = this.lexer.token_end;
+        let scope_node = this.create_node(PRELUDE_SELECTORLIST, paren_start, paren_end);
+        let trimmed = trim_boundaries(this.source, content_start, content_end);
+        if (trimmed) {
+          this.arena.set_value_start_delta(scope_node, trimmed[0] - paren_start);
+          this.arena.set_value_length(scope_node, trimmed[1] - trimmed[0]);
+        }
+        nodes.push(scope_node);
+      } else if (token_type === TOKEN_IDENT) {
+        this.next_token();
+        let text = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+        if (str_equals("to", text)) {
+          nodes.push(this.create_node(PRELUDE_OPERATOR, this.lexer.token_start, this.lexer.token_end));
+        }
+      } else {
+        this.next_token();
+      }
+    }
+    return nodes;
+  }
+  // Parse @custom-media prelude: --name <media-condition>
+  // e.g. @custom-media --small (max-width: 30em);
+  parse_custom_media_prelude() {
+    let nodes = [];
+    this.skip_whitespace();
+    if (this.lexer.pos >= this.prelude_end) return [];
+    this.next_token();
+    if (this.lexer.token_type !== TOKEN_IDENT) return [];
+    nodes.push(this.create_node(IDENTIFIER, this.lexer.token_start, this.lexer.token_end));
+    nodes.push(...this.parse_media_query_list());
     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

@@ -8,8 +8,8 @@ import { TOKEN_EOF, TOKEN_AT_KEYWORD, TOKEN_LEFT_BRACE, TOKEN_RIGHT_BRACE, TOKEN
 import { trim_boundaries } from './parse-utils.js';
 import { CHAR_PERIOD, CHAR_GREATER_THAN, CHAR_PLUS, CHAR_TILDE, CHAR_AMPERSAND } from './string-utils.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"]);
+let DECLARATION_AT_RULES = /* @__PURE__ */ new Set(["font-face", "font-feature-values", "page", "property", "counter-style", "color-profile", "font-palette-values", "position-try", "view-transition"]);
+let CONDITIONAL_AT_RULES = /* @__PURE__ */ new Set(["media", "supports", "container", "layer", "nest", "scope", "starting-style"]);
 class Parser {
   source;
   lexer;

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.2",
+	"version": "0.13.4",
 	"description": "High-performance CSS lexer and parser, optimized for CSS inspection and analysis",
 	"author": "Bart Veneman <bart@projectwallace.com>",
 	"license": "MIT",