@projectwallace/css-parser 0.8.4 → 0.8.6

package/dist/tokenize.js

@@ -1,6 +1,432 @@
-import { Lexer } from './lexer.js';
-import { TOKEN_EOF } from './token-types.js';
+import { is_whitespace, is_newline, is_digit, is_ident_start, is_hex_digit, is_ident_char } from './char-types.js';
+import { TOKEN_EOF, TOKEN_LEFT_BRACE, TOKEN_RIGHT_BRACE, TOKEN_COLON, TOKEN_SEMICOLON, TOKEN_COMMA, TOKEN_LEFT_BRACKET, TOKEN_RIGHT_BRACKET, TOKEN_LEFT_PAREN, TOKEN_RIGHT_PAREN, TOKEN_CDO, TOKEN_CDC, TOKEN_DELIM, TOKEN_WHITESPACE, TOKEN_COMMENT, TOKEN_STRING, TOKEN_BAD_STRING, TOKEN_PERCENTAGE, TOKEN_DIMENSION, TOKEN_NUMBER, TOKEN_FUNCTION, TOKEN_IDENT, TOKEN_AT_KEYWORD, TOKEN_HASH } from './token-types.js';
 
+const CHAR_LEFT_BRACE = 123;
+const CHAR_RIGHT_BRACE = 125;
+const CHAR_COLON = 58;
+const CHAR_SEMICOLON = 59;
+const CHAR_COMMA = 44;
+const CHAR_LEFT_BRACKET = 91;
+const CHAR_RIGHT_BRACKET = 93;
+const CHAR_LEFT_PAREN = 40;
+const CHAR_RIGHT_PAREN = 41;
+const CHAR_FORWARD_SLASH = 47;
+const CHAR_ASTERISK = 42;
+const CHAR_DOUBLE_QUOTE = 34;
+const CHAR_SINGLE_QUOTE = 39;
+const CHAR_DOT = 46;
+const CHAR_LESS_THAN = 60;
+const CHAR_EXCLAMATION = 33;
+const CHAR_HYPHEN = 45;
+const CHAR_GREATER_THAN = 62;
+const CHAR_AT_SIGN = 64;
+const CHAR_HASH = 35;
+const CHAR_BACKSLASH = 92;
+const CHAR_PLUS = 43;
+const CHAR_PERCENT = 37;
+const CHAR_LOWERCASE_E = 101;
+const CHAR_UPPERCASE_E = 69;
+const CHAR_CARRIAGE_RETURN = 13;
+const CHAR_LINE_FEED = 10;
+class Lexer {
+  source;
+  pos;
+  line;
+  column;
+  skip_comments;
+  // Current token properties (avoiding object allocation)
+  token_type;
+  token_start;
+  token_end;
+  token_line;
+  token_column;
+  constructor(source, skip_comments = false) {
+    this.source = source;
+    this.pos = 0;
+    this.line = 1;
+    this.column = 1;
+    this.skip_comments = skip_comments;
+    this.token_type = TOKEN_EOF;
+    this.token_start = 0;
+    this.token_end = 0;
+    this.token_line = 1;
+    this.token_column = 1;
+  }
+  // Fast token advancing without object allocation (for internal parser use)
+  next_token_fast(skip_whitespace = false) {
+    if (skip_whitespace) {
+      while (this.pos < this.source.length) {
+        let ch2 = this.source.charCodeAt(this.pos);
+        if (!is_whitespace(ch2) && !is_newline(ch2)) break;
+        this.advance();
+      }
+    }
+    if (this.pos >= this.source.length) {
+      return this.make_token(TOKEN_EOF, this.pos, this.pos);
+    }
+    let ch = this.source.charCodeAt(this.pos);
+    let start = this.pos;
+    let start_line = this.line;
+    let start_column = this.column;
+    if (ch === CHAR_LEFT_BRACE) {
+      this.advance();
+      return this.make_token(TOKEN_LEFT_BRACE, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_RIGHT_BRACE) {
+      this.advance();
+      return this.make_token(TOKEN_RIGHT_BRACE, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_COLON) {
+      this.advance();
+      return this.make_token(TOKEN_COLON, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_SEMICOLON) {
+      this.advance();
+      return this.make_token(TOKEN_SEMICOLON, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_COMMA) {
+      this.advance();
+      return this.make_token(TOKEN_COMMA, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_LEFT_BRACKET) {
+      this.advance();
+      return this.make_token(TOKEN_LEFT_BRACKET, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_RIGHT_BRACKET) {
+      this.advance();
+      return this.make_token(TOKEN_RIGHT_BRACKET, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_LEFT_PAREN) {
+      this.advance();
+      return this.make_token(TOKEN_LEFT_PAREN, start, this.pos, start_line, start_column);
+    }
+    if (ch === CHAR_RIGHT_PAREN) {
+      this.advance();
+      return this.make_token(TOKEN_RIGHT_PAREN, start, this.pos, start_line, start_column);
+    }
+    if (is_whitespace(ch) || is_newline(ch)) {
+      return this.consume_whitespace(start_line, start_column);
+    }
+    if (ch === CHAR_FORWARD_SLASH && this.peek() === CHAR_ASTERISK) {
+      if (this.skip_comments) {
+        this.advance(2);
+        while (this.pos < this.source.length - 1) {
+          let ch2 = this.source.charCodeAt(this.pos);
+          if (ch2 === CHAR_ASTERISK && this.source.charCodeAt(this.pos + 1) === CHAR_FORWARD_SLASH) {
+            this.advance(2);
+            break;
+          }
+          this.advance();
+        }
+        return this.next_token_fast(skip_whitespace);
+      }
+      return this.consume_comment(start_line, start_column);
+    }
+    if (ch === CHAR_DOUBLE_QUOTE || ch === CHAR_SINGLE_QUOTE) {
+      return this.consume_string(ch, start_line, start_column);
+    }
+    if (is_digit(ch)) {
+      return this.consume_number(start_line, start_column);
+    }
+    if (ch === CHAR_DOT && is_digit(this.peek())) {
+      return this.consume_number(start_line, start_column);
+    }
+    if (ch === CHAR_LESS_THAN && this.pos + 3 < this.source.length) {
+      if (this.source.charCodeAt(this.pos + 1) === CHAR_EXCLAMATION && this.source.charCodeAt(this.pos + 2) === CHAR_HYPHEN && this.source.charCodeAt(this.pos + 3) === CHAR_HYPHEN) {
+        this.advance(4);
+        return this.make_token(TOKEN_CDO, start, this.pos, start_line, start_column);
+      }
+    }
+    if (ch === CHAR_HYPHEN && this.pos + 2 < this.source.length) {
+      if (this.source.charCodeAt(this.pos + 1) === CHAR_HYPHEN && this.source.charCodeAt(this.pos + 2) === CHAR_GREATER_THAN) {
+        this.advance(3);
+        return this.make_token(TOKEN_CDC, start, this.pos, start_line, start_column);
+      }
+    }
+    if (ch === CHAR_AT_SIGN) {
+      return this.consume_at_keyword(start_line, start_column);
+    }
+    if (ch === CHAR_HASH) {
+      return this.consume_hash(start_line, start_column);
+    }
+    if (is_ident_start(ch)) {
+      return this.consume_ident_or_function(start_line, start_column);
+    }
+    if (ch === CHAR_HYPHEN) {
+      let next = this.peek();
+      if (is_ident_start(next) || next === CHAR_HYPHEN) {
+        return this.consume_ident_or_function(start_line, start_column);
+      }
+    }
+    if (ch === CHAR_BACKSLASH) {
+      let next = this.peek();
+      if (next !== 0 && !is_newline(next)) {
+        return this.consume_ident_or_function(start_line, start_column);
+      }
+    }
+    if (ch === CHAR_HYPHEN || ch === CHAR_PLUS) {
+      let next = this.peek();
+      if (is_digit(next) || next === CHAR_DOT && is_digit(this.peek(2))) {
+        return this.consume_number(start_line, start_column);
+      }
+    }
+    this.advance();
+    return this.make_token(TOKEN_DELIM, start, this.pos, start_line, start_column);
+  }
+  consume_whitespace(start_line, start_column) {
+    let start = this.pos;
+    while (this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (!is_whitespace(ch) && !is_newline(ch)) break;
+      this.advance();
+    }
+    return this.make_token(TOKEN_WHITESPACE, start, this.pos, start_line, start_column);
+  }
+  consume_comment(start_line, start_column) {
+    let start = this.pos;
+    this.advance(2);
+    while (this.pos < this.source.length - 1) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (ch === CHAR_ASTERISK && this.source.charCodeAt(this.pos + 1) === CHAR_FORWARD_SLASH) {
+        this.advance(2);
+        break;
+      }
+      this.advance();
+    }
+    return this.make_token(TOKEN_COMMENT, start, this.pos, start_line, start_column);
+  }
+  consume_string(quote, start_line, start_column) {
+    let start = this.pos;
+    this.advance();
+    while (this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (ch === quote) {
+        this.advance();
+        return this.make_token(TOKEN_STRING, start, this.pos, start_line, start_column);
+      }
+      if (is_newline(ch)) {
+        return this.make_token(TOKEN_BAD_STRING, start, this.pos, start_line, start_column);
+      }
+      if (ch === CHAR_BACKSLASH) {
+        this.advance();
+        if (this.pos < this.source.length) {
+          let next = this.source.charCodeAt(this.pos);
+          if (is_hex_digit(next)) {
+            this.consume_hex_escape();
+          } else if (!is_newline(next)) {
+            this.advance();
+          } else {
+            this.advance();
+          }
+        }
+        continue;
+      }
+      this.advance();
+    }
+    return this.make_token(TOKEN_BAD_STRING, start, this.pos, start_line, start_column);
+  }
+  consume_hex_escape() {
+    let count = 0;
+    while (count < 6 && this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (!is_hex_digit(ch)) break;
+      this.advance();
+      count++;
+    }
+    if (this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (is_whitespace(ch) || is_newline(ch)) {
+        this.advance();
+      }
+    }
+  }
+  consume_number(start_line, start_column) {
+    let start = this.pos;
+    let ch = this.source.charCodeAt(this.pos);
+    if (ch === CHAR_PLUS || ch === CHAR_HYPHEN) {
+      this.advance();
+    }
+    while (this.pos < this.source.length && is_digit(this.source.charCodeAt(this.pos))) {
+      this.advance();
+    }
+    if (this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_DOT && this.pos + 1 < this.source.length && is_digit(this.source.charCodeAt(this.pos + 1))) {
+      this.advance();
+      while (this.pos < this.source.length && is_digit(this.source.charCodeAt(this.pos))) {
+        this.advance();
+      }
+    }
+    if (this.pos < this.source.length) {
+      let ch2 = this.source.charCodeAt(this.pos);
+      if (ch2 === CHAR_LOWERCASE_E || ch2 === CHAR_UPPERCASE_E) {
+        let next = this.peek();
+        if (is_digit(next) || (next === CHAR_PLUS || next === CHAR_HYPHEN) && is_digit(this.peek(2))) {
+          this.advance();
+          if (this.pos < this.source.length) {
+            let sign = this.source.charCodeAt(this.pos);
+            if (sign === CHAR_PLUS || sign === CHAR_HYPHEN) {
+              this.advance();
+            }
+          }
+          while (this.pos < this.source.length && is_digit(this.source.charCodeAt(this.pos))) {
+            this.advance();
+          }
+        }
+      }
+    }
+    if (this.pos < this.source.length) {
+      let ch2 = this.source.charCodeAt(this.pos);
+      if (ch2 === CHAR_PERCENT) {
+        this.advance();
+        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))) {
+          this.advance();
+        }
+        return this.make_token(TOKEN_DIMENSION, start, this.pos, start_line, start_column);
+      }
+    }
+    return this.make_token(TOKEN_NUMBER, start, this.pos, start_line, start_column);
+  }
+  consume_ident_or_function(start_line, start_column) {
+    let start = this.pos;
+    while (this.pos < this.source.length) {
+      let ch = this.source.charCodeAt(this.pos);
+      if (ch === CHAR_BACKSLASH) {
+        if (this.pos + 1 >= this.source.length) break;
+        let next = this.source.charCodeAt(this.pos + 1);
+        if (is_newline(next)) break;
+        this.advance();
+        if (is_hex_digit(next)) {
+          this.advance();
+          for (let i = 0; i < 5 && this.pos < this.source.length; i++) {
+            if (!is_hex_digit(this.source.charCodeAt(this.pos))) break;
+            this.advance();
+          }
+          if (this.pos < this.source.length) {
+            let ws = this.source.charCodeAt(this.pos);
+            if (is_whitespace(ws) || is_newline(ws)) {
+              this.advance();
+            }
+          }
+        } else {
+          this.advance();
+        }
+      } else if (is_ident_char(ch)) {
+        this.advance();
+      } else {
+        break;
+      }
+    }
+    if (this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_LEFT_PAREN) {
+      this.advance();
+      return this.make_token(TOKEN_FUNCTION, start, this.pos, start_line, start_column);
+    }
+    return this.make_token(TOKEN_IDENT, start, this.pos, start_line, start_column);
+  }
+  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))) {
+      this.advance();
+    }
+    return this.make_token(TOKEN_AT_KEYWORD, start, this.pos, start_line, start_column);
+  }
+  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))) {
+      this.advance();
+    }
+    return this.make_token(TOKEN_HASH, start, this.pos, start_line, start_column);
+  }
+  advance(count = 1) {
+    if (count === 1) {
+      if (this.pos >= this.source.length) return;
+      let ch = this.source.charCodeAt(this.pos);
+      this.pos++;
+      if (is_newline(ch)) {
+        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++;
+      }
+      return;
+    }
+    for (let i = 0; i < count; i++) {
+      if (this.pos >= this.source.length) break;
+      let ch = this.source.charCodeAt(this.pos);
+      this.pos++;
+      if (is_newline(ch)) {
+        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++;
+      }
+    }
+  }
+  peek(offset = 1) {
+    let index = this.pos + offset;
+    if (index >= this.source.length) return 0;
+    return this.source.charCodeAt(index);
+  }
+  make_token(type, start, end, line = this.line, column = this.column) {
+    this.token_type = type;
+    this.token_start = start;
+    this.token_end = end;
+    this.token_line = line;
+    this.token_column = column;
+    return type;
+  }
+  // Public API: returns Token object for backwards compatibility
+  next_token(skip_whitespace = false) {
+    this.next_token_fast(skip_whitespace);
+    return {
+      type: this.token_type,
+      start: this.token_start,
+      end: this.token_end,
+      line: this.token_line,
+      column: this.token_column
+    };
+  }
+  /**
+   * Save complete lexer state for backtracking
+   * @returns Object containing all lexer state
+   */
+  save_position() {
+    return {
+      pos: this.pos,
+      line: this.line,
+      column: this.column,
+      token_type: this.token_type,
+      token_start: this.token_start,
+      token_end: this.token_end,
+      token_line: this.token_line,
+      token_column: this.token_column
+    };
+  }
+  /**
+   * Restore lexer state from saved position
+   * @param saved The saved position to restore
+   */
+  restore_position(saved) {
+    this.pos = saved.pos;
+    this.line = saved.line;
+    this.column = saved.column;
+    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;
+  }
+}
 function* tokenize(source, skip_comments = true) {
   const lexer = new Lexer(source, skip_comments);
   while (true) {
@@ -12,4 +438,4 @@ function* tokenize(source, skip_comments = true) {
   }
 }
 
-export { tokenize };
+export { Lexer, tokenize };

package/dist/walk.d.ts

@@ -3,34 +3,12 @@ export declare const SKIP: unique symbol;
 export declare const BREAK: unique symbol;
 type WalkCallback = (node: CSSNode, depth: number) => void | typeof SKIP | typeof BREAK;
 /**
- * Walk the AST in depth-first order, calling the callback for each node
+ * Walk the AST in depth-first order, calling the callback for each node.
+ * Return SKIP to skip children, BREAK to stop traversal. See API.md for examples.
  *
  * @param node - The root node to start walking from
- * @param callback - Function to call for each node visited. Receives the node and its depth (0 for root).
- *                   Return SKIP to skip children of current node, or BREAK to stop traversal entirely.
+ * @param callback - Function called for each node. Receives the node and its depth (0 for root).
  * @param depth - Starting depth (default: 0)
- *
- * @example
- * import { parse, walk, SKIP, BREAK } from '@projectwallace/css-parser'
- *
- * const ast = parse('.a { .b { .c { color: red; } } }')
- *
- * // Skip nested rules
- * walk(ast, (node) => {
- *   if (node.type === STYLE_RULE) {
- *     console.log(node.text)
- *     return SKIP // Don't visit nested rules
- *   }
- * })
- * // Output: .a { ... }, but not .b or .c
- *
- * // Stop on first declaration
- * walk(ast, (node) => {
- *   if (node.type === DECLARATION) {
- *     console.log(node.name)
- *     return BREAK // Stop traversal
- *   }
- * })
  */
 export declare function walk(node: CSSNode, callback: WalkCallback, depth?: number): boolean;
 type WalkEnterLeaveCallback = (node: CSSNode) => void | typeof SKIP | typeof BREAK;
@@ -39,36 +17,11 @@ interface WalkEnterLeaveOptions {
     leave?: WalkEnterLeaveCallback;
 }
 /**
- * Walk the AST in depth-first order, calling enter before visiting children and leave after
+ * Walk the AST in depth-first order, calling enter before visiting children and leave after.
+ * Return SKIP in enter to skip children (leave still called), BREAK to stop (leave NOT called). See API.md for examples.
  *
  * @param node - The root node to start walking from
  * @param options - Object with optional enter and leave callback functions
- * @param options.enter - Called before visiting children. Return SKIP to skip children (leave still called),
- *                        or BREAK to stop traversal entirely (leave NOT called).
- * @param options.leave - Called after visiting children. Return BREAK to stop traversal.
- *
- * @example
- * import { parse, traverse, SKIP, BREAK } from '@projectwallace/css-parser'
- *
- * const ast = parse('@media screen { .a { color: red; } }')
- *
- * // Track context with skip
- * let depth = 0
- * traverse(ast, {
- *   enter(node) {
- *     depth++
- *     if (node.type === AT_RULE) {
- *       console.log('Entering media query at depth', depth)
- *       return SKIP // Skip contents but still call leave
- *     }
- *   },
- *   leave(node) {
- *     if (node.type === AT_RULE) {
- *       console.log('Leaving media query at depth', depth)
- *     }
- *     depth--
- *   }
- * })
  */
 export declare function traverse(node: CSSNode, { enter, leave }?: WalkEnterLeaveOptions): boolean;
 export {};

package/dist/walk.js

@@ -1,5 +1,5 @@
-const SKIP = Symbol("SKIP");
-const BREAK = Symbol("BREAK");
+const SKIP = /* @__PURE__ */ Symbol("SKIP");
+const BREAK = /* @__PURE__ */ Symbol("BREAK");
 function walk(node, callback, depth = 0) {
   const result = callback(node, depth);
   if (result === BREAK) {

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@projectwallace/css-parser",
-	"version": "0.8.4",
+	"version": "0.8.6",
 	"description": "High-performance CSS lexer and parser, optimized for CSS inspection and analysis",
-	"author": "Bart Veneman <bat@projectwallace.com>",
+	"author": "Bart Veneman <bart@projectwallace.com>",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -70,6 +70,7 @@
 		"ast"
 	],
 	"devDependencies": {
+		"@codecov/vite-plugin": "^1.9.1",
 		"@projectwallace/preset-oxlint": "^0.0.7",
 		"@types/node": "^24.10.1",
 		"@vitest/coverage-v8": "^4.0.8",
@@ -84,5 +85,10 @@
 		"typescript": "^5.9.3",
 		"vite": "^7.2.2",
 		"vitest": "^4.0.8"
+	},
+	"overrides": {
+		"@codecov/vite-plugin": {
+			"vite": "$vite"
+		}
 	}
 }

package/dist/lexer.d.ts

@@ -1,11 +0,0 @@
-import { type TokenType } from './token-types';
-export interface LexerPosition {
-    pos: number;
-    line: number;
-    column: number;
-    token_type: TokenType;
-    token_start: number;
-    token_end: number;
-    token_line: number;
-    token_column: number;
-}