simview 3.2__py3-none-any.whl

simview/static/lib/chroma-js-3.1.2/src/io/hsi/hsi2rgb.js

@@ -0,0 +1,45 @@
+import { unpack, limit, TWOPI, PITHIRD } from '../../utils/index.js';
+const { cos } = Math;
+
+/*
+ * hue [0..360]
+ * saturation [0..1]
+ * intensity [0..1]
+ */
+const hsi2rgb = (...args) => {
+    /*
+    borrowed from here:
+    http://hummer.stanford.edu/museinfo/doc/examples/humdrum/keyscape2/hsi2rgb.cpp
+    */
+    args = unpack(args, 'hsi');
+    let [h, s, i] = args;
+    let r, g, b;
+
+    if (isNaN(h)) h = 0;
+    if (isNaN(s)) s = 0;
+    // normalize hue
+    if (h > 360) h -= 360;
+    if (h < 0) h += 360;
+    h /= 360;
+    if (h < 1 / 3) {
+        b = (1 - s) / 3;
+        r = (1 + (s * cos(TWOPI * h)) / cos(PITHIRD - TWOPI * h)) / 3;
+        g = 1 - (b + r);
+    } else if (h < 2 / 3) {
+        h -= 1 / 3;
+        r = (1 - s) / 3;
+        g = (1 + (s * cos(TWOPI * h)) / cos(PITHIRD - TWOPI * h)) / 3;
+        b = 1 - (r + g);
+    } else {
+        h -= 2 / 3;
+        g = (1 - s) / 3;
+        b = (1 + (s * cos(TWOPI * h)) / cos(PITHIRD - TWOPI * h)) / 3;
+        r = 1 - (g + b);
+    }
+    r = limit(i * r * 3);
+    g = limit(i * g * 3);
+    b = limit(i * b * 3);
+    return [r * 255, g * 255, b * 255, args.length > 3 ? args[3] : 1];
+};
+
+export default hsi2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/hsi/index.js

@@ -0,0 +1,27 @@
+import { unpack, type } from '../../utils/index.js';
+import chroma from '../../chroma.js';
+import Color from '../../Color.js';
+import input from '../input.js';
+import hsi2rgb from './hsi2rgb.js';
+import rgb2hsi from './rgb2hsi.js';
+
+Color.prototype.hsi = function () {
+    return rgb2hsi(this._rgb);
+};
+
+const hsi = (...args) => new Color(...args, 'hsi');
+chroma.hsi = hsi;
+
+input.format.hsi = hsi2rgb;
+
+input.autodetect.push({
+    p: 2,
+    test: (...args) => {
+        args = unpack(args, 'hsi');
+        if (type(args) === 'array' && args.length === 3) {
+            return 'hsi';
+        }
+    }
+});
+
+export { hsi };

simview/static/lib/chroma-js-3.1.2/src/io/hsi/rgb2hsi.js

@@ -0,0 +1,31 @@
+import { unpack, TWOPI } from '../../utils/index.js';
+const { min, sqrt, acos } = Math;
+
+const rgb2hsi = (...args) => {
+    /*
+    borrowed from here:
+    http://hummer.stanford.edu/museinfo/doc/examples/humdrum/keyscape2/rgb2hsi.cpp
+    */
+    let [r, g, b] = unpack(args, 'rgb');
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    let h;
+    const min_ = min(r, g, b);
+    const i = (r + g + b) / 3;
+    const s = i > 0 ? 1 - min_ / i : 0;
+    if (s === 0) {
+        h = NaN;
+    } else {
+        h = (r - g + (r - b)) / 2;
+        h /= sqrt((r - g) * (r - g) + (r - b) * (g - b));
+        h = acos(h);
+        if (b > g) {
+            h = TWOPI - h;
+        }
+        h /= TWOPI;
+    }
+    return [h * 360, s, i];
+};
+
+export default rgb2hsi;

simview/static/lib/chroma-js-3.1.2/src/io/hsl/hsl2rgb.js

@@ -0,0 +1,35 @@
+import { unpack } from '../../utils/index.js';
+
+const hsl2rgb = (...args) => {
+    args = unpack(args, 'hsl');
+    const [h, s, l] = args;
+    let r, g, b;
+    if (s === 0) {
+        r = g = b = l * 255;
+    } else {
+        const t3 = [0, 0, 0];
+        const c = [0, 0, 0];
+        const t2 = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const t1 = 2 * l - t2;
+        const h_ = h / 360;
+        t3[0] = h_ + 1 / 3;
+        t3[1] = h_;
+        t3[2] = h_ - 1 / 3;
+        for (let i = 0; i < 3; i++) {
+            if (t3[i] < 0) t3[i] += 1;
+            if (t3[i] > 1) t3[i] -= 1;
+            if (6 * t3[i] < 1) c[i] = t1 + (t2 - t1) * 6 * t3[i];
+            else if (2 * t3[i] < 1) c[i] = t2;
+            else if (3 * t3[i] < 2) c[i] = t1 + (t2 - t1) * (2 / 3 - t3[i]) * 6;
+            else c[i] = t1;
+        }
+        [r, g, b] = [c[0] * 255, c[1] * 255, c[2] * 255];
+    }
+    if (args.length > 3) {
+        // keep alpha channel
+        return [r, g, b, args[3]];
+    }
+    return [r, g, b, 1];
+};
+
+export default hsl2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/hsl/index.js

@@ -0,0 +1,27 @@
+import { unpack, type } from '../../utils/index.js';
+import chroma from '../../chroma.js';
+import Color from '../../Color.js';
+import input from '../input.js';
+import hsl2rgb from './hsl2rgb.js';
+import rgb2hsl from './rgb2hsl.js';
+
+Color.prototype.hsl = function () {
+    return rgb2hsl(this._rgb);
+};
+
+const hsl = (...args) => new Color(...args, 'hsl');
+chroma.hsl = hsl;
+
+input.format.hsl = hsl2rgb;
+
+input.autodetect.push({
+    p: 2,
+    test: (...args) => {
+        args = unpack(args, 'hsl');
+        if (type(args) === 'array' && args.length === 3) {
+            return 'hsl';
+        }
+    }
+});
+
+export { hsl };

simview/static/lib/chroma-js-3.1.2/src/io/hsl/rgb2hsl.js

@@ -0,0 +1,45 @@
+import { unpack, min, max } from '../../utils/index.js';
+
+/*
+ * supported arguments:
+ * - rgb2hsl(r,g,b)
+ * - rgb2hsl(r,g,b,a)
+ * - rgb2hsl([r,g,b])
+ * - rgb2hsl([r,g,b,a])
+ * - rgb2hsl({r,g,b,a})
+ */
+const rgb2hsl = (...args) => {
+    args = unpack(args, 'rgba');
+    let [r, g, b] = args;
+
+    r /= 255;
+    g /= 255;
+    b /= 255;
+
+    const minRgb = min(r, g, b);
+    const maxRgb = max(r, g, b);
+
+    const l = (maxRgb + minRgb) / 2;
+    let s, h;
+
+    if (maxRgb === minRgb) {
+        s = 0;
+        h = Number.NaN;
+    } else {
+        s =
+            l < 0.5
+                ? (maxRgb - minRgb) / (maxRgb + minRgb)
+                : (maxRgb - minRgb) / (2 - maxRgb - minRgb);
+    }
+
+    if (r == maxRgb) h = (g - b) / (maxRgb - minRgb);
+    else if (g == maxRgb) h = 2 + (b - r) / (maxRgb - minRgb);
+    else if (b == maxRgb) h = 4 + (r - g) / (maxRgb - minRgb);
+
+    h *= 60;
+    if (h < 0) h += 360;
+    if (args.length > 3 && args[3] !== undefined) return [h, s, l, args[3]];
+    return [h, s, l];
+};
+
+export default rgb2hsl;

simview/static/lib/chroma-js-3.1.2/src/io/hsv/hsv2rgb.js

@@ -0,0 +1,47 @@
+import { unpack } from '../../utils/index.js';
+const { floor } = Math;
+
+const hsv2rgb = (...args) => {
+    args = unpack(args, 'hsv');
+    let [h, s, v] = args;
+    let r, g, b;
+    v *= 255;
+    if (s === 0) {
+        r = g = b = v;
+    } else {
+        if (h === 360) h = 0;
+        if (h > 360) h -= 360;
+        if (h < 0) h += 360;
+        h /= 60;
+
+        const i = floor(h);
+        const f = h - i;
+        const p = v * (1 - s);
+        const q = v * (1 - s * f);
+        const t = v * (1 - s * (1 - f));
+
+        switch (i) {
+            case 0:
+                [r, g, b] = [v, t, p];
+                break;
+            case 1:
+                [r, g, b] = [q, v, p];
+                break;
+            case 2:
+                [r, g, b] = [p, v, t];
+                break;
+            case 3:
+                [r, g, b] = [p, q, v];
+                break;
+            case 4:
+                [r, g, b] = [t, p, v];
+                break;
+            case 5:
+                [r, g, b] = [v, p, q];
+                break;
+        }
+    }
+    return [r, g, b, args.length > 3 ? args[3] : 1];
+};
+
+export default hsv2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/hsv/index.js

@@ -0,0 +1,27 @@
+import { unpack, type } from '../../utils/index.js';
+import chroma from '../../chroma.js';
+import Color from '../../Color.js';
+import input from '../input.js';
+import hsv2rgb from './hsv2rgb.js';
+import rgb2hsv from './rgb2hsv.js';
+
+Color.prototype.hsv = function () {
+    return rgb2hsv(this._rgb);
+};
+
+const hsv = (...args) => new Color(...args, 'hsv');
+chroma.hsv = hsv;
+
+input.format.hsv = hsv2rgb;
+
+input.autodetect.push({
+    p: 2,
+    test: (...args) => {
+        args = unpack(args, 'hsv');
+        if (type(args) === 'array' && args.length === 3) {
+            return 'hsv';
+        }
+    }
+});
+
+export { hsv };

simview/static/lib/chroma-js-3.1.2/src/io/hsv/rgb2hsv.js

@@ -0,0 +1,32 @@
+import { unpack } from '../../utils/index.js';
+const { min, max } = Math;
+
+/*
+ * supported arguments:
+ * - rgb2hsv(r,g,b)
+ * - rgb2hsv([r,g,b])
+ * - rgb2hsv({r,g,b})
+ */
+const rgb2hsl = (...args) => {
+    args = unpack(args, 'rgb');
+    let [r, g, b] = args;
+    const min_ = min(r, g, b);
+    const max_ = max(r, g, b);
+    const delta = max_ - min_;
+    let h, s, v;
+    v = max_ / 255.0;
+    if (max_ === 0) {
+        h = Number.NaN;
+        s = 0;
+    } else {
+        s = delta / max_;
+        if (r === max_) h = (g - b) / delta;
+        if (g === max_) h = 2 + (b - r) / delta;
+        if (b === max_) h = 4 + (r - g) / delta;
+        h *= 60;
+        if (h < 0) h += 360;
+    }
+    return [h, s, v];
+};
+
+export default rgb2hsl;

simview/static/lib/chroma-js-3.1.2/src/io/input.js

@@ -0,0 +1,4 @@
+export default {
+    format: {},
+    autodetect: []
+};

simview/static/lib/chroma-js-3.1.2/src/io/lab/index.js

@@ -0,0 +1,28 @@
+import { unpack, type } from '../../utils/index.js';
+import chroma from '../../chroma.js';
+import Color from '../../Color.js';
+import input from '../input.js';
+import lab2rgb from './lab2rgb.js';
+import rgb2lab from './rgb2lab.js';
+import { getLabWhitePoint, setLabWhitePoint } from './lab-constants.js';
+
+Color.prototype.lab = function () {
+    return rgb2lab(this._rgb);
+};
+
+const lab = (...args) => new Color(...args, 'lab');
+Object.assign(chroma, { lab, getLabWhitePoint, setLabWhitePoint });
+
+input.format.lab = lab2rgb;
+
+input.autodetect.push({
+    p: 2,
+    test: (...args) => {
+        args = unpack(args, 'lab');
+        if (type(args) === 'array' && args.length === 3) {
+            return 'lab';
+        }
+    }
+});
+
+export { lab, getLabWhitePoint, setLabWhitePoint };

simview/static/lib/chroma-js-3.1.2/src/io/lab/lab-constants.js

@@ -0,0 +1,120 @@
+const labConstants = {
+    // Corresponds roughly to RGB brighter/darker
+    Kn: 18,
+
+    // D65 standard referent
+    labWhitePoint: 'd65',
+    Xn: 0.95047,
+    Yn: 1,
+    Zn: 1.08883,
+
+    t0: 0.137931034, // 4 / 29
+    t1: 0.206896552, // 6 / 29
+    t2: 0.12841855, // 3 * t1 * t1
+    t3: 0.008856452, // t1 * t1 * t1,
+
+    kE: 216.0 / 24389.0,
+    kKE: 8.0,
+    kK: 24389.0 / 27.0,
+
+    RefWhiteRGB: {
+        // sRGB
+        X: 0.95047,
+        Y: 1,
+        Z: 1.08883
+    },
+
+    MtxRGB2XYZ: {
+        m00: 0.4124564390896922,
+        m01: 0.21267285140562253,
+        m02: 0.0193338955823293,
+        m10: 0.357576077643909,
+        m11: 0.715152155287818,
+        m12: 0.11919202588130297,
+        m20: 0.18043748326639894,
+        m21: 0.07217499330655958,
+        m22: 0.9503040785363679
+    },
+
+    MtxXYZ2RGB: {
+        m00: 3.2404541621141045,
+        m01: -0.9692660305051868,
+        m02: 0.055643430959114726,
+        m10: -1.5371385127977166,
+        m11: 1.8760108454466942,
+        m12: -0.2040259135167538,
+        m20: -0.498531409556016,
+        m21: 0.041556017530349834,
+        m22: 1.0572251882231791
+    },
+
+    // used in rgb2xyz
+    As: 0.9414285350000001,
+    Bs: 1.040417467,
+    Cs: 1.089532651,
+
+    MtxAdaptMa: {
+        m00: 0.8951,
+        m01: -0.7502,
+        m02: 0.0389,
+        m10: 0.2664,
+        m11: 1.7135,
+        m12: -0.0685,
+        m20: -0.1614,
+        m21: 0.0367,
+        m22: 1.0296
+    },
+
+    MtxAdaptMaI: {
+        m00: 0.9869929054667123,
+        m01: 0.43230526972339456,
+        m02: -0.008528664575177328,
+        m10: -0.14705425642099013,
+        m11: 0.5183602715367776,
+        m12: 0.04004282165408487,
+        m20: 0.15996265166373125,
+        m21: 0.0492912282128556,
+        m22: 0.9684866957875502
+    }
+};
+
+export default labConstants;
+
+// taken from https://de.mathworks.com/help/images/ref/whitepoint.html
+const ILLUMINANTS = new Map([
+    // ASTM E308-01
+    ['a', [1.0985, 0.35585]],
+    // Wyszecki & Stiles, p. 769
+    ['b', [1.0985, 0.35585]],
+    // C ASTM E308-01
+    ['c', [0.98074, 1.18232]],
+    // D50 (ASTM E308-01)
+    ['d50', [0.96422, 0.82521]],
+    // D55 (ASTM E308-01)
+    ['d55', [0.95682, 0.92149]],
+    // D65 (ASTM E308-01)
+    ['d65', [0.95047, 1.08883]],
+    // E (ASTM E308-01)
+    ['e', [1, 1, 1]],
+    // F2 (ASTM E308-01)
+    ['f2', [0.99186, 0.67393]],
+    // F7 (ASTM E308-01)
+    ['f7', [0.95041, 1.08747]],
+    // F11 (ASTM E308-01)
+    ['f11', [1.00962, 0.6435]],
+    ['icc', [0.96422, 0.82521]]
+]);
+
+export function setLabWhitePoint(name) {
+    const ill = ILLUMINANTS.get(String(name).toLowerCase());
+    if (!ill) {
+        throw new Error('unknown Lab illuminant ' + name);
+    }
+    labConstants.labWhitePoint = name;
+    labConstants.Xn = ill[0];
+    labConstants.Zn = ill[1];
+}
+
+export function getLabWhitePoint() {
+    return labConstants.labWhitePoint;
+}

simview/static/lib/chroma-js-3.1.2/src/io/lab/lab2rgb.js

@@ -0,0 +1,101 @@
+import LAB_CONSTANTS from './lab-constants.js';
+import { unpack } from '../../utils/index.js';
+
+/*
+ * L* [0..100]
+ * a [-100..100]
+ * b [-100..100]
+ */
+const lab2rgb = (...args) => {
+    args = unpack(args, 'lab');
+    const [L, a, b] = args;
+    const [x, y, z] = lab2xyz(L, a, b);
+    const [r, g, b_] = xyz2rgb(x, y, z);
+    return [r, g, b_, args.length > 3 ? args[3] : 1];
+};
+
+const lab2xyz = (L, a, b) => {
+    const { kE, kK, kKE, Xn, Yn, Zn } = LAB_CONSTANTS;
+
+    const fy = (L + 16.0) / 116.0;
+    const fx = 0.002 * a + fy;
+    const fz = fy - 0.005 * b;
+
+    const fx3 = fx * fx * fx;
+    const fz3 = fz * fz * fz;
+
+    const xr = fx3 > kE ? fx3 : (116.0 * fx - 16.0) / kK;
+    const yr = L > kKE ? Math.pow((L + 16.0) / 116.0, 3.0) : L / kK;
+    const zr = fz3 > kE ? fz3 : (116.0 * fz - 16.0) / kK;
+
+    const x = xr * Xn;
+    const y = yr * Yn;
+    const z = zr * Zn;
+
+    return [x, y, z];
+};
+
+const compand = (linear) => {
+    /* sRGB */
+    const sign = Math.sign(linear);
+    linear = Math.abs(linear);
+    return (
+        (linear <= 0.0031308
+            ? linear * 12.92
+            : 1.055 * Math.pow(linear, 1.0 / 2.4) - 0.055) * sign
+    );
+};
+
+const xyz2rgb = (x, y, z) => {
+    const { MtxAdaptMa, MtxAdaptMaI, MtxXYZ2RGB, RefWhiteRGB, Xn, Yn, Zn } =
+        LAB_CONSTANTS;
+
+    const As = Xn * MtxAdaptMa.m00 + Yn * MtxAdaptMa.m10 + Zn * MtxAdaptMa.m20;
+    const Bs = Xn * MtxAdaptMa.m01 + Yn * MtxAdaptMa.m11 + Zn * MtxAdaptMa.m21;
+    const Cs = Xn * MtxAdaptMa.m02 + Yn * MtxAdaptMa.m12 + Zn * MtxAdaptMa.m22;
+
+    const Ad =
+        RefWhiteRGB.X * MtxAdaptMa.m00 +
+        RefWhiteRGB.Y * MtxAdaptMa.m10 +
+        RefWhiteRGB.Z * MtxAdaptMa.m20;
+    const Bd =
+        RefWhiteRGB.X * MtxAdaptMa.m01 +
+        RefWhiteRGB.Y * MtxAdaptMa.m11 +
+        RefWhiteRGB.Z * MtxAdaptMa.m21;
+    const Cd =
+        RefWhiteRGB.X * MtxAdaptMa.m02 +
+        RefWhiteRGB.Y * MtxAdaptMa.m12 +
+        RefWhiteRGB.Z * MtxAdaptMa.m22;
+
+    const X1 =
+        (x * MtxAdaptMa.m00 + y * MtxAdaptMa.m10 + z * MtxAdaptMa.m20) *
+        (Ad / As);
+    const Y1 =
+        (x * MtxAdaptMa.m01 + y * MtxAdaptMa.m11 + z * MtxAdaptMa.m21) *
+        (Bd / Bs);
+    const Z1 =
+        (x * MtxAdaptMa.m02 + y * MtxAdaptMa.m12 + z * MtxAdaptMa.m22) *
+        (Cd / Cs);
+
+    const X2 =
+        X1 * MtxAdaptMaI.m00 + Y1 * MtxAdaptMaI.m10 + Z1 * MtxAdaptMaI.m20;
+    const Y2 =
+        X1 * MtxAdaptMaI.m01 + Y1 * MtxAdaptMaI.m11 + Z1 * MtxAdaptMaI.m21;
+    const Z2 =
+        X1 * MtxAdaptMaI.m02 + Y1 * MtxAdaptMaI.m12 + Z1 * MtxAdaptMaI.m22;
+
+    const r = compand(
+        X2 * MtxXYZ2RGB.m00 + Y2 * MtxXYZ2RGB.m10 + Z2 * MtxXYZ2RGB.m20
+    );
+    const g = compand(
+        X2 * MtxXYZ2RGB.m01 + Y2 * MtxXYZ2RGB.m11 + Z2 * MtxXYZ2RGB.m21
+    );
+    const b = compand(
+        X2 * MtxXYZ2RGB.m02 + Y2 * MtxXYZ2RGB.m12 + Z2 * MtxXYZ2RGB.m22
+    );
+
+    return [r * 255, g * 255, b * 255];
+};
+
+export default lab2rgb;
+export { xyz2rgb };

simview/static/lib/chroma-js-3.1.2/src/io/lab/rgb2lab.js

@@ -0,0 +1,67 @@
+import LAB_CONSTANTS from './lab-constants.js';
+import { unpack } from '../../utils/index.js';
+
+const rgb2lab = (...args) => {
+    const [r, g, b, ...rest] = unpack(args, 'rgb');
+    const [x, y, z] = rgb2xyz(r, g, b);
+    const [L, a, b_] = xyz2lab(x, y, z);
+    return [L, a, b_, ...(rest.length > 0 && rest[0] < 1 ? [rest[0]] : [])];
+};
+
+function xyz2lab(x, y, z) {
+    const { Xn, Yn, Zn, kE, kK } = LAB_CONSTANTS;
+    const xr = x / Xn;
+    const yr = y / Yn;
+    const zr = z / Zn;
+
+    const fx = xr > kE ? Math.pow(xr, 1.0 / 3.0) : (kK * xr + 16.0) / 116.0;
+    const fy = yr > kE ? Math.pow(yr, 1.0 / 3.0) : (kK * yr + 16.0) / 116.0;
+    const fz = zr > kE ? Math.pow(zr, 1.0 / 3.0) : (kK * zr + 16.0) / 116.0;
+
+    return [116.0 * fy - 16.0, 500.0 * (fx - fy), 200.0 * (fy - fz)];
+}
+
+function gammaAdjustSRGB(companded) {
+    const sign = Math.sign(companded);
+    companded = Math.abs(companded);
+    const linear =
+        companded <= 0.04045
+            ? companded / 12.92
+            : Math.pow((companded + 0.055) / 1.055, 2.4);
+    return linear * sign;
+}
+
+const rgb2xyz = (r, g, b) => {
+    // normalize and gamma adjust
+    r = gammaAdjustSRGB(r / 255);
+    g = gammaAdjustSRGB(g / 255);
+    b = gammaAdjustSRGB(b / 255);
+
+    const { MtxRGB2XYZ, MtxAdaptMa, MtxAdaptMaI, Xn, Yn, Zn, As, Bs, Cs } =
+        LAB_CONSTANTS;
+
+    let x = r * MtxRGB2XYZ.m00 + g * MtxRGB2XYZ.m10 + b * MtxRGB2XYZ.m20;
+    let y = r * MtxRGB2XYZ.m01 + g * MtxRGB2XYZ.m11 + b * MtxRGB2XYZ.m21;
+    let z = r * MtxRGB2XYZ.m02 + g * MtxRGB2XYZ.m12 + b * MtxRGB2XYZ.m22;
+
+    const Ad = Xn * MtxAdaptMa.m00 + Yn * MtxAdaptMa.m10 + Zn * MtxAdaptMa.m20;
+    const Bd = Xn * MtxAdaptMa.m01 + Yn * MtxAdaptMa.m11 + Zn * MtxAdaptMa.m21;
+    const Cd = Xn * MtxAdaptMa.m02 + Yn * MtxAdaptMa.m12 + Zn * MtxAdaptMa.m22;
+
+    let X = x * MtxAdaptMa.m00 + y * MtxAdaptMa.m10 + z * MtxAdaptMa.m20;
+    let Y = x * MtxAdaptMa.m01 + y * MtxAdaptMa.m11 + z * MtxAdaptMa.m21;
+    let Z = x * MtxAdaptMa.m02 + y * MtxAdaptMa.m12 + z * MtxAdaptMa.m22;
+
+    X *= Ad / As;
+    Y *= Bd / Bs;
+    Z *= Cd / Cs;
+
+    x = X * MtxAdaptMaI.m00 + Y * MtxAdaptMaI.m10 + Z * MtxAdaptMaI.m20;
+    y = X * MtxAdaptMaI.m01 + Y * MtxAdaptMaI.m11 + Z * MtxAdaptMaI.m21;
+    z = X * MtxAdaptMaI.m02 + Y * MtxAdaptMaI.m12 + Z * MtxAdaptMaI.m22;
+
+    return [x, y, z];
+};
+
+export default rgb2lab;
+export { rgb2xyz };

simview/static/lib/chroma-js-3.1.2/src/io/lch/hcl2rgb.js

@@ -0,0 +1,9 @@
+import { unpack, reverse3 } from '../../utils/index.js';
+import lch2rgb from './lch2rgb.js';
+
+const hcl2rgb = (...args) => {
+    const hcl = reverse3(unpack(args, 'hcl'));
+    return lch2rgb(...hcl);
+};
+
+export default hcl2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/lch/index.js

@@ -0,0 +1,35 @@
+import { unpack, type, reverse3 } from '../../utils/index.js';
+import chroma from '../../chroma.js';
+import Color from '../../Color.js';
+import input from '../input.js';
+import lch2rgb from './lch2rgb.js';
+import hcl2rgb from './hcl2rgb.js';
+import rgb2lch from './rgb2lch.js';
+
+Color.prototype.lch = function () {
+    return rgb2lch(this._rgb);
+};
+Color.prototype.hcl = function () {
+    return reverse3(rgb2lch(this._rgb));
+};
+
+const lch = (...args) => new Color(...args, 'lch');
+const hcl = (...args) => new Color(...args, 'hcl');
+
+Object.assign(chroma, { lch, hcl });
+
+input.format.lch = lch2rgb;
+input.format.hcl = hcl2rgb;
+['lch', 'hcl'].forEach((m) =>
+    input.autodetect.push({
+        p: 2,
+        test: (...args) => {
+            args = unpack(args, m);
+            if (type(args) === 'array' && args.length === 3) {
+                return m;
+            }
+        }
+    })
+);
+
+export { lch, hcl };