@tbela99/css-parser 0.6.0 → 0.7.0

package/dist/lib/renderer/render.js

@@ -8,8 +8,7 @@ import { expand } from '../ast/expand.js';
 import { colorMix } from './color/colormix.js';
 import { parseRelativeColor } from './color/relativecolor.js';
 import { SourceMap } from './sourcemap/sourcemap.js';
-import '../parser/parse.js';
-import { isColor, isNewLine } from '../parser/utils/syntax.js';
+import { isColor, isNewLine } from '../syntax/syntax.js';
 
 const colorsFunc = ['rgb', 'rgba', 'hsl', 'hsla', 'hwb', 'device-cmyk', 'color-mix', 'color', 'oklab', 'lab', 'oklch', 'lch', 'light-dark'];
 function reduceNumber(val) {
@@ -93,7 +92,7 @@ function doRender(data, options = {}) {
         options.output = options.resolve(options.output, options.cwd).absolute;
     }
     if (sourcemap != null) {
-        result.map = sourcemap.toJSON();
+        result.map = sourcemap;
     }
     return result;
 }
@@ -201,6 +200,10 @@ function renderAstNode(data, options, sourcemap, position, errors, reducer, cach
                 return `@${data.nam}${data.val === '' ? '' : options.indent || ' '}${data.val}${options.indent}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
             }
             return data.sel + `${options.indent}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
+        case EnumToken.InvalidRuleTokenType:
+            return '';
+        default:
+            throw new Error(`render: unexpected token ${JSON.stringify(data, null, 1)}`);
     }
     return '';
 }
@@ -274,6 +277,7 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
             return ' + ';
         case EnumToken.Sub:
             return ' - ';
+        case EnumToken.UniversalSelectorTokenType:
         case EnumToken.Mul:
             return '*';
         case EnumToken.Div:
@@ -406,7 +410,7 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
                 renderToken(token.r, options, cache, reducer, errors) +
                 (token.attr ? ' ' + token.attr : '');
         case EnumToken.NameSpaceAttributeTokenType:
-            return (token.l == null ? '' : renderToken(token.l, options, cache, reducer, errors) + '|') +
+            return (token.l == null ? '' : renderToken(token.l, options, cache, reducer, errors)) + '|' +
                 renderToken(token.r, options, cache, reducer, errors);
         case EnumToken.BlockStartTokenType:
             return '{';
@@ -414,6 +418,8 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
             return '}';
         case EnumToken.StartParensTokenType:
             return '(';
+        case EnumToken.DelimTokenType:
+            return '=';
         case EnumToken.IncludeMatchTokenType:
             return '~=';
         case EnumToken.DashMatchTokenType:
@@ -428,7 +434,12 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
             return '<';
         case EnumToken.LteTokenType:
             return '<=';
+        case EnumToken.SubsequentSiblingCombinatorTokenType:
+            return '~';
+        case EnumToken.NextSiblingCombinatorTokenType:
+            return '+';
         case EnumToken.GtTokenType:
+        case EnumToken.ChildCombinatorTokenType:
             return '>';
         case EnumToken.GteTokenType:
             return '>=';
@@ -440,6 +451,7 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
             return '[';
         case EnumToken.AttrEndTokenType:
             return ']';
+        case EnumToken.DescendantCombinatorTokenType:
         case EnumToken.WhitespaceTokenType:
             return ' ';
         case EnumToken.ColonTokenType:
@@ -571,12 +583,20 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
             }
         case EnumToken.HashTokenType:
         case EnumToken.IdenTokenType:
-        case EnumToken.DelimTokenType:
         case EnumToken.AtRuleTokenType:
         case EnumToken.StringTokenType:
         case EnumToken.LiteralTokenType:
         case EnumToken.DashedIdenTokenType:
+        case EnumToken.ClassSelectorTokenType:
             return /* options.minify && 'Pseudo-class' == token.typ && '::' == token.val.slice(0, 2) ? token.val.slice(1) :  */ token.val;
+        case EnumToken.NestingSelectorTokenType:
+            return '&';
+        case EnumToken.InvalidAttrTokenType:
+            return '[' + token.chi.reduce((acc, curr) => acc + renderToken(curr, options, cache), '');
+        case EnumToken.InvalidClassSelectorTokenType:
+            return token.val;
+        default:
+            throw new Error(`render: unexpected token ${JSON.stringify(token, null, 1)}`);
     }
     errors?.push({ action: 'ignore', message: `render: unexpected token ${JSON.stringify(token, null, 1)}` });
     return '';

package/dist/lib/syntax/syntax.js

@@ -0,0 +1,456 @@
+import { colorsFunc } from '../renderer/render.js';
+import { EnumToken } from '../ast/types.js';
+import '../ast/minify.js';
+import '../parser/parse.js';
+import '../parser/utils/config.js';
+import { COLORS_NAMES } from '../renderer/color/utils/constants.js';
+
+// https://www.w3.org/TR/CSS21/syndata.html#syntax
+// https://www.w3.org/TR/2021/CRD-css-syntax-3-20211224/#typedef-ident-token
+// '\\'
+const REVERSE_SOLIDUS = 0x5c;
+const dimensionUnits = new Set([
+    'q', 'cap', 'ch', 'cm', 'cqb', 'cqh', 'cqi', 'cqmax', 'cqmin', 'cqw', 'dvb',
+    'dvh', 'dvi', 'dvmax', 'dvmin', 'dvw', 'em', 'ex', 'ic', 'in', 'lh', 'lvb',
+    'lvh', 'lvi', 'lvmax', 'lvw', 'mm', 'pc', 'pt', 'px', 'rem', 'rlh', 'svb',
+    'svh', 'svi', 'svmin', 'svw', 'vb', 'vh', 'vi', 'vmax', 'vmin', 'vw'
+]);
+function isLength(dimension) {
+    return 'unit' in dimension && dimensionUnits.has(dimension.unit.toLowerCase());
+}
+function isResolution(dimension) {
+    return 'unit' in dimension && ['dpi', 'dpcm', 'dppx', 'x'].includes(dimension.unit.toLowerCase());
+}
+function isAngle(dimension) {
+    return 'unit' in dimension && ['rad', 'turn', 'deg', 'grad'].includes(dimension.unit.toLowerCase());
+}
+function isTime(dimension) {
+    return 'unit' in dimension && ['ms', 's'].includes(dimension.unit.toLowerCase());
+}
+function isFrequency(dimension) {
+    return 'unit' in dimension && ['hz', 'khz'].includes(dimension.unit.toLowerCase());
+}
+function isColorspace(token) {
+    if (token.typ != EnumToken.IdenTokenType) {
+        return false;
+    }
+    return ['srgb', 'srgb-linear', 'lab', 'oklab', 'lch', 'oklch', 'xyz', 'xyz-d50', 'xyz-d65', 'display-p3', 'a98-rgb', 'prophoto-rgb', 'rec2020', 'rgb', 'hsl', 'hwb'].includes(token.val.toLowerCase());
+}
+function isRectangularOrthogonalColorspace(token) {
+    if (token.typ != EnumToken.IdenTokenType) {
+        return false;
+    }
+    return ['srgb', 'srgb-linear', 'display-p3', 'a98-rgb', 'prophoto-rgb', 'rec2020', 'lab', 'oklab', 'xyz', 'xyz-d50', 'xyz-d65'].includes(token.val.toLowerCase());
+}
+function isPolarColorspace(token) {
+    if (token.typ != EnumToken.IdenTokenType) {
+        return false;
+    }
+    return ['hsl', 'hwb', 'lch', 'oklch'].includes(token.val);
+}
+function isHueInterpolationMethod(token) {
+    if (token.typ != EnumToken.IdenTokenType) {
+        return false;
+    }
+    return ['shorter', 'longer', 'increasing', 'decreasing'].includes(token.val);
+}
+function isColor(token) {
+    if (token.typ == EnumToken.ColorTokenType) {
+        return true;
+    }
+    if (token.typ == EnumToken.IdenTokenType) {
+        // named color
+        return token.val.toLowerCase() in COLORS_NAMES;
+    }
+    let isLegacySyntax = false;
+    if (token.typ == EnumToken.FunctionTokenType && token.chi.length > 0 && colorsFunc.includes(token.val)) {
+        if (token.val == 'light-dark') {
+            const children = token.chi.filter((t) => [EnumToken.IdenTokenType, EnumToken.NumberTokenType, EnumToken.LiteralTokenType, EnumToken.ColorTokenType, EnumToken.FunctionTokenType, EnumToken.PercentageTokenType].includes(t.typ));
+            if (children.length != 2) {
+                return false;
+            }
+            if (isColor(children[0]) && isColor(children[1])) {
+                return true;
+            }
+        }
+        if (token.val == 'color') {
+            const children = token.chi.filter((t) => [EnumToken.IdenTokenType, EnumToken.NumberTokenType, EnumToken.LiteralTokenType, EnumToken.ColorTokenType, EnumToken.FunctionTokenType, EnumToken.PercentageTokenType].includes(t.typ));
+            const isRelative = children[0].typ == EnumToken.IdenTokenType && children[0].val == 'from';
+            if (children.length < 4 || children.length > 8) {
+                return false;
+            }
+            if (!isRelative && !isColorspace(children[0])) {
+                return false;
+            }
+            for (let i = 1; i < children.length - 2; i++) {
+                if (children[i].typ == EnumToken.IdenTokenType) {
+                    if (children[i].val != 'none' &&
+                        !(isRelative && ['alpha', 'r', 'g', 'b', 'x', 'y', 'z'].includes(children[i].val) || isColorspace(children[i]))) {
+                        return false;
+                    }
+                }
+                if (children[i].typ == EnumToken.FunctionTokenType && !['calc'].includes(children[i].val)) {
+                    return false;
+                }
+            }
+            if (children.length == 4 || (isRelative && children.length == 6)) {
+                return true;
+            }
+            if (children.length == 8 || children.length == 6) {
+                const sep = children.at(-2);
+                const alpha = children.at(-1);
+                // @ts-ignore
+                if ((children.length > 6 || !isRelative) && sep.typ != EnumToken.LiteralTokenType || sep.val != '/') {
+                    return false;
+                }
+                if (alpha.typ == EnumToken.IdenTokenType && alpha.val != 'none') {
+                    return false;
+                }
+                else {
+                    // @ts-ignore
+                    if (alpha.typ == EnumToken.PercentageTokenType) {
+                        if (+alpha.val < 0 || +alpha.val > 100) {
+                            return false;
+                        }
+                    }
+                    else if (alpha.typ == EnumToken.NumberTokenType) {
+                        if (+alpha.val < 0 || +alpha.val > 1) {
+                            return false;
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        else if (token.val == 'color-mix') {
+            const children = token.chi.reduce((acc, t) => {
+                if (t.typ == EnumToken.CommaTokenType) {
+                    acc.push([]);
+                }
+                else {
+                    if (![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ)) {
+                        acc[acc.length - 1].push(t);
+                    }
+                }
+                return acc;
+            }, [[]]);
+            if (children.length == 3) {
+                if (children[0].length > 3 ||
+                    children[0][0].typ != EnumToken.IdenTokenType ||
+                    children[0][0].val != 'in' ||
+                    !isColorspace(children[0][1]) ||
+                    (children[0].length == 3 && !isHueInterpolationMethod(children[0][2])) ||
+                    children[1].length > 2 ||
+                    children[1][0].typ != EnumToken.ColorTokenType ||
+                    children[2].length > 2 ||
+                    children[2][0].typ != EnumToken.ColorTokenType) {
+                    return false;
+                }
+                if (children[1].length == 2) {
+                    if (!(children[1][1].typ == EnumToken.PercentageTokenType || (children[1][1].typ == EnumToken.NumberTokenType && children[1][1].val == '0'))) {
+                        return false;
+                    }
+                }
+                if (children[2].length == 2) {
+                    if (!(children[2][1].typ == EnumToken.PercentageTokenType || (children[2][1].typ == EnumToken.NumberTokenType && children[2][1].val == '0'))) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        else {
+            const keywords = ['from', 'none'];
+            if (['rgb', 'hsl', 'hwb', 'lab', 'lch', 'oklab', 'oklch'].includes(token.val)) {
+                keywords.push('alpha', ...token.val.slice(-3).split(''));
+            }
+            // @ts-ignore
+            for (const v of token.chi) {
+                if (v.typ == EnumToken.CommaTokenType) {
+                    isLegacySyntax = true;
+                }
+                if (v.typ == EnumToken.IdenTokenType) {
+                    if (!(keywords.includes(v.val) || v.val.toLowerCase() in COLORS_NAMES)) {
+                        return false;
+                    }
+                    if (keywords.includes(v.val)) {
+                        if (isLegacySyntax) {
+                            return false;
+                        }
+                        if (v.val == 'from' && ['rgba', 'hsla'].includes(token.val)) {
+                            return false;
+                        }
+                    }
+                    continue;
+                }
+                if (v.typ == EnumToken.FunctionTokenType && (v.val == 'calc' || v.val == 'var' || colorsFunc.includes(v.val))) {
+                    continue;
+                }
+                if (![EnumToken.ColorTokenType, EnumToken.IdenTokenType, EnumToken.NumberTokenType, EnumToken.AngleTokenType, EnumToken.PercentageTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType, EnumToken.LiteralTokenType].includes(v.typ)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function isLetter(codepoint) {
+    // lowercase
+    return (codepoint >= 0x61 && codepoint <= 0x7a) ||
+        // uppercase
+        (codepoint >= 0x41 && codepoint <= 0x5a);
+}
+function isNonAscii(codepoint) {
+    return codepoint >= 0x80;
+}
+function isIdentStart(codepoint) {
+    // _
+    return codepoint == 0x5f || isLetter(codepoint) || isNonAscii(codepoint);
+}
+function isDigit(codepoint) {
+    return codepoint >= 0x30 && codepoint <= 0x39;
+}
+function isIdentCodepoint(codepoint) {
+    // -
+    return codepoint == 0x2d || isDigit(codepoint) || isIdentStart(codepoint);
+}
+function isIdent(name) {
+    const j = name.length - 1;
+    let i = 0;
+    let codepoint = name.charCodeAt(0);
+    // -
+    if (codepoint == 0x2d) {
+        const nextCodepoint = name.charCodeAt(1);
+        if (Number.isNaN(nextCodepoint)) {
+            return false;
+        }
+        // -
+        if (nextCodepoint == 0x2d) {
+            return true;
+        }
+        if (nextCodepoint == REVERSE_SOLIDUS) {
+            return name.length > 2 && !isNewLine(name.charCodeAt(2));
+        }
+        return true;
+    }
+    if (!isIdentStart(codepoint)) {
+        return false;
+    }
+    while (i < j) {
+        i += codepoint < 0x80 ? 1 : String.fromCodePoint(codepoint).length;
+        codepoint = name.charCodeAt(i);
+        if (codepoint == REVERSE_SOLIDUS) {
+            i += codepoint < 0x80 ? 1 : String.fromCodePoint(codepoint).length;
+            codepoint = name.charCodeAt(i);
+            i += codepoint < 0x80 ? 1 : String.fromCodePoint(codepoint).length;
+            continue;
+        }
+        if (!isIdentCodepoint(codepoint)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isNonPrintable(codepoint) {
+    // null -> backspace
+    return (codepoint >= 0 && codepoint <= 0x8) ||
+        // tab
+        codepoint == 0xb ||
+        // delete
+        codepoint == 0x7f ||
+        (codepoint >= 0xe && codepoint <= 0x1f);
+}
+function isPseudo(name) {
+    return name.charAt(0) == ':' &&
+        ((name.endsWith('(') && isIdent(name.charAt(1) == ':' ? name.slice(2, -1) : name.slice(1, -1))) ||
+            isIdent(name.charAt(1) == ':' ? name.slice(2) : name.slice(1)));
+}
+function isHash(name) {
+    return name.charAt(0) == '#' && isIdent(name.charAt(1));
+}
+function isNumber(name) {
+    if (name.length == 0) {
+        return false;
+    }
+    let codepoint = name.charCodeAt(0);
+    let i = 0;
+    const j = name.length;
+    if (j == 1 && !isDigit(codepoint)) {
+        return false;
+    }
+    // '+' '-'
+    if ([0x2b, 0x2d].includes(codepoint)) {
+        i++;
+    }
+    // consume digits
+    while (i < j) {
+        codepoint = name.charCodeAt(i);
+        if (isDigit(codepoint)) {
+            i++;
+            continue;
+        }
+        // '.' 'E' 'e'
+        if (codepoint == 0x2e || codepoint == 0x45 || codepoint == 0x65) {
+            break;
+        }
+        return false;
+    }
+    // '.'
+    if (codepoint == 0x2e) {
+        if (!isDigit(name.charCodeAt(++i))) {
+            return false;
+        }
+    }
+    while (i < j) {
+        codepoint = name.charCodeAt(i);
+        if (isDigit(codepoint)) {
+            i++;
+            continue;
+        }
+        // 'E' 'e'
+        if (codepoint == 0x45 || codepoint == 0x65) {
+            i++;
+            break;
+        }
+        return false;
+    }
+    // 'E' 'e'
+    if (codepoint == 0x45 || codepoint == 0x65) {
+        if (i == j) {
+            return false;
+        }
+        codepoint = name.charCodeAt(i + 1);
+        // '+' '-'
+        if ([0x2b, 0x2d].includes(codepoint)) {
+            i++;
+        }
+        codepoint = name.charCodeAt(i + 1);
+        if (!isDigit(codepoint)) {
+            return false;
+        }
+    }
+    while (++i < j) {
+        codepoint = name.charCodeAt(i);
+        if (!isDigit(codepoint)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isDimension(name) {
+    let index = name.length;
+    while (index--) {
+        if (isLetter(name.charCodeAt(index))) {
+            continue;
+        }
+        index++;
+        break;
+    }
+    const number = name.slice(0, index);
+    return number.length > 0 && isIdentStart(name.charCodeAt(index)) && isNumber(number);
+}
+function isPercentage(name) {
+    return name.endsWith('%') && isNumber(name.slice(0, -1));
+}
+function isFlex(name) {
+    return name.endsWith('fr') && isNumber(name.slice(0, -2));
+}
+function parseDimension(name) {
+    let index = name.length;
+    while (index--) {
+        if (isLetter(name.charCodeAt(index))) {
+            continue;
+        }
+        index++;
+        break;
+    }
+    const dimension = {
+        typ: EnumToken.DimensionTokenType,
+        val: name.slice(0, index),
+        unit: name.slice(index)
+    };
+    if (isAngle(dimension)) {
+        // @ts-ignore
+        dimension.typ = EnumToken.AngleTokenType;
+    }
+    else if (isLength(dimension)) {
+        // @ts-ignore
+        dimension.typ = EnumToken.LengthTokenType;
+    }
+    else if (isTime(dimension)) {
+        // @ts-ignore
+        dimension.typ = EnumToken.TimeTokenType;
+    }
+    else if (isResolution(dimension)) {
+        // @ts-ignore
+        dimension.typ = EnumToken.ResolutionTokenType;
+        if (dimension.unit == 'dppx') {
+            dimension.unit = 'x';
+        }
+    }
+    else if (isFrequency(dimension)) {
+        // @ts-ignore
+        dimension.typ = EnumToken.FrequencyTokenType;
+    }
+    return dimension;
+}
+function isHexColor(name) {
+    if (name.charAt(0) != '#' || ![4, 5, 7, 9].includes(name.length)) {
+        return false;
+    }
+    for (let chr of name.slice(1)) {
+        let codepoint = chr.charCodeAt(0);
+        if (!isDigit(codepoint) &&
+            // A-F
+            !(codepoint >= 0x41 && codepoint <= 0x46) &&
+            // a-f
+            !(codepoint >= 0x61 && codepoint <= 0x66)) {
+            return false;
+        }
+    }
+    return true;
+}
+/*
+export function isHexDigit(name: string): boolean {
+
+    if (name.length || name.length > 6) {
+
+        return false;
+    }
+
+    for (let chr of name) {
+
+        let codepoint = <number>chr.charCodeAt(0);
+
+        if (!isDigit(codepoint) &&
+            // A F
+            !(codepoint >= 0x41 && codepoint <= 0x46) &&
+            // a f
+            !(codepoint >= 0x61 && codepoint <= 0x66)) {
+
+            return false;
+        }
+    }
+
+    return true;
+}
+*/
+function isFunction(name) {
+    return name.endsWith('(') && isIdent(name.slice(0, -1));
+}
+function isAtKeyword(name) {
+    return name.charCodeAt(0) == 0x40 && isIdent(name.slice(1));
+}
+function isNewLine(codepoint) {
+    // \n \r \f
+    return codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
+}
+function isWhiteSpace(codepoint) {
+    return codepoint == 0x9 || codepoint == 0x20 ||
+        // isNewLine
+        codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
+}
+
+export { isAngle, isAtKeyword, isColor, isColorspace, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, parseDimension };

package/dist/lib/validation/config.js

@@ -0,0 +1,9 @@
+import config from './config.json.js';
+
+Object.freeze(config);
+function getConfig() {
+    // @ts-ignore
+    return config;
+}
+
+export { getConfig };