@tbela99/css-parser 0.2.0 → 0.4.0

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

@@ -0,0 +1,152 @@
+import { convert, getNumber } from './color.js';
+import { EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import { walkValues } from '../../ast/walk.js';
+import '../../parser/parse.js';
+import { reduceNumber } from '../render.js';
+import { colorRange } from './utils/constants.js';
+import { eq } from '../../parser/utils/eq.js';
+import { evaluate } from '../../ast/math/expression.js';
+
+function parseRelativeColor(relativeKeys, original, rExp, gExp, bExp, aExp) {
+    let r;
+    let g;
+    let b;
+    let alpha = null;
+    let keys = {};
+    let values = {};
+    // colorFuncColorSpace x,y,z or r,g,b
+    const names = relativeKeys.startsWith('xyz') ? 'xyz' : relativeKeys.slice(-3);
+    // @ts-ignore
+    const converted = convert(original, relativeKeys);
+    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 == 'color' ? children.slice(1) : children;
+    values = {
+        [names[0]]: getValue(r, converted, names[0]),
+        [names[1]]: getValue(g, converted, names[1]), // string,
+        [names[2]]: getValue(b, converted, names[2]),
+        // @ts-ignore
+        alpha: alpha == null || eq(alpha, {
+            typ: EnumToken.IdenTokenType,
+            val: 'none'
+        }) ? {
+            typ: EnumToken.NumberTokenType,
+            val: '1'
+        } : (alpha.typ == EnumToken.PercentageTokenType ? {
+            typ: EnumToken.NumberTokenType,
+            val: String(getNumber(alpha))
+        } : alpha)
+    };
+    keys = {
+        [names[0]]: getValue(rExp, converted, names[0]),
+        [names[1]]: getValue(gExp, converted, names[1]),
+        [names[2]]: getValue(bExp, converted, names[2]),
+        // @ts-ignore
+        alpha: getValue(aExp == null || eq(aExp, { typ: EnumToken.IdenTokenType, val: 'none' }) ? {
+            typ: EnumToken.NumberTokenType,
+            val: '1'
+        } : aExp)
+    };
+    return computeComponentValue(keys, values);
+}
+function getValue(t, converted, component) {
+    if (t == null) {
+        return t;
+    }
+    if (t.typ == EnumToken.PercentageTokenType) {
+        let value = getNumber(t);
+        if (converted.kin in colorRange) {
+            // @ts-ignore
+            value *= colorRange[converted.kin][component].at(-1);
+        }
+        return {
+            typ: EnumToken.NumberTokenType,
+            val: String(value)
+        };
+    }
+    return t;
+}
+function computeComponentValue(expr, values) {
+    for (const object of [values, expr]) {
+        if ('h' in object) {
+            // normalize hue
+            // @ts-ignore
+            for (const k of walkValues([object.h])) {
+                if (k.value.typ == EnumToken.AngleTokenType && k.value.unit == 'deg') {
+                    // @ts-ignore
+                    k.value.typ = EnumToken.NumberTokenType;
+                    // @ts-ignore
+                    delete k.value.unit;
+                }
+            }
+        }
+    }
+    for (const [key, exp] of Object.entries(expr)) {
+        if (exp == null) {
+            if (key in values) {
+                if (typeof values[key] == 'number') {
+                    expr[key] = {
+                        typ: EnumToken.NumberTokenType,
+                        val: reduceNumber(values[key])
+                    };
+                }
+                else {
+                    expr[key] = values[key];
+                }
+            }
+        }
+        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];
+            }
+        }
+        else if (exp.typ == EnumToken.FunctionTokenType && exp.val == 'calc') {
+            for (let { value, parent } of walkValues(exp.chi)) {
+                if (value.typ == EnumToken.IdenTokenType) {
+                    if (!(value.val in values)) {
+                        return null;
+                    }
+                    if (parent == null) {
+                        parent = exp;
+                    }
+                    if (parent.typ == EnumToken.BinaryExpressionTokenType) {
+                        if (parent.l == value) {
+                            parent.l = values[value.val];
+                        }
+                        else {
+                            parent.r = values[value.val];
+                        }
+                    }
+                    else {
+                        for (let i = 0; i < parent.chi.length; i++) {
+                            if (parent.chi[i] == value) {
+                                parent.chi.splice(i, 1, values[value.val]);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            const result = evaluate(exp.chi);
+            if (result.length == 1 && result[0].typ != EnumToken.BinaryExpressionTokenType) {
+                expr[key] = result[0];
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    return expr;
+}
+
+export { parseRelativeColor };

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

@@ -0,0 +1,44 @@
+import { minmax } from './color.js';
+import { COLORS_NAMES } from './utils/constants.js';
+import '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../parser/parse.js';
+import { expandHexValue } from './hex.js';
+import { hwb2srgb, hslvalues, hsl2srgbvalues, cmyk2srgb, oklab2srgb, oklch2srgb, lab2srgb, lch2srgb } from './srgb.js';
+import '../sourcemap/lib/encode.js';
+
+function srgb2rgb(value) {
+    return minmax(Math.round(value * 255), 0, 255);
+}
+function hex2rgb(token) {
+    const value = expandHexValue(token.kin == '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));
+    }
+    return rgb;
+}
+function hwb2rgb(token) {
+    return hwb2srgb(token).map(srgb2rgb);
+}
+function hsl2rgb(token) {
+    let { h, s, l, a } = hslvalues(token);
+    return hsl2srgbvalues(h, s, l, a).map((t) => minmax(Math.round(t * 255), 0, 255));
+}
+function cmyk2rgb(token) {
+    return cmyk2srgb(token).map(srgb2rgb);
+}
+function oklab2rgb(token) {
+    return oklab2srgb(token).map(srgb2rgb);
+}
+function oklch2rgb(token) {
+    return oklch2srgb(token).map(srgb2rgb);
+}
+function lab2rgb(token) {
+    return lab2srgb(token).map(srgb2rgb);
+}
+function lch2rgb(token) {
+    return lch2srgb(token).map(srgb2rgb);
+}
+
+export { cmyk2rgb, hex2rgb, hsl2rgb, hwb2rgb, lab2rgb, lch2rgb, oklab2rgb, oklch2rgb, srgb2rgb };

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

@@ -0,0 +1,261 @@
+import { COLORS_NAMES } from './utils/constants.js';
+import { getComponents } from './utils/components.js';
+import { color2srgbvalues, getNumber, getAngle } from './color.js';
+import { EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../parser/parse.js';
+import { expandHexValue } from './hex.js';
+import { lch2labvalues, getLABComponents, Lab_to_sRGB } from './lab.js';
+import { getOKLABComponents, OKLab_to_sRGB } from './oklab.js';
+import { getLCHComponents } from './lch.js';
+import { getOKLCHComponents } from './oklch.js';
+import { XYZ_to_lin_sRGB } from './xyz.js';
+import { eq } from '../../parser/utils/eq.js';
+import '../sourcemap/lib/encode.js';
+
+// from https://www.w3.org/TR/css-color-4/#color-conversion-code
+// srgb-linear -> srgb
+// 0 <= r, g, b <= 1
+function srgbvalues(token) {
+    switch (token.kin) {
+        case 'lit':
+        case 'hex':
+            return hex2srgb(token);
+        case 'rgb':
+        case 'rgba':
+            return rgb2srgb(token);
+        case 'hsl':
+        case 'hsla':
+            return hsl2srgb(token);
+        case 'hwb':
+            return hwb2srgb(token);
+        case 'lab':
+            return lab2srgb(token);
+        case 'lch':
+            return lch2srgb(token);
+        case 'oklab':
+            return oklab2srgb(token);
+        case 'oklch':
+            return oklch2srgb(token);
+        case 'color':
+            return color2srgbvalues(token);
+    }
+    return null;
+}
+function rgb2srgb(token) {
+    return getComponents(token).map((t, index) => index == 3 ? (eq(t, {
+        typ: EnumToken.IdenTokenType,
+        val: 'none'
+    }) ? 1 : getNumber(t)) : (t.typ == EnumToken.PercentageTokenType ? 255 : 1) * getNumber(t) / 255);
+}
+function hex2srgb(token) {
+    const value = expandHexValue(token.kin == '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) / 255);
+    }
+    return rgb;
+}
+function xyz2srgb(x, y, z) {
+    // @ts-ignore
+    return lsrgb2srgbvalues(...XYZ_to_lin_sRGB(x, y, z));
+}
+function hwb2srgb(token) {
+    const { h: hue, s: white, l: black, a: alpha } = hslvalues(token);
+    const rgb = hsl2srgbvalues(hue, 1, .5);
+    for (let i = 0; i < 3; i++) {
+        rgb[i] *= (1 - white - black);
+        rgb[i] = rgb[i] + white;
+    }
+    if (alpha != null && alpha != 1) {
+        rgb.push(alpha);
+    }
+    return rgb;
+}
+function hsl2srgb(token) {
+    let { h, s, l, a } = hslvalues(token);
+    return hsl2srgbvalues(h, s, l, a);
+}
+function cmyk2srgb(token) {
+    const components = getComponents(token);
+    // @ts-ignore
+    let t = components[0];
+    // @ts-ignore
+    const c = getNumber(t);
+    // @ts-ignore
+    t = components[1];
+    // @ts-ignore
+    const m = getNumber(t);
+    // @ts-ignore
+    t = components[2];
+    // @ts-ignore
+    const y = getNumber(t);
+    // @ts-ignore
+    t = components[3];
+    // @ts-ignore
+    const k = getNumber(t);
+    const rgb = [
+        1 - Math.min(1, c * (1 - k) + k),
+        1 - Math.min(1, m * (1 - k) + k),
+        1 - Math.min(1, y * (1 - k) + k)
+    ];
+    // @ts-ignore
+    if (token.chi.length >= 9) {
+        // @ts-ignore
+        t = token.chi[8];
+        // @ts-ignore
+        rgb.push(getNumber(t));
+    }
+    return rgb;
+}
+function oklab2srgb(token) {
+    const [l, a, b, alpha] = getOKLABComponents(token);
+    const rgb = OKLab_to_sRGB(l, a, b);
+    if (alpha != null && alpha != 1) {
+        rgb.push(alpha);
+    }
+    return rgb;
+}
+function oklch2srgb(token) {
+    const [l, c, h, alpha] = getOKLCHComponents(token);
+    // @ts-ignore
+    const rgb = OKLab_to_sRGB(...lch2labvalues(l, c, h));
+    if (alpha != 1) {
+        rgb.push(alpha);
+    }
+    return rgb;
+}
+function hslvalues(token) {
+    const components = getComponents(token);
+    let t;
+    // @ts-ignore
+    let h = getAngle(components[0]);
+    // @ts-ignore
+    t = components[1];
+    // @ts-ignore
+    let s = getNumber(t);
+    // @ts-ignore
+    t = components[2];
+    // @ts-ignore
+    let l = getNumber(t);
+    let a = null;
+    if (token.chi?.length == 4) {
+        // @ts-ignore
+        t = token.chi[3];
+        // @ts-ignore
+        a = getNumber(t);
+    }
+    return a == null ? { h, s, l } : { h, s, l, a };
+}
+function hsl2srgbvalues(h, s, l, a = null) {
+    let v = l <= .5 ? l * (1.0 + s) : l + s - l * s;
+    let r = l;
+    let g = l;
+    let b = l;
+    if (v > 0) {
+        let m = l + l - v;
+        let sv = (v - m) / v;
+        h *= 6.0;
+        let sextant = Math.floor(h);
+        let fract = h - sextant;
+        let vsf = v * sv * fract;
+        let mid1 = m + vsf;
+        let mid2 = v - vsf;
+        switch (sextant) {
+            case 0:
+                r = v;
+                g = mid1;
+                b = m;
+                break;
+            case 1:
+                r = mid2;
+                g = v;
+                b = m;
+                break;
+            case 2:
+                r = m;
+                g = v;
+                b = mid1;
+                break;
+            case 3:
+                r = m;
+                g = mid2;
+                b = v;
+                break;
+            case 4:
+                r = mid1;
+                g = m;
+                b = v;
+                break;
+            case 5:
+                r = v;
+                g = m;
+                b = mid2;
+                break;
+        }
+    }
+    const values = [r, g, b];
+    if (a != null && a != 1) {
+        values.push(a);
+    }
+    return values;
+}
+function lab2srgb(token) {
+    const [l, a, b, alpha] = getLABComponents(token);
+    const rgb = Lab_to_sRGB(l, a, b);
+    if (alpha != null && alpha != 1) {
+        rgb.push(alpha);
+    }
+    return rgb;
+}
+function lch2srgb(token) {
+    // @ts-ignore
+    const [l, a, b, alpha] = lch2labvalues(...getLCHComponents(token));
+    // https://www.w3.org/TR/css-color-4/#lab-to-lch
+    const rgb = Lab_to_sRGB(l, a, b);
+    if (alpha != 1) {
+        rgb.push(alpha);
+    }
+    return rgb;
+}
+// sRGB -> lRGB
+function srgb2lsrgbvalues(r, g, b, a = null) {
+    // convert an array of linear-light sRGB values in the range 0.0-1.0
+    // to gamma corrected form
+    // https://en.wikipedia.org/wiki/SRGB
+    // Extended transfer function:
+    // For negative values, linear portion extends on reflection
+    // of axis, then uses reflected pow below that
+    const rgb = [r, g, b].map((val) => {
+        const abs = Math.abs(val);
+        if (abs <= 0.04045) {
+            return val / 12.92;
+        }
+        return (Math.sign(val) || 1) * Math.pow((abs + 0.055) / 1.055, 2.4);
+    });
+    if (a != 1 && a != null) {
+        rgb.push(a);
+    }
+    return rgb;
+}
+function lsrgb2srgbvalues(r, g, b, alpha) {
+    // convert an array of linear-light sRGB values in the range 0.0-1.0
+    // to gamma corrected form
+    // https://en.wikipedia.org/wiki/SRGB
+    // Extended transfer function:
+    // For negative values, linear portion extends on reflection
+    // of axis, then uses reflected pow below that
+    const rgb = [r, g, b].map((val) => {
+        let abs = Math.abs(val);
+        if (Math.abs(val) > 0.0031308) {
+            return (Math.sign(val) || 1) * (1.055 * Math.pow(abs, 1 / 2.4) - 0.055);
+        }
+        return 12.92 * val;
+    });
+    if (alpha != 1 && alpha != null) {
+        rgb.push(alpha);
+    }
+    return rgb;
+}
+
+export { cmyk2srgb, hex2srgb, hsl2srgb, hsl2srgbvalues, hslvalues, hwb2srgb, lab2srgb, lch2srgb, lsrgb2srgbvalues, oklab2srgb, oklch2srgb, rgb2srgb, srgb2lsrgbvalues, srgbvalues, xyz2srgb };

package/dist/lib/renderer/color/utils/components.js

@@ -0,0 +1,20 @@
+import { EnumToken } from '../../../ast/types.js';
+import '../../../ast/minify.js';
+import '../../../parser/parse.js';
+import { COLORS_NAMES } from './constants.js';
+import { expandHexValue } from '../hex.js';
+import '../../sourcemap/lib/encode.js';
+
+function getComponents(token) {
+    if (token.kin == 'hex' || token.kin == 'lit') {
+        const value = expandHexValue(token.kin == 'lit' ? COLORS_NAMES[token.val.toLowerCase()] : token.val);
+        // @ts-ignore
+        return value.slice(1).match(/([a-fA-F0-9]{2})/g).map((t) => {
+            return { typ: EnumToken.Number, val: parseInt(t, 16).toString() };
+        });
+    }
+    return token.chi
+        .filter((t) => ![EnumToken.LiteralTokenType, EnumToken.CommentTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType].includes(t.typ));
+}
+
+export { getComponents };

package/dist/lib/renderer/color/utils/constants.js

@@ -0,0 +1,191 @@
+import { EnumToken } from '../../../ast/types.js';
+import '../../../ast/minify.js';
+import '../../../parser/parse.js';
+import '../../sourcemap/lib/encode.js';
+
+const colorRange = {
+    lab: {
+        l: [0, 100],
+        a: [-125, 125],
+        b: [-125, 125]
+    },
+    lch: {
+        l: [0, 100],
+        c: [0, 150],
+        h: [0, 360]
+    },
+    oklab: {
+        l: [0, 1],
+        a: [-0.4, .4],
+        b: [-0.4, 0.4]
+    },
+    oklch: {
+        l: [0, 1],
+        a: [0, .4],
+        b: [0, 0.4]
+    }
+};
+const colorFuncColorSpace = ['srgb', 'srgb-linear', 'display-p3', 'prophoto-rgb', 'a98-rgb', 'rec2020', 'xyz', 'xyz-d65', 'xyz-d50'];
+const powerlessColorComponent = { typ: EnumToken.IdenTokenType, val: 'none' };
+const D50 = [0.3457 / 0.3585, 1.00000, (1.0 - 0.3457 - 0.3585) / 0.3585];
+const k = Math.pow(29, 3) / Math.pow(3, 3);
+const e = Math.pow(6, 3) / Math.pow(29, 3);
+// name to color
+const COLORS_NAMES = Object.seal({
+    'aliceblue': '#f0f8ff',
+    'antiquewhite': '#faebd7',
+    'aqua': '#00ffff',
+    'aquamarine': '#7fffd4',
+    'azure': '#f0ffff',
+    'beige': '#f5f5dc',
+    'bisque': '#ffe4c4',
+    'black': '#000000',
+    'blanchedalmond': '#ffebcd',
+    'blue': '#0000ff',
+    'blueviolet': '#8a2be2',
+    'brown': '#a52a2a',
+    'burlywood': '#deb887',
+    'cadetblue': '#5f9ea0',
+    'chartreuse': '#7fff00',
+    'chocolate': '#d2691e',
+    'coral': '#ff7f50',
+    'cornflowerblue': '#6495ed',
+    'cornsilk': '#fff8dc',
+    'crimson': '#dc143c',
+    'cyan': '#00ffff',
+    'darkblue': '#00008b',
+    'darkcyan': '#008b8b',
+    'darkgoldenrod': '#b8860b',
+    'darkgray': '#a9a9a9',
+    'darkgrey': '#a9a9a9',
+    'darkgreen': '#006400',
+    'darkkhaki': '#bdb76b',
+    'darkmagenta': '#8b008b',
+    'darkolivegreen': '#556b2f',
+    'darkorange': '#ff8c00',
+    'darkorchid': '#9932cc',
+    'darkred': '#8b0000',
+    'darksalmon': '#e9967a',
+    'darkseagreen': '#8fbc8f',
+    'darkslateblue': '#483d8b',
+    'darkslategray': '#2f4f4f',
+    'darkslategrey': '#2f4f4f',
+    'darkturquoise': '#00ced1',
+    'darkviolet': '#9400d3',
+    'deeppink': '#ff1493',
+    'deepskyblue': '#00bfff',
+    'dimgray': '#696969',
+    'dimgrey': '#696969',
+    'dodgerblue': '#1e90ff',
+    'firebrick': '#b22222',
+    'floralwhite': '#fffaf0',
+    'forestgreen': '#228b22',
+    'fuchsia': '#ff00ff',
+    'gainsboro': '#dcdcdc',
+    'ghostwhite': '#f8f8ff',
+    'gold': '#ffd700',
+    'goldenrod': '#daa520',
+    'gray': '#808080',
+    'grey': '#808080',
+    'green': '#008000',
+    'greenyellow': '#adff2f',
+    'honeydew': '#f0fff0',
+    'hotpink': '#ff69b4',
+    'indianred': '#cd5c5c',
+    'indigo': '#4b0082',
+    'ivory': '#fffff0',
+    'khaki': '#f0e68c',
+    'lavender': '#e6e6fa',
+    'lavenderblush': '#fff0f5',
+    'lawngreen': '#7cfc00',
+    'lemonchiffon': '#fffacd',
+    'lightblue': '#add8e6',
+    'lightcoral': '#f08080',
+    'lightcyan': '#e0ffff',
+    'lightgoldenrodyellow': '#fafad2',
+    'lightgray': '#d3d3d3',
+    'lightgrey': '#d3d3d3',
+    'lightgreen': '#90ee90',
+    'lightpink': '#ffb6c1',
+    'lightsalmon': '#ffa07a',
+    'lightseagreen': '#20b2aa',
+    'lightskyblue': '#87cefa',
+    'lightslategray': '#778899',
+    'lightslategrey': '#778899',
+    'lightsteelblue': '#b0c4de',
+    'lightyellow': '#ffffe0',
+    'lime': '#00ff00',
+    'limegreen': '#32cd32',
+    'linen': '#faf0e6',
+    'magenta': '#ff00ff',
+    'maroon': '#800000',
+    'mediumaquamarine': '#66cdaa',
+    'mediumblue': '#0000cd',
+    'mediumorchid': '#ba55d3',
+    'mediumpurple': '#9370d8',
+    'mediumseagreen': '#3cb371',
+    'mediumslateblue': '#7b68ee',
+    'mediumspringgreen': '#00fa9a',
+    'mediumturquoise': '#48d1cc',
+    'mediumvioletred': '#c71585',
+    'midnightblue': '#191970',
+    'mintcream': '#f5fffa',
+    'mistyrose': '#ffe4e1',
+    'moccasin': '#ffe4b5',
+    'navajowhite': '#ffdead',
+    'navy': '#000080',
+    'oldlace': '#fdf5e6',
+    'olive': '#808000',
+    'olivedrab': '#6b8e23',
+    'orange': '#ffa500',
+    'orangered': '#ff4500',
+    'orchid': '#da70d6',
+    'palegoldenrod': '#eee8aa',
+    'palegreen': '#98fb98',
+    'paleturquoise': '#afeeee',
+    'palevioletred': '#d87093',
+    'papayawhip': '#ffefd5',
+    'peachpuff': '#ffdab9',
+    'peru': '#cd853f',
+    'pink': '#ffc0cb',
+    'plum': '#dda0dd',
+    'powderblue': '#b0e0e6',
+    'purple': '#800080',
+    'red': '#ff0000',
+    'rosybrown': '#bc8f8f',
+    'royalblue': '#4169e1',
+    'saddlebrown': '#8b4513',
+    'salmon': '#fa8072',
+    'sandybrown': '#f4a460',
+    'seagreen': '#2e8b57',
+    'seashell': '#fff5ee',
+    'sienna': '#a0522d',
+    'silver': '#c0c0c0',
+    'skyblue': '#87ceeb',
+    'slateblue': '#6a5acd',
+    'slategray': '#708090',
+    'slategrey': '#708090',
+    'snow': '#fffafa',
+    'springgreen': '#00ff7f',
+    'steelblue': '#4682b4',
+    'tan': '#d2b48c',
+    'teal': '#008080',
+    'thistle': '#d8bfd8',
+    'tomato': '#ff6347',
+    'turquoise': '#40e0d0',
+    'violet': '#ee82ee',
+    'wheat': '#f5deb3',
+    'white': '#ffffff',
+    'whitesmoke': '#f5f5f5',
+    'yellow': '#ffff00',
+    'yellowgreen': '#9acd32',
+    'rebeccapurple': '#663399',
+    'transparent': '#00000000'
+});
+// color to name
+const NAMES_COLORS = Object.seal(Object.entries(COLORS_NAMES).reduce((acc, [key, value]) => {
+    acc[value] = key;
+    return acc;
+}, Object.create(null)));
+
+export { COLORS_NAMES, D50, NAMES_COLORS, colorFuncColorSpace, colorRange, e, k, powerlessColorComponent };