@tbela99/css-parser 0.3.0 → 0.4.1

package/dist/lib/parser/utils/declaration.js

@@ -3,7 +3,7 @@ import '../../ast/minify.js';
 import { walkValues } from '../../ast/walk.js';
 import '../parse.js';
 import { isWhiteSpace } from './syntax.js';
-import '../../renderer/utils/color.js';
+import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function parseDeclaration(node, errors, src, position) {

package/dist/lib/parser/utils/syntax.js

@@ -1,8 +1,8 @@
 import { colorsFunc } from '../../renderer/render.js';
-import { COLORS_NAMES } from '../../renderer/utils/color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../parse.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
@@ -29,6 +29,30 @@ function isTime(dimension) {
 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;
@@ -39,36 +63,119 @@ function isColor(token) {
     }
     let isLegacySyntax = false;
     if (token.typ == EnumToken.FunctionTokenType && token.chi.length > 0 && colorsFunc.includes(token.val)) {
-        const keywords = ['from', 'none'];
-        if (['rgb', 'hsl', 'hwb'].includes(token.val)) {
-            keywords.push('a', ...token.val.split(''));
-        }
-        // console.debug(JSON.stringify({token}, null, 1));
-        // @ts-ignore
-        for (const v of token.chi) {
-            // console.debug(JSON.stringify({v}, null, 1));
-            if (v.typ == EnumToken.CommaTokenType) {
-                isLegacySyntax = 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;
             }
-            if (v.typ == EnumToken.IdenTokenType) {
-                if (!(keywords.includes(v.val) || v.val.toLowerCase() in COLORS_NAMES)) {
+            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'].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 == 8 || children.length == 6) {
+                const sep = children.at(-2);
+                const alpha = children.at(-1);
+                if (sep.typ != EnumToken.LiteralTokenType || sep.val != '/') {
+                    return false;
+                }
+                if (alpha.typ == EnumToken.IdenTokenType && alpha.val != 'none') {
                     return false;
                 }
-                if (keywords.includes(v.val)) {
-                    if (isLegacySyntax) {
+                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 (v.val == 'from' && ['rgba', 'hsla'].includes(token.val)) {
+                }
+                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;
                     }
                 }
-                continue;
+                return true;
             }
-            if (v.typ == EnumToken.FunctionTokenType && (v.val == 'calc' || colorsFunc.includes(v.val))) {
-                continue;
+            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(''));
             }
-            if (![EnumToken.ColorTokenType, EnumToken.IdenTokenType, EnumToken.NumberTokenType, EnumToken.AngleTokenType, EnumToken.PercentageTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType, EnumToken.LiteralTokenType].includes(v.typ)) {
-                return false;
+            // @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;
@@ -239,7 +346,11 @@ function parseDimension(name) {
         index++;
         break;
     }
-    const dimension = { typ: EnumToken.DimensionTokenType, val: name.slice(0, index), unit: name.slice(index) };
+    const dimension = {
+        typ: EnumToken.DimensionTokenType,
+        val: name.slice(0, index),
+        unit: name.slice(index)
+    };
     if (isAngle(dimension)) {
         // @ts-ignore
         dimension.typ = EnumToken.AngleTokenType;
@@ -281,6 +392,31 @@ function isHexColor(name) {
     }
     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));
 }
@@ -297,4 +433,4 @@ function isWhiteSpace(codepoint) {
         codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
 }
 
-export { isAngle, isAtKeyword, isColor, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, parseDimension };
+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/parser/utils/type.js

@@ -1,7 +1,7 @@
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../parse.js';
-import '../../renderer/utils/color.js';
+import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 // https://www.w3.org/TR/css-values-4/#math-function
@@ -22,7 +22,7 @@ function matchType(val, properties) {
     }
     if (val.typ == EnumToken.FunctionTokenType) {
         if (funcList.includes(val.val)) {
-            return val.chi.every((t => [EnumToken.LiteralTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType, EnumToken.StartParensTokenType, EnumToken.EndParensTokenType].includes(t.typ) || matchType(t, properties)));
+            return val.chi.every(((t) => [EnumToken.LiteralTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType, EnumToken.StartParensTokenType, EnumToken.EndParensTokenType].includes(t.typ) || matchType(t, properties)));
         }
         // match type defined like function 'symbols()', 'url()', 'attr()' etc.
         // return properties.types.includes((<FunctionToken>val).val + '()')

package/dist/lib/renderer/color/a98rgb.js

@@ -0,0 +1,64 @@
+import { xyz2srgb } from './srgb.js';
+import { multiplyMatrices } from './utils/matrix.js';
+import './utils/constants.js';
+import '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../parser/parse.js';
+import { srgb2xyz } from './xyz.js';
+import '../sourcemap/lib/encode.js';
+
+function a98rgb2srgbvalues(r, g, b, a = null) {
+    //  @ts-ignore
+    return xyz2srgb(...la98rgb2xyz(...a98rgb2la98(r, g, b, a)));
+}
+function srgb2a98values(r, g, b, a = null) {
+    // @ts-ignore
+    return la98rgb2a98rgb(xyz2la98rgb(...srgb2xyz(r, g, b, a)));
+}
+// a98-rgb functions
+function a98rgb2la98(r, g, b, a = null) {
+    // convert an array of a98-rgb values in the range 0.0 - 1.0
+    // to linear light (un-companded) form.
+    // negative values are also now accepted
+    return [r, g, b].map(function (val) {
+        let sign = val < 0 ? -1 : 1;
+        let abs = Math.abs(val);
+        return sign * Math.pow(abs, 563 / 256);
+    }).concat(a == null || a == 1 ? [] : [a]);
+}
+function la98rgb2a98rgb(r, g, b, a = null) {
+    // convert an array of linear-light a98-rgb  in the range 0.0-1.0
+    // to gamma corrected form
+    // negative values are also now accepted
+    return [r, b, g].map(function (val) {
+        let sign = val < 0 ? -1 : 1;
+        let abs = Math.abs(val);
+        return sign * Math.pow(abs, 256 / 563);
+    }).concat(a == null || a == 1 ? [] : [a]);
+}
+function la98rgb2xyz(r, g, b, a = null) {
+    // convert an array of linear-light a98-rgb values to CIE XYZ
+    // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+    // has greater numerical precision than section 4.3.5.3 of
+    // https://www.adobe.com/digitalimag/pdfs/AdobeRGB1998.pdf
+    // but the values below were calculated from first principles
+    // from the chromaticity coordinates of R G B W
+    // see matrixmaker.html
+    var M = [
+        [573536 / 994567, 263643 / 1420810, 187206 / 994567],
+        [591459 / 1989134, 6239551 / 9945670, 374412 / 4972835],
+        [53769 / 1989134, 351524 / 4972835, 4929758 / 4972835],
+    ];
+    return multiplyMatrices(M, [r, g, b]).concat(a == null || a == 1 ? [] : [a]);
+}
+function xyz2la98rgb(x, y, z, a = null) {
+    // convert XYZ to linear-light a98-rgb
+    var M = [
+        [1829569 / 896150, -506331 / 896150, -308931 / 896150],
+        [-851781 / 878810, 1648619 / 878810, 36519 / 878810],
+        [16779 / 1248040, -147721 / 1248040, 1266979 / 1248040],
+    ];
+    return multiplyMatrices(M, [x, y, z]).concat(a == null || a == 1 ? [] : [a]);
+}
+
+export { a98rgb2srgbvalues, srgb2a98values };