@tbela99/css-parser 1.1.1 → 1.3.0

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

@@ -0,0 +1,179 @@
+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 { color2srgbvalues, getNumber } from './color.js';
+import { srgb2rgb, cmyk2rgbvalues, hwb2rgbvalues, hsl2rgbvalues } from './rgb.js';
+import { COLORS_NAMES, NAMES_COLORS } from './utils/constants.js';
+import { getComponents } from './utils/components.js';
+import { lch2srgbvalues, lab2srgbvalues, oklch2srgbvalues, oklab2srgbvalues } from './srgb.js';
+import '../../renderer/sourcemap/lib/encode.js';
+
+function toHexString(acc, value) {
+    return acc + value.toString(16).padStart(2, '0');
+}
+function reduceHexValue(value) {
+    if (value[0] != '#') {
+        value = COLORS_NAMES[value.toLowerCase()] ?? value;
+    }
+    const named_color = NAMES_COLORS[expandHexValue(value)];
+    if (value.length == 7) {
+        if (value[1] == value[2] &&
+            value[3] == value[4] &&
+            value[5] == value[6]) {
+            value = `#${value[1]}${value[3]}${value[5]}`;
+        }
+    }
+    else if (value.length == 9) {
+        if (value[1] == value[2] &&
+            value[3] == value[4] &&
+            value[5] == value[6] &&
+            value[7] == value[8]) {
+            value = `#${value[1]}${value[3]}${value[5]}${value[7] == 'f' ? '' : value[7]}`;
+        }
+    }
+    return named_color != null && named_color.length <= value.length ? named_color : value;
+}
+function expandHexValue(value) {
+    if (value.length == 4) {
+        return `#${value[1]}${value[1]}${value[2]}${value[2]}${value[3]}${value[3]}`;
+    }
+    if (value.length == 5) {
+        return `#${value[1]}${value[1]}${value[2]}${value[2]}${value[3]}${value[3]}${value[4]}${value[4]}`;
+    }
+    return value;
+}
+function rgb2HexToken(token) {
+    let value = rgb2hexvalues(token);
+    if (value == null) {
+        return null;
+    }
+    return hexToken(value);
+}
+function hsl2HexToken(token) {
+    let value = hsl2hexvalues(token);
+    if (value == null) {
+        return null;
+    }
+    return hexToken(value);
+}
+function cmyk2HexToken(token) {
+    let value = cmyk2hexvalues(token);
+    if (value == null) {
+        return null;
+    }
+    return hexToken(value);
+}
+function hwb2HexToken(token) {
+    let value = hwb2hexvalues(token);
+    if (value == null) {
+        return null;
+    }
+    return hexToken(value);
+}
+function color2HexToken(token) {
+    let value = color2srgbvalues(token);
+    if (value == null) {
+        return null;
+    }
+    return hexToken(value.reduce((acc, curr) => acc + srgb2rgb(curr).toString(16).padStart(2, '0'), '#'));
+}
+function oklab2HexToken(token) {
+    let value = oklab2srgbvalues(token);
+    if (value == null) {
+        return null;
+    }
+    return hexToken(value.reduce((acc, curr) => acc + srgb2rgb(curr).toString(16).padStart(2, '0'), '#'));
+}
+function oklch2HexToken(token) {
+    let value = oklch2srgbvalues(token);
+    if (value == null) {
+        return null;
+    }
+    return hexToken(value.reduce((acc, curr) => acc + srgb2rgb(curr).toString(16).padStart(2, '0'), '#'));
+}
+function lab2HexToken(token) {
+    let value = lab2srgbvalues(token);
+    if (value == null) {
+        return null;
+    }
+    return hexToken(value.reduce((acc, curr) => acc + srgb2rgb(curr).toString(16).padStart(2, '0'), '#'));
+}
+function lch2HexToken(token) {
+    let value = lch2srgbvalues(token);
+    if (value == null) {
+        return null;
+    }
+    return hexToken(value.reduce((acc, curr) => acc + srgb2rgb(curr).toString(16).padStart(2, '0'), '#'));
+}
+function hexToken(value) {
+    value = reduceHexValue(value);
+    return {
+        typ: EnumToken.ColorTokenType,
+        val: value,
+        kin: value[0] == '#' ? ColorType.HEX : ColorType.LIT
+    };
+}
+function rgb2hexvalues(token) {
+    let value = '#';
+    let t;
+    // @ts-ignore
+    const components = getComponents(token);
+    if (components == null || components.length < 3) {
+        return null;
+    }
+    // @ts-ignore
+    for (let i = 0; i < 3; i++) {
+        // @ts-ignore
+        t = components[i];
+        // @ts-ignore
+        value += (t.typ == EnumToken.Iden && t.val == 'none' ? '0' : Math.round(getNumber(t) * (t.typ == EnumToken.PercentageTokenType ? 255 : 1))).toString(16).padStart(2, '0');
+    }
+    // @ts-ignore
+    if (components.length == 4) {
+        // @ts-ignore
+        t = components[3];
+        // @ts-ignore
+        const v = getNumber(t);
+        // @ts-ignore
+        if (v < 1) {
+            // @ts-ignore
+            value += Math.round(255 * getNumber(t)).toString(16).padStart(2, '0');
+        }
+    }
+    return value;
+}
+function hsl2hexvalues(token) {
+    const t = hsl2rgbvalues(token);
+    if (t == null) {
+        return null;
+    }
+    if (t.length == 4) {
+        t[3] = srgb2rgb(t[3]);
+    }
+    return `${t.reduce(toHexString, '#')}`;
+}
+function hwb2hexvalues(token) {
+    const t = hwb2rgbvalues(token);
+    if (t == null) {
+        return null;
+    }
+    if (t.length == 4) {
+        t[3] = srgb2rgb(t[3]);
+    }
+    return `${t.reduce(toHexString, '#')}`;
+}
+function cmyk2hexvalues(token) {
+    const t = cmyk2rgbvalues(token);
+    if (t == null) {
+        return null;
+    }
+    if (t.length == 4) {
+        t[3] = srgb2rgb(t[3]);
+    }
+    return `#${t.reduce(toHexString, '')}`;
+}
+
+export { cmyk2HexToken, cmyk2hexvalues, color2HexToken, expandHexValue, hsl2HexToken, hsl2hexvalues, hwb2HexToken, hwb2hexvalues, lab2HexToken, lch2HexToken, oklab2HexToken, oklch2HexToken, reduceHexValue, rgb2HexToken, rgb2hexvalues };

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

@@ -0,0 +1,201 @@
+import { hwb2hsv } from './hsv.js';
+import { color2srgbvalues, toPrecisionAngle, getNumber } from './color.js';
+import { lch2rgbvalues, lab2rgbvalues, cmyk2rgbvalues } from './rgb.js';
+import './utils/constants.js';
+import { getComponents } from './utils/components.js';
+import { hex2srgbvalues, oklch2srgbvalues, oklab2srgbvalues, hslvalues } from './srgb.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 '../../renderer/sourcemap/lib/encode.js';
+
+function hex2HslToken(token) {
+    // @ts-ignore
+    return hslToken(srgb2hslvalues(...hex2srgbvalues(token)));
+}
+function rgb2HslToken(token) {
+    const values = rgb2hslvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hslToken(values);
+}
+function hwb2HslToken(token) {
+    const values = hwb2hslvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hslToken(values);
+}
+function cmyk2HslToken(token) {
+    const values = cmyk2hslvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hslToken(values);
+}
+function oklab2HslToken(token) {
+    const values = oklab2hslvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hslToken(values);
+}
+function oklch2HslToken(token) {
+    const values = oklch2hslvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hslToken(values);
+}
+function lab2HslToken(token) {
+    const values = lab2hslvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hslToken(values);
+}
+function lch2HslToken(token) {
+    const values = lch2hslvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hslToken(values);
+}
+function color2HslToken(token) {
+    const values = color2srgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    // @ts-ignore
+    return hslToken(srgb2hslvalues(...values));
+}
+function hslToken(values) {
+    values[0] = toPrecisionAngle(values[0] * 360);
+    const chi = [
+        { typ: EnumToken.NumberTokenType, val: values[0] },
+        { typ: EnumToken.PercentageTokenType, val: values[1] * 100 },
+        { typ: EnumToken.PercentageTokenType, val: values[2] * 100 },
+    ];
+    if (values.length == 4 && values[3] != 1) {
+        chi.push({ typ: EnumToken.LiteralTokenType, val: '/' }, { typ: EnumToken.PercentageTokenType, val: values[3] * 100 });
+    }
+    return {
+        typ: EnumToken.ColorTokenType,
+        val: 'hsl',
+        chi,
+        kin: ColorType.HSL
+    };
+}
+function rgb2hslvalues(token) {
+    const chi = getComponents(token);
+    if (chi == null || chi.length < 3) {
+        return null;
+    }
+    // @ts-ignore
+    let t = chi[0];
+    // @ts-ignore
+    let r = getNumber(t);
+    // @ts-ignore
+    t = chi[1];
+    // @ts-ignore
+    let g = getNumber(t);
+    // @ts-ignore
+    t = chi[2];
+    // @ts-ignore
+    let b = getNumber(t);
+    // @ts-ignore
+    let a = null;
+    if (chi.length == 4) {
+        a = getNumber(chi[3]);
+    }
+    const values = [r, g, b];
+    if (a != null && a != 1) {
+        values.push(a);
+    }
+    // @ts-ignore
+    return rgbvalues2hslvalues(...values);
+}
+// https://gist.github.com/defims/0ca2ef8832833186ed396a2f8a204117#file-annotated-js
+function hsv2hsl(h, s, v, a) {
+    const result = [
+        //[hue, saturation, lightness]
+        //Range should be between 0 - 1
+        h, //Hue stays the same
+        //Saturation is very different between the two color spaces
+        //If (2-sat)*val < 1 set it to sat*val/((2-sat)*val)
+        //Otherwise sat*val/(2-(2-sat)*val)
+        //Conditional is not operating with hue, it is reassigned!
+        s * v / ((h = (2 - s) * v) < 1 ? h : 2 - h),
+        h / 2, //Lightness is (2-sat)*val/2
+    ];
+    if (a != null) {
+        result.push(a);
+    }
+    return result;
+}
+function cmyk2hslvalues(token) {
+    const values = cmyk2rgbvalues(token);
+    // @ts-ignore
+    return values == null ? null : rgbvalues2hslvalues(...values);
+}
+function hwb2hslvalues(token) {
+    // @ts-ignore
+    return hsv2hsl(...hwb2hsv(...Object.values(hslvalues(token))));
+}
+function lab2hslvalues(token) {
+    // @ts-ignore
+    return rgbvalues2hslvalues(...lab2rgbvalues(token));
+}
+function lch2hslvalues(token) {
+    // @ts-ignore
+    return rgbvalues2hslvalues(...lch2rgbvalues(token));
+}
+function oklab2hslvalues(token) {
+    const t = oklab2srgbvalues(token);
+    // @ts-ignore
+    return t == null ? null : srgb2hslvalues(...t);
+}
+function oklch2hslvalues(token) {
+    const t = oklch2srgbvalues(token);
+    // @ts-ignore
+    return t == null ? null : srgb2hslvalues(...t);
+}
+function rgbvalues2hslvalues(r, g, b, a = null) {
+    return srgb2hslvalues(r / 255, g / 255, b / 255, a);
+}
+function srgb2hslvalues(r, g, b, a = null) {
+    let max = Math.max(r, g, b);
+    let min = Math.min(r, g, b);
+    let h = 0;
+    let s = 0;
+    let l = (max + min) / 2;
+    if (max != min) {
+        let d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r:
+                h = (g - b) / d + (g < b ? 6 : 0);
+                break;
+            case g:
+                h = (b - r) / d + 2;
+                break;
+            case b:
+                h = (r - g) / d + 4;
+                break;
+        }
+        h /= 6;
+    }
+    const hsl = [h, s, l];
+    if (a != null && a < 1) {
+        // @ts-ignore
+        return hsl.concat([a]);
+    }
+    // @ts-ignore
+    return hsl;
+}
+
+export { cmyk2HslToken, cmyk2hslvalues, color2HslToken, hex2HslToken, hsv2hsl, hwb2HslToken, hwb2hslvalues, lab2HslToken, lab2hslvalues, lch2HslToken, lch2hslvalues, oklab2HslToken, oklab2hslvalues, oklch2HslToken, oklch2hslvalues, rgb2HslToken, rgb2hslvalues, rgbvalues2hslvalues, srgb2hslvalues };

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

@@ -0,0 +1,204 @@
+import { hsl2hsv } from './hsv.js';
+import './utils/constants.js';
+import { getComponents } from './utils/components.js';
+import { color2srgbvalues, toPrecisionAngle, getAngle, getNumber } from './color.js';
+import { cmyk2srgbvalues, lch2srgbvalues, lab2srgbvalues, oklch2srgbvalues, oklab2srgbvalues } from './srgb.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 '../../renderer/sourcemap/lib/encode.js';
+
+function rgb2hwbToken(token) {
+    const values = rgb2hwbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hwbToken(values);
+}
+function hsl2hwbToken(token) {
+    const values = hsl2hwbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hwbToken(values);
+}
+function cmyk2hwbToken(token) {
+    const values = cmyk2hwbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hwbToken(values);
+}
+function oklab2hwbToken(token) {
+    const values = oklab2hwbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hwbToken(values);
+}
+function oklch2hwbToken(token) {
+    const values = oklch2hwbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hwbToken(values);
+}
+function lab2hwbToken(token) {
+    const values = lab2hwbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hwbToken(values);
+}
+function lch2hwbToken(token) {
+    const values = lch2hwbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hwbToken(values);
+}
+function color2hwbToken(token) {
+    const values = color2hwbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    return hwbToken(values);
+}
+function hwbToken(values) {
+    values[0] = toPrecisionAngle(values[0] * 360);
+    const chi = [
+        { typ: EnumToken.NumberTokenType, val: values[0] },
+        { typ: EnumToken.PercentageTokenType, val: values[1] * 100 },
+        { typ: EnumToken.PercentageTokenType, val: values[2] * 100 },
+    ];
+    if (values.length == 4) {
+        chi.push({ typ: EnumToken.LiteralTokenType, val: '/' }, {
+            typ: EnumToken.PercentageTokenType,
+            val: values[3] * 100
+        });
+    }
+    return {
+        typ: EnumToken.ColorTokenType,
+        val: 'hwb',
+        chi,
+        kin: ColorType.HWB
+    };
+}
+function rgb2hwbvalues(token) {
+    // @ts-ignore
+    return srgb2hwb(...getComponents(token).map((t, index) => {
+        if (index == 3) {
+            return getNumber(t);
+        }
+        return getNumber(t) / 255;
+    }));
+}
+function cmyk2hwbvalues(token) {
+    // @ts-ignore
+    return srgb2hwb(...cmyk2srgbvalues(token));
+}
+function hsl2hwbvalues(token) {
+    // @ts-ignore
+    return hslvalues2hwbvalues(...getComponents(token).map((t, index) => {
+        if (index == 3 && (t.typ == EnumToken.IdenTokenType && t.val == 'none')) {
+            return 1;
+        }
+        if (index == 0) {
+            return getAngle(t);
+        }
+        return getNumber(t);
+    }));
+}
+function lab2hwbvalues(token) {
+    const values = lab2srgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    // @ts-ignore
+    return srgb2hwb(...values);
+}
+function lch2hwbvalues(token) {
+    const values = lch2srgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    // @ts-ignore
+    return srgb2hwb(...values);
+}
+function oklab2hwbvalues(token) {
+    const values = oklab2srgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    // @ts-ignore
+    return srgb2hwb(...values);
+}
+function oklch2hwbvalues(token) {
+    const values = oklch2srgbvalues(token);
+    // @ts-ignore
+    return values == null ? null : srgb2hwb(...values);
+}
+function rgb2hue(r, g, b, fallback = 0) {
+    let value = rgb2value(r, g, b);
+    let whiteness = rgb2whiteness(r, g, b);
+    let delta = value - whiteness;
+    if (delta > 0) {
+        // calculate segment
+        let segment = value === r ? (g - b) / delta : (value === g
+            ? (b - r) / delta
+            : (r - g) / delta);
+        // calculate shift
+        let shift = value === r ? segment < 0
+            ? 360 / 60
+            : 0 / 60 : (value === g
+            ? 120 / 60
+            : 240 / 60);
+        // calculate hue
+        return (segment + shift) * 60;
+    }
+    return fallback;
+}
+function rgb2value(r, g, b) {
+    return Math.max(r, g, b);
+}
+function rgb2whiteness(r, g, b) {
+    return Math.min(r, g, b);
+}
+function color2hwbvalues(token) {
+    const values = color2srgbvalues(token);
+    if (values == null) {
+        return null;
+    }
+    // @ts-ignore
+    return srgb2hwb(...values);
+}
+function srgb2hwb(r, g, b, a = null, fallback = 0) {
+    r *= 100;
+    g *= 100;
+    b *= 100;
+    let hue = rgb2hue(r, g, b, fallback);
+    let whiteness = rgb2whiteness(r, g, b);
+    let value = Math.round(rgb2value(r, g, b));
+    let blackness = 100 - value;
+    const result = [hue / 360, whiteness / 100, blackness / 100];
+    if (a != null) {
+        result.push(a);
+    }
+    return result;
+}
+function hsv2hwb(h, s, v, a = null) {
+    const result = [h, (1 - s) * v, 1 - v];
+    if (a != null) {
+        result.push(a);
+    }
+    return result;
+}
+function hslvalues2hwbvalues(h, s, l, a = null) {
+    // @ts-ignore
+    return hsv2hwb(...hsl2hsv(h, s, l, a));
+}
+
+export { cmyk2hwbToken, cmyk2hwbvalues, color2hwbToken, color2hwbvalues, hsl2hwbToken, hsl2hwbvalues, hslvalues2hwbvalues, hsv2hwb, hwbToken, lab2hwbToken, lab2hwbvalues, lch2hwbToken, lch2hwbvalues, oklab2hwbToken, oklab2hwbvalues, oklch2hwbToken, oklch2hwbvalues, rgb2hwbToken, rgb2hwbvalues, srgb2hwb };