@eslint/css-tree 3.2.0

package/lib/lexer/search.js

@@ -0,0 +1,61 @@
+import { List } from '../utils/List.js';
+
+function getFirstMatchNode(matchNode) {
+    if ('node' in matchNode) {
+        return matchNode.node;
+    }
+
+    return getFirstMatchNode(matchNode.match[0]);
+}
+
+function getLastMatchNode(matchNode) {
+    if ('node' in matchNode) {
+        return matchNode.node;
+    }
+
+    return getLastMatchNode(matchNode.match[matchNode.match.length - 1]);
+}
+
+export function matchFragments(lexer, ast, match, type, name) {
+    function findFragments(matchNode) {
+        if (matchNode.syntax !== null &&
+            matchNode.syntax.type === type &&
+            matchNode.syntax.name === name) {
+            const start = getFirstMatchNode(matchNode);
+            const end = getLastMatchNode(matchNode);
+
+            lexer.syntax.walk(ast, function(node, item, list) {
+                if (node === start) {
+                    const nodes = new List();
+
+                    do {
+                        nodes.appendData(item.data);
+
+                        if (item.data === end) {
+                            break;
+                        }
+
+                        item = item.next;
+                    } while (item !== null);
+
+                    fragments.push({
+                        parent: list,
+                        nodes
+                    });
+                }
+            });
+        }
+
+        if (Array.isArray(matchNode.match)) {
+            matchNode.match.forEach(findFragments);
+        }
+    }
+
+    const fragments = [];
+
+    if (match.matched !== null) {
+        findFragments(match.matched);
+    }
+
+    return fragments;
+}

package/lib/lexer/structure.js

@@ -0,0 +1,169 @@
+import { List } from '../utils/List.js';
+
+const { hasOwnProperty } = Object.prototype;
+
+function isValidNumber(value) {
+    // Number.isInteger(value) && value >= 0
+    return (
+        typeof value === 'number' &&
+        isFinite(value) &&
+        Math.floor(value) === value &&
+        value >= 0
+    );
+}
+
+function isValidLocation(loc) {
+    return (
+        Boolean(loc) &&
+        isValidNumber(loc.offset) &&
+        isValidNumber(loc.line) &&
+        isValidNumber(loc.column)
+    );
+}
+
+function createNodeStructureChecker(type, fields) {
+    return function checkNode(node, warn) {
+        if (!node || node.constructor !== Object) {
+            return warn(node, 'Type of node should be an Object');
+        }
+
+        for (let key in node) {
+            let valid = true;
+
+            if (hasOwnProperty.call(node, key) === false) {
+                continue;
+            }
+
+            if (key === 'type') {
+                if (node.type !== type) {
+                    warn(node, 'Wrong node type `' + node.type + '`, expected `' + type + '`');
+                }
+            } else if (key === 'loc') {
+                if (node.loc === null) {
+                    continue;
+                } else if (node.loc && node.loc.constructor === Object) {
+                    if (typeof node.loc.source !== 'string') {
+                        key += '.source';
+                    } else if (!isValidLocation(node.loc.start)) {
+                        key += '.start';
+                    } else if (!isValidLocation(node.loc.end)) {
+                        key += '.end';
+                    } else {
+                        continue;
+                    }
+                }
+
+                valid = false;
+            } else if (fields.hasOwnProperty(key)) {
+                valid = false;
+
+                for (let i = 0; !valid && i < fields[key].length; i++) {
+                    const fieldType = fields[key][i];
+
+                    switch (fieldType) {
+                        case String:
+                            valid = typeof node[key] === 'string';
+                            break;
+
+                        case Boolean:
+                            valid = typeof node[key] === 'boolean';
+                            break;
+
+                        case null:
+                            valid = node[key] === null;
+                            break;
+
+                        default:
+                            if (typeof fieldType === 'string') {
+                                valid = node[key] && node[key].type === fieldType;
+                            } else if (Array.isArray(fieldType)) {
+                                valid = node[key] instanceof List;
+                            }
+                    }
+                }
+            } else {
+                warn(node, 'Unknown field `' + key + '` for ' + type + ' node type');
+            }
+
+            if (!valid) {
+                warn(node, 'Bad value for `' + type + '.' + key + '`');
+            }
+        }
+
+        for (const key in fields) {
+            if (hasOwnProperty.call(fields, key) &&
+                hasOwnProperty.call(node, key) === false) {
+                warn(node, 'Field `' + type + '.' + key + '` is missed');
+            }
+        }
+    };
+}
+
+function genTypesList(fieldTypes, path) {
+    const docsTypes = [];
+
+    for (let i = 0; i < fieldTypes.length; i++) {
+        const fieldType = fieldTypes[i];
+        if (fieldType === String || fieldType === Boolean) {
+            docsTypes.push(fieldType.name.toLowerCase());
+        } else if (fieldType === null) {
+            docsTypes.push('null');
+        } else if (typeof fieldType === 'string') {
+            docsTypes.push(fieldType);
+        } else if (Array.isArray(fieldType)) {
+            docsTypes.push('List<' + (genTypesList(fieldType, path) || 'any') + '>'); // TODO: use type enum
+        } else {
+            throw new Error('Wrong value `' + fieldType + '` in `' + path + '` structure definition');
+        }
+    }
+
+    return docsTypes.join(' | ');
+}
+
+function processStructure(name, nodeType) {
+    const structure = nodeType.structure;
+    const fields = {
+        type: String,
+        loc: true
+    };
+    const docs = {
+        type: '"' + name + '"'
+    };
+
+    for (const key in structure) {
+        if (hasOwnProperty.call(structure, key) === false) {
+            continue;
+        }
+
+        const fieldTypes = fields[key] = Array.isArray(structure[key])
+            ? structure[key].slice()
+            : [structure[key]];
+
+        docs[key] = genTypesList(fieldTypes, name + '.' + key);
+    }
+
+    return {
+        docs,
+        check: createNodeStructureChecker(name, fields)
+    };
+}
+
+export function getStructureFromConfig(config) {
+    const structure = {};
+
+    if (config.node) {
+        for (const name in config.node) {
+            if (hasOwnProperty.call(config.node, name)) {
+                const nodeType = config.node[name];
+
+                if (nodeType.structure) {
+                    structure[name] = processStructure(name, nodeType);
+                } else {
+                    throw new Error('Missed `structure` field in `' + name + '` node type definition');
+                }
+            }
+        }
+    }
+
+    return structure;
+};

package/lib/lexer/trace.js

@@ -0,0 +1,66 @@
+export function getTrace(node) {
+    function shouldPutToTrace(syntax) {
+        if (syntax === null) {
+            return false;
+        }
+
+        return (
+            syntax.type === 'Type' ||
+            syntax.type === 'Property' ||
+            syntax.type === 'Keyword'
+        );
+    }
+
+    function hasMatch(matchNode) {
+        if (Array.isArray(matchNode.match)) {
+            // use for-loop for better perfomance
+            for (let i = 0; i < matchNode.match.length; i++) {
+                if (hasMatch(matchNode.match[i])) {
+                    if (shouldPutToTrace(matchNode.syntax)) {
+                        result.unshift(matchNode.syntax);
+                    }
+
+                    return true;
+                }
+            }
+        } else if (matchNode.node === node) {
+            result = shouldPutToTrace(matchNode.syntax)
+                ? [matchNode.syntax]
+                : [];
+
+            return true;
+        }
+
+        return false;
+    }
+
+    let result = null;
+
+    if (this.matched !== null) {
+        hasMatch(this.matched);
+    }
+
+    return result;
+}
+
+export function isType(node, type) {
+    return testNode(this, node, match => match.type === 'Type' && match.name === type);
+}
+
+export function isProperty(node, property) {
+    return testNode(this, node, match => match.type === 'Property' && match.name === property);
+}
+
+export function isKeyword(node) {
+    return testNode(this, node, match => match.type === 'Keyword');
+}
+
+function testNode(match, node, fn) {
+    const trace = getTrace.call(match, node);
+
+    if (trace === null) {
+        return false;
+    }
+
+    return trace.some(fn);
+}

package/lib/lexer/units.js

@@ -0,0 +1,27 @@
+export const length = [
+    // absolute length units https://www.w3.org/TR/css-values-3/#lengths
+    'cm', 'mm', 'q', 'in', 'pt', 'pc', 'px',
+    // font-relative length units https://drafts.csswg.org/css-values-4/#font-relative-lengths
+    'em', 'rem',
+    'ex', 'rex',
+    'cap', 'rcap',
+    'ch', 'rch',
+    'ic', 'ric',
+    'lh', 'rlh',
+    // viewport-percentage lengths https://drafts.csswg.org/css-values-4/#viewport-relative-lengths
+    'vw', 'svw', 'lvw', 'dvw',
+    'vh', 'svh', 'lvh', 'dvh',
+    'vi', 'svi', 'lvi', 'dvi',
+    'vb', 'svb', 'lvb', 'dvb',
+    'vmin', 'svmin', 'lvmin', 'dvmin',
+    'vmax', 'svmax', 'lvmax', 'dvmax',
+    // container relative lengths https://drafts.csswg.org/css-contain-3/#container-lengths
+    'cqw', 'cqh', 'cqi', 'cqb', 'cqmin', 'cqmax'
+];
+export const angle = ['deg', 'grad', 'rad', 'turn'];    // https://www.w3.org/TR/css-values-3/#angles
+export const time = ['s', 'ms'];                        // https://www.w3.org/TR/css-values-3/#time
+export const frequency = ['hz', 'khz'];                 // https://www.w3.org/TR/css-values-3/#frequency
+export const resolution = ['dpi', 'dpcm', 'dppx', 'x']; // https://www.w3.org/TR/css-values-3/#resolution
+export const flex = ['fr'];                             // https://drafts.csswg.org/css-grid/#fr-unit
+export const decibel = ['db'];                          // https://www.w3.org/TR/css3-speech/#mixing-props-voice-volume
+export const semitones = ['st'];                        // https://www.w3.org/TR/css3-speech/#voice-props-voice-pitch

package/lib/parser/SyntaxError.js

@@ -0,0 +1,70 @@
+import { createCustomError } from '../utils/create-custom-error.js';
+
+const MAX_LINE_LENGTH = 100;
+const OFFSET_CORRECTION = 60;
+const TAB_REPLACEMENT = '    ';
+
+function sourceFragment({ source, line, column, baseLine, baseColumn }, extraLines) {
+    function processLines(start, end) {
+        return lines
+            .slice(start, end)
+            .map((line, idx) =>
+                String(start + idx + 1).padStart(maxNumLength) + ' |' + line
+            ).join('\n');
+    }
+
+    const prelines = '\n'.repeat(Math.max(baseLine - 1, 0));
+    const precolumns = ' '.repeat(Math.max(baseColumn - 1, 0));
+    const lines = (prelines + precolumns + source).split(/\r\n?|\n|\f/);
+    const startLine = Math.max(1, line - extraLines) - 1;
+    const endLine = Math.min(line + extraLines, lines.length + 1);
+    const maxNumLength = Math.max(4, String(endLine).length) + 1;
+    let cutLeft = 0;
+
+    // column correction according to replaced tab before column
+    column += (TAB_REPLACEMENT.length - 1) * (lines[line - 1].substr(0, column - 1).match(/\t/g) || []).length;
+
+    if (column > MAX_LINE_LENGTH) {
+        cutLeft = column - OFFSET_CORRECTION + 3;
+        column = OFFSET_CORRECTION - 2;
+    }
+
+    for (let i = startLine; i <= endLine; i++) {
+        if (i >= 0 && i < lines.length) {
+            lines[i] = lines[i].replace(/\t/g, TAB_REPLACEMENT);
+            lines[i] =
+                (cutLeft > 0 && lines[i].length > cutLeft ? '\u2026' : '') +
+                lines[i].substr(cutLeft, MAX_LINE_LENGTH - 2) +
+                (lines[i].length > cutLeft + MAX_LINE_LENGTH - 1 ? '\u2026' : '');
+        }
+    }
+
+    return [
+        processLines(startLine, line),
+        new Array(column + maxNumLength + 2).join('-') + '^',
+        processLines(line, endLine)
+    ].filter(Boolean)
+        .join('\n')
+        .replace(/^(\s+\d+\s+\|\n)+/, '')
+        .replace(/\n(\s+\d+\s+\|)+$/, '');
+}
+
+export function SyntaxError(message, source, offset, line, column, baseLine = 1, baseColumn = 1) {
+    const error = Object.assign(createCustomError('SyntaxError', message), {
+        source,
+        offset,
+        line,
+        column,
+        sourceFragment(extraLines) {
+            return sourceFragment({ source, line, column, baseLine, baseColumn }, isNaN(extraLines) ? 0 : extraLines);
+        },
+        get formattedMessage() {
+            return (
+                `Parse error: ${message}\n` +
+                sourceFragment({ source, line, column, baseLine, baseColumn }, 2)
+            );
+        }
+    });
+
+    return error;
+}