@woosh/meep-engine 3.63.3 → 3.64.1

package/src/format/image/exr/exr_read.js

@@ -0,0 +1,531 @@
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+import { decompress_bytes_into } from "../../../core/binary/compression/decompress_bytes_into.js";
+import { deflate_decompress_bound } from "../../../core/binary/compression/deflate_decompress_bound.js";
+import { EndianType } from "../../../core/binary/EndianType.js";
+import { utf8_decode } from "../../../core/binary/utf8/utf8_decode.js";
+import {
+    EXR_FLAG_LONG_NAMES,
+    EXR_FLAG_MULTI_PART,
+    EXR_FLAG_NON_IMAGE,
+    EXR_FLAG_TILED,
+    EXR_LONG_NAME_BYTES,
+    EXR_MAGIC,
+    EXR_VERSION
+} from "./exr_constants.js";
+import { exr_compare_names } from "./exr_compare_names.js";
+import { exr_sample_bits } from "./exr_sample_bits.js";
+import { exr_scanlines_per_chunk } from "./exr_scanlines_per_chunk.js";
+import { ExrCompression } from "./ExrCompression.js";
+import { ExrPixelType } from "./ExrPixelType.js";
+
+/**
+ * Read a scanline OpenEXR file.
+ *
+ * **What it reads**: a single-part scanline image with full-resolution channels, compressed with
+ * {@link ExrCompression.None}, {@link ExrCompression.ZIPS} or {@link ExrCompression.ZIP}, in any of
+ * OpenEXR's three pixel types, mixed freely between channels. Samples come back as they are stored — a
+ * HALF channel is a `Float16Array` holding the file's exact bits — so reading converts nothing. Chunks are
+ * found through the offset table, so the file's line order does not matter.
+ *
+ * Of the header, only what decoding depends on is read: the channel list, the compression method and the
+ * data window. OpenEXR requires five more attributes — display window, line order, pixel aspect ratio,
+ * screen window centre and width — and its own reader fills in a default for any a file leaves out;
+ * nothing here would use them, so they are skipped like every other attribute.
+ *
+ * **What it refuses**, by name: tiled, multi-part and deep files; every other compression method;
+ * subsampled channels; a header without the channel list, compression or data window, or with one of
+ * them of the wrong type; and a file whose chunks do not add up — an offset outside the file, a chunk
+ * holding other scanlines than its place in the table says, a chunk whose stored or inflated size
+ * disagrees with the scanlines it holds. Every chunk is checked before anything is allocated for the
+ * pixels — against its place, its scanline, and what deflate could inflate its stored bytes to — so a file
+ * cannot claim more pixel data than its own chunks could hold.
+ *
+ * @param {ArrayBuffer} bytes the whole file; keep unchanged until the promise settles
+ * @returns {Promise<ExrImage>}
+ * @throws {Error} naming what is unsupported or malformed
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export async function exr_read(bytes) {
+    const buffer = BinaryBuffer.fromArrayBuffer(bytes);
+
+    // OpenEXR is little-endian throughout
+    buffer.endianness = EndianType.LittleEndian;
+
+    const file_bytes = bytes.byteLength;
+
+    if (file_bytes < 8 || buffer.readUint32() !== EXR_MAGIC) {
+        throw new Error("EXR: not an OpenEXR file");
+    }
+
+    read_version(buffer);
+
+    const header = read_header(buffer);
+
+    const width = header.x_max - header.x_min + 1;
+    const height = header.y_max - header.y_min + 1;
+
+    if (width < 1 || height < 1) {
+        throw new Error(`EXR: the data window is ${width}x${height}`);
+    }
+
+    const scanlines_per_chunk = exr_scanlines_per_chunk(header.compression);
+
+    const deflated = header.compression !== ExrCompression.None;
+
+    const channels = header.channels;
+    const channel_count = channels.length;
+
+    let pixel_bytes = 0;
+
+    for (let c = 0; c < channel_count; c++) {
+        pixel_bytes += channels[c].pixel_type === ExrPixelType.HALF ? 2 : 4;
+    }
+
+    const line_bytes = width * pixel_bytes;
+
+    // the header is a claim; refuse one that no file of this length could back before allocating for it
+    const file_capacity = deflated ? deflate_decompress_bound(file_bytes) : file_bytes;
+
+    if (line_bytes * height > file_capacity) {
+        throw new Error(
+            `EXR: the header claims a ${width}x${height} image of ${pixel_bytes} bytes a pixel,`
+            + ` which a ${file_bytes} byte file cannot hold`
+        );
+    }
+
+    const chunk_count = Math.ceil(height / scanlines_per_chunk);
+
+    const table_offset = buffer.position;
+    const pixel_data_offset = table_offset + chunk_count * 8;
+
+    if (pixel_data_offset > file_bytes) {
+        throw new Error(`EXR: the file ends inside its offset table of ${chunk_count} chunks`);
+    }
+
+    /**
+     * Seek to a chunk's pixel data, refusing a chunk outside the file, holding other scanlines than its
+     * place in the table says, or of a stored size its scanlines rule out — too small among them, when
+     * deflate could not inflate it to them.
+     *
+     * @param {number} i
+     * @returns {number} the chunk's stored size
+     */
+    const seek_chunk = (i) => {
+        const first_line = i * scanlines_per_chunk;
+        const unpacked_size = Math.min(scanlines_per_chunk, height - first_line) * line_bytes;
+
+        buffer.position = table_offset + i * 8;
+
+        const offset = Number(buffer.readUint64());
+
+        if (offset < pixel_data_offset || offset > file_bytes - 8) {
+            throw new Error(`EXR: chunk ${i} is at offset ${offset}, outside the file's pixel data`);
+        }
+
+        buffer.position = offset;
+
+        const y = buffer.readInt32();
+        const packed_size = buffer.readInt32();
+
+        if (y !== header.y_min + first_line) {
+            throw new Error(`EXR: chunk ${i} holds scanline ${y}, where scanline ${header.y_min + first_line} belongs`);
+        }
+
+        if (packed_size < 0 || packed_size > file_bytes - buffer.position) {
+            throw new Error(`EXR: chunk ${i} claims ${packed_size} bytes, past the end of the file`);
+        }
+
+        if (packed_size > unpacked_size || (!deflated && packed_size !== unpacked_size)) {
+            throw new Error(`EXR: chunk ${i} is ${packed_size} bytes, but its scanlines are ${unpacked_size}`);
+        }
+
+        if (packed_size < unpacked_size && unpacked_size > deflate_decompress_bound(packed_size)) {
+            throw new Error(
+                `EXR: chunk ${i} is ${packed_size} bytes, which cannot inflate to the ${unpacked_size} bytes of its scanlines`
+            );
+        }
+
+        return packed_size;
+    };
+
+    // every chunk is checked before anything is allocated for the pixels or any chunk is inflated, so
+    // what is allocated is bounded by what the chunks themselves could inflate to
+    for (let i = 0; i < chunk_count; i++) {
+        seek_chunk(i);
+    }
+
+    const planes = new Array(channel_count);
+    const plane_bits = new Array(channel_count);
+
+    for (let c = 0; c < channel_count; c++) {
+        planes[c] = create_plane(channels[c].pixel_type, width * height);
+        plane_bits[c] = exr_sample_bits(planes[c]);
+    }
+
+    const chunk_bytes = Math.min(scanlines_per_chunk, height) * line_bytes;
+
+    const inflated = deflated ? new Uint8Array(chunk_bytes) : null;
+    const reconstructed = deflated ? BinaryBuffer.fromArrayBuffer(new ArrayBuffer(chunk_bytes)) : null;
+
+    if (deflated) {
+        reconstructed.endianness = EndianType.LittleEndian;
+    }
+
+    for (let i = 0; i < chunk_count; i++) {
+        const packed_size = seek_chunk(i);
+
+        const first_line = i * scanlines_per_chunk;
+        const line_count = Math.min(scanlines_per_chunk, height - first_line);
+        const unpacked_size = line_count * line_bytes;
+
+        let source = buffer;
+
+        if (packed_size < unpacked_size) {
+            let written;
+
+            try {
+                written = await decompress_bytes_into(
+                    inflated, 0, unpacked_size,
+                    [new Uint8Array(bytes, buffer.position, packed_size)],
+                    "deflate"
+                );
+            } catch (error) {
+                // the platform's stream errors can carry their reason only in the cause
+                throw new Error(
+                    `EXR: chunk ${i} does not inflate: ${error?.message || error?.cause?.message || "not a zlib stream"}`,
+                    { cause: error }
+                );
+            }
+
+            if (written !== unpacked_size) {
+                throw new Error(`EXR: chunk ${i} inflates to ${written} bytes, but its scanlines are ${unpacked_size}`);
+            }
+
+            zip_reconstruct(inflated, reconstructed.raw_bytes, unpacked_size);
+
+            reconstructed.position = 0;
+
+            source = reconstructed;
+        }
+
+        // a chunk that deflate could not shrink is stored as it is, and is read from the file directly
+        read_scanlines(source, plane_bits, width, first_line, line_count);
+    }
+
+    const result = new Array(channel_count);
+
+    for (let c = 0; c < channel_count; c++) {
+        result[c] = { name: channels[c].name, data: planes[c] };
+    }
+
+    return { width, height, channels: result };
+}
+
+/**
+ * Read the version field and refuse every kind of file other than a single-part scanline image.
+ *
+ * @param {BinaryBuffer} buffer
+ */
+function read_version(buffer) {
+    const version = buffer.readUint32();
+
+    if ((version & 0xFF) !== EXR_VERSION) {
+        throw new Error(`EXR: format version ${version & 0xFF} is not supported; ${EXR_VERSION} is`);
+    }
+
+    if ((version & EXR_FLAG_TILED) !== 0) {
+        throw new Error("EXR: tiled files are not supported; scanline files are");
+    }
+
+    if ((version & EXR_FLAG_MULTI_PART) !== 0) {
+        throw new Error("EXR: multi-part files are not supported; single-part files are");
+    }
+
+    if ((version & EXR_FLAG_NON_IMAGE) !== 0) {
+        throw new Error("EXR: deep data is not supported; flat images are");
+    }
+
+    const unknown = (version & ~(0xFF | EXR_FLAG_LONG_NAMES)) >>> 0;
+
+    if (unknown !== 0) {
+        throw new Error(`EXR: the version field sets unknown flags 0x${unknown.toString(16)}`);
+    }
+}
+
+/**
+ * Read the header's attributes up to its terminator, keeping the three that decoding the pixels needs.
+ *
+ * @param {BinaryBuffer} buffer
+ * @returns {{channels: {name: string, pixel_type: ExrPixelType}[], compression: number, x_min: number, y_min: number, x_max: number, y_max: number}}
+ */
+function read_header(buffer) {
+    let channels = null;
+    let compression = -1;
+    let has_data_window = false;
+    let x_min = 0, y_min = 0, x_max = 0, y_max = 0;
+
+    const file_end = buffer.capacity;
+
+    for (; ;) {
+        const name = read_name(buffer, file_end, "attribute name");
+
+        if (name === "") {
+            break;
+        }
+
+        const type = read_name(buffer, file_end, `type of attribute '${name}'`);
+
+        if (buffer.position + 4 > file_end) {
+            throw new Error(`EXR: the file ends inside the size of attribute '${name}'`);
+        }
+
+        const size = buffer.readInt32();
+        const end = buffer.position + size;
+
+        if (size < 0 || end > buffer.capacity) {
+            throw new Error(`EXR: attribute '${name}' claims ${size} bytes, past the end of the file`);
+        }
+
+        switch (name) {
+            case "channels":
+                check_attribute(name, type, size, "chlist", size);
+                channels = read_channel_list(buffer, end);
+                break;
+            case "compression":
+                check_attribute(name, type, size, "compression", 1);
+                compression = buffer.readUint8();
+                break;
+            case "dataWindow":
+                check_attribute(name, type, size, "box2i", 16);
+                x_min = buffer.readInt32();
+                y_min = buffer.readInt32();
+                x_max = buffer.readInt32();
+                y_max = buffer.readInt32();
+                has_data_window = true;
+                break;
+        }
+
+        buffer.position = end;
+    }
+
+    if (channels === null || compression === -1 || !has_data_window) {
+        const missing = [];
+
+        if (channels === null) missing.push("channels");
+        if (compression === -1) missing.push("compression");
+        if (!has_data_window) missing.push("dataWindow");
+
+        throw new Error(`EXR: the header has no ${missing.join(", ")} attribute`);
+    }
+
+    return { channels, compression, x_min, y_min, x_max, y_max };
+}
+
+/**
+ * @param {string} name
+ * @param {string} type as the file gives it
+ * @param {number} size as the file gives it
+ * @param {string} expected_type
+ * @param {number} expected_size
+ */
+function check_attribute(name, type, size, expected_type, expected_size) {
+    if (type !== expected_type || size !== expected_size) {
+        throw new Error(
+            `EXR: attribute '${name}' is a ${size} byte '${type}', where a ${expected_size} byte '${expected_type}' belongs`
+        );
+    }
+}
+
+/**
+ * Read a `chlist` attribute's value.
+ *
+ * OpenEXR keeps a channel list in name order, by {@link exr_compare_names}, whatever order a writer listed
+ * it in, and the pixel data follows that order — so the list is sorted here, and two channels of one name
+ * are refused as OpenEXR refuses them.
+ *
+ * @param {BinaryBuffer} buffer at the start of the value
+ * @param {number} end where the value ends
+ * @returns {{name: string, pixel_type: ExrPixelType}[]} in the pixel data's order
+ */
+function read_channel_list(buffer, end) {
+    const channels = [];
+
+    for (; ;) {
+        const name = read_name_bytes(buffer, end, "channel name");
+
+        if (name.length === 0) {
+            break;
+        }
+
+        // pixel type; pLinear and three reserved bytes; x and y sampling
+        if (buffer.position + 16 > end) {
+            throw new Error("EXR: the channel list's contents disagree with its size");
+        }
+
+        const pixel_type = buffer.readInt32();
+
+        // pLinear, then three reserved bytes
+        buffer.skip(4);
+
+        const x_sampling = buffer.readInt32();
+        const y_sampling = buffer.readInt32();
+
+        if (pixel_type !== ExrPixelType.UINT && pixel_type !== ExrPixelType.HALF && pixel_type !== ExrPixelType.FLOAT) {
+            throw new Error(`EXR: channel '${utf8_decode(name)}' has pixel type ${pixel_type}, which OpenEXR does not define`);
+        }
+
+        if (x_sampling !== 1 || y_sampling !== 1) {
+            throw new Error(
+                `EXR: channel '${utf8_decode(name)}' is subsampled ${x_sampling}x${y_sampling};`
+                + ` only full-resolution channels are supported`
+            );
+        }
+
+        channels.push({ name, pixel_type });
+    }
+
+    if (buffer.position !== end) {
+        throw new Error("EXR: the channel list's contents disagree with its size");
+    }
+
+    if (channels.length === 0) {
+        throw new Error("EXR: the image has no channels");
+    }
+
+    channels.sort((a, b) => exr_compare_names(a.name, b.name));
+
+    const result = new Array(channels.length);
+
+    for (let c = 0; c < channels.length; c++) {
+        const name = utf8_decode(channels[c].name);
+
+        if (c > 0 && exr_compare_names(channels[c - 1].name, channels[c].name) === 0) {
+            throw new Error(`EXR: there are two channels named '${name}'`);
+        }
+
+        result[c] = { name, pixel_type: channels[c].pixel_type };
+    }
+
+    return result;
+}
+
+/**
+ * Read a null-terminated name: an attribute's, its type's, or a channel's.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} limit where the name's terminator must come by: the end of the file, or of the channel list
+ * @param {string} what named in the error
+ * @returns {Uint8Array} the name's bytes, a view onto the file; empty for the terminator that ends a header
+ * or a channel list
+ */
+function read_name_bytes(buffer, limit, what) {
+    const bytes = buffer.raw_bytes;
+    const start = buffer.position;
+
+    const scan_end = Math.min(start + EXR_LONG_NAME_BYTES + 1, limit);
+
+    const length = bytes.subarray(start, scan_end).indexOf(0);
+
+    if (length === -1) {
+        throw new Error(
+            scan_end - start > EXR_LONG_NAME_BYTES
+                ? `EXR: the ${what} at offset ${start} is longer than ${EXR_LONG_NAME_BYTES} bytes`
+                : `EXR: the ${what} at offset ${start} is cut off at offset ${scan_end}`
+        );
+    }
+
+    buffer.position = start + length + 1;
+
+    return bytes.subarray(start, start + length);
+}
+
+/**
+ * {@link read_name_bytes}, decoded.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} limit
+ * @param {string} what
+ * @returns {string}
+ */
+function read_name(buffer, limit, what) {
+    return utf8_decode(read_name_bytes(buffer, limit, what));
+}
+
+/**
+ * @param {ExrPixelType} pixel_type
+ * @param {number} length
+ * @returns {Uint32Array|Float16Array|Float32Array}
+ */
+function create_plane(pixel_type, length) {
+    switch (pixel_type) {
+        case ExrPixelType.UINT:
+            return new Uint32Array(length);
+        case ExrPixelType.HALF:
+            return new Float16Array(length);
+        default:
+            return new Float32Array(length);
+    }
+}
+
+/**
+ * Scatter a chunk's scanlines into the channel planes. Within a scanline the channels follow one another,
+ * each a full row of samples, in the order of the channel list.
+ *
+ * @param {BinaryBuffer} source at the first byte of the chunk's pixel data
+ * @param {(Uint16Array|Uint32Array)[]} plane_bits
+ * @param {number} width
+ * @param {number} first_line row of the image the chunk starts at
+ * @param {number} line_count
+ */
+function read_scanlines(source, plane_bits, width, first_line, line_count) {
+    const channel_count = plane_bits.length;
+
+    for (let line = first_line; line < first_line + line_count; line++) {
+        const row = line * width;
+
+        for (let c = 0; c < channel_count; c++) {
+            const bits = plane_bits[c];
+
+            if (bits.BYTES_PER_ELEMENT === 2) {
+                source.readUint16Array(bits, row, width);
+            } else {
+                source.readUint32Array(bits, row, width);
+            }
+        }
+    }
+}
+
+/**
+ * Undo what ZIP compression does to a chunk before deflating it — the inverse of `zip_prepare` in
+ * `exr_write`.
+ *
+ * The chunk's bytes were split into two runs, the bytes at even positions followed by those at odd ones,
+ * and the runs then delta-coded byte by byte with a bias of 128. Decoding keeps a running sum over the
+ * runs and deals each byte back to its position.
+ *
+ * @param {Uint8Array} source inflated bytes
+ * @param {Uint8Array} destination the chunk's pixel data
+ * @param {number} length bytes, at least one
+ */
+function zip_reconstruct(source, destination, length) {
+    const half = (length + 1) >> 1;
+
+    let value = source[0];
+
+    destination[0] = value;
+
+    for (let i = 1; i < half; i++) {
+        value = (value + source[i] - 128) & 0xFF;
+
+        destination[2 * i] = value;
+    }
+
+    for (let i = half; i < length; i++) {
+        value = (value + source[i] - 128) & 0xFF;
+
+        destination[2 * (i - half) + 1] = value;
+    }
+}

package/src/format/image/exr/exr_sample_bits.d.ts

@@ -0,0 +1,16 @@
+/**
+ * View a channel's samples as the unsigned integers that hold them: 16 bits for a `Float16Array`, 32 for a
+ * `Float32Array` or a `Uint32Array`.
+ *
+ * Samples move between an {@link ExrImage} and a file through this view, so they move as bits: nothing is
+ * converted, a NaN keeps its payload, and the byte order is {@link BinaryBuffer}'s business rather than the
+ * host's.
+ *
+ * @param {Float16Array|Float32Array|Uint32Array} data
+ * @returns {Uint16Array|Uint32Array} over the same memory
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_sample_bits(data: Float16Array | Float32Array | Uint32Array): Uint16Array | Uint32Array;
+//# sourceMappingURL=exr_sample_bits.d.ts.map

package/src/format/image/exr/exr_sample_bits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exr_sample_bits.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/exr_sample_bits.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,sCANW,eAAa,YAAY,GAAC,WAAW,GACnC,WAAW,GAAC,WAAW,CAWnC"}

package/src/format/image/exr/exr_sample_bits.js

@@ -0,0 +1,21 @@
+/**
+ * View a channel's samples as the unsigned integers that hold them: 16 bits for a `Float16Array`, 32 for a
+ * `Float32Array` or a `Uint32Array`.
+ *
+ * Samples move between an {@link ExrImage} and a file through this view, so they move as bits: nothing is
+ * converted, a NaN keeps its payload, and the byte order is {@link BinaryBuffer}'s business rather than the
+ * host's.
+ *
+ * @param {Float16Array|Float32Array|Uint32Array} data
+ * @returns {Uint16Array|Uint32Array} over the same memory
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_sample_bits(data) {
+    if (data.BYTES_PER_ELEMENT === 2) {
+        return new Uint16Array(data.buffer, data.byteOffset, data.length);
+    }
+
+    return new Uint32Array(data.buffer, data.byteOffset, data.length);
+}

package/src/format/image/exr/exr_scanlines_per_chunk.d.ts

@@ -0,0 +1,17 @@
+/**
+ * How many scanlines a chunk of pixel data holds under a compression method — every chunk but the
+ * last, which holds whatever remains of the image.
+ *
+ * This is also where an unsupported method is refused, by name, for reading and writing alike.
+ *
+ * @param {ExrCompression|number} compression
+ * @returns {number}
+ * @throws {Error} for a method other than {@link ExrCompression.None}, {@link ExrCompression.ZIPS} and
+ * {@link ExrCompression.ZIP}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_scanlines_per_chunk(compression: ExrCompression | number): number;
+import { ExrCompression } from "./ExrCompression.js";
+//# sourceMappingURL=exr_scanlines_per_chunk.d.ts.map

package/src/format/image/exr/exr_scanlines_per_chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exr_scanlines_per_chunk.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/exr_scanlines_per_chunk.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,qDARW,cAAc,GAAC,MAAM,GACnB,MAAM,CAoBlB;+BA7B8B,qBAAqB"}

package/src/format/image/exr/exr_scanlines_per_chunk.js

@@ -0,0 +1,31 @@
+import { objectKeyByValue } from "../../../core/model/object/objectKeyByValue.js";
+import { ExrCompression } from "./ExrCompression.js";
+
+/**
+ * How many scanlines a chunk of pixel data holds under a compression method — every chunk but the
+ * last, which holds whatever remains of the image.
+ *
+ * This is also where an unsupported method is refused, by name, for reading and writing alike.
+ *
+ * @param {ExrCompression|number} compression
+ * @returns {number}
+ * @throws {Error} for a method other than {@link ExrCompression.None}, {@link ExrCompression.ZIPS} and
+ * {@link ExrCompression.ZIP}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_scanlines_per_chunk(compression) {
+    switch (compression) {
+        case ExrCompression.None:
+        case ExrCompression.ZIPS:
+            return 1;
+        case ExrCompression.ZIP:
+            return 16;
+        default:
+            throw new Error(
+                `EXR: ${objectKeyByValue(ExrCompression, compression) ?? `unknown (${compression})`}`
+                + ` compression is not supported; NONE, ZIPS and ZIP are`
+            );
+    }
+}

package/src/format/image/exr/exr_write.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Write an image as a scanline OpenEXR file.
+ *
+ * Each channel is written in the pixel type its array holds — a `Float16Array` as HALF, a `Float32Array`
+ * as FLOAT, a `Uint32Array` as UINT — and its samples go into the file as the bits they are. The header
+ * carries OpenEXR's required attributes and nothing else: both windows at the origin exactly covering the
+ * pixels, increasing line order, square pixels and the default screen window.
+ *
+ * Under {@link ExrCompression.ZIP} and {@link ExrCompression.ZIPS} a chunk that deflate does not make
+ * smaller is stored as it is, as OpenEXR's own writer does and every reader expects.
+ *
+ * The channels' arrays are read chunk by chunk as earlier chunks are compressed, so keep them unchanged
+ * until the promise settles.
+ *
+ * @param {ExrImage} image channels in any order, with distinct names of 1 to 255 bytes in UTF-8
+ * @param {ExrCompression} compression {@link ExrCompression.None}, {@link ExrCompression.ZIPS} or
+ * {@link ExrCompression.ZIP}
+ * @returns {Promise<ArrayBuffer>} the whole file
+ * @throws {Error} naming what about the image or the compression method cannot be written
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_write(image: ExrImage, compression: ExrCompression): Promise<ArrayBuffer>;
+import { ExrCompression } from "./ExrCompression.js";
+//# sourceMappingURL=exr_write.d.ts.map

package/src/format/image/exr/exr_write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exr_write.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/exr_write.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iCAVW,QAAQ,eACR,cAAc,GAEZ,QAAQ,WAAW,CAAC,CA+GhC;+BA3I8B,qBAAqB"}