@eslint/css-tree 3.2.0

package/lib/syntax/node/index-parse.js

@@ -0,0 +1,49 @@
+export { parse as AnPlusB } from './AnPlusB.js';
+export { parse as Atrule } from './Atrule.js';
+export { parse as AtrulePrelude } from './AtrulePrelude.js';
+export { parse as AttributeSelector } from './AttributeSelector.js';
+export { parse as Block } from './Block.js';
+export { parse as Brackets } from './Brackets.js';
+export { parse as CDC } from './CDC.js';
+export { parse as CDO } from './CDO.js';
+export { parse as ClassSelector } from './ClassSelector.js';
+export { parse as Combinator } from './Combinator.js';
+export { parse as Comment } from './Comment.js';
+export { parse as Condition } from './Condition.js';
+export { parse as Declaration } from './Declaration.js';
+export { parse as DeclarationList } from './DeclarationList.js';
+export { parse as Dimension } from './Dimension.js';
+export { parse as Feature } from './Feature.js';
+export { parse as FeatureFunction } from './FeatureFunction.js';
+export { parse as FeatureRange } from './FeatureRange.js';
+export { parse as Function } from './Function.js';
+export { parse as GeneralEnclosed } from './GeneralEnclosed.js';
+export { parse as Hash } from './Hash.js';
+export { parse as Identifier } from './Identifier.js';
+export { parse as IdSelector } from './IdSelector.js';
+export { parse as Layer } from './Layer.js';
+export { parse as LayerList } from './LayerList.js';
+export { parse as MediaQuery } from './MediaQuery.js';
+export { parse as MediaQueryList } from './MediaQueryList.js';
+export { parse as NestingSelector } from './NestingSelector.js';
+export { parse as Nth } from './Nth.js';
+export { parse as Number } from './Number.js';
+export { parse as Operator } from './Operator.js';
+export { parse as Parentheses } from './Parentheses.js';
+export { parse as Percentage } from './Percentage.js';
+export { parse as PseudoClassSelector } from './PseudoClassSelector.js';
+export { parse as PseudoElementSelector } from './PseudoElementSelector.js';
+export { parse as Ratio } from './Ratio.js';
+export { parse as Raw } from './Raw.js';
+export { parse as Rule } from './Rule.js';
+export { parse as Scope } from './Scope.js';
+export { parse as Selector } from './Selector.js';
+export { parse as SelectorList } from './SelectorList.js';
+export { parse as String } from './String.js';
+export { parse as StyleSheet } from './StyleSheet.js';
+export { parse as SupportsDeclaration } from './SupportsDeclaration.js';
+export { parse as TypeSelector } from './TypeSelector.js';
+export { parse as UnicodeRange } from './UnicodeRange.js';
+export { parse as Url } from './Url.js';
+export { parse as Value } from './Value.js';
+export { parse as WhiteSpace } from './WhiteSpace.js';

package/lib/syntax/node/index.js

@@ -0,0 +1,49 @@
+export * as AnPlusB from './AnPlusB.js';
+export * as Atrule from './Atrule.js';
+export * as AtrulePrelude from './AtrulePrelude.js';
+export * as AttributeSelector from './AttributeSelector.js';
+export * as Block from './Block.js';
+export * as Brackets from './Brackets.js';
+export * as CDC from './CDC.js';
+export * as CDO from './CDO.js';
+export * as ClassSelector from './ClassSelector.js';
+export * as Combinator from './Combinator.js';
+export * as Comment from './Comment.js';
+export * as Condition from './Condition.js';
+export * as Declaration from './Declaration.js';
+export * as DeclarationList from './DeclarationList.js';
+export * as Dimension from './Dimension.js';
+export * as Feature from './Feature.js';
+export * as FeatureFunction from './FeatureFunction.js';
+export * as FeatureRange from './FeatureRange.js';
+export * as Function from './Function.js';
+export * as GeneralEnclosed from './GeneralEnclosed.js';
+export * as Hash from './Hash.js';
+export * as Identifier from './Identifier.js';
+export * as IdSelector from './IdSelector.js';
+export * as Layer from './Layer.js';
+export * as LayerList from './LayerList.js';
+export * as MediaQuery from './MediaQuery.js';
+export * as MediaQueryList from './MediaQueryList.js';
+export * as NestingSelector from './NestingSelector.js';
+export * as Nth from './Nth.js';
+export * as Number from './Number.js';
+export * as Operator from './Operator.js';
+export * as Parentheses from './Parentheses.js';
+export * as Percentage from './Percentage.js';
+export * as PseudoClassSelector from './PseudoClassSelector.js';
+export * as PseudoElementSelector from './PseudoElementSelector.js';
+export * as Ratio from './Ratio.js';
+export * as Raw from './Raw.js';
+export * as Rule from './Rule.js';
+export * as Scope from './Scope.js';
+export * as Selector from './Selector.js';
+export * as SelectorList from './SelectorList.js';
+export * as String from './String.js';
+export * as StyleSheet from './StyleSheet.js';
+export * as SupportsDeclaration from './SupportsDeclaration.js';
+export * as TypeSelector from './TypeSelector.js';
+export * as UnicodeRange from './UnicodeRange.js';
+export * as Url from './Url.js';
+export * as Value from './Value.js';
+export * as WhiteSpace from './WhiteSpace.js';

package/lib/syntax/pseudo/index.js

@@ -0,0 +1,56 @@
+import { parseLanguageRangeList } from './lang.js';
+
+const selectorList = {
+    parse() {
+        return this.createSingleNodeList(
+            this.SelectorList()
+        );
+    }
+};
+
+const selector = {
+    parse() {
+        return this.createSingleNodeList(
+            this.Selector()
+        );
+    }
+};
+
+const identList = {
+    parse() {
+        return this.createSingleNodeList(
+            this.Identifier()
+        );
+    }
+};
+
+const langList = {
+    parse: parseLanguageRangeList
+};
+
+const nth = {
+    parse() {
+        return this.createSingleNodeList(
+            this.Nth()
+        );
+    }
+};
+
+export default {
+    'dir': identList,
+    'has': selectorList,
+    'lang': langList,
+    'matches': selectorList,
+    'is': selectorList,
+    '-moz-any': selectorList,
+    '-webkit-any': selectorList,
+    'where': selectorList,
+    'not': selectorList,
+    'nth-child': nth,
+    'nth-last-child': nth,
+    'nth-last-of-type': nth,
+    'nth-of-type': nth,
+    'slotted': selector,
+    'host': selector,
+    'host-context': selector
+};

package/lib/syntax/pseudo/lang.js

@@ -0,0 +1,33 @@
+import { Comma, String as StringToken, Ident, RightParenthesis } from '../../tokenizer/index.js';
+
+export function parseLanguageRangeList() {
+    const children = this.createList();
+
+    this.skipSC();
+
+    loop: while (!this.eof) {
+        switch (this.tokenType) {
+            case Ident:
+                children.push(this.Identifier());
+                break;
+
+            case StringToken:
+                children.push(this.String());
+                break;
+
+            case Comma:
+                children.push(this.Operator());
+                break;
+
+            case RightParenthesis:
+                break loop;
+
+            default:
+                this.error('Identifier, string or comma is expected');
+        }
+
+        this.skipSC();
+    }
+
+    return children;
+}

package/lib/syntax/scope/atrulePrelude.js

@@ -0,0 +1,5 @@
+import getNode from './default.js';
+
+export default {
+    getNode
+};

package/lib/syntax/scope/default.js

@@ -0,0 +1,85 @@
+import {
+    Ident,
+    String as StringToken,
+    Number as NumberToken,
+    Function as FunctionToken,
+    Url,
+    Hash,
+    Dimension,
+    Percentage,
+    LeftParenthesis,
+    LeftSquareBracket,
+    Comma,
+    Delim
+} from '../../tokenizer/index.js';
+
+const NUMBERSIGN = 0x0023;  // U+0023 NUMBER SIGN (#)
+const ASTERISK = 0x002A;    // U+002A ASTERISK (*)
+const PLUSSIGN = 0x002B;    // U+002B PLUS SIGN (+)
+const HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)
+const SOLIDUS = 0x002F;     // U+002F SOLIDUS (/)
+const U = 0x0075;           // U+0075 LATIN SMALL LETTER U (u)
+
+export default function defaultRecognizer(context) {
+    switch (this.tokenType) {
+        case Hash:
+            return this.Hash();
+
+        case Comma:
+            return this.Operator();
+
+        case LeftParenthesis:
+            return this.Parentheses(this.readSequence, context.recognizer);
+
+        case LeftSquareBracket:
+            return this.Brackets(this.readSequence, context.recognizer);
+
+        case StringToken:
+            return this.String();
+
+        case Dimension:
+            return this.Dimension();
+
+        case Percentage:
+            return this.Percentage();
+
+        case NumberToken:
+            return this.Number();
+
+        case FunctionToken:
+            return this.cmpStr(this.tokenStart, this.tokenEnd, 'url(')
+                ? this.Url()
+                : this.Function(this.readSequence, context.recognizer);
+
+        case Url:
+            return this.Url();
+
+        case Ident:
+            // check for unicode range, it should start with u+ or U+
+            if (this.cmpChar(this.tokenStart, U) &&
+                this.cmpChar(this.tokenStart + 1, PLUSSIGN)) {
+                return this.UnicodeRange();
+            } else {
+                return this.Identifier();
+            }
+
+        case Delim: {
+            const code = this.charCodeAt(this.tokenStart);
+
+            if (code === SOLIDUS ||
+                code === ASTERISK ||
+                code === PLUSSIGN ||
+                code === HYPHENMINUS) {
+                return this.Operator(); // TODO: replace with Delim
+            }
+
+            // TODO: produce a node with Delim node type
+
+            if (code === NUMBERSIGN) {
+                this.error('Hex or identifier is expected', this.tokenStart + 1);
+            }
+
+            break;
+        }
+    }
+};

package/lib/syntax/scope/index.js

@@ -0,0 +1,3 @@
+export { default as AtrulePrelude } from './atrulePrelude.js';
+export { default as Selector } from './selector.js';
+export { default as Value } from './value.js';

package/lib/syntax/scope/selector.js

@@ -0,0 +1,94 @@
+import {
+    Delim,
+    Ident,
+    Dimension,
+    Percentage,
+    Number as NumberToken,
+    Hash,
+    Colon,
+    LeftSquareBracket
+} from '../../tokenizer/index.js';
+
+const NUMBERSIGN = 0x0023;      // U+0023 NUMBER 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 (/)
+const FULLSTOP = 0x002E;        // U+002E FULL STOP (.)
+const GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)
+const VERTICALLINE = 0x007C;    // U+007C VERTICAL LINE (|)
+const TILDE = 0x007E;           // U+007E TILDE (~)
+
+function onWhiteSpace(next, children) {
+    if (children.last !== null && children.last.type !== 'Combinator' &&
+        next !== null && next.type !== 'Combinator') {
+        children.push({  // FIXME: this.Combinator() should be used instead
+            type: 'Combinator',
+            loc: null,
+            name: ' '
+        });
+    }
+}
+
+function getNode() {
+    switch (this.tokenType) {
+        case LeftSquareBracket:
+            return this.AttributeSelector();
+
+        case Hash:
+            return this.IdSelector();
+
+        case Colon:
+            if (this.lookupType(1) === Colon) {
+                return this.PseudoElementSelector();
+            } else {
+                return this.PseudoClassSelector();
+            }
+
+        case Ident:
+            return this.TypeSelector();
+
+        case NumberToken:
+        case Percentage:
+            return this.Percentage();
+
+        case Dimension:
+            // throws when .123ident
+            if (this.charCodeAt(this.tokenStart) === FULLSTOP) {
+                this.error('Identifier is expected', this.tokenStart + 1);
+            }
+            break;
+
+        case Delim: {
+            const code = this.charCodeAt(this.tokenStart);
+
+            switch (code) {
+                case PLUSSIGN:
+                case GREATERTHANSIGN:
+                case TILDE:
+                case SOLIDUS:  // /deep/
+                    return this.Combinator();
+
+                case FULLSTOP:
+                    return this.ClassSelector();
+
+                case ASTERISK:
+                case VERTICALLINE:
+                    return this.TypeSelector();
+
+                case NUMBERSIGN:
+                    return this.IdSelector();
+
+                case AMPERSAND:
+                    return this.NestingSelector();
+            }
+
+            break;
+        }
+    }
+};
+
+export default {
+    onWhiteSpace,
+    getNode
+};

package/lib/syntax/scope/value.js

@@ -0,0 +1,25 @@
+import getNode from './default.js';
+import expressionFn from '../function/expression.js';
+import varFn from '../function/var.js';
+
+function isPlusMinusOperator(node) {
+    return (
+        node !== null &&
+        node.type === 'Operator' &&
+        (node.value[node.value.length - 1] === '-' || node.value[node.value.length - 1] === '+')
+    );
+}
+
+export default {
+    getNode,
+    onWhiteSpace(next, children) {
+        if (isPlusMinusOperator(next)) {
+            next.value = ' ' + next.value;
+        }
+        if (isPlusMinusOperator(children.last)) {
+            children.last.value += ' ';
+        }
+    },
+    'expression': expressionFn,
+    'var': varFn
+};

package/lib/tokenizer/OffsetToLocation.js

@@ -0,0 +1,87 @@
+import { adoptBuffer } from './adopt-buffer.js';
+import { isBOM } from './char-code-definitions.js';
+
+const N = 10;
+const F = 12;
+const R = 13;
+
+function computeLinesAndColumns(host) {
+    const source = host.source;
+    const sourceLength = source.length;
+    const startOffset = source.length > 0 ? isBOM(source.charCodeAt(0)) : 0;
+    const lines = adoptBuffer(host.lines, sourceLength);
+    const columns = adoptBuffer(host.columns, sourceLength);
+    let line = host.startLine;
+    let column = host.startColumn;
+
+    for (let i = startOffset; i < sourceLength; i++) {
+        const code = source.charCodeAt(i);
+
+        lines[i] = line;
+        columns[i] = column++;
+
+        if (code === N || code === R || code === F) {
+            if (code === R && i + 1 < sourceLength && source.charCodeAt(i + 1) === N) {
+                i++;
+                lines[i] = line;
+                columns[i] = column;
+            }
+
+            line++;
+            column = 1;
+        }
+    }
+
+    lines[sourceLength] = line;
+    columns[sourceLength] = column;
+
+    host.lines = lines;
+    host.columns = columns;
+    host.computed = true;
+}
+
+export class OffsetToLocation {
+    constructor(source, startOffset, startLine, startColumn) {
+        this.setSource(source, startOffset, startLine, startColumn);
+        this.lines = null;
+        this.columns = null;
+    }
+    setSource(source = '', startOffset = 0, startLine = 1, startColumn = 1) {
+        this.source = source;
+        this.startOffset = startOffset;
+        this.startLine = startLine;
+        this.startColumn = startColumn;
+        this.computed = false;
+    }
+    getLocation(offset, filename) {
+        if (!this.computed) {
+            computeLinesAndColumns(this);
+        }
+
+        return {
+            source: filename,
+            offset: this.startOffset + offset,
+            line: this.lines[offset],
+            column: this.columns[offset]
+        };
+    }
+    getLocationRange(start, end, filename) {
+        if (!this.computed) {
+            computeLinesAndColumns(this);
+        }
+
+        return {
+            source: filename,
+            start: {
+                offset: this.startOffset + start,
+                line: this.lines[start],
+                column: this.columns[start]
+            },
+            end: {
+                offset: this.startOffset + end,
+                line: this.lines[end],
+                column: this.columns[end]
+            }
+        };
+    }
+};