@eslint/css-tree 3.6.9 → 4.0.1

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/index.d.ts

@@ -2921,14 +2921,64 @@ interface SyntaxMatchGraph {
     source: DSNode;
 }
 
+/**
+ * Kinds of syntax descriptors created by the lexer.
+ */
+type SyntaxDescriptorType = "AtruleDescriptor" | "AtrulePrelude" | "Property" | "Type";
+
+/**
+ * The built-in unit groups stored on a `Lexer` instance.
+ */
+interface LexerUnits {
+    /**
+     * Length units such as `px`, `em`, and `vh`.
+     */
+    length: string[];
+
+    /**
+     * Angle units such as `deg` and `rad`.
+     */
+    angle: string[];
+
+    /**
+     * Time units such as `s` and `ms`.
+     */
+    time: string[];
+
+    /**
+     * Frequency units such as `hz` and `khz`.
+     */
+    frequency: string[];
+
+    /**
+     * Resolution units such as `dpi` and `dppx`.
+     */
+    resolution: string[];
+
+    /**
+     * Flex units such as `fr`.
+     */
+    flex: string[];
+
+    /**
+     * Volume-related decibel units.
+     */
+    decibel: string[];
+
+    /**
+     * Pitch-related semitone units.
+     */
+    semitones: string[];
+}
+
 /**
  * Describes a syntax rule or definition.
  */
-type SyntaxDescriptor = {
+type SyntaxDescriptor<Kind extends SyntaxDescriptorType = SyntaxDescriptorType> = {
     /**
      * The type of the syntax descriptor (e.g., "Type", "Property").
      */
-    type: string;
+    type: Kind;
 
     /**
      * The name of the syntax descriptor.
@@ -2946,9 +2996,9 @@ type SyntaxDescriptor = {
     serializable: boolean;
 
     /**
-     * The syntax object associated with the descriptor.
+     * The parsed definition-syntax AST, or `null` for function-backed descriptors.
      */
-    syntax: Syntax;
+    syntax: DSNode | null;
 
     /**
      * The graph of syntax matches for this descriptor, or `null` if none exists.
@@ -2958,9 +3008,34 @@ type SyntaxDescriptor = {
     /**
      * A reference to a graph of syntax matches, or `null` if none exists.
      */
-    matchRef?: SyntaxMatchGraph | null;
+    matchRef: SyntaxMatchGraph | null;
 };
 
+/**
+ * An at-rule definition exposed through `Lexer#atrules`.
+ */
+interface LexerAtruleDefinition {
+    /**
+     * Discriminator for at-rule entries.
+     */
+    type: "Atrule";
+
+    /**
+     * The at-rule name.
+     */
+    name: string;
+
+    /**
+     * The descriptor for the at-rule prelude, if one exists.
+     */
+    prelude: SyntaxDescriptor<"AtrulePrelude"> | null;
+
+    /**
+     * At-rule descriptors keyed by descriptor name, if any.
+     */
+    descriptors: Record<string, SyntaxDescriptor<"AtruleDescriptor"> | undefined> | null;
+}
+
 /**
  * Represents a fragment match, including its parent list and nodes.
  */
@@ -2996,6 +3071,46 @@ type LexerValidationResult = {
  * It provides utilities for handling at-rules, properties, types, and general syntax.
  */
 export class Lexer {
+    /**
+     * CSS-wide keywords accepted by the lexer.
+     */
+    cssWideKeywords: string[];
+
+    /**
+     * The associated `Syntax` instance, if the lexer was created from one.
+     */
+    syntax: Syntax | undefined;
+
+    /**
+     * Whether generic types are enabled for this lexer.
+     */
+    generic: boolean;
+
+    /**
+     * Known CSS units grouped by unit family.
+     */
+    units: LexerUnits;
+
+    /**
+     * Known at-rule definitions keyed by at-rule name.
+     */
+    atrules: Record<string, LexerAtruleDefinition | undefined>;
+
+    /**
+     * Known property definitions keyed by property name.
+     */
+    properties: Record<string, SyntaxDescriptor<"Property"> | undefined>;
+
+    /**
+     * Known type definitions keyed by type name.
+     */
+    types: Record<string, SyntaxDescriptor<"Type"> | undefined>;
+
+    /**
+     * Node structure validators used by `checkStructure()`.
+     */
+    structure: Structure;
+
     /**
      * Creates a new `Lexer` instance.
      *
@@ -3147,13 +3262,13 @@ export class Lexer {
     findAllFragments(ast: AnyCssNode, type: string, name: string): FragmentMatch[];
 
     /**
-     * Retrieves the syntax descriptor for an at-rule.
+     * Retrieves the definition for an at-rule.
      *
      * @param atruleName - The name of the at-rule.
      * @param fallbackBasename - (Optional) Whether to use a fallback basename.
-     * @returns The syntax descriptor or `null` if not found.
+     * @returns The at-rule definition or `null` if not found.
      */
-    getAtrule(atruleName: string, fallbackBasename?: boolean): SyntaxDescriptor | null;
+    getAtrule(atruleName: string, fallbackBasename?: boolean): LexerAtruleDefinition | null;
 
     /**
      * Retrieves the prelude descriptor for an at-rule.
@@ -3162,7 +3277,7 @@ export class Lexer {
      * @param fallbackBasename - (Optional) Whether to use a fallback basename.
      * @returns The syntax descriptor or `null` if not found.
      */
-    getAtrulePrelude(atruleName: string, fallbackBasename?: boolean): SyntaxDescriptor | null;
+    getAtrulePrelude(atruleName: string, fallbackBasename?: boolean): SyntaxDescriptor<"AtrulePrelude"> | null;
 
     /**
      * Retrieves the descriptor for an at-rule's property.
@@ -3171,7 +3286,7 @@ export class Lexer {
      * @param name - The property name.
      * @returns The syntax descriptor or `null` if not found.
      */
-    getAtruleDescriptor(atruleName: string, name: string): SyntaxDescriptor | null;
+    getAtruleDescriptor(atruleName: string, name: string): SyntaxDescriptor<"AtruleDescriptor"> | null;
 
     /**
      * Retrieves the syntax descriptor for a property.
@@ -3180,7 +3295,7 @@ export class Lexer {
      * @param fallbackBasename - (Optional) Whether to use a fallback basename.
      * @returns The syntax descriptor or `null` if not found.
      */
-    getProperty(propertyName: string, fallbackBasename?: boolean): SyntaxDescriptor | null;
+    getProperty(propertyName: string, fallbackBasename?: boolean): SyntaxDescriptor<"Property"> | null;
 
     /**
      * Retrieves the syntax descriptor for a type.
@@ -3188,7 +3303,7 @@ export class Lexer {
      * @param name - The name of the type.
      * @returns The syntax descriptor or `null` if not found.
      */
-    getType(name: string): SyntaxDescriptor | null;
+    getType(name: string): SyntaxDescriptor<"Type"> | null;
 
     /**
      * Validates the syntax rules and properties.

package/lib/lexer/Lexer.js

@@ -439,9 +439,13 @@ export class Lexer {
         return atrule && atrule.prelude || null;
     }
     getAtruleDescriptor(atruleName, name) {
-        return this.atrules.hasOwnProperty(atruleName) && this.atrules.declarators
-            ? this.atrules[atruleName].declarators[name] || null
+        const atrule = this.getAtrule(atruleName);
+        const descriptor = names.keyword(name);
+        const descriptorEntry = atrule && atrule.descriptors
+            ? atrule.descriptors[descriptor.name] || atrule.descriptors[descriptor.basename]
             : null;
+
+        return descriptorEntry || null;
     }
     getProperty(propertyName, fallbackBasename = true) {
         const property = names.property(propertyName);

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint/css-tree",
-  "version": "3.6.9",
+  "version": "4.0.1",
   "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",