format-png 0.1.0

package/dist/wasm/format_png_wasm.js

@@ -0,0 +1,1517 @@
+/* @ts-self-types="./format_png_wasm.d.ts" */
+
+/**
+ * A raw ancillary chunk. JavaScript reads `chunkType` and `position`, then calls
+ * `intoData()` once, which copies the data out and frees this object.
+ */
+export class Chunk {
+    static __wrap(ptr) {
+        const obj = Object.create(Chunk.prototype);
+        obj.__wbg_ptr = ptr;
+        ChunkFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChunkFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chunk_free(ptr, 0);
+    }
+    /**
+     * The four-letter type, for example "tEXt".
+     * @returns {string}
+     */
+    get chunkType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.chunk_chunkType(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The chunk's data, without length, type and CRC. Consumes the chunk.
+     * @returns {Uint8Array}
+     */
+    intoData() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.chunk_intoData(ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * "before-palette", "before-image-data" or "after-image-data".
+     * @returns {string}
+     */
+    get position() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.chunk_position(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Chunk.prototype[Symbol.dispose] = Chunk.prototype.free;
+
+/**
+ * Every chunk of a PNG, from `read_chunks`. The raw chunks are flat arrays,
+ * one entry per chunk in file order, so JavaScript can view their data in the
+ * input it already has instead of copying it out of wasm memory.
+ */
+export class ChunkList {
+    static __wrap(ptr) {
+        const obj = Object.create(ChunkList.prototype);
+        obj.__wbg_ptr = ptr;
+        ChunkListFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChunkListFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chunklist_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get crcs() {
+        const ret = wasm.chunklist_crcs(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Header}
+     */
+    header() {
+        const ret = wasm.chunklist_header(this.__wbg_ptr);
+        return Header.__wrap(ret);
+    }
+    /**
+     * 1 for each chunk this crate parses, 0 for unknown ones.
+     * @returns {Uint8Array}
+     */
+    get known() {
+        const ret = wasm.chunklist_known(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * The length of each chunk's data.
+     * @returns {Uint32Array}
+     */
+    get lengths() {
+        const ret = wasm.chunklist_lengths(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Metadata}
+     */
+    metadata() {
+        const ret = wasm.chunklist_metadata(this.__wbg_ptr);
+        return Metadata.__wrap(ret);
+    }
+    /**
+     * Where each chunk starts in the input: its length field.
+     * @returns {Uint32Array}
+     */
+    get offsets() {
+        const ret = wasm.chunklist_offsets(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * `PLTE`: red, green and blue for each entry, in index order.
+     * @returns {Uint8Array | undefined}
+     */
+    get palette() {
+        const ret = wasm.chunklist_palette(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `tRNS`: "gray", "rgb" or "palette".
+     * @returns {string | undefined}
+     */
+    get transparencyKind() {
+        const ret = wasm.chunklist_transparencyKind(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `tRNS`: the transparent gray value, the transparent red, green and blue,
+     * or an alpha for each palette entry.
+     * @returns {Uint16Array | undefined}
+     */
+    get transparencyValues() {
+        const ret = wasm.chunklist_transparencyValues(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
+        }
+        return v1;
+    }
+    /**
+     * The four-letter types of every chunk, joined.
+     * @returns {string}
+     */
+    get types() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.chunklist_types(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) ChunkList.prototype[Symbol.dispose] = ChunkList.prototype.free;
+
+/**
+ * A decoded RGBA8 image. JavaScript reads `width`, `height`, `metadata()` and
+ * `takeChunks()`, then calls `intoPixels()` once, which copies the pixels out
+ * and frees this object.
+ */
+export class DecodedImage {
+    static __wrap(ptr) {
+        const obj = Object.create(DecodedImage.prototype);
+        obj.__wbg_ptr = ptr;
+        DecodedImageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DecodedImageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_decodedimage_free(ptr, 0);
+    }
+    /**
+     * The RGBA pixels, `width * height * 4` bytes. Consumes the image.
+     * @returns {Uint8Array}
+     */
+    intoPixels() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.decodedimage_intoPixels(ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * The parsed ancillary chunks; empty unless `preserveMetadata` was set.
+     * @returns {Metadata}
+     */
+    metadata() {
+        const ret = wasm.decodedimage_metadata(this.__wbg_ptr);
+        return Metadata.__wrap(ret);
+    }
+    /**
+     * The raw ancillary chunks; empty unless `preserveChunks` was set. Moves
+     * them out, so a second call returns none.
+     * @returns {Chunk[]}
+     */
+    takeChunks() {
+        const ret = wasm.decodedimage_takeChunks(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.__wbg_get_decodedimage_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.__wbg_get_decodedimage_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DecodedImage.prototype[Symbol.dispose] = DecodedImage.prototype.free;
+
+/**
+ * A decoder that keeps its buffers between images.
+ */
+export class Decoder {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DecoderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_decoder_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {DecodedImage}
+     */
+    decodeRgba8(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.decoder_decodeRgba8(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DecodedImage.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {RawImage}
+     */
+    decode(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.decoder_decode(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RawImage.__wrap(ret[0]);
+    }
+    /**
+     * @param {boolean} validate_crc
+     * @param {boolean} preserve_metadata
+     * @param {boolean} preserve_chunks
+     * @param {boolean} strict_ancillary
+     */
+    constructor(validate_crc, preserve_metadata, preserve_chunks, strict_ancillary) {
+        const ret = wasm.decoder_new(validate_crc, preserve_metadata, preserve_chunks, strict_ancillary);
+        this.__wbg_ptr = ret;
+        DecoderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {ChunkList}
+     */
+    readChunks(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.decoder_readChunks(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ChunkList.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) Decoder.prototype[Symbol.dispose] = Decoder.prototype.free;
+
+/**
+ * An image to encode, built up from JavaScript: the constructor takes the
+ * header and pixels, and each setter adds a chunk. Pass it to `encode` or
+ * `Encoder.encode`, then call `free()`.
+ */
+export class EncodeImage {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EncodeImageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_encodeimage_free(ptr, 0);
+    }
+    /**
+     * Adds a raw chunk, written at `position`: one of the strings
+     * `Chunk.position` returns.
+     * @param {string} chunk_type
+     * @param {Uint8Array} data
+     * @param {string} position
+     */
+    addChunk(chunk_type, data, position) {
+        const ptr0 = passStringToWasm0(chunk_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(position, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.encodeimage_addChunk(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Adds a `tEXt`, `zTXt` or `iTXt` chunk. `compressed` only matters for
+     * `iTXt`, and the language tag and translated keyword are only written
+     * there.
+     * @param {string} chunk_type
+     * @param {string} keyword
+     * @param {string} text
+     * @param {string} language_tag
+     * @param {string} translated_keyword
+     * @param {boolean} compressed
+     */
+    addText(chunk_type, keyword, text, language_tag, translated_keyword, compressed) {
+        const ptr0 = passStringToWasm0(chunk_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(keyword, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(language_tag, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(translated_keyword, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.encodeimage_addText(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, compressed);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * `colorType` is one of the strings `Header.colorType` returns. `data` is
+     * in the PNG's own pixel format; see `format_png::ImageRef`.
+     * @param {number} width
+     * @param {number} height
+     * @param {number} bit_depth
+     * @param {string} color_type
+     * @param {boolean} interlaced
+     * @param {Uint8Array} data
+     */
+    constructor(width, height, bit_depth, color_type, interlaced, data) {
+        const ptr0 = passStringToWasm0(color_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.encodeimage_new(width, height, bit_depth, ptr0, len0, interlaced, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        EncodeImageFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * `cHRM`: white, red, green and blue x and y, in that order, as fractions.
+     * @param {Float64Array} values
+     */
+    setChromaticities(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encodeimage_setChromaticities(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * `cICP`: H.273 color primaries, transfer function and matrix coefficients,
+     * and whether samples use the full range.
+     * @param {number} color_primaries
+     * @param {number} transfer_function
+     * @param {number} matrix_coefficients
+     * @param {boolean} full_range
+     */
+    setCicp(color_primaries, transfer_function, matrix_coefficients, full_range) {
+        wasm.encodeimage_setCicp(this.__wbg_ptr, color_primaries, transfer_function, matrix_coefficients, full_range);
+    }
+    /**
+     * `eXIf`: Exif data, starting with its TIFF header, which is checked.
+     * @param {Uint8Array} data
+     */
+    setExif(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encodeimage_setExif(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * `gAMA`, for example 0.45455.
+     * @param {number} gamma
+     */
+    setGamma(gamma) {
+        const ret = wasm.encodeimage_setGamma(this.__wbg_ptr, gamma);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * `iCCP`: an ICC profile, uncompressed, and its name. The encoder checks
+     * the name and compresses the profile.
+     * @param {string} name
+     * @param {Uint8Array} profile
+     */
+    setIccProfile(name, profile) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(profile, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.encodeimage_setIccProfile(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * `PLTE`: red, green and blue for each entry, in index order.
+     * @param {Uint8Array} colors
+     */
+    setPalette(colors) {
+        const ptr0 = passArray8ToWasm0(colors, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encodeimage_setPalette(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * `pHYs`: pixels per unit, with unit "meter" or "unknown".
+     * @param {number} x
+     * @param {number} y
+     * @param {string} unit
+     */
+    setPhysicalDimensions(x, y, unit) {
+        const ptr0 = passStringToWasm0(unit, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encodeimage_setPhysicalDimensions(this.__wbg_ptr, x, y, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * `sRGB`, with one of the intents `Metadata.srgb` returns.
+     * @param {string} intent
+     */
+    setSrgb(intent) {
+        const ptr0 = passStringToWasm0(intent, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encodeimage_setSrgb(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * `tIME`: year, month, day, hour, minute and second, in UTC. The encoder
+     * checks the ranges.
+     * @param {number} year
+     * @param {number} month
+     * @param {number} day
+     * @param {number} hour
+     * @param {number} minute
+     * @param {number} second
+     */
+    setTime(year, month, day, hour, minute, second) {
+        wasm.encodeimage_setTime(this.__wbg_ptr, year, month, day, hour, minute, second);
+    }
+    /**
+     * `tRNS`: `kind` is "gray", "rgb" or "palette", and `values` as
+     * `ChunkList.transparencyValues` returns them.
+     * @param {string} kind
+     * @param {Uint16Array} values
+     */
+    setTransparency(kind, values) {
+        const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray16ToWasm0(values, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.encodeimage_setTransparency(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) EncodeImage.prototype[Symbol.dispose] = EncodeImage.prototype.free;
+
+/**
+ * An encoder that keeps its compressor and buffers between images.
+ */
+export class Encoder {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EncoderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_encoder_free(ptr, 0);
+    }
+    /**
+     * @param {EncodeImage} image
+     * @returns {Uint8Array}
+     */
+    encode(image) {
+        _assertClass(image, EncodeImage);
+        const ret = wasm.encoder_encode(this.__wbg_ptr, image.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * `compression` is 0 to 9. `compressionStrategy` is "dynamic", "fixed" or
+     * "stored"; `filter` is "adaptive", "none", "sub", "up", "average" or
+     * "paeth"; `palette` is "keep" or "auto"; `strip` is "keep", "safe" or "all".
+     * @param {number} compression
+     * @param {string} compression_strategy
+     * @param {string} filter
+     * @param {boolean} keep_unsafe_chunks
+     * @param {string} palette
+     * @param {string} strip
+     */
+    constructor(compression, compression_strategy, filter, keep_unsafe_chunks, palette, strip) {
+        const ptr0 = passStringToWasm0(compression_strategy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(palette, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(strip, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.encoder_new(compression, ptr0, len0, ptr1, len1, keep_unsafe_chunks, ptr2, len2, ptr3, len3);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        EncoderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) Encoder.prototype[Symbol.dispose] = Encoder.prototype.free;
+
+/**
+ * The contents of the `IHDR` chunk.
+ */
+export class Header {
+    static __wrap(ptr) {
+        const obj = Object.create(Header.prototype);
+        obj.__wbg_ptr = ptr;
+        HeaderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HeaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_header_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get bitDepth() {
+        const ret = wasm.__wbg_get_header_bitDepth(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.__wbg_get_header_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get interlaced() {
+        const ret = wasm.__wbg_get_header_interlaced(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.__wbg_get_header_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * "grayscale", "rgb", "indexed", "grayscale-alpha" or "rgba".
+     * @returns {string}
+     */
+    get colorType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.header_colorType(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Header.prototype[Symbol.dispose] = Header.prototype.free;
+
+/**
+ * The known ancillary chunks. Each getter is `undefined` if the chunk is absent.
+ */
+export class Metadata {
+    static __wrap(ptr) {
+        const obj = Object.create(Metadata.prototype);
+        obj.__wbg_ptr = ptr;
+        MetadataFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MetadataFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_metadata_free(ptr, 0);
+    }
+    /**
+     * `cHRM`: white, red, green and blue x and y, in that order, as fractions.
+     * @returns {Float64Array | undefined}
+     */
+    get chromaticities() {
+        const ret = wasm.metadata_chromaticities(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * `cICP`: color primaries, transfer function, matrix coefficients and the
+     * full-range flag (1 or 0), in that order.
+     * @returns {Uint8Array | undefined}
+     */
+    get cicp() {
+        const ret = wasm.metadata_cicp(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `eXIf`: "big-endian" or "little-endian".
+     * @returns {string | undefined}
+     */
+    get exifByteOrder() {
+        const ret = wasm.metadata_exifByteOrder(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `eXIf`: the Exif data, raw, starting with its TIFF header.
+     * @returns {Uint8Array | undefined}
+     */
+    get exif() {
+        const ret = wasm.metadata_exif(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `gAMA`, for example 0.45455.
+     * @returns {number | undefined}
+     */
+    get gamma() {
+        const ret = wasm.metadata_gamma(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * `iCCP`: the profile's name.
+     * @returns {string | undefined}
+     */
+    get iccProfileName() {
+        const ret = wasm.metadata_iccProfileName(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `iCCP`: the ICC profile, decompressed.
+     * @returns {Uint8Array | undefined}
+     */
+    get iccProfile() {
+        const ret = wasm.metadata_iccProfile(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `pHYs`: pixels per unit, x then y.
+     * @returns {Uint32Array | undefined}
+     */
+    get physicalPixelsPerUnit() {
+        const ret = wasm.metadata_physicalPixelsPerUnit(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
+    /**
+     * `pHYs` unit: "meter" or "unknown" (the values are only an aspect ratio).
+     * @returns {string | undefined}
+     */
+    get physicalUnit() {
+        const ret = wasm.metadata_physicalUnit(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `sRGB`: "perceptual", "relative-colorimetric", "saturation" or "absolute-colorimetric".
+     * @returns {string | undefined}
+     */
+    get srgb() {
+        const ret = wasm.metadata_srgb(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `tEXt`, `zTXt` and `iTXt`, in file order.
+     * @returns {Text[]}
+     */
+    text() {
+        const ret = wasm.metadata_text(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * `tIME`: year, month, day, hour, minute and second, in UTC.
+     * @returns {Uint16Array | undefined}
+     */
+    get time() {
+        const ret = wasm.metadata_time(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
+        }
+        return v1;
+    }
+}
+if (Symbol.dispose) Metadata.prototype[Symbol.dispose] = Metadata.prototype.free;
+
+/**
+ * A decoded image in the file's own format, from `decode`. JavaScript reads
+ * the header, palette, transparency, `metadata()` and `takeChunks()`, then
+ * calls `intoData()` once, which copies the samples out and frees this object.
+ */
+export class RawImage {
+    static __wrap(ptr) {
+        const obj = Object.create(RawImage.prototype);
+        obj.__wbg_ptr = ptr;
+        RawImageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RawImageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rawimage_free(ptr, 0);
+    }
+    /**
+     * @returns {Header}
+     */
+    header() {
+        const ret = wasm.rawimage_header(this.__wbg_ptr);
+        return Header.__wrap(ret);
+    }
+    /**
+     * The samples in the file's own layout: rows of the header's stride, 16-bit
+     * samples big-endian, pixels under 8 bits packed with each row padded to a
+     * whole byte, palette indices for indexed images. Consumes the image.
+     * @returns {Uint8Array}
+     */
+    intoData() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.rawimage_intoData(ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * The parsed ancillary chunks; empty unless `preserveMetadata` was set.
+     * @returns {Metadata}
+     */
+    metadata() {
+        const ret = wasm.rawimage_metadata(this.__wbg_ptr);
+        return Metadata.__wrap(ret);
+    }
+    /**
+     * `PLTE`: red, green and blue for each entry, in index order.
+     * @returns {Uint8Array | undefined}
+     */
+    get palette() {
+        const ret = wasm.rawimage_palette(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * The raw ancillary chunks; empty unless `preserveChunks` was set.
+     * @returns {Chunk[]}
+     */
+    takeChunks() {
+        const ret = wasm.rawimage_takeChunks(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * `tRNS`: "gray", "rgb" or "palette".
+     * @returns {string | undefined}
+     */
+    get transparencyKind() {
+        const ret = wasm.rawimage_transparencyKind(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `tRNS`, as `ChunkList.transparencyValues`.
+     * @returns {Uint16Array | undefined}
+     */
+    get transparencyValues() {
+        const ret = wasm.rawimage_transparencyValues(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
+        }
+        return v1;
+    }
+}
+if (Symbol.dispose) RawImage.prototype[Symbol.dispose] = RawImage.prototype.free;
+
+/**
+ * A `tEXt`, `zTXt` or `iTXt` chunk, decoded. JavaScript reads the getters, then
+ * calls `free()`.
+ */
+export class Text {
+    static __wrap(ptr) {
+        const obj = Object.create(Text.prototype);
+        obj.__wbg_ptr = ptr;
+        TextFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TextFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_text_free(ptr, 0);
+    }
+    /**
+     * "tEXt", "zTXt" or "iTXt".
+     * @returns {string}
+     */
+    get chunkType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.text_chunkType(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Whether the text was zlib-compressed in the file.
+     * @returns {boolean}
+     */
+    get compressed() {
+        const ret = wasm.text_compressed(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    get keyword() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.text_keyword(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get languageTag() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.text_languageTag(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get text() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.text_text(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get translatedKeyword() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.text_translatedKeyword(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Text.prototype[Symbol.dispose] = Text.prototype.free;
+
+/**
+ * Decodes a PNG in its own format with a one-off decoder.
+ * @param {Uint8Array} bytes
+ * @param {boolean} validate_crc
+ * @param {boolean} preserve_metadata
+ * @param {boolean} preserve_chunks
+ * @param {boolean} strict_ancillary
+ * @returns {RawImage}
+ */
+export function decode(bytes, validate_crc, preserve_metadata, preserve_chunks, strict_ancillary) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decode(ptr0, len0, validate_crc, preserve_metadata, preserve_chunks, strict_ancillary);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return RawImage.__wrap(ret[0]);
+}
+
+/**
+ * Decodes a PNG to RGBA8 with a one-off decoder.
+ * @param {Uint8Array} bytes
+ * @param {boolean} validate_crc
+ * @param {boolean} preserve_metadata
+ * @param {boolean} preserve_chunks
+ * @param {boolean} strict_ancillary
+ * @returns {DecodedImage}
+ */
+export function decodeRgba8(bytes, validate_crc, preserve_metadata, preserve_chunks, strict_ancillary) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decodeRgba8(ptr0, len0, validate_crc, preserve_metadata, preserve_chunks, strict_ancillary);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return DecodedImage.__wrap(ret[0]);
+}
+
+/**
+ * Encodes an image with a one-off encoder.
+ * @param {EncodeImage} image
+ * @param {number} compression
+ * @param {string} compression_strategy
+ * @param {string} filter
+ * @param {boolean} keep_unsafe_chunks
+ * @param {string} palette
+ * @param {string} strip
+ * @returns {Uint8Array}
+ */
+export function encode(image, compression, compression_strategy, filter, keep_unsafe_chunks, palette, strip) {
+    _assertClass(image, EncodeImage);
+    const ptr0 = passStringToWasm0(compression_strategy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(palette, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passStringToWasm0(strip, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.encode(image.__wbg_ptr, compression, ptr0, len0, ptr1, len1, keep_unsafe_chunks, ptr2, len2, ptr3, len3);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v5 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v5;
+}
+
+/**
+ * Parses the data of a `tEXt`, `zTXt` or `iTXt` chunk on its own.
+ * @param {string} chunk_type
+ * @param {Uint8Array} data
+ * @returns {Text}
+ */
+export function parseText(chunk_type, data) {
+    const ptr0 = passStringToWasm0(chunk_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.parseText(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Text.__wrap(ret[0]);
+}
+
+/**
+ * Reads and parses every chunk without decompressing the image data.
+ * @param {Uint8Array} bytes
+ * @param {boolean} validate_crc
+ * @param {boolean} strict_ancillary
+ * @returns {ChunkList}
+ */
+export function readChunks(bytes, validate_crc, strict_ancillary) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.readChunks(ptr0, len0, validate_crc, strict_ancillary);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ChunkList.__wrap(ret[0]);
+}
+
+/**
+ * Reads only the header.
+ * @param {Uint8Array} bytes
+ * @returns {Header}
+ */
+export function readHeader(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.readHeader(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Header.__wrap(ret[0]);
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_67e7344beaa85059: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_chunk_new: function(arg0) {
+            const ret = Chunk.__wrap(arg0);
+            return ret;
+        },
+        __wbg_text_new: function(arg0) {
+            const ret = Text.__wrap(arg0);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./format_png_wasm_bg.js": import0,
+    };
+}
+
+const ChunkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chunk_free(ptr, 1));
+const ChunkListFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chunklist_free(ptr, 1));
+const DecodedImageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_decodedimage_free(ptr, 1));
+const DecoderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_decoder_free(ptr, 1));
+const EncodeImageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encodeimage_free(ptr, 1));
+const EncoderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encoder_free(ptr, 1));
+const HeaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_header_free(ptr, 1));
+const MetadataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_metadata_free(ptr, 1));
+const RawImageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rawimage_free(ptr, 1));
+const TextFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_text_free(ptr, 1));
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function getArrayU16FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint16ArrayMemory0 = null;
+function getUint16ArrayMemory0() {
+    if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
+        cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
+    }
+    return cachedUint16ArrayMemory0;
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray16ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 2, 2) >>> 0;
+    getUint16ArrayMemory0().set(arg, ptr / 2);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint16ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('format_png_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };