@woosh/meep-engine 2.100.1 → 2.100.3

package/build/meep.module.js

@@ -67746,6 +67746,83 @@ class AssetLoader {
     }
 }
 
+/**
+ *
+ * @param {Response} input
+ * @param {function} progress
+ * @return {Response}
+ */
+function observeResponseProgress(input, progress) {
+    let response = input;
+
+
+    if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
+
+        return response;
+
+    }
+
+    /**
+     * @type {ReadableStreamDefaultReader<Uint8Array>}
+     */
+    const reader = response.body.getReader();
+
+    const contentLength = response.headers.get('Content-Length');
+    const total = contentLength ? parseInt(contentLength) : 0;
+    let loaded = 0;
+
+    // periodically read data into the new stream tracking while download progress
+    const stream_prototype = {
+        type: "bytes",
+        start(controller) {
+
+            pump();
+
+            function pump() {
+
+                reader.read().then(({ done, value }) => {
+
+                    if (done) {
+                        // no more data, we're done
+                        controller.close();
+                        return;
+                    }
+
+                    loaded += value.byteLength;
+
+                    progress(loaded, total);
+
+                    controller.enqueue(value);
+                    pump();
+
+                });
+
+            }
+
+        }
+
+    };
+
+    /**
+     * @type {ReadableStream}
+     */
+    let stream;
+
+    try {
+        stream = new ReadableStream(stream_prototype);
+
+        response = new Response(stream);
+    } catch (e) {
+        /*
+         Workaround for Safari bug: "TypeError: ReadableByteStreamController is not implemented"
+         By not wrapping the response we lose the ability to track progress, but that's not a critical issue in most cases
+         */
+    }
+
+    return response;
+
+}
+
 class ArrayBufferLoader extends AssetLoader {
     /**
      *
@@ -67764,7 +67841,13 @@ class ArrayBufferLoader extends AssetLoader {
         this.__fetch_priority = fetch_priority;
     }
 
-    load(scope, path, success, failure = console.error, progress = noop) {
+    async load(
+        scope,
+        path,
+        success,
+        failure = console.error,
+        progress = noop
+    ) {
         const coc = this.assetManager !== null ? this.assetManager.crossOriginConfig : CrossOriginConfig.default;
 
         const headers = new Headers();
@@ -67779,93 +67862,36 @@ class ArrayBufferLoader extends AssetLoader {
             request.priority = this.__fetch_priority;
         }
 
-        fetch(request)
-            .then(handle_response)
-            .then(response_to_asset)
-            .catch(failure);
+        let response = await fetch(request);
 
-        /**
-         *
-         * @param {Response} response
-         * @return {Promise<void>}
-         */
-        async function response_to_asset(response) {
-            const arrayBuffer = await response.arrayBuffer();
+        if (!(response.status === 200 || response.status === 0)) {
 
-            const asset = new Asset(
-                function () {
-                    return arrayBuffer;
-                },
-                arrayBuffer.byteSize
-            );
+            throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
 
-            success(asset);
         }
 
-        /**
-         *
-         * @param {Response} response
-         * @return {Response}
-         */
-        function handle_response(response) {
-            if (!(response.status === 200 || response.status === 0)) {
-
-                throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
-
-            }
-
-            // Some browsers return HTTP Status 0 when using non-http protocol
-            // e.g. 'file://' or 'data://'. Handle as success.
-
-            if (response.status === 0) ;
-
-            if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
-
-                return response;
-
-            }
-
-            const reader = response.body.getReader();
-            const contentLength = response.headers.get('Content-Length');
-            const total = contentLength ? parseInt(contentLength) : 0;
-            let loaded = 0;
-
-            // periodically read data into the new stream tracking while download progress
-            const stream = new ReadableStream({
-                type: "bytes",
-                start(controller) {
-
-                    pump();
-
-                    function pump() {
-
-                        reader.read().then(({ done, value }) => {
-
-                            if (done) {
-                                // no more data, we're done
-                                controller.close();
-                                return;
-                            }
-
-                            loaded += value.byteLength;
+        // Some browsers return HTTP Status 0 when using non-http protocol
+        // e.g. 'file://' or 'data://'. Handle as success.
 
-                            progress(loaded, total);
+        if (response.status === 0) ;
 
-                            controller.enqueue(value);
-                            pump();
-
-                        });
-
-                    }
-
-                }
+        try {
+            response = observeResponseProgress(response, progress);
+        } catch (e) {
+        }
 
-            });
+        const arrayBuffer = await response.arrayBuffer();
 
-            return new Response(stream);
-        }
+        const asset = new Asset(
+            function () {
+                return arrayBuffer;
+            },
+            arrayBuffer.byteSize
+        );
 
+        success(asset);
 
+        return asset;
     }
 }
 
@@ -86223,7 +86249,12 @@ class AssetManager {
         try {
 
 
-            loader.load(scope, full_path, success, failure, progress);
+            const result = loader.load(scope, full_path, success, failure, progress);
+
+            if (result instanceof Promise) {
+                // allow promise responses
+                result.catch(failure);
+            }
 
         } catch (e) {
             failure(e);

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.100.1",
+  "version": "2.100.3",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/downloadUrlAsFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"downloadUrlAsFile.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/downloadUrlAsFile.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,uCAHW,MAAM,YACN,MAAM,QAShB"}
+{"version":3,"file":"downloadUrlAsFile.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/downloadUrlAsFile.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,uCAHW,MAAM,YACN,MAAM,QAWhB"}

package/src/core/binary/downloadUrlAsFile.js

@@ -4,9 +4,11 @@
  * @param {string} filename
  */
 export function downloadUrlAsFile(url, filename) {
-    const elem = window.document.createElement('a');
+    const elem = document.createElement('a');
     elem.href = url;
     elem.download = filename;
+
+    // only elements on the dom are clickable, so we add it
     document.body.appendChild(elem);
     elem.click();
     document.body.removeChild(elem);

package/src/core/color/oklab/Okhsv.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Okhsv.spec.d.ts.map

package/src/core/color/oklab/Okhsv.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Okhsv.spec.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/oklab/Okhsv.spec.js"],"names":[],"mappings":""}

package/src/core/color/oklab/Okhsv.spec.js

@@ -0,0 +1,17 @@
+import { linear_srgb_to_okhsv } from "./linear_srgb_to_okhsv.js";
+import { okhsv_to_linear_srgb } from "./okhsv_to_linear_srgb.js";
+
+test("to/from consistency", () => {
+
+    const out = [];
+
+    const sample = [0.123, 0.345, 0.457];
+
+    okhsv_to_linear_srgb(out, ...sample);
+
+    linear_srgb_to_okhsv(out, ...out);
+
+    expect(out[0]).toBeCloseTo(sample[0]);
+    expect(out[1]).toBeCloseTo(sample[1]);
+    expect(out[2]).toBeCloseTo(sample[2]);
+});

package/src/core/color/oklab/XYZ.spec.js

@@ -7,9 +7,9 @@ test("to/from consistency", () => {
 
     const sample = [0.123, 0.345, 0.457];
 
-    oklab_to_xyz(sample, out);
+    oklab_to_xyz(out, ...sample);
 
-    xyz_to_oklab(out, out);
+    xyz_to_oklab(out, ...out);
 
     expect(out[0]).toBeCloseTo(sample[0]);
     expect(out[1]).toBeCloseTo(sample[1]);

package/src/core/color/oklab/compute_max_saturation.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Finds the maximum saturation possible for a given hue that fits in sRGB
+ * Saturation here is defined as S = C/L
+ * a and b must be normalized so a^2 + b^2 == 1
+ * @copyright "Company Named Limited" 2023
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+export function compute_max_saturation(a: number, b: number): number;
+//# sourceMappingURL=compute_max_saturation.d.ts.map

package/src/core/color/oklab/compute_max_saturation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_max_saturation.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/oklab/compute_max_saturation.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,0CAJW,MAAM,KACN,MAAM,GACJ,MAAM,CA4ElB"}

package/src/core/color/oklab/compute_max_saturation.js

@@ -0,0 +1,84 @@
+/**
+ * Finds the maximum saturation possible for a given hue that fits in sRGB
+ * Saturation here is defined as S = C/L
+ * a and b must be normalized so a^2 + b^2 == 1
+ * @copyright "Company Named Limited" 2023
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+export function compute_max_saturation(a, b) {
+    // Max saturation will be when one of r, g or b goes below zero.
+
+    // Select different coefficients depending on which component goes below zero first
+    let k0, k1, k2, k3, k4, wl, wm, ws;
+
+    if (-1.88170328 * a - 0.80936493 * b > 1) {
+        // Red component
+        k0 = +1.19086277;
+        k1 = +1.76576728;
+        k2 = +0.59662641;
+        k3 = +0.75515197;
+        k4 = +0.56771245;
+        wl = +4.0767416621;
+        wm = -3.3077115913;
+        ws = +0.2309699292;
+    } else if (1.81444104 * a - 1.19445276 * b > 1) {
+        // Green component
+        k0 = +0.73956515;
+        k1 = -0.45954404;
+        k2 = +0.08285427;
+        k3 = +0.12541070;
+        k4 = +0.14503204;
+        wl = -1.2684380046;
+        wm = +2.6097574011;
+        ws = -0.3413193965;
+    } else {
+        // Blue component
+        k0 = +1.35733652;
+        k1 = -0.00915799;
+        k2 = -1.15130210;
+        k3 = -0.50559606;
+        k4 = +0.00692167;
+        wl = -0.0041960863;
+        wm = -0.7034186147;
+        ws = +1.7076147010;
+    }
+
+    // Approximate max saturation using a polynomial:
+    let S = k0 + k1 * a + k2 * b + k3 * a * a + k4 * a * b;
+
+    // Do one step of Halley's method to get closer
+    // this gives an error less than 10e6, except for some blue hues where the dS/dh is close to infinite
+    // this should be sufficient for most applications, otherwise do two/three steps
+
+    const k_l = +0.3963377774 * a + 0.2158037573 * b;
+    const k_m = -0.1055613458 * a - 0.0638541728 * b;
+    const k_s = -0.0894841775 * a - 1.2914855480 * b;
+
+    {
+        const l_ = 1. + S * k_l;
+        const m_ = 1. + S * k_m;
+        const s_ = 1. + S * k_s;
+
+        const l = l_ * l_ * l_;
+        const m = m_ * m_ * m_;
+        const s = s_ * s_ * s_;
+
+        const l_dS = 3. * k_l * l_ * l_;
+        const m_dS = 3. * k_m * m_ * m_;
+        const s_dS = 3. * k_s * s_ * s_;
+
+        const l_dS2 = 6. * k_l * k_l * l_;
+        const m_dS2 = 6. * k_m * k_m * m_;
+        const s_dS2 = 6. * k_s * k_s * s_;
+
+        const f = wl * l + wm * m + ws * s;
+        const f1 = wl * l_dS + wm * m_dS + ws * s_dS;
+        const f2 = wl * l_dS2 + wm * m_dS2 + ws * s_dS2;
+
+        S = S - f * f1 / (f1 * f1 - 0.5 * f * f2);
+    }
+
+    return S;
+}

package/src/core/color/oklab/find_cusp.d.ts

@@ -0,0 +1,10 @@
+/**
+ * finds L_cusp and C_cusp for a given hue
+ * a and b must be normalized so a^2 + b^2 == 1
+ * @copyright "Company Named Limited" 2023
+ * @param {number[]} output [L, C]
+ * @param {number} a
+ * @param {number} b
+ */
+export function find_cusp(output: number[], a: number, b: number): void;
+//# sourceMappingURL=find_cusp.d.ts.map

package/src/core/color/oklab/find_cusp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find_cusp.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/oklab/find_cusp.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,kCAJW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,QAahB"}

package/src/core/color/oklab/find_cusp.js

@@ -0,0 +1,27 @@
+import { max3 } from "../../math/max3.js";
+import { compute_max_saturation } from "./compute_max_saturation.js";
+import { oklab_to_linear_srgb } from "./oklab_to_linear_srgb.js";
+
+const rgb_at_max = [0, 0, 0];
+
+
+/**
+ * finds L_cusp and C_cusp for a given hue
+ * a and b must be normalized so a^2 + b^2 == 1
+ * @copyright "Company Named Limited" 2023
+ * @param {number[]} output [L, C]
+ * @param {number} a
+ * @param {number} b
+ */
+export function find_cusp(output, a, b) {
+    // First, find the maximum saturation (saturation S = C/L)
+    const S_cusp = compute_max_saturation(a, b);
+
+    // Convert to linear sRGB to find the first point where at least one of r,g or b >= 1:
+    oklab_to_linear_srgb(rgb_at_max, 1, S_cusp * a, S_cusp * b);
+    const L_cusp = Math.cbrt(1. / max3(rgb_at_max[0], rgb_at_max[1], rgb_at_max[2]));
+    const C_cusp = L_cusp * S_cusp;
+
+    output[0] = L_cusp;
+    output[1] = C_cusp;
+}

package/src/core/color/oklab/find_gamut_intersection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Finds intersection of the line defined by
+ * L = L0 * (1 - t) + t * L1;
+ * C = t * C1;
+ * a and b must be normalized so a^2 + b^2 == 1
+ * @copyright "Company Named Limited" 2023
+ * @param {number} a
+ * @param {number} b
+ * @param {number} L1
+ * @param {number} C1
+ * @param {number} L0
+ * @returns {number}
+ */
+export function find_gamut_intersection(a: number, b: number, L1: number, C1: number, L0: number): number;
+//# sourceMappingURL=find_gamut_intersection.d.ts.map

package/src/core/color/oklab/find_gamut_intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find_gamut_intersection.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/oklab/find_gamut_intersection.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,2CAPW,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAoFlB"}

package/src/core/color/oklab/find_gamut_intersection.js

@@ -0,0 +1,101 @@
+import { min3 } from "../../math/min3.js";
+import { find_cusp } from "./find_cusp.js";
+
+const cusp = [0, 0];
+
+/**
+ * Finds intersection of the line defined by
+ * L = L0 * (1 - t) + t * L1;
+ * C = t * C1;
+ * a and b must be normalized so a^2 + b^2 == 1
+ * @copyright "Company Named Limited" 2023
+ * @param {number} a
+ * @param {number} b
+ * @param {number} L1
+ * @param {number} C1
+ * @param {number} L0
+ * @returns {number}
+ */
+export function find_gamut_intersection(a, b, L1, C1, L0) {
+    // Find the cusp of the gamut triangle
+    find_cusp(cusp, a, b);
+
+    // Find the intersection for upper and lower half seprately
+    let t;
+    if (((L1 - L0) * cusp[1] - (cusp[0] - L0) * C1) <= 0.) {
+        // Lower half
+
+        t = cusp[1] * L0 / (C1 * cusp[0] + cusp[1] * (L0 - L1));
+    } else {
+        // Upper half
+
+        // First intersect with triangle
+        t = cusp[1] * (L0 - 1.) / (C1 * (cusp[0] - 1.) + cusp[1] * (L0 - L1));
+
+        // Then one step of Halley's method
+        {
+            const dL = L1 - L0;
+            const dC = C1;
+
+            const k_l = +0.3963377774 * a + 0.2158037573 * b;
+            const k_m = -0.1055613458 * a - 0.0638541728 * b;
+            const k_s = -0.0894841775 * a - 1.2914855480 * b;
+
+            const l_dt = dL + dC * k_l;
+            const m_dt = dL + dC * k_m;
+            const s_dt = dL + dC * k_s;
+
+
+            // If higher accuracy is required, 2 or 3 iterations of the following block can be used:
+            {
+                const L = L0 * (1 - t) + t * L1;
+                const C = t * C1;
+
+                const l_ = L + C * k_l;
+                const m_ = L + C * k_m;
+                const s_ = L + C * k_s;
+
+                const l = l_ * l_ * l_;
+                const m = m_ * m_ * m_;
+                const s = s_ * s_ * s_;
+
+                const ldt = 3 * l_dt * l_ * l_;
+                const mdt = 3 * m_dt * m_ * m_;
+                const sdt = 3 * s_dt * s_ * s_;
+
+                const ldt2 = 6 * l_dt * l_dt * l_;
+                const mdt2 = 6 * m_dt * m_dt * m_;
+                const sdt2 = 6 * s_dt * s_dt * s_;
+
+                const r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s - 1;
+                const r1 = 4.0767416621 * ldt - 3.3077115913 * mdt + 0.2309699292 * sdt;
+                const r2 = 4.0767416621 * ldt2 - 3.3077115913 * mdt2 + 0.2309699292 * sdt2;
+
+                const u_r = r1 / (r1 * r1 - 0.5 * r * r2);
+                let t_r = -r * u_r;
+
+                const g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s - 1;
+                const g1 = -1.2684380046 * ldt + 2.6097574011 * mdt - 0.3413193965 * sdt;
+                const g2 = -1.2684380046 * ldt2 + 2.6097574011 * mdt2 - 0.3413193965 * sdt2;
+
+                const u_g = g1 / (g1 * g1 - 0.5 * g * g2);
+                let t_g = -g * u_g;
+
+                const b = -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s - 1;
+                const b1 = -0.0041960863 * ldt - 0.7034186147 * mdt + 1.7076147010 * sdt;
+                const b2 = -0.0041960863 * ldt2 - 0.7034186147 * mdt2 + 1.7076147010 * sdt2;
+
+                const u_b = b1 / (b1 * b1 - 0.5 * b * b2);
+                let t_b = -b * u_b;
+
+                t_r = u_r >= 0 ? t_r : Number.MAX_VALUE;
+                t_g = u_g >= 0 ? t_g : Number.MAX_VALUE;
+                t_b = u_b >= 0 ? t_b : Number.MAX_VALUE;
+
+                t += min3(t_r, t_g, t_b);
+            }
+        }
+    }
+
+    return t;
+}

package/src/core/color/oklab/linear_srgb_to_okhsv.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number[]} output
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ */
+export function linear_srgb_to_okhsv(output: number[], r: number, g: number, b: number): void;
+//# sourceMappingURL=linear_srgb_to_okhsv.d.ts.map

package/src/core/color/oklab/linear_srgb_to_okhsv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear_srgb_to_okhsv.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/oklab/linear_srgb_to_okhsv.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,6CALW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,QAkDhB"}

package/src/core/color/oklab/linear_srgb_to_okhsv.js

@@ -0,0 +1,74 @@
+import { find_cusp } from "./find_cusp.js";
+import { linear_srgb_to_oklab } from "./linear_srgb_to_oklab.js";
+import { oklab_to_linear_srgb } from "./oklab_to_linear_srgb.js";
+import { toe, toe_inv } from "./toe.js";
+
+const Lab = [0, 0, 0];
+
+/**
+ *
+ * @type {number[]}
+ */
+const cusp = [0, 0];
+/**
+ *
+ * @type {number[]}
+ */
+const rgb_scale = [0, 0, 0];
+
+/**
+ *
+ * @param {number[]} output
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ */
+export function linear_srgb_to_okhsv(output, r, g, b) {
+
+    linear_srgb_to_oklab(Lab, r, g, b)
+
+    let C = Math.sqrt(Lab[1] * Lab[1] + Lab[2] * Lab[2]);
+    const a_ = Lab[1] / C;
+    const b_ = Lab[2] / C;
+
+    let L = Lab[0];
+    const h = 0.5 + 0.5 * Math.atan2(-Lab[2], -Lab[1]) / Math.PI;
+
+    find_cusp(cusp, a_, b_);
+
+    const S_max = cusp[1] / cusp[0];
+    const T_max = cusp[1] / (1 - cusp[0]);
+
+    const S_0 = 0.5;
+    const k = 1 - S_0 / S_max;
+
+    // first we find L_v, C_v, L_vt and C_vt
+
+    const t = T_max / (C + L * T_max);
+    const L_v = t * L;
+    const C_v = t * C;
+
+    const L_vt = toe_inv(L_v);
+    const C_vt = C_v * L_vt / L_v;
+
+    // we can then use these to invert the step that compensates for the toe and the curved top part of the triangle:
+
+    oklab_to_linear_srgb(rgb_scale, L_vt, a_ * C_vt, b_ * C_vt);
+
+    const scale_L = Math.cbrt(1. / Math.max(rgb_scale[0], rgb_scale[1], rgb_scale[2], 0));
+
+    L = L / scale_L;
+    C = C / scale_L;
+
+    C = C * toe(L) / L;
+    L = toe(L);
+
+    // we can now compute v and s:
+
+    const v = L / L_v;
+    const s = (S_0 + T_max) * C_v / ((T_max * S_0) + T_max * k * C_v);
+
+    output[0] = h;
+    output[1] = s;
+    output[2] = v;
+}

package/src/core/color/oklab/linear_srgb_to_oklab.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number[]} output
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ */
+export function linear_srgb_to_oklab(output: number[], r: number, g: number, b: number): void;
+//# sourceMappingURL=linear_srgb_to_oklab.d.ts.map

package/src/core/color/oklab/linear_srgb_to_oklab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear_srgb_to_oklab.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/oklab/linear_srgb_to_oklab.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,6CALW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,QAchB"}

package/src/core/color/oklab/linear_srgb_to_oklab.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param {number[]} output
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ */
+export function linear_srgb_to_oklab(output, r, g, b) {
+    const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+    const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+    const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+
+    const l_ = Math.cbrt(l);
+    const m_ = Math.cbrt(m);
+    const s_ = Math.cbrt(s);
+
+    output[0] = 0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_;
+    output[1] = 1.9779984951 * l_ - 2.4285922050 * m_ + 0.4505937099 * s_;
+    output[2] = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.8086757660 * s_;
+}