@tbela99/css-parser 0.3.0 → 0.4.0

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

@@ -0,0 +1,136 @@
+import { e, k, D50 } from './utils/constants.js';
+import { getComponents } from './utils/components.js';
+import { srgb2xyz, xyzd502srgb } from './xyz.js';
+import { hex2srgb, rgb2srgb, hsl2srgb, hwb2srgb, oklch2srgb } from './srgb.js';
+import { getLCHComponents } from './lch.js';
+import { OKLab_to_XYZ, getOKLABComponents } from './oklab.js';
+import { getNumber } from './color.js';
+import { EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../parser/parse.js';
+import '../sourcemap/lib/encode.js';
+
+// L: 0% = 0.0, 100% = 100.0
+// for a and b: -100% = -125, 100% = 125
+function hex2lab(token) {
+    //  @ts-ignore
+    return srgb2lab(...hex2srgb(token));
+}
+function rgb2lab(token) {
+    // @ts-ignore
+    return srgb2lab(...rgb2srgb(token));
+}
+function hsl2lab(token) {
+    // @ts-ignore
+    return srgb2lab(...hsl2srgb(token));
+}
+function hwb2lab(token) {
+    // @ts-ignore
+    return srgb2lab(...hwb2srgb(token));
+}
+function lch2lab(token) {
+    // @ts-ignore
+    return lch2labvalues(...getLCHComponents(token));
+}
+function oklab2lab(token) {
+    // @ts-ignore
+    return xyz2lab(...OKLab_to_XYZ(...getOKLABComponents(token)));
+}
+function oklch2lab(token) {
+    // @ts-ignore
+    return srgb2lab(...oklch2srgb(token));
+}
+function srgb2lab(r, g, b, a) {
+    // @ts-ignore */
+    const result = xyz2lab(...srgb2xyz(r, g, b));
+    // Fixes achromatic RGB colors having a _slight_ chroma due to floating-point errors
+    // and approximated computations in sRGB <-> CIELab.
+    // See: https://github.com/d3/d3-color/pull/46
+    if (r === b && b === g) {
+        result[1] = result[2] = 0;
+    }
+    if (a != null) {
+        result.push(a);
+    }
+    return result;
+}
+function xyz2lab(x, y, z, a = null) {
+    // Assuming XYZ is relative to D50, convert to CIE Lab
+    // from CIE standard, which now defines these as a rational fraction
+    // var e = 216/24389;  // 6^3/29^3
+    // var k = 24389/27;   // 29^3/3^3
+    // compute xyz, which is XYZ scaled relative to reference white
+    const xyz = [x, y, z].map((value, i) => value / D50[i]);
+    // now compute f
+    const f = xyz.map((value) => value > e ? Math.cbrt(value) : (k * value + 16) / 116);
+    const result = [
+        (116 * f[1]) - 16, // L
+        500 * (f[0] - f[1]), // a
+        200 * (f[1] - f[2]) // b
+    ];
+    // L in range [0,100]. For use in CSS, add a percent
+    if (a != null && a != 1) {
+        result.push(a);
+    }
+    return result;
+}
+function lch2labvalues(l, c, h, a = null) {
+    // l, c * Math.cos(360 * h * Math.PI / 180), c * Math.sin(360 * h * Math.PI / 180
+    const result = [l, c * Math.cos(h * Math.PI / 180), c * Math.sin(h * Math.PI / 180)];
+    if (a != null) {
+        result.push(a);
+    }
+    return result;
+}
+function getLABComponents(token) {
+    const components = getComponents(token);
+    // @ts-ignore
+    let t = components[0];
+    // @ts-ignore
+    const l = getNumber(t) * (t.typ == EnumToken.PercentageTokenType ? 100 : 1);
+    // @ts-ignore
+    t = components[1];
+    // @ts-ignore
+    const a = getNumber(t) * (t.typ == EnumToken.PercentageTokenType ? 125 : 1);
+    // @ts-ignore
+    t = components[2];
+    // @ts-ignore
+    const b = getNumber(t) * (t.typ == EnumToken.PercentageTokenType ? 125 : 1);
+    // @ts-ignore
+    t = components[3];
+    // @ts-ignore
+    const alpha = t == null ? 1 : getNumber(t);
+    const result = [l, a, b];
+    if (alpha != null && alpha != 1) {
+        result.push(alpha);
+    }
+    return result;
+}
+// from https://www.w3.org/TR/css-color-4/#color-conversion-code
+// D50 LAB
+function Lab_to_sRGB(l, a, b) {
+    // @ts-ignore
+    return xyzd502srgb(...Lab_to_XYZ(l, a, b));
+}
+// from https://www.w3.org/TR/css-color-4/#color-conversion-code
+function Lab_to_XYZ(l, a, b) {
+    // Convert Lab to D50-adapted XYZ
+    // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+    const k = 24389 / 27; // 29^3/3^3
+    const e = 216 / 24389; // 6^3/29^3
+    const f = [];
+    // compute f, starting with the luminance-related term
+    f[1] = (l + 16) / 116;
+    f[0] = a / 500 + f[1];
+    f[2] = f[1] - b / 200;
+    // compute xyz
+    const xyz = [
+        Math.pow(f[0], 3) > e ? Math.pow(f[0], 3) : (116 * f[0] - 16) / k,
+        l > k * e ? Math.pow((l + 16) / 116, 3) : l / k,
+        Math.pow(f[2], 3) > e ? Math.pow(f[2], 3) : (116 * f[2] - 16) / k
+    ];
+    // Compute XYZ by scaling xyz by reference white
+    return xyz.map((value, i) => value * D50[i]);
+}
+
+export { Lab_to_XYZ, Lab_to_sRGB, getLABComponents, hex2lab, hsl2lab, hwb2lab, lch2lab, lch2labvalues, oklab2lab, oklch2lab, rgb2lab, srgb2lab, xyz2lab };

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

@@ -0,0 +1,79 @@
+import './utils/constants.js';
+import { getComponents } from './utils/components.js';
+import { getNumber, getAngle } from './color.js';
+import { EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../parser/parse.js';
+import { srgb2lab, xyz2lab, hex2lab, rgb2lab, hsl2lab, hwb2lab, getLABComponents, oklab2lab, oklch2lab } from './lab.js';
+import '../sourcemap/lib/encode.js';
+
+function hex2lch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...hex2lab(token));
+}
+function rgb2lch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...rgb2lab(token));
+}
+function hsl2lch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...hsl2lab(token));
+}
+function hwb2lch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...hwb2lab(token));
+}
+function lab2lch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...getLABComponents(token));
+}
+function srgb2lch(r, g, blue, alpha) {
+    // @ts-ignore
+    return lab2lchvalues(...srgb2lab(r, g, blue, alpha));
+}
+function oklab2lch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...oklab2lab(token));
+}
+function oklch2lch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...oklch2lab(token));
+}
+function lab2lchvalues(l, a, b, alpha = null) {
+    let c = Math.sqrt(a * a + b * b);
+    let h = Math.atan2(b, a) * 180 / Math.PI;
+    if (h < 0) {
+        h += 360;
+    }
+    if (c < .0001) {
+        c = h = 0;
+    }
+    return alpha == null ? [l, c, h] : [l, c, h, alpha];
+}
+function xyz2lchvalues(x, y, z, alpha) {
+    // @ts-ignore(
+    const lch = lab2lchvalues(...xyz2lab(x, y, z));
+    return alpha == null || alpha == 1 ? lch : lch.concat(alpha);
+}
+function getLCHComponents(token) {
+    const components = getComponents(token);
+    // @ts-ignore
+    let t = components[0];
+    // @ts-ignore
+    const l = getNumber(t) * (t.typ == EnumToken.PercentageTokenType ? 100 : 1);
+    // @ts-ignore
+    t = components[1];
+    // @ts-ignore
+    const c = getNumber(t) * (t.typ == EnumToken.PercentageTokenType ? 150 : 1);
+    // @ts-ignore
+    t = components[2];
+    // @ts-ignore
+    const h = getAngle(t) * 360;
+    // @ts-ignore
+    t = components[3];
+    // @ts-ignore
+    const alpha = t == null ? 1 : getNumber(t);
+    return alpha == null ? [l, c, h] : [l, c, h, alpha];
+}
+
+export { getLCHComponents, hex2lch, hsl2lch, hwb2lch, lab2lch, lab2lchvalues, oklab2lch, oklch2lch, rgb2lch, srgb2lch, xyz2lchvalues };

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

@@ -0,0 +1,121 @@
+import { multiplyMatrices } from './utils/matrix.js';
+import { powerlessColorComponent } from './utils/constants.js';
+import { getComponents } from './utils/components.js';
+import { srgb2lsrgbvalues, hex2srgb, rgb2srgb, hsl2srgb, hwb2srgb, lab2srgb, lch2srgb, lsrgb2srgbvalues } from './srgb.js';
+import { getNumber } from './color.js';
+import { EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../parser/parse.js';
+import { eq } from '../../parser/utils/eq.js';
+import { lch2labvalues } from './lab.js';
+import { getOKLCHComponents } from './oklch.js';
+import '../sourcemap/lib/encode.js';
+
+function hex2oklab(token) {
+    // @ts-ignore
+    return srgb2oklab(...hex2srgb(token));
+}
+function rgb2oklab(token) {
+    // @ts-ignore
+    return srgb2oklab(...rgb2srgb(token));
+}
+function hsl2oklab(token) {
+    // @ts-ignore
+    return srgb2oklab(...hsl2srgb(token));
+}
+function hwb2oklab(token) {
+    // @ts-ignore
+    return srgb2oklab(...hwb2srgb(token));
+}
+function lab2oklab(token) {
+    // @ts-ignore
+    return srgb2oklab(...lab2srgb(token));
+}
+function lch2oklab(token) {
+    // @ts-ignore
+    return srgb2oklab(...lch2srgb(token));
+}
+function oklch2oklab(token) {
+    // @ts-ignore
+    return lch2labvalues(...getOKLCHComponents(token));
+}
+function srgb2oklab(r, g, blue, alpha) {
+    [r, g, blue] = srgb2lsrgbvalues(r, g, blue);
+    let L = Math.cbrt(0.41222147079999993 * r + 0.5363325363 * g + 0.0514459929 * blue);
+    let M = Math.cbrt(0.2119034981999999 * r + 0.6806995450999999 * g + 0.1073969566 * blue);
+    let S = Math.cbrt(0.08830246189999998 * r + 0.2817188376 * g + 0.6299787005000002 * blue);
+    const l = 0.2104542553 * L + 0.793617785 * M - 0.0040720468 * S;
+    const a = r == g && g == blue ? 0 : 1.9779984951 * L - 2.428592205 * M + 0.4505937099 * S;
+    const b = r == g && g == blue ? 0 : 0.0259040371 * L + 0.7827717662 * M - 0.808675766 * S;
+    return alpha == null ? [l, a, b] : [l, a, b, alpha];
+}
+function getOKLABComponents(token) {
+    const components = getComponents(token);
+    // @ts-ignore
+    let t = components[0];
+    // @ts-ignore
+    const l = getNumber(t);
+    // @ts-ignore
+    t = components[1];
+    // @ts-ignore
+    const a = getNumber(t) * (t.typ == EnumToken.PercentageTokenType ? .4 : 1);
+    // @ts-ignore
+    t = components[2];
+    // @ts-ignore
+    const b = getNumber(t) * (t.typ == EnumToken.PercentageTokenType ? .4 : 1);
+    // @ts-ignore
+    t = components[3];
+    // @ts-ignore
+    const alpha = t == null || eq(t, powerlessColorComponent) ? 1 : getNumber(t);
+    const rgb = [l, a, b];
+    if (alpha != 1 && alpha != null) {
+        rgb.push(alpha);
+    }
+    return rgb;
+}
+function OKLab_to_XYZ(l, a, b, alpha = null) {
+    // Given OKLab, convert to XYZ relative to D65
+    const LMStoXYZ = [
+        [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
+        [-0.0405757452148008, 1.1122868032803170, -0.0717110580655164],
+        [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]
+    ];
+    const OKLabtoLMS = [
+        [1.0000000000000000, 0.3963377773761749, 0.2158037573099136],
+        [1.0000000000000000, -0.1055613458156586, -0.0638541728258133],
+        [1.0000000000000000, -0.0894841775298119, -1.2914855480194092]
+    ];
+    const LMSnl = multiplyMatrices(OKLabtoLMS, [l, a, b]);
+    const xyz = multiplyMatrices(LMStoXYZ, LMSnl.map((c) => c ** 3));
+    if (alpha != null) {
+        xyz.push(alpha);
+    }
+    return xyz;
+}
+// from https://www.w3.org/TR/css-color-4/#color-conversion-code
+function OKLab_to_sRGB(l, a, b) {
+    let L = Math.pow(l * 0.99999999845051981432 +
+        0.39633779217376785678 * a +
+        0.21580375806075880339 * b, 3);
+    let M = Math.pow(l * 1.0000000088817607767 -
+        0.1055613423236563494 * a -
+        0.063854174771705903402 * b, 3);
+    let S = Math.pow(l * 1.0000000546724109177 -
+        0.089484182094965759684 * a -
+        1.2914855378640917399 * b, 3);
+    return lsrgb2srgbvalues(
+    /* r: */
+    +4.076741661347994 * L -
+        3.307711590408193 * M +
+        0.230969928729428 * S, 
+    /*  g: */
+    -1.2684380040921763 * L +
+        2.6097574006633715 * M -
+        0.3413193963102197 * S, 
+    /*  b: */
+    -0.004196086541837188 * L -
+        0.7034186144594493 * M +
+        1.7076147009309444 * S);
+}
+
+export { OKLab_to_XYZ, OKLab_to_sRGB, getOKLABComponents, hex2oklab, hsl2oklab, hwb2oklab, lab2oklab, lch2oklab, oklch2oklab, rgb2oklab, srgb2oklab };

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

@@ -0,0 +1,65 @@
+import { powerlessColorComponent } from './utils/constants.js';
+import { getComponents } from './utils/components.js';
+import { getNumber, getAngle } from './color.js';
+import { EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../parser/parse.js';
+import { lab2lchvalues } from './lch.js';
+import { srgb2oklab, hex2oklab, rgb2oklab, hsl2oklab, hwb2oklab, lab2oklab, lch2oklab, getOKLABComponents } from './oklab.js';
+import { eq } from '../../parser/utils/eq.js';
+import '../sourcemap/lib/encode.js';
+
+function hex2oklch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...hex2oklab(token));
+}
+function rgb2oklch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...rgb2oklab(token));
+}
+function hsl2oklch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...hsl2oklab(token));
+}
+function hwb2oklch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...hwb2oklab(token));
+}
+function lab2oklch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...lab2oklab(token));
+}
+function lch2oklch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...lch2oklab(token));
+}
+function oklab2oklch(token) {
+    // @ts-ignore
+    return lab2lchvalues(...getOKLABComponents(token));
+}
+function srgb2oklch(r, g, blue, alpha) {
+    // @ts-ignore
+    return lab2lchvalues(...srgb2oklab(r, g, blue, alpha));
+}
+function getOKLCHComponents(token) {
+    const components = getComponents(token);
+    // @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 || eq(t, powerlessColorComponent) ? 1 : getNumber(t);
+    return [l, c, h, alpha];
+}
+
+export { getOKLCHComponents, hex2oklch, hsl2oklch, hwb2oklch, lab2oklch, lch2oklch, oklab2oklch, rgb2oklch, srgb2oklch };

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

@@ -0,0 +1,57 @@
+import { xyz2srgb, srgb2lsrgbvalues, lsrgb2srgbvalues } 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 p32srgbvalues(r, g, b, alpha) {
+    // @ts-ignore
+    return xyz2srgb(...lp32xyz(...p32lp3(r, g, b, alpha)));
+}
+function srgb2p3values(r, g, b, alpha) {
+    // @ts-ignore
+    return srgb2xyz(...xyz2lp3(...lp32p3(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
+    // to linear light (un-companded) form.
+    return srgb2lsrgbvalues(r, g, b, alpha); // same as sRGB
+}
+function lp32p3(r, g, b, alpha) {
+    // convert an array of linear-light display-p3 RGB  in the range 0.0-1.0
+    // to gamma corrected form
+    return lsrgb2srgbvalues(r, g, b, alpha); // same as sRGB
+}
+function lp32xyz(r, g, b, alpha) {
+    // convert an array of linear-light display-p3 values to CIE XYZ
+    // using  D65 (no chromatic adaptation)
+    // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+    const M = [
+        [608311 / 1250200, 189793 / 714400, 198249 / 1000160],
+        [35783 / 156275, 247089 / 357200, 198249 / 2500400],
+        [0, 32229 / 714400, 5220557 / 5000800],
+    ];
+    const result = multiplyMatrices(M, [r, g, b]);
+    if (alpha != null && alpha != 1) {
+        result.push(alpha);
+    }
+    return result;
+}
+function xyz2lp3(x, y, z, alpha) {
+    // convert XYZ to linear-light P3
+    const M = [
+        [446124 / 178915, -333277 / 357830, -72051 / 178915],
+        [-14852 / 17905, 63121 / 35810, 423 / 17905],
+        [11844 / 330415, -50337 / 660830, 316169 / 330415],
+    ];
+    const result = multiplyMatrices(M, [x, y, z]);
+    if (alpha != null && alpha != 1) {
+        result.push(alpha);
+    }
+    return result;
+}
+
+export { lp32p3, lp32xyz, p32lp3, p32srgbvalues, srgb2p3values, xyz2lp3 };

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

@@ -0,0 +1,56 @@
+import { xyzd502srgb, srgb2xyz } from './xyz.js';
+import { XYZ_D65_to_D50 } from './xyzd50.js';
+
+function prophotorgb2srgbvalues(r, g, b, a = null) {
+    // @ts-ignore
+    return xyzd502srgb(...prophotorgb2xyz50(r, g, b, a));
+}
+function srgb2prophotorgbvalues(r, g, b, a) {
+    // @ts-ignore
+    return xyz50_to_prophotorgb(...XYZ_D65_to_D50(...srgb2xyz(r, g, b, a)));
+}
+function prophotorgb2lin_ProPhoto(r, g, b, a = null) {
+    return [r, g, b].map(v => {
+        let abs = Math.abs(v);
+        if (abs >= 16 / 512) {
+            return Math.sign(v) * Math.pow(abs, 1.8);
+        }
+        return v / 16;
+    }).concat(a == null || a == 1 ? [] : [a]);
+}
+function prophotorgb2xyz50(r, g, b, a = null) {
+    [r, g, b, a] = prophotorgb2lin_ProPhoto(r, g, b, a);
+    const xyz = [
+        0.7977666449006423 * r +
+            0.1351812974005331 * g +
+            0.0313477341283922 * b,
+        0.2880748288194013 * r +
+            0.7118352342418731 * g +
+            0.0000899369387256 * b,
+        0.8251046025104602 * b
+    ];
+    return xyz.concat(a == null || a == 1 ? [] : [a]);
+}
+function xyz50_to_prophotorgb(x, y, z, a) {
+    // @ts-ignore
+    return gam_prophotorgb(...[
+        x * 1.3457868816471585 -
+            y * 0.2555720873797946 -
+            0.0511018649755453 * z,
+        x * -0.5446307051249019 +
+            y * 1.5082477428451466 +
+            0.0205274474364214 * z,
+        1.2119675456389452 * z
+    ].concat(a == null || a == 1 ? [] : [a]));
+}
+function gam_prophotorgb(r, g, b, a) {
+    return [r, g, b].map(v => {
+        let abs = Math.abs(v);
+        if (abs >= 1 / 512) {
+            return Math.sign(v) * Math.pow(abs, 1 / 1.8);
+        }
+        return 16 * v;
+    }).concat(a == null || a == 1 ? [] : [a]);
+}
+
+export { prophotorgb2srgbvalues, srgb2prophotorgbvalues };

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

@@ -0,0 +1,70 @@
+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 rec20202srgb(r, g, b, a) {
+    // @ts-ignore
+    return xyz2srgb(...lrec20202xyz(...rec20202lrec2020(r, g, b)), a);
+}
+function srgb2rec2020values(r, g, b, a) {
+    // @ts-ignore
+    return lrec20202rec2020(...xyz2lrec2020(...srgb2xyz(r, g, b)), a);
+}
+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;
+    return [r, g, b].map(function (val) {
+        let sign = val < 0 ? -1 : 1;
+        let abs = Math.abs(val);
+        if (abs < β * 4.5) {
+            return val / 4.5;
+        }
+        return sign * (Math.pow((abs + α - 1) / α, 1 / 0.45));
+    }).concat(a == null || a == 1 ? [] : [a]);
+}
+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;
+    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));
+        }
+        return 4.5 * val;
+    }).concat(a == null || a == 1 ? [] : [a]);
+}
+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 = [
+        [63426534 / 99577255, 20160776 / 139408157, 47086771 / 278816314],
+        [26158966 / 99577255, 472592308 / 697040785, 8267143 / 139408157],
+        [0, 19567812 / 697040785, 295819943 / 278816314],
+    ];
+    // 0 is actually calculated as  4.994106574466076e-17
+    return multiplyMatrices(M, [r, g, b]).concat(a == null || a == 1 ? [] : [a]);
+}
+function xyz2lrec2020(x, y, z, a) {
+    // convert XYZ to linear-light rec2020
+    var M = [
+        [30757411 / 17917100, -6372589 / 17917100, -4539589 / 17917100],
+        [-19765991 / 29648200, 47925759 / 29648200, 467509 / 29648200],
+        [792561 / 44930125, -1921689 / 44930125, 42328811 / 44930125],
+    ];
+    return multiplyMatrices(M, [x, y, z]).concat(a == null || a == 1 ? [] : [a]);
+}
+
+export { rec20202srgb, srgb2rec2020values };