@tbela99/css-parser 1.1.1-alpha4 → 1.2.0

package/dist/lib/syntax/color/oklch.js

@@ -0,0 +1,166 @@
+import './utils/constants.js';
+import { getComponents } from './utils/components.js';
+import { color2srgbvalues, toPrecisionAngle, getNumber, getAngle } from './color.js';
+import { srgb2oklab, lch2oklabvalues, getOKLABComponents, lab2oklabvalues, hwb2oklabvalues, hsl2oklabvalues, rgb2oklabvalues, hex2oklabvalues } from './oklab.js';
+import { EnumToken, ColorType } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
+import { cmyk2srgbvalues } from './srgb.js';
+import { labvalues2lchvalues } from './lch.js';
+import '../../renderer/sourcemap/lib/encode.js';
+
+function hex2oklchToken(token) {
+    const values = hex2oklchvalues(token);
+    return oklchToken(values);
+}
+function rgb2oklchToken(token) {
+    const values = rgb2oklchvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return oklchToken(values);
+}
+function hsl2oklchToken(token) {
+    const values = hsl2oklchvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return oklchToken(values);
+}
+function hwb2oklchToken(token) {
+    const values = hwb2oklchvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return oklchToken(values);
+}
+function cmyk2oklchToken(token) {
+    const values = cmyk2oklchvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return oklchToken(values);
+}
+function lab2oklchToken(token) {
+    const values = lab2oklchvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return oklchToken(values);
+}
+function oklab2oklchToken(token) {
+    const values = oklab2oklchvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return oklchToken(values);
+}
+function lch2oklchToken(token) {
+    const values = lch2oklchvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return oklchToken(values);
+}
+function color2oklchToken(token) {
+    const values = color2srgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    // @ts-ignore
+    return oklchToken(srgb2oklch(...values));
+}
+function oklchToken(values) {
+    values[2] = toPrecisionAngle(values[2]);
+    const chi = [
+        { typ: EnumToken.NumberTokenType, val: String(values[0]) },
+        { typ: EnumToken.NumberTokenType, val: String(values[1]) },
+        { typ: EnumToken.NumberTokenType, val: String(values[2]) },
+    ];
+    if (values.length == 4) {
+        chi.push({ typ: EnumToken.LiteralTokenType, val: '/' }, {
+            typ: EnumToken.PercentageTokenType,
+            val: (values[3] * 100).toFixed()
+        });
+    }
+    return {
+        typ: EnumToken.ColorTokenType,
+        val: 'oklch',
+        chi,
+        kin: ColorType.OKLCH
+    };
+}
+function hex2oklchvalues(token) {
+    // @ts-ignore
+    return labvalues2lchvalues(...hex2oklabvalues(token));
+}
+function rgb2oklchvalues(token) {
+    const values = rgb2oklabvalues(token);
+    if (values == null) {
+        return null;
+    }
+    // @ts-ignore
+    return labvalues2lchvalues(...values);
+}
+function hsl2oklchvalues(token) {
+    // @ts-ignore
+    return labvalues2lchvalues(...hsl2oklabvalues(token));
+}
+function hwb2oklchvalues(token) {
+    // @ts-ignore
+    return labvalues2lchvalues(...hwb2oklabvalues(token));
+}
+function cmyk2oklchvalues(token) {
+    const values = cmyk2srgbvalues(token);
+    // @ts-ignore
+    return values == null ? null : srgb2oklch(...values);
+}
+function lab2oklchvalues(token) {
+    // @ts-ignore
+    return labvalues2lchvalues(...lab2oklabvalues(token));
+}
+function lch2oklchvalues(token) {
+    // @ts-ignore
+    return labvalues2lchvalues(...lch2oklabvalues(token));
+}
+function oklab2oklchvalues(token) {
+    // @ts-ignore
+    return labvalues2lchvalues(...getOKLABComponents(token));
+}
+function srgb2oklch(r, g, blue, alpha) {
+    // @ts-ignore
+    return labvalues2lchvalues(...srgb2oklab(r, g, blue, alpha));
+}
+function getOKLCHComponents(token) {
+    const components = getComponents(token);
+    if (components == null) {
+        return null;
+    }
+    for (let i = 0; i < components.length; i++) {
+        if (![EnumToken.NumberTokenType, EnumToken.PercentageTokenType, EnumToken.AngleTokenType, EnumToken.IdenTokenType].includes(components[i].typ)) {
+            return [];
+        }
+    }
+    // @ts-ignore
+    let t = components[0];
+    // @ts-ignore
+    const l = getNumber(t);
+    // @ts-ignore
+    t = components[1];
+    // @ts-ignore
+    const c = getNumber(t) * (t.typ == EnumToken.PercentageTokenType ? .4 : 1);
+    // @ts-ignore
+    t = components[2];
+    // @ts-ignore
+    const h = getAngle(t) * 360;
+    // @ts-ignore
+    t = components[3];
+    // @ts-ignore
+    const alpha = t == null || (t.typ == EnumToken.IdenTokenType && t.val == 'none') ? 1 : getNumber(t);
+    return [l, c, h, alpha];
+}
+
+export { cmyk2oklchToken, cmyk2oklchvalues, color2oklchToken, getOKLCHComponents, hex2oklchToken, hex2oklchvalues, hsl2oklchToken, hsl2oklchvalues, hwb2oklchToken, hwb2oklchvalues, lab2oklchToken, lab2oklchvalues, lch2oklchToken, lch2oklchvalues, oklab2oklchToken, oklab2oklchvalues, rgb2oklchToken, rgb2oklchvalues, srgb2oklch };

package/dist/lib/{renderer → syntax}/color/p3.js

@@ -1,4 +1,4 @@
-import { xyz2srgb, lsrgb2srgbvalues, srgb2lsrgbvalues } from './srgb.js';
+import { lsrgb2srgbvalues, xyz2srgb, srgb2lsrgbvalues } from './srgb.js';
 import { multiplyMatrices } from './utils/matrix.js';
 import './utils/constants.js';
 import '../../ast/types.js';
@@ -8,7 +8,7 @@ import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
 import { srgb2xyz } from './xyz.js';
-import '../sourcemap/lib/encode.js';
+import '../../renderer/sourcemap/lib/encode.js';
 
 function p32srgbvalues(r, g, b, alpha) {
     // @ts-ignore
@@ -16,7 +16,7 @@ function p32srgbvalues(r, g, b, alpha) {
 }
 function srgb2p3values(r, g, b, alpha) {
     // @ts-ignore
-    return srgb2xyz(...xyz2lp3(...lp32p3(r, g, b, alpha)));
+    return lp32p3(...xyz2lp3(...srgb2xyz(r, g, b, alpha)));
 }
 function p32lp3(r, g, b, alpha) {
     // convert an array of display-p3 RGB values in the range 0.0 - 1.0

package/dist/lib/{renderer → syntax}/color/rec2020.js

@@ -8,7 +8,7 @@ import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
 import { srgb2xyz } from './xyz.js';
-import '../sourcemap/lib/encode.js';
+import '../../renderer/sourcemap/lib/encode.js';
 
 function rec20202srgb(r, g, b, a) {
     // @ts-ignore
@@ -22,28 +22,28 @@ function rec20202lrec2020(r, g, b, a) {
     // convert an array of rec2020 RGB values in the range 0.0 - 1.0
     // to linear light (un-companded) form.
     // ITU-R BT.2020-2 p.4
-    const α = 1.09929682680944;
-    const β = 0.018053968510807;
+    const alpha = 1.09929682680944;
+    const beta = 0.018053968510807;
     return [r, g, b].map(function (val) {
         let sign = val < 0 ? -1 : 1;
         let abs = Math.abs(val);
-        if (abs < β * 4.5) {
+        if (abs < beta * 4.5) {
             return val / 4.5;
         }
-        return sign * (Math.pow((abs + α - 1) / α, 1 / 0.45));
+        return sign * (Math.pow((abs + alpha - 1) / alpha, 1 / 0.45));
     }).concat([] );
 }
 function lrec20202rec2020(r, g, b, a) {
     // convert an array of linear-light rec2020 RGB  in the range 0.0-1.0
     // to gamma corrected form
     // ITU-R BT.2020-2 p.4
-    const α = 1.09929682680944;
-    const β = 0.018053968510807;
+    const alpha = 1.09929682680944;
+    const beta = 0.018053968510807;
     return [r, g, b].map(function (val) {
         let sign = val < 0 ? -1 : 1;
         let abs = Math.abs(val);
-        if (abs > β) {
-            return sign * (α * Math.pow(abs, 0.45) - (α - 1));
+        if (abs > beta) {
+            return sign * (alpha * Math.pow(abs, 0.45) - (alpha - 1));
         }
         return 4.5 * val;
     }).concat(a == null || a == 1 ? [] : [a]);
@@ -52,7 +52,7 @@ function lrec20202xyz(r, g, b, a) {
     // convert an array of linear-light rec2020 values to CIE XYZ
     // using  D65 (no chromatic adaptation)
     // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
-    var M = [
+    let M = [
         [63426534 / 99577255, 20160776 / 139408157, 47086771 / 278816314],
         [26158966 / 99577255, 472592308 / 697040785, 8267143 / 139408157],
         [0, 19567812 / 697040785, 295819943 / 278816314],
@@ -62,7 +62,7 @@ function lrec20202xyz(r, g, b, a) {
 }
 function xyz2lrec2020(x, y, z, a) {
     // convert XYZ to linear-light rec2020
-    var M = [
+    let M = [
         [30757411 / 17917100, -6372589 / 17917100, -4539589 / 17917100],
         [-19765991 / 29648200, 47925759 / 29648200, 467509 / 29648200],
         [792561 / 44930125, -1921689 / 44930125, 42328811 / 44930125],

package/dist/lib/{renderer → syntax}/color/relativecolor.js

@@ -1,14 +1,14 @@
-import { convert, getNumber } from './color.js';
-import { EnumToken } from '../../ast/types.js';
+import { convertColor, getNumber } from './color.js';
+import { ColorType, EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { walkValues } from '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import { mathFuncs } from '../../syntax/syntax.js';
-import { reduceNumber } from '../render.js';
-import { ColorKind, colorRange } from './utils/constants.js';
+import { mathFuncs } from '../syntax.js';
+import { colorRange } from './utils/constants.js';
 import { evaluateFunc, evaluate } from '../../ast/math/expression.js';
+import '../../renderer/sourcemap/lib/encode.js';
 
 function parseRelativeColor(relativeKeys, original, rExp, gExp, bExp, aExp) {
     let r;
@@ -19,12 +19,12 @@ function parseRelativeColor(relativeKeys, original, rExp, gExp, bExp, aExp) {
     let values = {};
     // colorFuncColorSpace x,y,z or r,g,b
     const names = relativeKeys.startsWith('xyz') ? 'xyz' : relativeKeys.slice(-3);
-    const converted = convert(original, ColorKind[relativeKeys.toUpperCase().replaceAll('-', '_')]);
+    const converted = convertColor(original, ColorType[relativeKeys.toUpperCase().replaceAll('-', '_')]);
     if (converted == null) {
         return null;
     }
     const children = converted.chi.filter(t => ![EnumToken.WhitespaceTokenType, EnumToken.LiteralTokenType, EnumToken.CommentTokenType].includes(t.typ));
-    [r, g, b, alpha] = converted.kin == ColorKind.COLOR ? children.slice(1) : children;
+    [r, g, b, alpha] = converted.kin == ColorType.COLOR ? children.slice(1) : children;
     values = {
         [names[0]]: getValue(r, converted, names[0]),
         [names[1]]: getValue(g, converted, names[1]), // string,
@@ -57,12 +57,13 @@ function parseRelativeColor(relativeKeys, original, rExp, gExp, bExp, aExp) {
     return computeComponentValue(keys, converted, values);
 }
 function getValue(t, converted, component) {
-    if (t == null) {
-        return t;
-    }
+    // if (t == null) {
+    //
+    //     return t;
+    // }
     if (t.typ == EnumToken.PercentageTokenType) {
         let value = getNumber(t);
-        let colorSpace = ColorKind[converted.kin].toLowerCase().replaceAll('-', '_');
+        let colorSpace = ColorType[converted.kin].toLowerCase().replaceAll('-', '_');
         if (colorSpace in colorRange) {
             // @ts-ignore
             value *= colorRange[colorSpace][component].at(-1);
@@ -89,44 +90,55 @@ function computeComponentValue(expr, converted, values) {
         }
     }
     for (const [key, exp] of Object.entries(expr)) {
+        /*
         if (exp == null) {
+
             if (key in values) {
-                if (typeof values[key] == 'number') {
-                    expr[key] = {
+
+                if (typeof values[<RelativeColorTypes>key] == 'number') {
+
+                    expr[<RelativeColorTypes>key] = {
                         typ: EnumToken.NumberTokenType,
-                        val: reduceNumber(values[key])
+                        val: reduceNumber(<number>values[<RelativeColorTypes>key])
                     };
-                }
-                else {
-                    expr[key] = values[key];
+                } else {
+
+                    expr[<RelativeColorTypes>key] = <Token>values[<RelativeColorTypes>key];
                 }
             }
-        }
-        else if ([EnumToken.NumberTokenType, EnumToken.PercentageTokenType, EnumToken.AngleTokenType, EnumToken.LengthTokenType].includes(exp.typ)) ;
+
+        } else
+            */
+        if ([EnumToken.NumberTokenType, EnumToken.PercentageTokenType, EnumToken.AngleTokenType, EnumToken.LengthTokenType].includes(exp.typ)) ;
         else if (exp.typ == EnumToken.IdenTokenType && exp.val in values) {
-            if (typeof values[exp.val] == 'number') {
-                expr[key] = {
-                    typ: EnumToken.NumberTokenType,
-                    val: reduceNumber(values[exp.val])
-                };
-            }
-            else {
-                expr[key] = values[exp.val];
-            }
+            // if (typeof values[<RelativeColorTypes>exp.val] == 'number') {
+            //
+            //     expr[<RelativeColorTypes>key] = {
+            //         typ: EnumToken.NumberTokenType,
+            //         val: reduceNumber(<number>values[<RelativeColorTypes>exp.val])
+            //     };
+            // } else {
+            expr[key] = values[exp.val];
+            // }
         }
         else if (exp.typ == EnumToken.FunctionTokenType && mathFuncs.includes(exp.val)) {
             for (let { value, parent } of walkValues(exp.chi, exp)) {
-                if (parent == null) {
-                    parent = exp;
-                }
+                // if (parent == null) {
+                //
+                //     parent = exp;
+                // }
+                /*
                 if (value.typ == EnumToken.PercentageTokenType) {
-                    replaceValue(parent, value, getValue(value, converted, key));
-                }
-                else if (value.typ == EnumToken.IdenTokenType) {
+
+                    replaceValue(parent as BinaryExpressionToken | FunctionToken | ParensToken, value, getValue(value, converted, <RelativeColorTypes>key));
+                } else
+                    */
+                if (value.typ == EnumToken.IdenTokenType) {
                     // @ts-ignore
-                    if (!(value.val in values || typeof Math[value.val.toUpperCase()] == 'number')) {
-                        return null;
-                    }
+                    // if (!(value.val in values || typeof Math[(value as IdentToken).val.toUpperCase()] == 'number')) {
+                    //
+                    //     return null;
+                    // }
                     // @ts-ignore
                     replaceValue(parent, value, values[value.val] ?? {
                         typ: EnumToken.NumberTokenType,
@@ -140,9 +152,10 @@ function computeComponentValue(expr, converted, values) {
             if (result.length == 1 && result[0].typ != EnumToken.BinaryExpressionTokenType) {
                 expr[key] = result[0];
             }
-            else {
-                return null;
-            }
+            // else {
+            //
+            //     return null;
+            // }
         }
     }
     return expr;

package/dist/lib/syntax/color/rgb.js

@@ -0,0 +1,140 @@
+import { color2srgbvalues, minmax } from './color.js';
+import { COLORS_NAMES } from './utils/constants.js';
+import { EnumToken, ColorType } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
+import { expandHexValue } from './hex.js';
+import { hslvalues, hslvalues2srgbvalues, lch2srgbvalues, lab2srgbvalues, oklch2srgbvalues, oklab2srgbvalues, cmyk2srgbvalues, hwb2srgbvalues } from './srgb.js';
+import '../../renderer/sourcemap/lib/encode.js';
+
+function srgb2rgb(value) {
+    return minmax(Math.round(value * 255), 0, 255);
+}
+function hex2RgbToken(token) {
+    return rgb2RgbToken(hex2rgbvalues(token));
+}
+function hsl2RgbToken(token) {
+    const values = hsl2rgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return rgb2RgbToken(values);
+}
+function hwb2RgbToken(token) {
+    const values = hwb2rgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return rgb2RgbToken(values);
+}
+function cmyk2RgbToken(token) {
+    const values = cmyk2rgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return rgb2RgbToken(values);
+}
+function oklab2RgbToken(token) {
+    const values = oklab2rgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return rgb2RgbToken(values);
+}
+function oklch2RgbToken(token) {
+    const values = oklch2rgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return rgb2RgbToken(values);
+}
+function lab2RgbToken(token) {
+    const values = lab2rgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return rgb2RgbToken(values);
+}
+function lch2RgbToken(token) {
+    const values = lch2rgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return rgb2RgbToken(values);
+}
+function color2RgbToken(token) {
+    const values = color2srgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return rgb2RgbToken(values.map((t, index) => index == 3 ? t : srgb2rgb(t)));
+}
+function rgb2RgbToken(values) {
+    const chi = [
+        { typ: EnumToken.NumberTokenType, val: String(values[0]) },
+        { typ: EnumToken.NumberTokenType, val: String(values[1]) },
+        { typ: EnumToken.NumberTokenType, val: String(values[2]) },
+    ];
+    if (values.length == 4) {
+        chi.push({ typ: EnumToken.PercentageTokenType, val: (values[3] * 100).toFixed() });
+    }
+    return {
+        typ: EnumToken.ColorTokenType,
+        val: 'rgb',
+        chi,
+        kin: ColorType.RGB
+    };
+}
+function hex2rgbvalues(token) {
+    const value = expandHexValue(token.kin == ColorType.LIT ? COLORS_NAMES[token.val.toLowerCase()] : token.val);
+    const rgb = [];
+    for (let i = 1; i < value.length; i += 2) {
+        rgb.push(parseInt(value.slice(i, i + 2), 16));
+    }
+    if (rgb.length == 4) {
+        if (rgb[3] == 255) {
+            rgb.pop();
+        }
+        else {
+            rgb[3] = +(rgb[3] / 255).toFixed(2);
+        }
+    }
+    return rgb;
+}
+function hwb2rgbvalues(token) {
+    return hwb2srgbvalues(token)?.map?.((t, index) => index == 3 ? t : srgb2rgb(t)) ?? null;
+}
+function hsl2rgbvalues(token) {
+    let { h, s, l, a } = hslvalues(token) ?? {};
+    if (h == null || s == null || l == null) {
+        return null;
+    }
+    return hslvalues2srgbvalues(h, s, l).map((t) => minmax(Math.round(t * 255), 0, 255)).concat(a == 1 || a == null ? [] : [a]);
+}
+function hsl2srgbvalues(token) {
+    let { h, s, l, a } = hslvalues(token) ?? {};
+    if (h == null || s == null || l == null) {
+        return null;
+    }
+    return hslvalues2srgbvalues(h, s, l).concat(a == 1 || a == null ? [] : [a]);
+}
+function cmyk2rgbvalues(token) {
+    return cmyk2srgbvalues(token)?.map?.((t, index) => index == 3 ? t : srgb2rgb(t)) ?? null;
+}
+function oklab2rgbvalues(token) {
+    return oklab2srgbvalues(token)?.map?.((t, index) => index == 3 ? t : srgb2rgb(t)) ?? null;
+}
+function oklch2rgbvalues(token) {
+    return oklch2srgbvalues(token)?.map?.((t, index) => index == 3 ? t : srgb2rgb(t)) ?? null;
+}
+function lab2rgbvalues(token) {
+    return lab2srgbvalues(token)?.map?.((t, index) => index == 3 ? t : srgb2rgb(t)) ?? null;
+}
+function lch2rgbvalues(token) {
+    return lch2srgbvalues(token)?.map?.((t, index) => index == 3 ? t : srgb2rgb(t)) ?? null;
+}
+
+export { cmyk2RgbToken, cmyk2rgbvalues, color2RgbToken, hex2RgbToken, hex2rgbvalues, hsl2RgbToken, hsl2rgbvalues, hsl2srgbvalues, hwb2RgbToken, hwb2rgbvalues, lab2RgbToken, lab2rgbvalues, lch2RgbToken, lch2rgbvalues, oklab2RgbToken, oklab2rgbvalues, oklch2RgbToken, oklch2rgbvalues, srgb2rgb };