@woosh/meep-engine 2.100.1 → 2.100.2

package/build/meep.module.js

@@ -67825,13 +67825,17 @@ class ArrayBufferLoader extends AssetLoader {
 
             }
 
+            /**
+             * @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 = new ReadableStream({
+            const stream_prototype = {
                 type: "bytes",
                 start(controller) {
 
@@ -67860,7 +67864,22 @@ class ArrayBufferLoader extends AssetLoader {
 
                 }
 
-            });
+            };
+
+            /**
+             * @type {ReadableStream}
+             */
+            let stream;
+
+            try {
+                stream = new ReadableStream(stream_prototype);
+            } 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;
+            }
 
             return new Response(stream);
         }

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.2",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

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_;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @copyright "Company Named Limited" 2023
+ * @param {number[]} output
+ * @param {number} h
+ * @param {number} s
+ * @param {number} v
+ */
+export function okhsv_to_linear_srgb(output: number[], h: number, s: number, v: number): void;
+//# sourceMappingURL=okhsv_to_linear_srgb.d.ts.map

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

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

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

@@ -0,0 +1,59 @@
+import { find_cusp } from "./find_cusp.js";
+import { oklab_to_linear_srgb } from "./oklab_to_linear_srgb.js";
+import { toe_inv } from "./toe.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const cusp = [0, 0];
+/**
+ *
+ * @type {number[]}
+ */
+const rgb_scale = [0, 0, 0];
+
+/**
+ * @copyright "Company Named Limited" 2023
+ * @param {number[]} output
+ * @param {number} h
+ * @param {number} s
+ * @param {number} v
+ */
+export function okhsv_to_linear_srgb(output, h, s, v) {
+
+    const a_ = Math.cos(2 * Math.PI * h);
+    const b_ = Math.sin(2 * Math.PI * h);
+
+    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 compute L and V as if the gamut is a perfect triangle:
+
+    // L, C when v==1:
+    const L_v = 1 - s * S_0 / (S_0 + T_max - T_max * k * s);
+    const C_v = s * T_max * S_0 / (S_0 + T_max - T_max * k * s);
+
+    let L = v * L_v;
+    let C = v * C_v;
+
+    // then we compensate for both toe and the curved top part of the triangle:
+    const L_vt = toe_inv(L_v);
+    const C_vt = C_v * L_vt / L_v;
+
+    const L_new = toe_inv(L);
+    C = C * L_new / L;
+    L = L_new;
+
+    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;
+
+    oklab_to_linear_srgb(output, L, C * a_, C * b_);
+}

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

@@ -0,0 +1,10 @@
+/**
+ *
+ * @copyright "Company Named Limited" 2023
+ * @param {number[]} output
+ * @param {number} L
+ * @param {number} a
+ * @param {number} b
+ */
+export function oklab_to_linear_srgb(output: number[], L: number, a: number, b: number): void;
+//# sourceMappingURL=oklab_to_linear_srgb.d.ts.map

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

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

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

@@ -0,0 +1,21 @@
+/**
+ *
+ * @copyright "Company Named Limited" 2023
+ * @param {number[]} output
+ * @param {number} L
+ * @param {number} a
+ * @param {number} b
+ */
+export function oklab_to_linear_srgb(output, L, a, b) {
+    const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+    const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+    const s_ = L - 0.0894841775 * a - 1.2914855480 * b;
+
+    const l = l_ * l_ * l_;
+    const m = m_ * m_ * m_;
+    const s = s_ * s_ * s_;
+
+    output[0] = +4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+    output[1] = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+    output[2] = -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s;
+}

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

@@ -2,8 +2,11 @@
  *
  * Converts Oklab color space to CIE XYZ.
  * Oklab as defined by Björn Ottosson
- * @param {number[]} input Oklab
+ * @copyright "Company Named Limited" 2023
  * @param {number[]} output XYZ
+ * @param {number} L
+ * @param {number} a
+ * @param {number} b
  */
-export function oklab_to_xyz(input: number[], output: number[]): void;
+export function oklab_to_xyz(output: number[], L: number, a: number, b: number): void;
 //# sourceMappingURL=oklab_to_xyz.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"oklab_to_xyz.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/oklab/oklab_to_xyz.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,oCAHW,MAAM,EAAE,UACR,MAAM,EAAE,QA0BlB"}
+{"version":3,"file":"oklab_to_xyz.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/oklab/oklab_to_xyz.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,qCALW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,QAuBhB"}

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

@@ -2,13 +2,13 @@
  *
  * Converts Oklab color space to CIE XYZ.
  * Oklab as defined by Björn Ottosson
- * @param {number[]} input Oklab
+ * @copyright "Company Named Limited" 2023
  * @param {number[]} output XYZ
+ * @param {number} L
+ * @param {number} a
+ * @param {number} b
  */
-export function oklab_to_xyz(input, output) {
-    const L = input[0];
-    const a = input[1];
-    const b = input[2];
+export function oklab_to_xyz(output, L, a, b) {
 
     // apply M2 inverse
 

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

@@ -4,25 +4,25 @@ test("known samples", () => {
 
     const out = [];
 
-    oklab_to_xyz([1, 0, 0], out);
+    oklab_to_xyz(out, 1, 0, 0);
 
     expect(out[0]).toBeCloseTo(0.950);
     expect(out[1]).toBeCloseTo(1.000);
     expect(out[2]).toBeCloseTo(1.089);
 
-    oklab_to_xyz([0.450, 1.236, -0.019], out);
+    oklab_to_xyz(out, 0.450, 1.236, -0.019);
 
     expect(out[0]).toBeCloseTo(1);
     expect(out[1]).toBeCloseTo(0);
     expect(out[2]).toBeCloseTo(0);
 
-    oklab_to_xyz([0.922, -0.671, 0.263], out);
+    oklab_to_xyz(out, 0.922, -0.671, 0.263);
 
     expect(out[0]).toBeCloseTo(0);
     expect(out[1]).toBeCloseTo(1);
     expect(out[2]).toBeCloseTo(0);
 
-    oklab_to_xyz([0.153, -1.415, -0.449], out);
+    oklab_to_xyz(out, 0.153, -1.415, -0.449);
 
     expect(out[0]).toBeCloseTo(0);
     expect(out[1]).toBeCloseTo(0);