@eslint/css-tree 3.2.0

package/lib/syntax/node/Declaration.js

@@ -0,0 +1,165 @@
+import { isCustomProperty } from '../../utils/names.js';
+import {
+    Ident,
+    Hash,
+    Colon,
+    Semicolon,
+    Delim,
+    WhiteSpace
+} from '../../tokenizer/index.js';
+
+const EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)
+const NUMBERSIGN = 0x0023;      // U+0023 NUMBER SIGN (#)
+const DOLLARSIGN = 0x0024;      // U+0024 DOLLAR SIGN ($)
+const AMPERSAND = 0x0026;       // U+0026 AMPERSAND (&)
+const ASTERISK = 0x002A;        // U+002A ASTERISK (*)
+const PLUSSIGN = 0x002B;        // U+002B PLUS SIGN (+)
+const SOLIDUS = 0x002F;         // U+002F SOLIDUS (/)
+
+function consumeValueRaw() {
+    return this.Raw(this.consumeUntilExclamationMarkOrSemicolon, true);
+}
+
+function consumeCustomPropertyRaw() {
+    return this.Raw(this.consumeUntilExclamationMarkOrSemicolon, false);
+}
+
+function consumeValue() {
+    const startValueToken = this.tokenIndex;
+    const value = this.Value();
+
+    if (value.type !== 'Raw' &&
+        this.eof === false &&
+        this.tokenType !== Semicolon &&
+        this.isDelim(EXCLAMATIONMARK) === false &&
+        this.isBalanceEdge(startValueToken) === false) {
+        this.error();
+    }
+
+    return value;
+}
+
+export const name = 'Declaration';
+export const walkContext = 'declaration';
+export const structure = {
+    important: [Boolean, String],
+    property: String,
+    value: ['Value', 'Raw']
+};
+
+export function parse() {
+    const start = this.tokenStart;
+    const startToken = this.tokenIndex;
+    const property = readProperty.call(this);
+    const customProperty = isCustomProperty(property);
+    const parseValue = customProperty ? this.parseCustomProperty : this.parseValue;
+    const consumeRaw = customProperty ? consumeCustomPropertyRaw : consumeValueRaw;
+    let important = false;
+    let value;
+
+    this.skipSC();
+    this.eat(Colon);
+
+    const valueStart = this.tokenIndex;
+
+    if (!customProperty) {
+        this.skipSC();
+    }
+
+    if (parseValue) {
+        value = this.parseWithFallback(consumeValue, consumeRaw);
+    } else {
+        value = consumeRaw.call(this, this.tokenIndex);
+    }
+
+    if (customProperty && value.type === 'Value' && value.children.isEmpty) {
+        for (let offset = valueStart - this.tokenIndex; offset <= 0; offset++) {
+            if (this.lookupType(offset) === WhiteSpace) {
+                value.children.appendData({
+                    type: 'WhiteSpace',
+                    loc: null,
+                    value: ' '
+                });
+                break;
+            }
+        }
+    }
+
+    if (this.isDelim(EXCLAMATIONMARK)) {
+        important = getImportant.call(this);
+        this.skipSC();
+    }
+
+    // Do not include semicolon to range per spec
+    // https://drafts.csswg.org/css-syntax/#declaration-diagram
+
+    if (this.eof === false &&
+        this.tokenType !== Semicolon &&
+        this.isBalanceEdge(startToken) === false) {
+        this.error();
+    }
+
+    return {
+        type: 'Declaration',
+        loc: this.getLocation(start, this.tokenStart),
+        important,
+        property,
+        value
+    };
+}
+
+export function generate(node) {
+    this.token(Ident, node.property);
+    this.token(Colon, ':');
+    this.node(node.value);
+
+    if (node.important) {
+        this.token(Delim, '!');
+        this.token(Ident, node.important === true ? 'important' : node.important);
+    }
+}
+
+function readProperty() {
+    const start = this.tokenStart;
+
+    // hacks
+    if (this.tokenType === Delim) {
+        switch (this.charCodeAt(this.tokenStart)) {
+            case ASTERISK:
+            case DOLLARSIGN:
+            case PLUSSIGN:
+            case NUMBERSIGN:
+            case AMPERSAND:
+                this.next();
+                break;
+
+            // TODO: not sure we should support this hack
+            case SOLIDUS:
+                this.next();
+                if (this.isDelim(SOLIDUS)) {
+                    this.next();
+                }
+                break;
+        }
+    }
+
+    if (this.tokenType === Hash) {
+        this.eat(Hash);
+    } else {
+        this.eat(Ident);
+    }
+
+    return this.substrToCursor(start);
+}
+
+// ! ws* important
+function getImportant() {
+    this.eat(Delim);
+    this.skipSC();
+
+    const important = this.consume(Ident);
+
+    // store original value in case it differ from `important`
+    // for better original source restoring and hacks like `!ie` support
+    return important === 'important' ? true : important;
+}

package/lib/syntax/node/DeclarationList.js

@@ -0,0 +1,62 @@
+import {
+    WhiteSpace,
+    Comment,
+    Semicolon,
+    AtKeyword
+} from '../../tokenizer/index.js';
+
+const AMPERSAND = 0x0026;       // U+0026 AMPERSAND (&)
+
+function consumeRaw() {
+    return this.Raw(this.consumeUntilSemicolonIncluded, true);
+}
+
+export const name = 'DeclarationList';
+export const structure = {
+    children: [[
+        'Declaration',
+        'Atrule',
+        'Rule'
+    ]]
+};
+
+export function parse() {
+    const children = this.createList();
+
+    scan:
+    while (!this.eof) {
+        switch (this.tokenType) {
+            case WhiteSpace:
+            case Comment:
+            case Semicolon:
+                this.next();
+                break;
+
+            case AtKeyword:
+                children.push(this.parseWithFallback(this.Atrule.bind(this, true), consumeRaw));
+                break;
+
+            default:
+                if (this.isDelim(AMPERSAND))  {
+                    children.push(this.parseWithFallback(this.Rule, consumeRaw));
+                } else {
+                    children.push(this.parseWithFallback(this.Declaration, consumeRaw));
+                }
+        }
+    }
+
+    return {
+        type: 'DeclarationList',
+        loc: this.getLocationFromList(children),
+        children
+    };
+}
+
+export function generate(node) {
+    this.children(node, prev => {
+        if (prev.type === 'Declaration') {
+            this.token(Semicolon, ';');
+        }
+    });
+}
+

package/lib/syntax/node/Dimension.js

@@ -0,0 +1,23 @@
+import { Dimension } from '../../tokenizer/index.js';
+
+export const name = 'Dimension';
+export const structure = {
+    value: String,
+    unit: String
+};
+
+export function parse() {
+    const start = this.tokenStart;
+    const value = this.consumeNumber(Dimension);
+
+    return {
+        type: 'Dimension',
+        loc: this.getLocation(start, this.tokenStart),
+        value,
+        unit: this.substring(start + value.length, this.tokenStart)
+    };
+}
+
+export function generate(node) {
+    this.token(Dimension, node.value + node.unit);
+}

package/lib/syntax/node/Feature.js

@@ -0,0 +1,103 @@
+import {
+    Ident,
+    Number,
+    Dimension,
+    Function as FunctionToken,
+    LeftParenthesis,
+    RightParenthesis,
+    Colon,
+    Delim
+} from '../../tokenizer/index.js';
+
+const SOLIDUS = 0x002F;  // U+002F SOLIDUS (/)
+
+export const name = 'Feature';
+export const structure = {
+    kind: String,
+    name: String,
+    value: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function', null]
+};
+
+export function parse(kind) {
+    const start = this.tokenStart;
+    let name;
+    let value = null;
+
+    this.eat(LeftParenthesis);
+    this.skipSC();
+
+    name = this.consume(Ident);
+    this.skipSC();
+
+    if (this.tokenType !== RightParenthesis) {
+        this.eat(Colon);
+        this.skipSC();
+
+        switch (this.tokenType) {
+            case Number:
+                if (this.lookupNonWSType(1) === Delim) {
+                    value = this.Ratio();
+                } else {
+                    value = this.Number();
+                }
+
+                break;
+
+            case Dimension:
+                value = this.Dimension();
+                break;
+
+            case Ident:
+                value = this.Identifier();
+                break;
+
+            case FunctionToken:
+                value = this.parseWithFallback(
+                    () => {
+                        const res = this.Function(this.readSequence, this.scope.Value);
+
+                        this.skipSC();
+
+                        if (this.isDelim(SOLIDUS)) {
+                            this.error();
+                        }
+
+                        return res;
+                    },
+                    () => {
+                        return this.Ratio();
+                    }
+                );
+                break;
+
+            default:
+                this.error('Number, dimension, ratio or identifier is expected');
+        }
+
+        this.skipSC();
+    }
+
+    if (!this.eof) {
+        this.eat(RightParenthesis);
+    }
+
+    return {
+        type: 'Feature',
+        loc: this.getLocation(start, this.tokenStart),
+        kind,
+        name,
+        value
+    };
+}
+
+export function generate(node) {
+    this.token(LeftParenthesis, '(');
+    this.token(Ident, node.name);
+
+    if (node.value !== null) {
+        this.token(Colon, ':');
+        this.node(node.value);
+    }
+
+    this.token(RightParenthesis, ')');
+}

package/lib/syntax/node/FeatureFunction.js

@@ -0,0 +1,63 @@
+import {
+    Function as FunctionToken,
+    RightParenthesis
+} from '../../tokenizer/index.js';
+
+export const name = 'FeatureFunction';
+export const structure = {
+    kind: String,
+    feature: String,
+    value: ['Declaration', 'Selector']
+};
+
+function getFeatureParser(kind, name) {
+    const featuresOfKind = this.features[kind] || {};
+    const parser = featuresOfKind[name];
+
+    if (typeof parser !== 'function') {
+        this.error(`Unknown feature ${name}()`);
+    }
+
+    return parser;
+}
+
+export function parse(kind = 'unknown') {
+    const start = this.tokenStart;
+    const functionName = this.consumeFunctionName();
+    const valueParser = getFeatureParser.call(this, kind, functionName.toLowerCase());
+
+    this.skipSC();
+
+    const value = this.parseWithFallback(
+        () => {
+            const startValueToken = this.tokenIndex;
+            const value = valueParser.call(this);
+
+            if (this.eof === false &&
+                this.isBalanceEdge(startValueToken) === false) {
+                this.error();
+            }
+
+            return value;
+        },
+        () => this.Raw(null, false)
+    );
+
+    if (!this.eof) {
+        this.eat(RightParenthesis);
+    }
+
+    return {
+        type: 'FeatureFunction',
+        loc: this.getLocation(start, this.tokenStart),
+        kind,
+        feature: functionName,
+        value
+    };
+}
+
+export function generate(node) {
+    this.token(FunctionToken, node.feature + '(');
+    this.node(node.value);
+    this.token(RightParenthesis, ')');
+}

package/lib/syntax/node/FeatureRange.js

@@ -0,0 +1,133 @@
+import {
+    Ident,
+    Number,
+    Dimension,
+    Function as FunctionToken,
+    LeftParenthesis,
+    RightParenthesis
+} from '../../tokenizer/index.js';
+
+const SOLIDUS = 0x002F;         // U+002F SOLIDUS (/)
+const LESSTHANSIGN = 0x003C;    // U+003C LESS-THAN SIGN (<)
+const EQUALSSIGN = 0x003D;      // U+003D EQUALS SIGN (=)
+const GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)
+
+export const name = 'FeatureRange';
+export const structure = {
+    kind: String,
+    left: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function'],
+    leftComparison: String,
+    middle: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function'],
+    rightComparison: [String, null],
+    right: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function', null]
+};
+
+function readTerm() {
+    this.skipSC();
+
+    switch (this.tokenType) {
+        case Number:
+            if (this.isDelim(SOLIDUS, this.lookupOffsetNonSC(1))) {
+                return this.Ratio();
+            } else {
+                return this.Number();
+            }
+
+        case Dimension:
+            return this.Dimension();
+
+        case Ident:
+            return this.Identifier();
+
+        case FunctionToken:
+            return this.parseWithFallback(
+                () => {
+                    const res = this.Function(this.readSequence, this.scope.Value);
+
+                    this.skipSC();
+
+                    if (this.isDelim(SOLIDUS)) {
+                        this.error();
+                    }
+
+                    return res;
+                },
+                () => {
+                    return this.Ratio();
+                }
+            );
+
+        default:
+            this.error('Number, dimension, ratio or identifier is expected');
+    }
+}
+
+function readComparison(expectColon) {
+    this.skipSC();
+
+    if (this.isDelim(LESSTHANSIGN) ||
+        this.isDelim(GREATERTHANSIGN)) {
+        const value = this.source[this.tokenStart];
+
+        this.next();
+
+        if (this.isDelim(EQUALSSIGN)) {
+            this.next();
+            return value + '=';
+        }
+
+        return value;
+    }
+
+    if (this.isDelim(EQUALSSIGN)) {
+        return '=';
+    }
+
+    this.error(`Expected ${expectColon ? '":", ' : ''}"<", ">", "=" or ")"`);
+}
+
+export function parse(kind = 'unknown') {
+    const start = this.tokenStart;
+
+    this.skipSC();
+    this.eat(LeftParenthesis);
+
+    const left = readTerm.call(this);
+    const leftComparison = readComparison.call(this, left.type === 'Identifier');
+    const middle = readTerm.call(this);
+    let rightComparison = null;
+    let right = null;
+
+    if (this.lookupNonWSType(0) !== RightParenthesis) {
+        rightComparison = readComparison.call(this);
+        right = readTerm.call(this);
+    }
+
+    this.skipSC();
+    this.eat(RightParenthesis);
+
+    return {
+        type: 'FeatureRange',
+        loc: this.getLocation(start, this.tokenStart),
+        kind,
+        left,
+        leftComparison,
+        middle,
+        rightComparison,
+        right
+    };
+}
+
+export function generate(node) {
+    this.token(LeftParenthesis, '(');
+    this.node(node.left);
+    this.tokenize(node.leftComparison);
+    this.node(node.middle);
+
+    if (node.right) {
+        this.tokenize(node.rightComparison);
+        this.node(node.right);
+    }
+
+    this.token(RightParenthesis, ')');
+}

package/lib/syntax/node/Function.js

@@ -0,0 +1,41 @@
+import {
+    Function as FunctionToken,
+    RightParenthesis
+} from '../../tokenizer/index.js';
+
+
+export const name = 'Function';
+export const walkContext = 'function';
+export const structure = {
+    name: String,
+    children: [[]]
+};
+
+// <function-token> <sequence> )
+export function parse(readSequence, recognizer) {
+    const start = this.tokenStart;
+    const name = this.consumeFunctionName();
+    const nameLowerCase = name.toLowerCase();
+    let children;
+
+    children = recognizer.hasOwnProperty(nameLowerCase)
+        ? recognizer[nameLowerCase].call(this, recognizer)
+        : readSequence.call(this, recognizer);
+
+    if (!this.eof) {
+        this.eat(RightParenthesis);
+    }
+
+    return {
+        type: 'Function',
+        loc: this.getLocation(start, this.tokenStart),
+        name,
+        children
+    };
+}
+
+export function generate(node) {
+    this.token(FunctionToken, node.name + '(');
+    this.children(node);
+    this.token(RightParenthesis, ')');
+}

package/lib/syntax/node/GeneralEnclosed.js

@@ -0,0 +1,66 @@
+import {
+    Function as FunctionToken,
+    LeftParenthesis,
+    RightParenthesis
+} from '../../tokenizer/index.js';
+
+
+export const name = 'GeneralEnclosed';
+export const structure = {
+    kind: String,
+    function: [String, null],
+    children: [[]]
+};
+
+// <function-token> <any-value> )
+// ( <any-value> )
+export function parse(kind) {
+    const start = this.tokenStart;
+    let functionName = null;
+
+    if (this.tokenType === FunctionToken) {
+        functionName = this.consumeFunctionName();
+    } else {
+        this.eat(LeftParenthesis);
+    }
+
+    const children = this.parseWithFallback(
+        () => {
+            const startValueToken = this.tokenIndex;
+            const children = this.readSequence(this.scope.Value);
+
+            if (this.eof === false &&
+                this.isBalanceEdge(startValueToken) === false) {
+                this.error();
+            }
+
+            return children;
+        },
+        () => this.createSingleNodeList(
+            this.Raw(null, false)
+        )
+    );
+
+    if (!this.eof) {
+        this.eat(RightParenthesis);
+    }
+
+    return {
+        type: 'GeneralEnclosed',
+        loc: this.getLocation(start, this.tokenStart),
+        kind,
+        function: functionName,
+        children
+    };
+}
+
+export function generate(node) {
+    if (node.function) {
+        this.token(FunctionToken, node.function + '(');
+    } else {
+        this.token(LeftParenthesis, '(');
+    }
+
+    this.children(node);
+    this.token(RightParenthesis, ')');
+}

package/lib/syntax/node/Hash.js

@@ -0,0 +1,23 @@
+import { Hash } from '../../tokenizer/index.js';
+
+// '#' ident
+export const xxx = 'XXX';
+export const name = 'Hash';
+export const structure = {
+    value: String
+};
+export function parse() {
+    const start = this.tokenStart;
+
+    this.eat(Hash);
+
+    return {
+        type: 'Hash',
+        loc: this.getLocation(start, this.tokenStart),
+        value: this.substrToCursor(start + 1)
+    };
+}
+export function generate(node) {
+    this.token(Hash, '#' + node.value);
+}
+

package/lib/syntax/node/IdSelector.js

@@ -0,0 +1,26 @@
+import { Hash, Delim } from '../../tokenizer/index.js';
+
+export const name = 'IdSelector';
+export const structure = {
+    name: String
+};
+
+export function parse() {
+    const start = this.tokenStart;
+
+    // TODO: check value is an ident
+    this.eat(Hash);
+
+    return {
+        type: 'IdSelector',
+        loc: this.getLocation(start, this.tokenStart),
+        name: this.substrToCursor(start + 1)
+    };
+}
+
+export function generate(node) {
+    // Using Delim instead of Hash is a hack to avoid for a whitespace between ident and id-selector
+    // in safe mode (e.g. "a#id"), because IE11 doesn't allow a sequence <ident-token> <hash-token>
+    // without a whitespace in values (e.g. "1px solid#000")
+    this.token(Delim, '#' + node.name);
+}