@woosh/meep-engine 3.8.0 → 3.10.0

package/src/avif/native/color/YuvImage.js

@@ -0,0 +1,66 @@
+/**
+ * A decoded image, as the AV1 layer produces it and the colour layer consumes it.
+ *
+ * Deliberately a description rather than an owner: the plane arrays belong to whoever allocated
+ * them, usually a frame context that reuses them across decodes. Nothing here copies samples, which
+ * is what lets a grid of tiles, an alpha channel and the colour conversion all talk about the same
+ * memory.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class YuvImage {
+    /** @type {Uint16Array[]} Y, Cb, Cr — or G, B, R when the matrix is the identity */
+    planes = [null, null, null];
+
+    /** @type {Int32Array} distance between rows of each plane, in samples */
+    stride = new Int32Array(3);
+
+    /** @type {number} */
+    width = 0;
+
+    /** @type {number} */
+    height = 0;
+
+    /** @type {number} `8`, `10` or `12` */
+    bit_depth = 8;
+
+    /** @type {number} */
+    subsampling_x = 0;
+
+    /** @type {number} */
+    subsampling_y = 0;
+
+    /** @type {number} `1` for monochrome */
+    num_planes = 1;
+
+    /** @type {number} a `CP_*` code */
+    color_primaries = 2;
+
+    /** @type {number} a `TC_*` code */
+    transfer_characteristics = 2;
+
+    /** @type {number} an `MC_*` code */
+    matrix_coefficients = 2;
+
+    /** @type {number} `1` when the samples use the full range of the bit depth */
+    color_range = 0;
+
+    /** @type {Uint16Array|null} the alpha plane, which AVIF codes as a separate monochrome image */
+    alpha = null;
+
+    /** @type {number} */
+    alpha_stride = 0;
+
+    /** @type {number} */
+    alpha_bit_depth = 8;
+
+    /** @type {number} */
+    alpha_range = 1;
+
+    /**
+     * @type {number} `1` when the colour channels have already been multiplied by alpha
+     * @see ISO/IEC 23000-22 `prem` item reference
+     */
+    alpha_premultiplied = 0;
+}

package/src/avif/native/color/clamp_sample.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Round a value to the nearest integer sample and hold it inside `0 .. maximum`.
+ *
+ * The last step of every path that turns arithmetic back into coded samples, on both sides of the
+ * codec: chroma that was averaged across a subsampling window on the way in, and colour that came
+ * out of the transform on the way out. Lossy coding and floating point both produce values a little
+ * outside the range the depth can express, and a wrapped sample is a wrong pixel of the opposite
+ * brightness rather than a slightly clipped one.
+ *
+ * @param {number} value already in sample units, not normalised
+ * @param {number} maximum largest representable sample, `(1 << bit_depth) - 1`
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function clamp_sample(value: number, maximum: number): number;
+//# sourceMappingURL=clamp_sample.d.ts.map

package/src/avif/native/color/clamp_sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp_sample.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/clamp_sample.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,oCAPW,MAAM,WACN,MAAM,GACJ,MAAM,CAalB"}

package/src/avif/native/color/clamp_sample.js

@@ -0,0 +1,25 @@
+/**
+ * Round a value to the nearest integer sample and hold it inside `0 .. maximum`.
+ *
+ * The last step of every path that turns arithmetic back into coded samples, on both sides of the
+ * codec: chroma that was averaged across a subsampling window on the way in, and colour that came
+ * out of the transform on the way out. Lossy coding and floating point both produce values a little
+ * outside the range the depth can express, and a wrapped sample is a wrong pixel of the opposite
+ * brightness rather than a slightly clipped one.
+ *
+ * @param {number} value already in sample units, not normalised
+ * @param {number} maximum largest representable sample, `(1 << bit_depth) - 1`
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function clamp_sample(value, maximum) {
+    const rounded = Math.round(value);
+
+    if (rounded < 0) {
+        return 0;
+    }
+
+    return rounded > maximum ? maximum : rounded;
+}

package/src/avif/native/color/linear_to_transfer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Encode linear light as a signal value.
+ *
+ * The inverse of {@link transfer_to_linear}, in the same normalisation: `1.0` of linear light is
+ * {@link LINEAR_REFERENCE_NITS}.
+ *
+ * @param {number} transfer_characteristics a `TC_*` code
+ * @param {number} value linear light
+ * @returns {number} signal, `0 .. 1`
+ * @see ITU-T H.273 table 3 "Transfer characteristics"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function linear_to_transfer(transfer_characteristics: number, value: number): number;
+/**
+ * Encode a row of interleaved linear RGB as signal values, in place.
+ *
+ * @param {number} transfer_characteristics
+ * @param {Float32Array} row interleaved, `width * 3` long
+ * @param {number} width
+ */
+export function transfer_row_from_linear(transfer_characteristics: number, row: Float32Array, width: number): void;
+//# sourceMappingURL=linear_to_transfer.d.ts.map

package/src/avif/native/color/linear_to_transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear_to_transfer.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/linear_to_transfer.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;GAaG;AACH,6DARW,MAAM,SACN,MAAM,GACJ,MAAM,CA4ClB;AAED;;;;;;GAMG;AACH,mEAJW,MAAM,OACN,YAAY,SACZ,MAAM,QA0BhB"}

package/src/avif/native/color/linear_to_transfer.js

@@ -0,0 +1,126 @@
+import { HLG_PEAK_NITS, LINEAR_REFERENCE_NITS } from "./transfer_to_linear.js";
+import { PQ_MAX_NITS } from "../../../core/color/PQ/PQ_constants.js";
+import {
+    TC_BT_470_B_G,
+    TC_BT_470_M,
+    TC_HLG,
+    TC_IEC_61966,
+    TC_LINEAR,
+    TC_SMPTE_2084,
+    TC_SMPTE_240,
+    TC_SMPTE_428,
+    TC_SRGB
+} from "../av1/tables/av1_symbols.js";
+import { convert_channel_linear_to_sRGB } from "../../../core/color/sRGB/linear_to_sRGB.js";
+import { linear_to_PQ } from "../../../core/color/PQ/linear_to_PQ.js";
+
+/** @type {number} */
+const HLG_A = 0.17883277;
+
+/** @type {number} */
+const HLG_B = 1 - 4 * HLG_A;
+
+/** @type {number} */
+const HLG_C = 0.5 - HLG_A * Math.log(4 * HLG_A);
+
+/**
+ * Encode linear light as a signal value.
+ *
+ * The inverse of {@link transfer_to_linear}, in the same normalisation: `1.0` of linear light is
+ * {@link LINEAR_REFERENCE_NITS}.
+ *
+ * @param {number} transfer_characteristics a `TC_*` code
+ * @param {number} value linear light
+ * @returns {number} signal, `0 .. 1`
+ * @see ITU-T H.273 table 3 "Transfer characteristics"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function linear_to_transfer(transfer_characteristics, value) {
+    const light = value < 0 ? 0 : value;
+
+    switch (transfer_characteristics) {
+        case TC_SMPTE_2084:
+            return linear_to_PQ(Math.min(light * (LINEAR_REFERENCE_NITS / PQ_MAX_NITS), 1));
+
+        case TC_HLG:
+            return scene_linear_to_hlg(Math.min(light * (LINEAR_REFERENCE_NITS / HLG_PEAK_NITS), 1));
+
+        case TC_LINEAR:
+            return Math.min(light, 1);
+
+        case TC_SRGB:
+        case TC_IEC_61966:
+            return convert_channel_linear_to_sRGB(Math.min(light, 1));
+
+        case TC_BT_470_M:
+            return Math.pow(Math.min(light, 1), 1 / 2.2);
+
+        case TC_BT_470_B_G:
+            return Math.pow(Math.min(light, 1), 1 / 2.8);
+
+        case TC_SMPTE_428:
+            return Math.pow(Math.min(light * (48.0 / 52.37), 1), 1 / 2.6);
+
+        case TC_SMPTE_240: {
+            const clipped = Math.min(light, 1);
+
+            return clipped < 0.0228 ? clipped * 4.0 : 1.1115 * Math.pow(clipped, 0.45) - 0.1115;
+        }
+
+        default: {
+            const clipped = Math.min(light, 1);
+
+            return clipped < 0.018 ? clipped * 4.5 : 1.099 * Math.pow(clipped, 0.45) - 0.099;
+        }
+    }
+}
+
+/**
+ * Encode a row of interleaved linear RGB as signal values, in place.
+ *
+ * @param {number} transfer_characteristics
+ * @param {Float32Array} row interleaved, `width * 3` long
+ * @param {number} width
+ */
+export function transfer_row_from_linear(transfer_characteristics, row, width) {
+    const count = width * 3;
+
+    if (transfer_characteristics === TC_HLG) {
+        // undo the opto-optical transfer function before the per channel curve, since it is what
+        // took the picture from scene to display referred in the first place
+        const scale = LINEAR_REFERENCE_NITS / HLG_PEAK_NITS;
+
+        for (let i = 0; i < count; i += 3) {
+            const luminance = (0.2627 * row[i] + 0.6780 * row[i + 1] + 0.0593 * row[i + 2]) * scale;
+
+            const gain = luminance <= 0 ? 0 : Math.pow(luminance, -0.2 / 1.2);
+
+            for (let c = 0; c < 3; c++) {
+                row[i + c] = scene_linear_to_hlg(Math.min(Math.max(row[i + c] * scale * gain, 0), 1));
+            }
+        }
+
+        return;
+    }
+
+    for (let i = 0; i < count; i++) {
+        row[i] = linear_to_transfer(transfer_characteristics, row[i]);
+    }
+}
+
+/**
+ * Hybrid log-gamma's opto-electronic transfer function.
+ *
+ * @param {number} scene scene linear, `0 .. 1`
+ * @returns {number}
+ * @see ITU-R BT.2100 table 5
+ */
+function scene_linear_to_hlg(scene) {
+    if (scene <= 1 / 12) {
+        return Math.sqrt(3 * scene);
+    }
+
+    return HLG_A * Math.log(12 * scene - HLG_B) + HLG_C;
+}

package/src/avif/native/color/primaries.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The chromaticities a primaries code stands for, or those of BT.709 when it names none.
+ *
+ * @param {number} color_primaries a `CP_*` code
+ * @returns {number[]} `[rx, ry, gx, gy, bx, by, wx, wy]`
+ */
+export function primaries_chromaticity(color_primaries: number): number[];
+/**
+ * Derive the luma coefficients a set of primaries implies.
+ *
+ * This is what `MC_CHROMAT_NCL` means: rather than name a matrix, the bitstream says "the one these
+ * primaries imply", and the decoder works it out. The result is the relative luminance of each
+ * primary under the white point, which is the same quantity BT.709 and BT.2020 tabulate.
+ *
+ * @param {number} color_primaries
+ * @param {Float64Array} out `[kr, kg, kb]`
+ * @see ITU-T H.273 section 8.3, equations 38 to 43
+ */
+export function derive_luma_coefficients(color_primaries: number, out: Float64Array): void;
+//# sourceMappingURL=primaries.d.ts.map

package/src/avif/native/color/primaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primaries.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/primaries.js"],"names":[],"mappings":"AAwCA;;;;;GAKG;AACH,wDAHW,MAAM,GACJ,MAAM,EAAE,CAUpB;AAED;;;;;;;;;;GAUG;AACH,0DAJW,MAAM,OACN,YAAY,QA6BtB"}

package/src/avif/native/color/primaries.js

@@ -0,0 +1,94 @@
+import {
+    CP_BT_2020,
+    CP_BT_470_B_G,
+    CP_BT_470_M,
+    CP_BT_601,
+    CP_BT_709,
+    CP_EBU_3213,
+    CP_GENERIC_FILM,
+    CP_SMPTE_240,
+    CP_SMPTE_431,
+    CP_SMPTE_432,
+    CP_XYZ
+} from "../av1/tables/av1_symbols.js";
+
+/**
+ * Chromaticities of every colour primaries code, as `[rx, ry, gx, gy, bx, by, wx, wy]`.
+ *
+ * Kept as one flat table rather than a map of objects: the lookup happens once per image, and a
+ * table is easier to check against the standard than eight named fields per entry.
+ *
+ * @type {Map<number, number[]>}
+ * @see ITU-T H.273 table 2 "Colour primaries"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+const CHROMATICITIES = new Map([
+    [CP_BT_709, [0.640, 0.330, 0.300, 0.600, 0.150, 0.060, 0.3127, 0.3290]],
+    [CP_BT_470_M, [0.670, 0.330, 0.210, 0.710, 0.140, 0.080, 0.3100, 0.3160]],
+    [CP_BT_470_B_G, [0.640, 0.330, 0.290, 0.600, 0.150, 0.060, 0.3127, 0.3290]],
+    [CP_BT_601, [0.630, 0.340, 0.310, 0.595, 0.155, 0.070, 0.3127, 0.3290]],
+    [CP_SMPTE_240, [0.630, 0.340, 0.310, 0.595, 0.155, 0.070, 0.3127, 0.3290]],
+    [CP_GENERIC_FILM, [0.681, 0.319, 0.243, 0.692, 0.145, 0.049, 0.3100, 0.3160]],
+    [CP_BT_2020, [0.708, 0.292, 0.170, 0.797, 0.131, 0.046, 0.3127, 0.3290]],
+    [CP_XYZ, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1 / 3, 1 / 3]],
+    [CP_SMPTE_431, [0.680, 0.320, 0.265, 0.690, 0.150, 0.060, 0.3140, 0.3510]],
+    [CP_SMPTE_432, [0.680, 0.320, 0.265, 0.690, 0.150, 0.060, 0.3127, 0.3290]],
+    [CP_EBU_3213, [0.630, 0.340, 0.295, 0.605, 0.155, 0.077, 0.3127, 0.3290]]
+]);
+
+/**
+ * The chromaticities a primaries code stands for, or those of BT.709 when it names none.
+ *
+ * @param {number} color_primaries a `CP_*` code
+ * @returns {number[]} `[rx, ry, gx, gy, bx, by, wx, wy]`
+ */
+export function primaries_chromaticity(color_primaries) {
+    const found = CHROMATICITIES.get(color_primaries);
+
+    if (found !== undefined) {
+        return found;
+    }
+
+    return CHROMATICITIES.get(CP_BT_709);
+}
+
+/**
+ * Derive the luma coefficients a set of primaries implies.
+ *
+ * This is what `MC_CHROMAT_NCL` means: rather than name a matrix, the bitstream says "the one these
+ * primaries imply", and the decoder works it out. The result is the relative luminance of each
+ * primary under the white point, which is the same quantity BT.709 and BT.2020 tabulate.
+ *
+ * @param {number} color_primaries
+ * @param {Float64Array} out `[kr, kg, kb]`
+ * @see ITU-T H.273 section 8.3, equations 38 to 43
+ */
+export function derive_luma_coefficients(color_primaries, out) {
+    const c = primaries_chromaticity(color_primaries);
+
+    const rx = c[0];
+    const ry = c[1];
+    const gx = c[2];
+    const gy = c[3];
+    const bx = c[4];
+    const by = c[5];
+    const wx = c[6];
+    const wy = c[7];
+
+    const rz = 1 - rx - ry;
+    const gz = 1 - gx - gy;
+    const bz = 1 - bx - by;
+    const wz = 1 - wx - wy;
+
+    const kr = (ry * (wx * (gy * bz - by * gz) + wy * (bx * gz - gx * bz) + wz * (gx * by - bx * gy)))
+        / (wy * (rx * (gy * bz - by * gz) + ry * (bx * gz - gx * bz) + rz * (gx * by - bx * gy)));
+
+    const kb = (by * (wx * (ry * gz - gy * rz) + wy * (gx * rz - rx * gz) + wz * (rx * gy - gx * ry)))
+        / (wy * (bx * (ry * gz - gy * rz) + by * (gx * rz - rx * gz) + bz * (rx * gy - gx * ry)));
+
+    out[0] = kr;
+    out[1] = 1 - kr - kb;
+    out[2] = kb;
+}

package/src/avif/native/color/rgb_row_to_ycbcr.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Convert one row of normalised R, G and B to coded samples.
+ *
+ * The inverse of {@link ycbcr_row_to_rgb}, and derived from the same transform struct — the forward
+ * matrix is recovered from the inverse's coefficients rather than tabulated a second time, so the
+ * two cannot disagree about what a matrix is.
+ *
+ * @param {ColourTransform} transform
+ * @param {Float32Array} rgb interleaved, `width * 3` long, `0 .. 1`
+ * @param {number} width
+ * @param {Uint16Array} luma
+ * @param {number} luma_offset
+ * @param {Float32Array} cb full width, in sample units
+ * @param {Float32Array} cr
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function rgb_row_to_ycbcr(transform: ColourTransform, rgb: Float32Array, width: number, luma: Uint16Array, luma_offset: number, cb: Float32Array, cr: Float32Array): void;
+//# sourceMappingURL=rgb_row_to_ycbcr.d.ts.map

package/src/avif/native/color/rgb_row_to_ycbcr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgb_row_to_ycbcr.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/rgb_row_to_ycbcr.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,kEAVW,YAAY,SACZ,MAAM,QACN,WAAW,eACX,MAAM,MACN,YAAY,MACZ,YAAY,QA8DtB"}

package/src/avif/native/color/rgb_row_to_ycbcr.js

@@ -0,0 +1,78 @@
+import { CONVERSION_IDENTITY, CONVERSION_YCGCO } from "./ColourTransform.js";
+
+/**
+ * Convert one row of normalised R, G and B to coded samples.
+ *
+ * The inverse of {@link ycbcr_row_to_rgb}, and derived from the same transform struct — the forward
+ * matrix is recovered from the inverse's coefficients rather than tabulated a second time, so the
+ * two cannot disagree about what a matrix is.
+ *
+ * @param {ColourTransform} transform
+ * @param {Float32Array} rgb interleaved, `width * 3` long, `0 .. 1`
+ * @param {number} width
+ * @param {Uint16Array} luma
+ * @param {number} luma_offset
+ * @param {Float32Array} cb full width, in sample units
+ * @param {Float32Array} cr
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function rgb_row_to_ycbcr(transform, rgb, width, luma, luma_offset, cb, cr) {
+    const y_offset = transform.y_offset;
+    const c_offset = transform.c_offset;
+
+    const y_range = 1 / transform.y_scale;
+    const c_range = 1 / transform.c_scale;
+
+    if (transform.kind === CONVERSION_IDENTITY) {
+        for (let x = 0; x < width; x++) {
+            const i = x * 3;
+
+            luma[luma_offset + x] = Math.round(rgb[i + 1] * y_range + y_offset);
+            cb[x] = Math.round(rgb[i + 2] * y_range + y_offset);
+            cr[x] = Math.round(rgb[i] * y_range + y_offset);
+        }
+
+        return;
+    }
+
+    if (transform.kind === CONVERSION_YCGCO) {
+        for (let x = 0; x < width; x++) {
+            const i = x * 3;
+
+            const r = rgb[i];
+            const g = rgb[i + 1];
+            const b = rgb[i + 2];
+
+            luma[luma_offset + x] = Math.round((0.25 * r + 0.5 * g + 0.25 * b) * y_range + y_offset);
+            cb[x] = Math.round((-0.25 * r + 0.5 * g - 0.25 * b) * c_range + c_offset);
+            cr[x] = Math.round((0.5 * r - 0.5 * b) * c_range + c_offset);
+        }
+
+        return;
+    }
+
+    // the inverse applies R = Y + a*Cr and B = Y + b*Cb, so the luma coefficients are recoverable
+    // from a and b alone: kr = 1 - a/2, kb = 1 - b/2
+    const kr = 1 - transform.cr_to_r / 2;
+    const kb = 1 - transform.cb_to_b / 2;
+    const kg = 1 - kr - kb;
+
+    const to_cb = 1 / transform.cb_to_b;
+    const to_cr = 1 / transform.cr_to_r;
+
+    for (let x = 0; x < width; x++) {
+        const i = x * 3;
+
+        const r = rgb[i];
+        const g = rgb[i + 1];
+        const b = rgb[i + 2];
+
+        const y = kr * r + kg * g + kb * b;
+
+        luma[luma_offset + x] = Math.round(y * y_range + y_offset);
+        cb[x] = Math.round((b - y) * to_cb * c_range + c_offset);
+        cr[x] = Math.round((r - y) * to_cr * c_range + c_offset);
+    }
+}

package/src/avif/native/color/transfer_to_linear.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Decode one signal value to linear light.
+ *
+ * HLG is the exception: what comes back is *scene* linear, because its opto-optical transfer
+ * function is a function of the picture's luminance rather than of one channel. Completing it is
+ * {@link transfer_row_to_linear}'s job, which is why nothing should call this directly for HLG.
+ *
+ * @param {number} transfer_characteristics a `TC_*` code
+ * @param {number} value signal, `0 .. 1`
+ * @returns {number} linear light, `1.0` being {@link LINEAR_REFERENCE_NITS}
+ * @see ITU-T H.273 table 3 "Transfer characteristics"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function transfer_to_linear(transfer_characteristics: number, value: number): number;
+/**
+ * Decode a row of interleaved RGB to linear light, in place.
+ *
+ * @param {number} transfer_characteristics a `TC_*` code
+ * @param {Float32Array} row interleaved, `width * 3` long
+ * @param {number} width
+ */
+export function transfer_row_to_linear(transfer_characteristics: number, row: Float32Array, width: number): void;
+/**
+ * Luminance that a linear value of `1.0` stands for, in nits.
+ *
+ * Every transfer function here decodes to this normalisation, so that SDR content lands at `1.0`
+ * whatever curve carried it and HDR content simply goes above it.
+ *
+ * A hundred rather than the engine's 203 deliberately, and it is not a renderer setting. The SDR
+ * curves in H.273 table 3 — BT.709, sRGB, gamma 2.2, gamma 2.8 — are defined against a hundred nit
+ * reference display, so signal `1.0` decoding to linear `1.0` is their own fixed point rather than
+ * a convention this file picks. Setting it to `SDR_WHITE_NITS` would land sRGB white at 0.4926 and
+ * make this module a statement about meep instead of a statement about the standard.
+ *
+ * 203 nits is a rendering convention (BT.2408 graphics white on an HDR display), so it lives on the
+ * renderer's side of the boundary: `sampler2d_to_avif` and `avif_to_sampler2d` each name their
+ * white to the codec through `linear_reference_nits`, and that is where the two meet.
+ * @type {number}
+ */
+export const LINEAR_REFERENCE_NITS: number;
+/**
+ * Peak luminance an HLG signal is decoded against, in nits. The curve carries no absolute luminance
+ * of its own, and this is the reference display ITU-R BT.2100 defines its system gamma on.
+ * @type {number}
+ */
+export const HLG_PEAK_NITS: number;
+//# sourceMappingURL=transfer_to_linear.d.ts.map

package/src/avif/native/color/transfer_to_linear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer_to_linear.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/transfer_to_linear.js"],"names":[],"mappings":"AAyDA;;;;;;;;;;;;;;GAcG;AACH,6DARW,MAAM,SACN,MAAM,GACJ,MAAM,CAmDlB;AAED;;;;;;GAMG;AACH,iEAJW,MAAM,OACN,YAAY,SACZ,MAAM,QA+BhB;AArID;;;;;;;;;;;;;;;;GAgBG;AACH,oCAFU,MAAM,CAEyB;AAEzC;;;;GAIG;AACH,4BAFU,MAAM,CAEkB"}