@woosh/meep-engine 3.9.0 → 3.11.0

package/src/core/color/illuminant/D65_spd_tabulated.js

@@ -1,105 +1,108 @@
-import { assert } from "../../assert.js";
-import { lerp } from "../../math/lerp.js";
-
-export const D65_MIN_NM = 300;
-export const D65_MAX_NM = 830;
-
-/**
- * CIE Standard Illuminant D65 Spectral Power Distribution (SPD)
- * Source: CVRL (Colour & Vision Research Laboratory)
- * Wavelength range: 300–830 nm in 1 nm steps.
- * Units are relative; use appropriate normalization constant when integrating.
- *
- * 300..830 inclusive → 531 samples
- *
- * @see http://www.cvrl.org/cie.htm
- */
-const D65_VALUES = new Float32Array([
-    0.0341, 0.36014, 0.68618, 1.01222, 1.33826, 1.6643, 1.99034, 2.31638, 2.64242, 2.96846,
-    3.2945, 4.98865, 6.6828, 8.37695, 10.0711, 11.7652, 13.4594, 15.1535, 16.8477, 18.5418,
-    20.236, 21.9177, 23.5995, 25.2812, 26.963, 28.6447, 30.3265, 32.0082, 33.69, 35.3717,
-    37.0535, 37.343, 37.6326, 37.9221, 38.2116, 38.5011, 38.7907, 39.0802, 39.3697, 39.6593,
-    39.9488, 40.4451, 40.9414, 41.4377, 41.934, 42.4302, 42.9265, 43.4228, 43.9191, 44.4154,
-    44.9117, 45.0844, 45.257, 45.4297, 45.6023, 45.775, 45.9477, 46.1203, 46.293, 46.4656,
-    46.6383, 47.1834, 47.7285, 48.2735, 48.8186, 49.3637, 49.9088, 50.4539, 50.9989, 51.544,
-    52.0891, 51.8777, 51.6664, 51.455, 51.2437, 51.0323, 50.8209, 50.6096, 50.3982, 50.1869,
-    49.9755, 50.4428, 50.91, 51.3773, 51.8446, 52.3118, 52.7791, 53.2464, 53.7137, 54.1809,
-    54.6482, 57.4589, 60.2695, 63.0802, 65.8909, 68.7015, 71.5122, 74.3229, 77.1336, 79.9442,
-    82.7549, 83.628, 84.5011, 85.3742, 86.2473, 87.1204, 87.9936, 88.8667, 89.7398, 90.6129,
-    91.486, 91.6806, 91.8752, 92.0697, 92.2643, 92.4589, 92.6535, 92.8481, 93.0426, 93.2372,
-    93.4318, 92.7568, 92.0819, 91.4069, 90.732, 90.057, 89.3821, 88.7071, 88.0322, 87.3572,
-    86.6823, 88.5006, 90.3188, 92.1371, 93.9554, 95.7736, 97.5919, 99.4102, 101.228, 103.047,
-    104.865, 106.079, 107.294, 108.508, 109.722, 110.936, 112.151, 113.365, 114.579, 115.794,
-    117.008, 117.088, 117.169, 117.249, 117.33, 117.41, 117.49, 117.571, 117.651, 117.732,
-    117.812, 117.517, 117.222, 116.927, 116.632, 116.336, 116.041, 115.746, 115.451, 115.156,
-    114.861, 114.967, 115.073, 115.18, 115.286, 115.392, 115.498, 115.604, 115.711, 115.817,
-    115.923, 115.212, 114.501, 113.789, 113.078, 112.367, 111.656, 110.945, 110.233, 109.522,
-    108.811, 108.865, 108.92, 108.974, 109.028, 109.082, 109.137, 109.191, 109.245, 109.3,
-    109.354, 109.199, 109.044, 108.888, 108.733, 108.578, 108.423, 108.268, 108.112, 107.957,
-    107.802, 107.501, 107.2, 106.898, 106.597, 106.296, 105.995, 105.694, 105.392, 105.091,
-    104.79, 105.08, 105.37, 105.66, 105.95, 106.239, 106.529, 106.819, 107.109, 107.399,
-    107.689, 107.361, 107.032, 106.704, 106.375, 106.047, 105.719, 105.39, 105.062, 104.733,
-    104.405, 104.369, 104.333, 104.297, 104.261, 104.225, 104.19, 104.154, 104.118, 104.082,
-    104.046, 103.641, 103.237, 102.832, 102.428, 102.023, 101.618, 101.214, 100.809, 100.405,
-    100.0, 99.6334, 99.2668, 98.9003, 98.5337, 98.1671, 97.8005, 97.4339, 97.0674, 96.7008,
-    96.3342, 96.2796, 96.225, 96.1703, 96.1157, 96.0611, 96.0065, 95.9519, 95.8972, 95.8426,
-    95.788, 95.0778, 94.3675, 93.6573, 92.947, 92.2368, 91.5266, 90.8163, 90.1061, 89.3958,
-    88.6856, 88.8177, 88.9497, 89.0818, 89.2138, 89.3459, 89.478, 89.61, 89.7421, 89.8741,
-    90.0062, 89.9655, 89.9248, 89.8841, 89.8434, 89.8026, 89.7619, 89.7212, 89.6805, 89.6398,
-    89.5991, 89.4091, 89.219, 89.029, 88.8389, 88.6489, 88.4589, 88.2688, 88.0788, 87.8887,
-    87.6987, 87.2577, 86.8167, 86.3757, 85.9347, 85.4936, 85.0526, 84.6116, 84.1706, 83.7296,
-    83.2886, 83.3297, 83.3707, 83.4118, 83.4528, 83.4939, 83.535, 83.576, 83.6171, 83.6581,
-    83.6992, 83.332, 82.9647, 82.5975, 82.2302, 81.863, 81.4958, 81.1285, 80.7613, 80.394,
-    80.0268, 80.0456, 80.0644, 80.0831, 80.1019, 80.1207, 80.1395, 80.1583, 80.177, 80.1958,
-    80.2146, 80.4209, 80.6272, 80.8336, 81.0399, 81.2462, 81.4525, 81.6588, 81.8652, 82.0715,
-    82.2778, 81.8784, 81.4791, 81.0797, 80.6804, 80.281, 79.8816, 79.4823, 79.0829, 78.6836,
-    78.2842, 77.4279, 76.5716, 75.7153, 74.859, 74.0027, 73.1465, 72.2902, 71.4339, 70.5776,
-    69.7213, 69.9101, 70.0989, 70.2876, 70.4764, 70.6652, 70.854, 71.0428, 71.2315, 71.4203,
-    71.6091, 71.8831, 72.1571, 72.4311, 72.7051, 72.979, 73.253, 73.527, 73.801, 74.075,
-    74.349, 73.0745, 71.8, 70.5255, 69.251, 67.9765, 66.702, 65.4275, 64.153, 62.8785,
-    61.604, 62.4322, 63.2603, 64.0885, 64.9166, 65.7448, 66.573, 67.4011, 68.2293, 69.0574,
-    69.8856, 70.4057, 70.9259, 71.446, 71.9662, 72.4863, 73.0064, 73.5266, 74.0467, 74.5669,
-    75.087, 73.9376, 72.7881, 71.6387, 70.4893, 69.3398, 68.1904, 67.041, 65.8916, 64.7421,
-    63.5927, 61.8752, 60.1578, 58.4403, 56.7229, 55.0054, 53.288, 51.5705, 49.8531, 48.1356,
-    46.4182, 48.4569, 50.4956, 52.5344, 54.5731, 56.6118, 58.6505, 60.6892, 62.728, 64.7667,
-    66.8054, 66.4631, 66.1209, 65.7786, 65.4364, 65.0941, 64.7518, 64.4096, 64.0673, 63.7251,
-    63.3828, 63.4749, 63.567, 63.6592, 63.7513, 63.8434, 63.9355, 64.0276, 64.1198, 64.2119,
-    64.304, 63.8188, 63.3336, 62.8484, 62.3632, 61.8779, 61.3927, 60.9075, 60.4223, 59.9371,
-    59.4519, 58.7026, 57.9533, 57.204, 56.4547, 55.7054, 54.9562, 54.2069, 53.4576, 52.7083,
-    51.959, 52.5072, 53.0553, 53.6035, 54.1516, 54.6998, 55.248, 55.7961, 56.3443, 56.8924,
-    57.4406, 57.7278, 58.015, 58.3022, 58.5894, 58.8765, 59.1637, 59.4509, 59.7381, 60.0253,
-    60.3125
-]);
-
-/**
- * Linear-interpolated D65 SPD at the given wavelength.
- * Returns 0 outside [300, 830] nm.
- *
- * NOTE: results are normalized to 100 instead of 1
- *
- * @param {number} wavelength_nm
- * @returns {number}
- */
-export function D65_spd_tabulated(wavelength_nm) {
-    assert.isNumber(wavelength_nm, 'wavelength_nm');
-    assert.isFinite(wavelength_nm, 'wavelength_nm');
-    assert.greaterThan(wavelength_nm, 0, 'wavelength_nm > 0');
-
-    if (wavelength_nm <= D65_MIN_NM || wavelength_nm >= D65_MAX_NM) {
-
-        if (wavelength_nm === D65_MIN_NM) return D65_VALUES[0];
-
-        if (wavelength_nm === D65_MAX_NM) return D65_VALUES[D65_VALUES.length - 1];
-
-        return 0;
-    }
-
-    const w = wavelength_nm;
-
-    const i0 = Math.floor(w) - D65_MIN_NM; // index for integer nm below w
-    const frac = w - Math.floor(w);
-
-    const v0 = D65_VALUES[i0];
-    const v1 = D65_VALUES[i0 + 1];
-    return lerp(v0, v1, frac);
+import { assert } from "../../assert.js";
+import { lerp } from "../../math/lerp.js";
+
+export const D65_MIN_NM = 300;
+export const D65_MAX_NM = 830;
+
+/**
+ * CIE Standard Illuminant D65 Spectral Power Distribution (SPD)
+ * Source: CVRL (Colour & Vision Research Laboratory)
+ * Wavelength range: 300–830 nm in 1 nm steps.
+ * Units are relative; use appropriate normalization constant when integrating.
+ *
+ * 300..830 inclusive → 531 samples
+ *
+ * @see http://www.cvrl.org/cie.htm
+ */
+const D65_VALUES = new Float32Array([
+    0.0341, 0.36014, 0.68618, 1.01222, 1.33826, 1.6643, 1.99034, 2.31638, 2.64242, 2.96846,
+    3.2945, 4.98865, 6.6828, 8.37695, 10.0711, 11.7652, 13.4594, 15.1535, 16.8477, 18.5418,
+    20.236, 21.9177, 23.5995, 25.2812, 26.963, 28.6447, 30.3265, 32.0082, 33.69, 35.3717,
+    37.0535, 37.343, 37.6326, 37.9221, 38.2116, 38.5011, 38.7907, 39.0802, 39.3697, 39.6593,
+    39.9488, 40.4451, 40.9414, 41.4377, 41.934, 42.4302, 42.9265, 43.4228, 43.9191, 44.4154,
+    44.9117, 45.0844, 45.257, 45.4297, 45.6023, 45.775, 45.9477, 46.1203, 46.293, 46.4656,
+    46.6383, 47.1834, 47.7285, 48.2735, 48.8186, 49.3637, 49.9088, 50.4539, 50.9989, 51.544,
+    52.0891, 51.8777, 51.6664, 51.455, 51.2437, 51.0323, 50.8209, 50.6096, 50.3982, 50.1869,
+    49.9755, 50.4428, 50.91, 51.3773, 51.8446, 52.3118, 52.7791, 53.2464, 53.7137, 54.1809,
+    54.6482, 57.4589, 60.2695, 63.0802, 65.8909, 68.7015, 71.5122, 74.3229, 77.1336, 79.9442,
+    82.7549, 83.628, 84.5011, 85.3742, 86.2473, 87.1204, 87.9936, 88.8667, 89.7398, 90.6129,
+    91.486, 91.6806, 91.8752, 92.0697, 92.2643, 92.4589, 92.6535, 92.8481, 93.0426, 93.2372,
+    93.4318, 92.7568, 92.0819, 91.4069, 90.732, 90.057, 89.3821, 88.7071, 88.0322, 87.3572,
+    86.6823, 88.5006, 90.3188, 92.1371, 93.9554, 95.7736, 97.5919, 99.4102, 101.228, 103.047,
+    104.865, 106.079, 107.294, 108.508, 109.722, 110.936, 112.151, 113.365, 114.579, 115.794,
+    117.008, 117.088, 117.169, 117.249, 117.33, 117.41, 117.49, 117.571, 117.651, 117.732,
+    117.812, 117.517, 117.222, 116.927, 116.632, 116.336, 116.041, 115.746, 115.451, 115.156,
+    114.861, 114.967, 115.073, 115.18, 115.286, 115.392, 115.498, 115.604, 115.711, 115.817,
+    115.923, 115.212, 114.501, 113.789, 113.078, 112.367, 111.656, 110.945, 110.233, 109.522,
+    108.811, 108.865, 108.92, 108.974, 109.028, 109.082, 109.137, 109.191, 109.245, 109.3,
+    109.354, 109.199, 109.044, 108.888, 108.733, 108.578, 108.423, 108.268, 108.112, 107.957,
+    107.802, 107.501, 107.2, 106.898, 106.597, 106.296, 105.995, 105.694, 105.392, 105.091,
+    104.79, 105.08, 105.37, 105.66, 105.95, 106.239, 106.529, 106.819, 107.109, 107.399,
+    107.689, 107.361, 107.032, 106.704, 106.375, 106.047, 105.719, 105.39, 105.062, 104.733,
+    104.405, 104.369, 104.333, 104.297, 104.261, 104.225, 104.19, 104.154, 104.118, 104.082,
+    104.046, 103.641, 103.237, 102.832, 102.428, 102.023, 101.618, 101.214, 100.809, 100.405,
+    100.0, 99.6334, 99.2668, 98.9003, 98.5337, 98.1671, 97.8005, 97.4339, 97.0674, 96.7008,
+    96.3342, 96.2796, 96.225, 96.1703, 96.1157, 96.0611, 96.0065, 95.9519, 95.8972, 95.8426,
+    95.788, 95.0778, 94.3675, 93.6573, 92.947, 92.2368, 91.5266, 90.8163, 90.1061, 89.3958,
+    88.6856, 88.8177, 88.9497, 89.0818, 89.2138, 89.3459, 89.478, 89.61, 89.7421, 89.8741,
+    90.0062, 89.9655, 89.9248, 89.8841, 89.8434, 89.8026, 89.7619, 89.7212, 89.6805, 89.6398,
+    89.5991, 89.4091, 89.219, 89.029, 88.8389, 88.6489, 88.4589, 88.2688, 88.0788, 87.8887,
+    87.6987, 87.2577, 86.8167, 86.3757, 85.9347, 85.4936, 85.0526, 84.6116, 84.1706, 83.7296,
+    83.2886, 83.3297, 83.3707, 83.4118, 83.4528, 83.4939, 83.535, 83.576, 83.6171, 83.6581,
+    83.6992, 83.332, 82.9647, 82.5975, 82.2302, 81.863, 81.4958, 81.1285, 80.7613, 80.394,
+    80.0268, 80.0456, 80.0644, 80.0831, 80.1019, 80.1207, 80.1395, 80.1583, 80.177, 80.1958,
+    80.2146, 80.4209, 80.6272, 80.8336, 81.0399, 81.2462, 81.4525, 81.6588, 81.8652, 82.0715,
+    82.2778, 81.8784, 81.4791, 81.0797, 80.6804, 80.281, 79.8816, 79.4823, 79.0829, 78.6836,
+    78.2842, 77.4279, 76.5716, 75.7153, 74.859, 74.0027, 73.1465, 72.2902, 71.4339, 70.5776,
+    69.7213, 69.9101, 70.0989, 70.2876, 70.4764, 70.6652, 70.854, 71.0428, 71.2315, 71.4203,
+    71.6091, 71.8831, 72.1571, 72.4311, 72.7051, 72.979, 73.253, 73.527, 73.801, 74.075,
+    74.349, 73.0745, 71.8, 70.5255, 69.251, 67.9765, 66.702, 65.4275, 64.153, 62.8785,
+    61.604, 62.4322, 63.2603, 64.0885, 64.9166, 65.7448, 66.573, 67.4011, 68.2293, 69.0574,
+    69.8856, 70.4057, 70.9259, 71.446, 71.9662, 72.4863, 73.0064, 73.5266, 74.0467, 74.5669,
+    75.087, 73.9376, 72.7881, 71.6387, 70.4893, 69.3398, 68.1904, 67.041, 65.8916, 64.7421,
+    63.5927, 61.8752, 60.1578, 58.4403, 56.7229, 55.0054, 53.288, 51.5705, 49.8531, 48.1356,
+    46.4182, 48.4569, 50.4956, 52.5344, 54.5731, 56.6118, 58.6505, 60.6892, 62.728, 64.7667,
+    66.8054, 66.4631, 66.1209, 65.7786, 65.4364, 65.0941, 64.7518, 64.4096, 64.0673, 63.7251,
+    63.3828, 63.4749, 63.567, 63.6592, 63.7513, 63.8434, 63.9355, 64.0276, 64.1198, 64.2119,
+    64.304, 63.8188, 63.3336, 62.8484, 62.3632, 61.8779, 61.3927, 60.9075, 60.4223, 59.9371,
+    59.4519, 58.7026, 57.9533, 57.204, 56.4547, 55.7054, 54.9562, 54.2069, 53.4576, 52.7083,
+    51.959, 52.5072, 53.0553, 53.6035, 54.1516, 54.6998, 55.248, 55.7961, 56.3443, 56.8924,
+    57.4406, 57.7278, 58.015, 58.3022, 58.5894, 58.8765, 59.1637, 59.4509, 59.7381, 60.0253,
+    60.3125
+]);
+
+const RECORD_COUNT = D65_VALUES.length;
+
+/**
+ * Linear-interpolated D65 SPD at the given wavelength.
+ * Returns 0 outside [300, 830] nm.
+ *
+ * NOTE: results are normalized to 100 instead of 1
+ *
+ * @param {number} wavelength_nm
+ * @returns {number}
+ */
+export function D65_spd_tabulated(wavelength_nm) {
+    // matches xyz_cmf_tabulated: reject what cannot be interpolated, let out-of-range fall through to the
+    // documented 0 rather than throwing, so both stay usable inside an integration loop
+    assert.isNumber(wavelength_nm, 'wavelength_nm');
+    assert.isFinite(wavelength_nm, 'wavelength_nm');
+
+    // Same boundary shape as xyz_cmf_tabulated: reject strictly outside the range, then let the clamped upper
+    // index handle the top endpoint. Testing `<=`/`>=` and re-testing for equality inside the rejection
+    // branch gets the same answers, but two sibling files solving one problem two ways is how they drift.
+    if (wavelength_nm < D65_MIN_NM || wavelength_nm > D65_MAX_NM) {
+        // outside the tabulated range
+        return 0;
+    }
+
+    const w = wavelength_nm;
+    const w_floor = Math.floor(w);
+
+    const frac = w - w_floor;
+
+    const i0 = w_floor - D65_MIN_NM; // index for integer nm below w
+    const i1 = Math.min(i0 + 1, RECORD_COUNT - 1);
+
+    return lerp(D65_VALUES[i0], D65_VALUES[i1], frac);
 }

package/src/core/color/int2rgb.d.ts

@@ -1,11 +1,2 @@
-/**
- *
- * @param {number} value
- * @returns {{r: number, b: number, g: number}}
- */
-export function int2rgb(value: number): {
-    r: number;
-    b: number;
-    g: number;
-};
+export { int_to_rgb as int2rgb } from "./int_to_rgb.js";
 //# sourceMappingURL=int2rgb.d.ts.map

package/src/core/color/int2rgb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"int2rgb.d.ts","sourceRoot":"","sources":["../../../../src/core/color/int2rgb.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,+BAHW,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAQ7C"}
+{"version":3,"file":"int2rgb.d.ts","sourceRoot":"","sources":["../../../../src/core/color/int2rgb.js"],"names":[],"mappings":""}

package/src/core/color/int2rgb.js

@@ -1,12 +1,7 @@
-/**
- *
- * @param {number} value
- * @returns {{r: number, b: number, g: number}}
- */
-export function int2rgb(value) {
-    return {
-        r: (value >> 16) & 255,
-        g: (value >> 8) & 255,
-        b: (value) & 255
-    }
-}
+/**
+ * @deprecated Renamed to `int_to_rgb`, following the package's `name_to_name` convention.
+ *
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a published
+ * interface as a function signature.
+ */
+export { int_to_rgb as int2rgb } from "./int_to_rgb.js";

package/src/core/color/int_to_rgb.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Unpack a 24-bit `0xRRGGBB` value into three bytes.
+ *
+ * The single implementation of this in the package: {@link Color#fromUint} and {@link parse_color} both
+ * delegate here. They used to carry their own copies, and the three masked different numbers of channels —
+ * which is how `parse_color(0xFF8000FF)` came to report a red of -128.
+ *
+ * A 32-bit value is rejected rather than truncated. `0xAARRGGBB` and `0xRRGGBBAA` are both plausible readings
+ * of the same bits, so there is no safe guess to make, and silently keeping the low three bytes would give a
+ * confident wrong answer.
+ *
+ * @param {number} value 24-bit `0xRRGGBB`
+ * @returns {{r: number, b: number, g: number}} channels in the Uint8 range (0...255)
+ * @throws Error if `value` is not an integer in `[0, 0xFFFFFF]`
+ */
+export function int_to_rgb(value: number): {
+    r: number;
+    b: number;
+    g: number;
+};
+//# sourceMappingURL=int_to_rgb.d.ts.map

package/src/core/color/int_to_rgb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"int_to_rgb.d.ts","sourceRoot":"","sources":["../../../../src/core/color/int_to_rgb.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,kCAJW,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAc7C"}

package/src/core/color/int_to_rgb.js

@@ -0,0 +1,33 @@
+/**
+ * Largest value that fits in the three packed bytes.
+ * @type {number}
+ */
+const UINT24_MAX = 0xFFFFFF;
+
+/**
+ * Unpack a 24-bit `0xRRGGBB` value into three bytes.
+ *
+ * The single implementation of this in the package: {@link Color#fromUint} and {@link parse_color} both
+ * delegate here. They used to carry their own copies, and the three masked different numbers of channels —
+ * which is how `parse_color(0xFF8000FF)` came to report a red of -128.
+ *
+ * A 32-bit value is rejected rather than truncated. `0xAARRGGBB` and `0xRRGGBBAA` are both plausible readings
+ * of the same bits, so there is no safe guess to make, and silently keeping the low three bytes would give a
+ * confident wrong answer.
+ *
+ * @param {number} value 24-bit `0xRRGGBB`
+ * @returns {{r: number, b: number, g: number}} channels in the Uint8 range (0...255)
+ * @throws Error if `value` is not an integer in `[0, 0xFFFFFF]`
+ */
+export function int_to_rgb(value) {
+
+    if (!Number.isInteger(value) || value < 0 || value > UINT24_MAX) {
+        throw new Error(`Failed to decode color '${value}', expected an integer in [0, 0xFFFFFF]`);
+    }
+
+    return {
+        r: (value >> 16) & 255,
+        g: (value >> 8) & 255,
+        b: (value) & 255
+    }
+}

package/src/core/color/kelvin/kelvin_to_rgb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kelvin_to_rgb.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/kelvin/kelvin_to_rgb.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;GAcG;AACH,sCARW,MAAM,EAAE,iBACR,MAAM,eACN,MAAM,QA6DhB"}
+{"version":3,"file":"kelvin_to_rgb.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/kelvin/kelvin_to_rgb.js"],"names":[],"mappings":"AAiHA;;;;;;;;;;;;;;GAcG;AACH,sCARW,MAAM,EAAE,iBACR,MAAM,eACN,MAAM,QA6DhB"}

package/src/core/color/kelvin/kelvin_to_rgb.js

@@ -4,6 +4,18 @@ import { inverseLerp } from "../../math/inverseLerp.js";
 import { lerp } from "../../math/lerp.js";
 
 
+/**
+ * Below this the red regime emits no blue at all.
+ * @type {number}
+ */
+const BLUE_SEAM_MIN = 20;
+
+/**
+ * Above this the blue fit is used as-is.
+ * @type {number}
+ */
+const BLUE_SEAM_MAX = 21;
+
 /**
  * Red-dominant approximation
  *
@@ -20,8 +32,16 @@ function approximate_regime_red(out, t) {
         -0.6088425710866344 - 0.001748900018414868 * (t - 2) + 0.4097731842899564 * Math.log(t - 2)
     );
 
-    const b = t <= 20 ? 0 : clamp01(
-        -0.9990954974165059 + 0.0032447435545127036 * (t - 10) + 0.453646839257496 * Math.log(t - 10)
+    // The blue fit is gated at t = 20, but it does not reach zero at its own gate — it reaches 0.0779, so
+    // gating it produced a hard step twenty times the 8-bit quantum at exactly 2000 K, and any temperature
+    // ramp through that point banded. Blend the fit in over a short window instead, the same treatment the
+    // 6600 K regime handover already gets below.
+    const b = t <= BLUE_SEAM_MIN ? 0 : lerp(
+        0,
+        clamp01(
+            -0.9990954974165059 + 0.0032447435545127036 * (t - 10) + 0.453646839257496 * Math.log(t - 10)
+        ),
+        clamp01(inverseLerp(BLUE_SEAM_MIN, BLUE_SEAM_MAX, t))
     );
 
     out[0] = r;

package/src/core/color/kelvin/rgb_to_kelvin.d.ts

@@ -1,10 +1,30 @@
 /**
  * Estimates the Color Temperature (Kelvin) from an RGB input.
  *
- * @param {number[]|ArrayLike<number>|{0:number,1:number,2:number}} input input array
+ * Inverts {@link kelvin_to_rgb} numerically, by bisecting on the blue/red ratio. Three limits are worth
+ * knowing before relying on the result:
+ *
+ * - **The usable range is 2000 K to 40000 K, not 1000 K.** {@link kelvin_to_rgb} emits no blue at all below
+ *   2000 K, so the ratio this bisects on is flat across that whole band and the search walks to its lower
+ *   bound. Every input below 2000 K comes back as exactly 1000. Candle-light (~1900 K) and the lower end of
+ *   tungsten sit inside that dead zone; the returned 1000 means "at or below 2000 K", not a measurement.
+ *   Fixing this properly means reading a channel that still varies down there — green does — or replacing
+ *   the solver with a CCT estimator; neither can recover anything below 1000 K, where `kelvin_to_rgb` locks
+ *   the hue and fades brightness, making 800 K and 1000 K the same chromaticity by construction.
+ * - **Green is never read.** Any colour with a matching blue/red ratio returns the same temperature no
+ *   matter how far it sits from the Planckian locus. There is no Duv, and no way to tell that the input was
+ *   not a blackbody at all.
+ * - **Accuracy is ~2% relative** over the usable range, worst around the 6600 K regime handover where blue
+ *   saturates and the ratio flattens. The bisection stops at an `epsilon` of 0.4 K, which is much finer than
+ *   the underlying approximation warrants.
+ *
+ * Exact black is the one input outside the range that answers honestly: it returns 0.
+ *
+ * @param {number[]|ArrayLike<number>|{0:number,1:number,2:number}} input input array, **encoded** sRGB, matching {@link kelvin_to_rgb}'s output
  * @param {number} [input_offset=0] offset into input array
- * @returns {number} Temperature in Kelvin (approx 1000 to 40000)
+ * @returns {number} Temperature in Kelvin, in `[2000, 40000]`; 1000 for any input below 2000 K, 0 for black
  *
+ * @see kelvin_to_rgb
  * @see https://www.zombieprototypes.com/?p=210
  */
 export function rgb_to_kelvin(input: number[] | ArrayLike<number> | {

package/src/core/color/kelvin/rgb_to_kelvin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rgb_to_kelvin.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/kelvin/rgb_to_kelvin.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH,qCANW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iBACvD,MAAM,GACJ,MAAM,CA4DlB"}
+{"version":3,"file":"rgb_to_kelvin.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/kelvin/rgb_to_kelvin.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qCAPW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iBACvD,MAAM,GACJ,MAAM,CA6DlB"}

package/src/core/color/kelvin/rgb_to_kelvin.js

@@ -10,10 +10,30 @@ const scratch_rgb = [];
 /**
  * Estimates the Color Temperature (Kelvin) from an RGB input.
  *
- * @param {number[]|ArrayLike<number>|{0:number,1:number,2:number}} input input array
+ * Inverts {@link kelvin_to_rgb} numerically, by bisecting on the blue/red ratio. Three limits are worth
+ * knowing before relying on the result:
+ *
+ * - **The usable range is 2000 K to 40000 K, not 1000 K.** {@link kelvin_to_rgb} emits no blue at all below
+ *   2000 K, so the ratio this bisects on is flat across that whole band and the search walks to its lower
+ *   bound. Every input below 2000 K comes back as exactly 1000. Candle-light (~1900 K) and the lower end of
+ *   tungsten sit inside that dead zone; the returned 1000 means "at or below 2000 K", not a measurement.
+ *   Fixing this properly means reading a channel that still varies down there — green does — or replacing
+ *   the solver with a CCT estimator; neither can recover anything below 1000 K, where `kelvin_to_rgb` locks
+ *   the hue and fades brightness, making 800 K and 1000 K the same chromaticity by construction.
+ * - **Green is never read.** Any colour with a matching blue/red ratio returns the same temperature no
+ *   matter how far it sits from the Planckian locus. There is no Duv, and no way to tell that the input was
+ *   not a blackbody at all.
+ * - **Accuracy is ~2% relative** over the usable range, worst around the 6600 K regime handover where blue
+ *   saturates and the ratio flattens. The bisection stops at an `epsilon` of 0.4 K, which is much finer than
+ *   the underlying approximation warrants.
+ *
+ * Exact black is the one input outside the range that answers honestly: it returns 0.
+ *
+ * @param {number[]|ArrayLike<number>|{0:number,1:number,2:number}} input input array, **encoded** sRGB, matching {@link kelvin_to_rgb}'s output
  * @param {number} [input_offset=0] offset into input array
- * @returns {number} Temperature in Kelvin (approx 1000 to 40000)
+ * @returns {number} Temperature in Kelvin, in `[2000, 40000]`; 1000 for any input below 2000 K, 0 for black
  *
+ * @see kelvin_to_rgb
  * @see https://www.zombieprototypes.com/?p=210
  */
 export function rgb_to_kelvin(

package/src/core/color/lab/lab_to_xyz.d.ts

@@ -0,0 +1,20 @@
+/**
+ * CIELab to CIE XYZ, against the D65 white point. The inverse of {@link xyz_to_lab}.
+ *
+ * Lab existed here in one direction only, which defeats the main reason to enter it: moving a colour *in*
+ * Lab — nudging lightness, rotating hue, measuring then correcting a difference — and coming back.
+ *
+ * `(100, 0, 0)` maps to the reference white exactly, and `(0, 0, 0)` to black, because both functions read
+ * the same derived {@link D65_TRISTIMULUS_XYZ} rather than a quoted white point.
+ *
+ * @param {number[]|Float32Array|Float64Array} output X, Y, Z
+ * @param {number} output_offset
+ * @param {number[]|Float32Array|Float64Array} input L*, a*, b*
+ * @param {number} input_offset
+ *
+ * @see xyz_to_lab
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function lab_to_xyz(output: number[] | Float32Array | Float64Array, output_offset: number, input: number[] | Float32Array | Float64Array, input_offset: number): void;
+//# sourceMappingURL=lab_to_xyz.d.ts.map

package/src/core/color/lab/lab_to_xyz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lab_to_xyz.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/lab/lab_to_xyz.js"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;;;;;GAiBG;AACH,mCATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,QAkBhB"}

package/src/core/color/lab/lab_to_xyz.js

@@ -0,0 +1,69 @@
+import { D65_TRISTIMULUS_XYZ } from "../illuminant/D65_TRISTIMULUS_XYZ.js";
+
+/**
+ * Breakpoint of the CIELab compression function, `6/29`.
+ * @type {number}
+ */
+const DELTA = 0.20689655172413793103;
+
+/**
+ * Gradient of the linear segment, `1 / (3 * delta^2)`. The inverse divides by it.
+ * @type {number}
+ */
+const LINEAR_GRADIENT = 1 / (3 * DELTA * DELTA);
+
+/**
+ * Intercept of the linear segment, `4/29`.
+ * @type {number}
+ */
+const LINEAR_INTERCEPT = 0.13793103448275862069;
+
+/**
+ * Inverse of `xyz_to_lab`'s compression.
+ *
+ * The branch is on the *compressed* value against `DELTA` rather than on the raw one against `DELTA` cubed,
+ * which is the same breakpoint read from the other side — writing it as `t > DELTA` is what makes the two
+ * functions visibly meet at the same place.
+ *
+ * @param {number} t
+ * @returns {number}
+ */
+function expand(t) {
+    if (t > DELTA) {
+        return t * t * t;
+    } else {
+        return (t - LINEAR_INTERCEPT) / LINEAR_GRADIENT;
+    }
+}
+
+/**
+ * CIELab to CIE XYZ, against the D65 white point. The inverse of {@link xyz_to_lab}.
+ *
+ * Lab existed here in one direction only, which defeats the main reason to enter it: moving a colour *in*
+ * Lab — nudging lightness, rotating hue, measuring then correcting a difference — and coming back.
+ *
+ * `(100, 0, 0)` maps to the reference white exactly, and `(0, 0, 0)` to black, because both functions read
+ * the same derived {@link D65_TRISTIMULUS_XYZ} rather than a quoted white point.
+ *
+ * @param {number[]|Float32Array|Float64Array} output X, Y, Z
+ * @param {number} output_offset
+ * @param {number[]|Float32Array|Float64Array} input L*, a*, b*
+ * @param {number} input_offset
+ *
+ * @see xyz_to_lab
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function lab_to_xyz(output, output_offset, input, input_offset) {
+    const L = input[input_offset];
+    const a = input[input_offset + 1];
+    const b = input[input_offset + 2];
+
+    const y = (L + 16) / 116;
+    const x = y + a / 500;
+    const z = y - b / 200;
+
+    output[output_offset] = expand(x) * D65_TRISTIMULUS_XYZ[0];
+    output[output_offset + 1] = expand(y) * D65_TRISTIMULUS_XYZ[1];
+    output[output_offset + 2] = expand(z) * D65_TRISTIMULUS_XYZ[2];
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Clip an out-of-gamut linear sRGB colour toward an `L0` chosen per colour, between its own lightness and
+ * mid-grey.
+ *
+ * The compromise between the other two. A colour only slightly outside the gamut is projected at nearly its
+ * own lightness, so nothing shifts visibly; one far outside is projected closer to 0.5, where the gamut is
+ * wide enough to keep some chroma. `alpha` sets how quickly it slides between the two, scaled by chroma —
+ * which is why a barely-out-of-gamut colour is left almost alone.
+ *
+ * This is usually the one to reach for when clipping a whole image, because it degrades gracefully instead of
+ * choosing a single failure mode for every pixel.
+ *
+ * @param {number[]|ArrayLike<number>} output length >= 3, receives linear sRGB in `[0, 1]`
+ * @param {number} r linear sRGB
+ * @param {number} g linear sRGB
+ * @param {number} b linear sRGB
+ * @param {number} [alpha] see {@link GAMUT_CLIP_DEFAULT_ALPHA}
+ * @returns {number[]|ArrayLike<number>} output
+ *
+ * @see https://bottosson.github.io/posts/gamutclipping/
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function gamut_clip_adaptive_l0(output: number[] | ArrayLike<number>, r: number, g: number, b: number, alpha?: number): number[] | ArrayLike<number>;
+/**
+ * How much the projection target is allowed to slide toward mid-grey per unit of chroma.
+ *
+ * Ottosson's default. Larger values behave more like {@link gamut_clip_project_to_lcusp}, smaller ones more
+ * like {@link gamut_clip_preserve_chroma}.
+ *
+ * @type {number}
+ */
+export const GAMUT_CLIP_DEFAULT_ALPHA: number;
+//# sourceMappingURL=gamut_clip_adaptive_l0.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gamut_clip_adaptive_l0.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/oklab/gamut_clip_adaptive_l0.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAXW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,KAC1B,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,CAgBtC;AA3CD;;;;;;;GAOG;AACH,uCAFU,MAAM,CAE6B"}

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

@@ -0,0 +1,46 @@
+import { gamut_clip_at_l0 } from "./gamut_clip_at_l0.js";
+
+/**
+ * How much the projection target is allowed to slide toward mid-grey per unit of chroma.
+ *
+ * Ottosson's default. Larger values behave more like {@link gamut_clip_project_to_lcusp}, smaller ones more
+ * like {@link gamut_clip_preserve_chroma}.
+ *
+ * @type {number}
+ */
+export const GAMUT_CLIP_DEFAULT_ALPHA = 0.05;
+
+/**
+ * Clip an out-of-gamut linear sRGB colour toward an `L0` chosen per colour, between its own lightness and
+ * mid-grey.
+ *
+ * The compromise between the other two. A colour only slightly outside the gamut is projected at nearly its
+ * own lightness, so nothing shifts visibly; one far outside is projected closer to 0.5, where the gamut is
+ * wide enough to keep some chroma. `alpha` sets how quickly it slides between the two, scaled by chroma —
+ * which is why a barely-out-of-gamut colour is left almost alone.
+ *
+ * This is usually the one to reach for when clipping a whole image, because it degrades gracefully instead of
+ * choosing a single failure mode for every pixel.
+ *
+ * @param {number[]|ArrayLike<number>} output length >= 3, receives linear sRGB in `[0, 1]`
+ * @param {number} r linear sRGB
+ * @param {number} g linear sRGB
+ * @param {number} b linear sRGB
+ * @param {number} [alpha] see {@link GAMUT_CLIP_DEFAULT_ALPHA}
+ * @returns {number[]|ArrayLike<number>} output
+ *
+ * @see https://bottosson.github.io/posts/gamutclipping/
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function gamut_clip_adaptive_l0(output, r, g, b, alpha = GAMUT_CLIP_DEFAULT_ALPHA) {
+
+    return gamut_clip_at_l0(output, r, g, b, (L, C) => {
+
+        const Ld = L - 0.5;
+
+        const e = 0.5 + Math.abs(Ld) + alpha * C;
+
+        return 0.5 * (1 + Math.sign(Ld) * (e - Math.sqrt(e * e - 2 * Math.abs(Ld))));
+    });
+}