@eslint/css-tree 3.6.8 → 4.0.0

package/lib/generator/token-before.js

@@ -1,5 +1,4 @@
 import {
-    WhiteSpace,
     Delim,
     Ident,
     Function as FunctionToken,
@@ -20,17 +19,20 @@ import {
 const PLUSSIGN = 0x002B;    // U+002B PLUS SIGN (+)
 const HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)
 
+// code:
+// 0xxxxxxx x0000000 - char code (0x80 for non-ASCII) or delim value
+// 00000000 0xxxxxx0 - token type (0 for delim, 1 for token)
+// 00000000 0000000x - reserved for carriage emit flag (0 for no space, 1 for space)
 const code = (type, value) => {
     if (type === Delim) {
         type = value;
     }
 
     if (typeof type === 'string') {
-        const charCode = type.charCodeAt(0);
-        return charCode > 0x7F ? 0x8000 : charCode << 8;
+        type = Math.min(type.charCodeAt(0), 0x80) << 6; // replace non-ASCII with 0x80
     }
 
-    return type;
+    return type << 1;
 };
 
 // https://www.w3.org/TR/css-syntax-3/#serialization
@@ -167,14 +169,10 @@ function createMap(pairs) {
                 type !== FunctionToken &&
                 type !== CDC) ||
             (nextCharCode === PLUSSIGN)
-                ? isWhiteSpaceRequired.has(prevCode << 16 | nextCharCode << 8)
-                : isWhiteSpaceRequired.has(prevCode << 16 | nextCode);
+                ? isWhiteSpaceRequired.has((prevCode & 0xFFFE) << 16 | nextCharCode << 7)
+                : isWhiteSpaceRequired.has((prevCode & 0xFFFE) << 16 | nextCode);
 
-        if (emitWs) {
-            this.emit(' ', WhiteSpace, true);
-        }
-
-        return nextCode;
+        return nextCode | emitWs;
     };
 }
 

package/lib/lexer/generic.js

@@ -698,10 +698,41 @@ export function createDemensionTypes(units) {
     };
 }
 
+// The <attr-unit> production matches any identifier that is an ASCII case-insensitive
+// match for the name of a CSS dimension unit, such as px, or the <delim-token> %.
+function createAttrUnit(units) {
+    const unitSet = new Set();
+
+    for (const group of unitGroups) {
+        if (Array.isArray(units[group])) {
+            for (const unit of units[group]) {
+                unitSet.add(unit.toLowerCase());
+            }
+        }
+    }
+
+    return function attrUnit(token) {
+        if (token === null) {
+            return 0;
+        }
+
+        if (token.type === Delim && token.value === '%') {
+            return 1;
+        }
+
+        if (token.type === Ident && unitSet.has(token.value.toLowerCase())) {
+            return 1;
+        }
+
+        return 0;
+    };
+}
+
 export function createGenericTypes(units) {
     return {
         ...tokenTypes,
         ...productionTypes,
-        ...createDemensionTypes(units)
+        ...createDemensionTypes(units),
+        'attr-unit': createAttrUnit(units)
     };
 };

package/lib/parser/create.js

@@ -29,6 +29,36 @@ const SEMICOLON = 0x003B;        // U+003B SEMICOLON (;)
 const LEFTCURLYBRACKET = 0x007B; // U+007B LEFT CURLY BRACKET ({)
 const NULL = 0;
 
+const arrayMethods = {
+    createList() {
+        return [];
+    },
+    createSingleNodeList(node) {
+        return [node];
+    },
+    getFirstListNode(list) {
+        return list && list[0] || null;
+    },
+    getLastListNode(list) {
+        return list && list.length > 0 ? list[list.length - 1] : null;
+    }
+};
+
+const listMethods = {
+    createList() {
+        return new List();
+    },
+    createSingleNodeList(node) {
+        return new List().appendData(node);
+    },
+    getFirstListNode(list) {
+        return list && list.first;
+    },
+    getLastListNode(list) {
+        return list && list.last;
+    }
+};
+
 function createParseContext(name) {
     return function() {
         return this[name]();
@@ -110,18 +140,10 @@ export function createParser(config) {
             return code === SEMICOLON ? 2 : 0;
         },
 
-        createList() {
-            return new List();
-        },
-        createSingleNodeList(node) {
-            return new List().appendData(node);
-        },
-        getFirstListNode(list) {
-            return list && list.first;
-        },
-        getLastListNode(list) {
-            return list && list.last;
-        },
+        createList: NOOP,
+        createSingleNodeList: NOOP,
+        getFirstListNode: NOOP,
+        getLastListNode: NOOP,
 
         parseWithFallback(consumer, fallback) {
             const startIndex = this.tokenIndex;
@@ -346,12 +368,14 @@ export function createParser(config) {
         parser.parseValue = 'parseValue' in options ? Boolean(options.parseValue) : true;
         parser.parseCustomProperty = 'parseCustomProperty' in options ? Boolean(options.parseCustomProperty) : false;
 
-        const { context = 'default', onComment, onToken } = options;
+        const { context = 'default', list = true, onComment, onToken } = options;
 
         if (context in parser.context === false) {
             throw new Error('Unknown context `' + context + '`');
         }
 
+        Object.assign(parser, list ? listMethods : arrayMethods);
+
         if (Array.isArray(onToken)) {
             parser.forEachToken((type, start, end) => {
                 onToken.push({ type, start, end });

package/lib/syntax/atrule/layer.js

@@ -5,8 +5,8 @@ export default {
                 this.LayerList()
             );
         },
-        block() {
-            return this.Block(false);
+        block(nested = false, { allowNestedRules = false } = {}) {
+            return this.Block(nested, { allowNestedRules });
         }
     }
 };

package/lib/syntax/node/Block.js

@@ -6,6 +6,7 @@ import {
     Hash,
     Colon,
     Ident,
+    Function,
     AtKeyword,
     LeftSquareBracket,
     LeftCurlyBracket,
@@ -58,10 +59,50 @@ function isElementSelectorStart() {
 
     const nextTokenType = this.lookupTypeNonSC(1);
 
+    // If next token is not colon, semicolon, or right curly bracket, it's likely a selector
     if (nextTokenType !== Colon && nextTokenType !== Semicolon && nextTokenType !== RightCurlyBracket) {
         return true;
     }
 
+    // If next token is colon, we need to look further ahead to distinguish
+    // between property declarations (p: value) and pseudo-class selectors (p:hover)
+    if (nextTokenType === Colon) {
+        // Look for the token after the colon (skipping whitespace)
+        const tokenAfterColon = this.lookupTypeNonSC(2);
+
+        // If it's an identifier (like 'hover', 'first-of-type') or function (like 'nth-child()', 'not()'),
+        // this could be a pseudo-class
+        if (tokenAfterColon === Ident || tokenAfterColon === Function) {
+            // Look further ahead to see if there's a left curly bracket
+            // which would indicate this is a selector with a block
+            let offset = 3;
+            let tokenType;
+
+            // Skip whitespace and look for either a left curly bracket or other tokens
+            while (offset <= 15) { // Increased limit to handle function pseudo-classes
+                tokenType = this.lookupType(offset);
+
+                if (tokenType === LeftCurlyBracket) {
+                    // Found opening brace, this is definitely a selector
+                    return true;
+                } else if (tokenType === Semicolon || tokenType === RightCurlyBracket) {
+                    // Found semicolon or closing brace before opening brace, likely a property
+                    return false;
+                } else if (tokenType === WhiteSpace || tokenType === Comment) {
+                    // Skip whitespace and comments
+                    offset++;
+                    continue;
+                } else {
+                    // Other tokens might indicate more complex selectors, continue looking
+                    offset++;
+                }
+            }
+        }
+
+        // If we can't determine conclusively, default to property behavior
+        return false;
+    }
+
     return false;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint/css-tree",
-  "version": "3.6.8",
+  "version": "4.0.0",
   "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",
@@ -107,21 +107,21 @@
     "test:types": "tsc -p tests/types/tsconfig.json"
   },
   "dependencies": {
-    "mdn-data": "2.23.0",
-    "source-map-js": "^1.0.1"
+    "mdn-data": "2.27.1",
+    "source-map-js": "^1.2.1"
   },
   "devDependencies": {
-    "c8": "^7.12.0",
+    "c8": "^11.0.0",
     "clap": "^2.0.1",
-    "esbuild": "^0.24.0",
-    "eslint": "^8.4.1",
+    "esbuild": "^0.27.3",
+    "eslint": "^8.50.0",
     "json-to-ast": "^2.1.0",
     "mocha": "^9.2.2",
-    "rollup": "^2.79.2",
+    "rollup": "^2.80.0",
     "typescript": "^5.7.3"
   },
   "engines": {
-    "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+    "node": "^20.19.0 || ^22.13.0 || >=24"
   },
   "files": [
     "data",