@eslint/css-tree 3.6.6 → 3.6.7

package/dist/version.cjs

@@ -1 +1 @@
-module.exports = "3.6.6";
+module.exports = "3.6.7";

package/dist/version.js

@@ -1 +1 @@
-export const version = "3.6.6";
+export const version = "3.6.7";

package/lib/syntax/node/Block.js

@@ -66,8 +66,31 @@ function isElementSelectorStart() {
 }
 
 function isSelectorStart() {
-    return this.tokenType === Delim && selectorStarts.has(this.source.charCodeAt(this.tokenStart)) ||
-        this.tokenType === Hash || this.tokenType === LeftSquareBracket ||
+    // Check for Delim tokens that might be selector starts
+    if (this.tokenType === Delim && selectorStarts.has(this.source.charCodeAt(this.tokenStart))) {
+        const code = this.source.charCodeAt(this.tokenStart);
+
+        // Special case: browser hack prefixes (*, +, &) followed immediately by an ident
+        // (no whitespace) are declarations, not selectors. Examples: *zoom: 1; +width: 100px; &prop: value;
+        if (code === STAR || code === PLUSSIGN || code === AMPERSAND) {
+            const nextToken = this.lookupType(1);
+            const nextTokenNonSC = this.lookupTypeNonSC(1);
+
+            // If next token is Ident and there's no whitespace between, it's a declaration
+            if (nextToken === Ident && nextTokenNonSC === Ident) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // Hash can be either a Hash token (#id selector) or Delim(#) + Ident (browser hack)
+    // When it's a Hash token, it's a selector. When it's Delim, check if followed by Ident without whitespace
+    if (this.tokenType === Hash) {
+        return true;
+    }
+
+    return this.tokenType === LeftSquareBracket ||
         this.tokenType === Colon || isElementSelectorStart.call(this);
 }
 

package/lib/syntax/node/DeclarationList.js

@@ -2,15 +2,71 @@ import {
     WhiteSpace,
     Comment,
     Semicolon,
-    AtKeyword
+    AtKeyword,
+    Delim,
+    Hash,
+    LeftSquareBracket,
+    Colon,
+    Ident,
+    RightCurlyBracket
 } from '../../tokenizer/index.js';
 
 const AMPERSAND = 0x0026;       // U+0026 AMPERSAND (&)
+const DOT = 0x002E;             // U+002E FULL STOP (.)
+const STAR = 0x002A;            // U+002A ASTERISK (*);
+const PLUSSIGN = 0x002B;        // U+002B PLUS SIGN (+)
+const GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)
+const TILDE = 0x007E;           // U+007E TILDE (~)
+
+const selectorStarts = new Set([
+    AMPERSAND,
+    DOT,
+    STAR,
+    PLUSSIGN,
+    GREATERTHANSIGN,
+    TILDE
+]);
 
 function consumeRaw() {
     return this.Raw(this.consumeUntilSemicolonIncluded, true);
 }
 
+function isElementSelectorStart() {
+    if (this.tokenType !== Ident) {
+        return false;
+    }
+
+    const nextTokenType = this.lookupTypeNonSC(1);
+
+    // Simple case: if next token is not colon, semicolon, or closing brace, it's likely a selector
+    if (nextTokenType !== Colon && nextTokenType !== Semicolon && nextTokenType !== RightCurlyBracket) {
+        return true;
+    }
+
+    // Special handling for colon case - could be pseudo-class/pseudo-element
+    if (nextTokenType === Colon) {
+        // Look ahead further to see what follows the colon
+        const afterColonType = this.lookupTypeNonSC(2);
+
+        // If after colon there's an identifier (pseudo-class/pseudo-element name),
+        // check what comes after that
+        if (afterColonType === Ident) {
+            const afterPseudoType = this.lookupTypeNonSC(3);
+            // If it's followed by { or other selector tokens, it's a selector
+            // If it's followed by ; or } or EOF, it's not a selector (property)
+            return afterPseudoType !== Semicolon && afterPseudoType !== RightCurlyBracket && afterPseudoType !== 0; // 0 is EOF
+        }
+    }
+
+    return false;
+}
+
+function isSelectorStart() {
+    return this.tokenType === Delim && selectorStarts.has(this.source.charCodeAt(this.tokenStart)) ||
+        this.tokenType === Hash || this.tokenType === LeftSquareBracket ||
+        this.tokenType === Colon || isElementSelectorStart.call(this);
+}
+
 export const name = 'DeclarationList';
 export const structure = {
     children: [[
@@ -37,7 +93,7 @@ export function parse() {
                 break;
 
             default:
-                if (this.isDelim(AMPERSAND))  {
+                if (isSelectorStart.call(this))  {
                     children.push(this.parseWithFallback(this.Rule, consumeRaw));
                 } else {
                     children.push(this.parseWithFallback(this.Declaration, consumeRaw));

package/lib/syntax/node/TypeSelector.js

@@ -9,6 +9,20 @@ function eatIdentifierOrAsterisk() {
         this.error('Identifier or asterisk is expected');
     }
 
+    // Check if asterisk is followed immediately by an ident (no whitespace)
+    // This is invalid in selectors (e.g., "*foo" should error, "* foo" or "*:hover" is ok)
+    if (this.isDelim(ASTERISK)) {
+        const currentTokenEnd = this.tokenStart + 1; // asterisk is 1 char
+        this.next();
+
+        // If next token is an ident and starts immediately after asterisk, it's an error
+        if (this.tokenType === Ident && this.tokenStart === currentTokenEnd) {
+            this.error('Whitespace is required between universal selector and type selector');
+        }
+
+        return;
+    }
+
     this.next();
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint/css-tree",
-  "version": "3.6.6",
+  "version": "3.6.7",
   "description": "A tool set for CSS: fast detailed parser (CSS → AST), walker (AST traversal), generator (AST → CSS) and lexer (validation and matching) based on specs and browser implementations",
   "author": "Roman Dvornov <rdvornov@gmail.com> (https://github.com/lahmatiy)",
   "license": "MIT",