imagescript 3.0.0 → 3.2.0

package/dist/codecs/gif.js

@@ -3,7 +3,7 @@ const DISPOSAL_TO_GIF = [0, 1, 3, 2];
 const DISPOSAL_FROM_GIF = [0, 1, 3, 2, 0, 0, 0, 0];
 const MAX_CODE = 4095;
 const UNEXPECTED_END = new Error('GIF: unexpected end of data');
-export function encode({ width, height, loopCount = -1, frames }, quality = 95) {
+export function encode({ width, height, loopCount = -1, frames }, quality = 95, comments = []) {
     const out = new ByteWriter();
     out.bytes(0x47, 0x49, 0x46, 0x38, 0x39, 0x61);
     out.u16(width);
@@ -16,8 +16,14 @@ export function encode({ width, height, loopCount = -1, frames }, quality = 95)
         out.u16(loopCount === -1 ? 0 : loopCount);
         out.bytes(0x00);
     }
-    for (const frame of frames) {
-        const { palette, indices, transparentIndex } = quantize(frame.pixels, frame.width, { quality });
+    for (const comment of comments) {
+        out.bytes(0x21, 0xfe);
+        writeSubBlocks(out, comment);
+    }
+    const restores = frames.some(frame => frame.dispose === 3);
+    for (const [i, frame] of frames.entries()) {
+        const transparent = frame.dispose === 3 || (i === 0 && restores);
+        const { palette, indices, transparentIndex } = quantize(frame.pixels, frame.width, { quality, transparent });
         const entries = palette.length / 3;
         const bits = Math.max(1, Math.ceil(Math.log2(entries)));
         out.bytes(0x21, 0xf9, 0x04);
@@ -184,20 +190,19 @@ export function decode(data, onlyFirstFrame = false) {
                 continue;
             const pixels = new Uint8Array(fw * fh * 4);
             const rows = interlaced ? interlacedRows(fh) : null;
+            const colors = new Uint8Array(256 * 4);
+            for (let index = 0; index < 256; index++) {
+                if (index === transparentIndex)
+                    continue;
+                if (table && index * 3 + 2 < table.length)
+                    colors.set(table.subarray(index * 3, index * 3 + 3), index * 4);
+                colors[index * 4 + 3] = 0xff;
+            }
+            const lookup = new Uint32Array(colors.buffer), out = new Uint32Array(pixels.buffer);
             for (let row = 0; row < fh; row++) {
-                const targetRow = rows ? rows[row] : row;
-                for (let column = 0; column < fw; column++) {
-                    const index = indices[row * fw + column];
-                    if (index === transparentIndex)
-                        continue;
-                    const o = (targetRow * fw + column) * 4;
-                    if (table && index * 3 + 2 < table.length) {
-                        pixels[o] = table[index * 3];
-                        pixels[o + 1] = table[index * 3 + 1];
-                        pixels[o + 2] = table[index * 3 + 2];
-                    }
-                    pixels[o + 3] = 0xff;
-                }
+                const target = (rows ? rows[row] : row) * fw, source = row * fw;
+                for (let column = 0; column < fw; column++)
+                    out[target + column] = lookup[indices[source + column]];
             }
             frames.push({ x, y, width: fw, height: fh, delay, dispose, pixels });
             if (onlyFirstFrame)
@@ -287,10 +292,18 @@ function lzwDecode(data, minCodeSize, pixelCount) {
         const length = lengths[entry];
         const end = Math.min(out + length, pixelCount);
         let c = entry;
-        for (let i = out + length - 1; i >= out; i--) {
-            if (i < end)
+        if (end === out + length) {
+            for (let i = end - 1; i >= out; i--) {
                 output[i] = suffix[c];
-            c = prefix[c];
+                c = prefix[c];
+            }
+        }
+        else {
+            for (let i = out + length - 1; i >= out; i--) {
+                if (i < end)
+                    output[i] = suffix[c];
+                c = prefix[c];
+            }
         }
         let written = end - out;
         if (code === next) {

package/dist/codecs/jpeg.js

@@ -5,6 +5,7 @@
  * (Copyright 2014 Mozilla Foundation, Apache License 2.0). See THIRD_PARTY_NOTICES.md
  */
 import { orientation as exifOrientation } from "./exif.js";
+import { concat } from "../util/mem.js";
 const ZIGZAG = Int32Array.of(0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63);
 function clamp8(v) {
     return v < 0 ? 0 : v > 255 ? 255 : v;
@@ -684,7 +685,7 @@ const CHROMA_QUANTIZATION = [
     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99
 ];
 const AAN_SCALE = [1, 1.387039845, 1.306562965, 1.175875602, 1, 0.785694958, 0.5411961, 0.275899379];
-export function encode(pixels, width, height, quality = 90) {
+export function encode(pixels, width, height, quality = 90, { exif, comment } = {}) {
     if (!width || !height || width > 0xffff || height > 0xffff)
         throw new RangeError('JPEG: invalid dimensions');
     quality = Math.min(100, Math.max(1, Math.round(quality)));
@@ -769,6 +770,17 @@ export function encode(pixels, width, height, quality = 90) {
     const writer = new BitWriter(width * height);
     writer.bytes(0xff, 0xd8);
     writer.bytes(0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00);
+    const segment = (marker, body) => {
+        if (body.length > 65533)
+            throw new RangeError('JPEG: metadata too large');
+        writer.bytes(0xff, marker, body.length + 2 >> 8, body.length + 2 & 255);
+        for (let i = 0; i < body.length; i++)
+            writer.bytes(body[i]);
+    };
+    if (exif)
+        segment(0xe1, concat([[0x45, 0x78, 0x69, 0x66, 0, 0], exif]));
+    if (comment)
+        segment(0xfe, comment);
     writer.bytes(0xff, 0xdb, 0x00, 0x84);
     for (let t = 0; t < 2; t++) {
         writer.bytes(t);

package/dist/codecs/png.js

@@ -13,6 +13,9 @@ const eXIf = 0x65584966;
 const tEXt = 0x74455874;
 const zTXt = 0x7a545874;
 const iTXt = 0x69545874;
+const acTL = 0x6163544c;
+const fcTL = 0x6663544c;
+const fdAT = 0x66644154;
 const COLOR_TYPE_CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
 const CHANNELS_TO_COLOR_TYPE = { 1: 0, 2: 4, 3: 2, 4: 6 };
 const VALID_DEPTHS = { 0: [1, 2, 4, 8, 16], 2: [8, 16], 3: [1, 2, 4, 8], 4: [8, 16], 6: [8, 16] };
@@ -38,15 +41,24 @@ export async function encode(data, { text, width, height, channels, depth = 8, l
         chunks.push(chunk(PLTE, palette));
     if (transparency)
         chunks.push(chunk(tRNS, transparency));
+    chunks.push(...textChunks(text));
     chunks.push(chunk(IDAT, await compressAsync(filtered, level)));
+    chunks.push(chunk(IEND, new Uint8Array(0)));
+    return concat([HEAD, ...chunks]);
+}
+function textChunks(text) {
+    const chunks = [];
+    const latin1 = (s) => Array.from(s, c => c.charCodeAt(0));
     for (const key in text) {
         const value = text[key];
         if (!value)
             continue;
-        chunks.push(chunk(0x74455874, concat([utf8(key), [0], utf8(value)])));
+        if (/^[\x00-\xff]*$/.test(value))
+            chunks.push(chunk(tEXt, concat([latin1(key), [0], latin1(value)])));
+        else
+            chunks.push(chunk(iTXt, concat([latin1(key), [0, 0, 0, 0, 0], utf8(value)])));
     }
-    chunks.push(chunk(IEND, new Uint8Array(0)));
-    return concat([HEAD, ...chunks]);
+    return chunks;
 }
 function filter(data, rowBytes, height, bpp) {
     const out = new Uint8Array(height * (rowBytes + 1));
@@ -63,7 +75,8 @@ function filter(data, rowBytes, height, bpp) {
         for (let i = bpp; i < rowBytes; i++) {
             const a = data[row + i - bpp], b = data[row + i - rowBytes], c = data[row + i - rowBytes - bpp];
             const pa = Math.abs(b - c), pb = Math.abs(a - c), pc = Math.abs(a + b - 2 * c);
-            out[o + i] = data[row + i] - (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
+            const notA = (pb - pa | pc - pa) >> 31, takeC = (pc - pb) >> 31;
+            out[o + i] = data[row + i] - (a ^ (a ^ b ^ (b ^ c) & takeC) & notA);
         }
     }
     return out;
@@ -77,32 +90,59 @@ function chunk(type, body) {
     view.setUint32(body.length + 8, crc32(out.subarray(4, body.length + 8)));
     return out;
 }
-export async function encodeRGBA(rgba, width, height, level, text) {
-    const count = width * height;
-    if (rgba.byteOffset % 4)
-        rgba = rgba.slice(0, count * 4);
-    const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, count);
+export function alphaCost(images) {
+    let grey = true;
+    const colors = new Set();
+    scan: for (const rgba of images) {
+        const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, rgba.length >> 2);
+        let previous = -1;
+        for (let i = 0; i < pixels.length; i++) {
+            const value = pixels[i];
+            if (value === previous)
+                continue;
+            previous = value;
+            const o = i * 4;
+            if (rgba[o + 3] === 0)
+                continue;
+            if (rgba[o] !== rgba[o + 1] || rgba[o] !== rgba[o + 2])
+                grey = false;
+            if (colors.size <= 256)
+                colors.add(value);
+            else if (!grey)
+                break scan;
+        }
+    }
+    const palette = (entries) => (entries <= 2 ? 1 : entries <= 4 ? 2 : entries <= 16 ? 4 : 8) / 8;
+    const transparent = colors.size < 256 ? palette(colors.size + 1) : grey ? 2 : 4;
+    const opaque = colors.size <= 256 ? palette(colors.size) : grey ? 1 : 3;
+    return transparent / opaque;
+}
+function pixelFormat(images) {
     let opaque = true, grey = true;
     let colors = new Map();
-    let previous = -1;
-    for (let i = 0; i < count; i++) {
-        const value = pixels[i];
-        if (value === previous)
-            continue;
-        previous = value;
-        const o = i * 4;
-        if (rgba[o + 3] !== 255)
-            opaque = false;
-        if (rgba[o] !== rgba[o + 1] || rgba[o] !== rgba[o + 2])
-            grey = false;
-        if (colors && !colors.has(value)) {
-            if (colors.size === 256)
-                colors = null;
-            else
-                colors.set(value, colors.size);
+    scan: for (const rgba of images) {
+        const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, rgba.length >> 2);
+        let previous = -1;
+        for (let i = 0; i < pixels.length; i++) {
+            const value = pixels[i];
+            if (value === previous)
+                continue;
+            previous = value;
+            const o = i * 4;
+            if (rgba[o + 3] !== 255)
+                opaque = false;
+            if (rgba[o] !== rgba[o + 1] || rgba[o] !== rgba[o + 2])
+                grey = false;
+            if (colors && !colors.has(value)) {
+                if (colors.size === 256)
+                    colors = null;
+                else
+                    colors.set(value, colors.size);
+            }
+            if (!colors && !opaque && !grey)
+                break scan;
         }
     }
-    const options = { width, height, level, text, filter: level > 0 };
     if (colors) {
         const entries = [...colors.keys()].map(value => new Uint8Array(new Uint32Array([value]).buffer));
         entries.sort((a, b) => a[3] - b[3]);
@@ -113,41 +153,145 @@ export async function encodeRGBA(rgba, width, height, level, text) {
         const translucent = entries.filter(bytes => bytes[3] !== 255).length;
         const transparency = translucent ? Uint8Array.from(entries.slice(0, translucent), bytes => bytes[3]) : undefined;
         const depth = entries.length <= 2 ? 1 : entries.length <= 4 ? 2 : entries.length <= 16 ? 4 : 8;
-        const rowBytes = Math.ceil(width * depth / 8);
-        const perByte = 8 / depth;
-        const data = new Uint8Array(rowBytes * height);
-        let last = -1, lastIndex = 0;
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                const value = pixels[y * width + x];
-                if (value !== last) {
-                    last = value;
-                    lastIndex = index.get(value);
+        return {
+            channels: 1, depth, palette, transparency,
+            convert(rgba, width, height) {
+                const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, width * height);
+                const rowBytes = Math.ceil(width * depth / 8);
+                const perByte = 8 / depth;
+                const data = new Uint8Array(rowBytes * height);
+                let last = -1, lastIndex = 0;
+                for (let y = 0; y < height; y++) {
+                    for (let x = 0; x < width; x++) {
+                        const value = pixels[y * width + x];
+                        if (value !== last) {
+                            last = value;
+                            lastIndex = index.get(value);
+                        }
+                        data[y * rowBytes + (x / perByte | 0)] |= lastIndex << (8 - depth - (x % perByte) * depth);
+                    }
                 }
-                data[y * rowBytes + (x / perByte | 0)] |= lastIndex << (8 - depth - (x % perByte) * depth);
+                return data;
             }
-        }
-        return encode(data, { ...options, channels: 1, depth, palette, transparency, filter: false });
+        };
     }
     const channels = (grey ? 1 : 3) + (opaque ? 0 : 1);
-    if (channels === 4)
-        return encode(rgba, { ...options, channels });
-    const data = new Uint8Array(count * channels);
-    for (let i = 0, o = 0; i < count; i++) {
-        const s = i * 4;
-        if (grey)
-            data[o++] = rgba[s];
+    return {
+        channels, depth: 8,
+        convert(rgba, width, height) {
+            if (channels === 4)
+                return rgba;
+            const count = width * height;
+            const data = new Uint8Array(count * channels);
+            if (channels === 3) {
+                for (let s = 0, o = 0; o < data.length; s += 4, o += 3) {
+                    data[o] = rgba[s];
+                    data[o + 1] = rgba[s + 1];
+                    data[o + 2] = rgba[s + 2];
+                }
+            }
+            else if (channels === 2) {
+                for (let s = 0, o = 0; o < data.length; s += 4, o += 2) {
+                    data[o] = rgba[s];
+                    data[o + 1] = rgba[s + 3];
+                }
+            }
+            else
+                for (let s = 0, o = 0; o < data.length; s += 4, o++)
+                    data[o] = rgba[s];
+            return data;
+        }
+    };
+}
+const aligned = (rgba) => rgba.byteOffset % 4 ? rgba.slice() : rgba;
+export async function encodeRGBA(rgba, width, height, level, text) {
+    rgba = aligned(rgba.subarray(0, width * height * 4));
+    const format = pixelFormat([rgba]);
+    const { channels, depth, palette, transparency } = format;
+    return encode(format.convert(rgba, width, height), { width, height, level, text, channels, depth, palette, transparency, filter: level > 0 && !palette });
+}
+async function compressRows(data, width, height, channels, depth, level, filterRows) {
+    const rowBytes = Math.ceil(width * channels * depth / 8);
+    let filtered;
+    if (filterRows)
+        filtered = filter(data, rowBytes, height, Math.max(1, channels * depth / 8));
+    else {
+        filtered = new Uint8Array(height * (rowBytes + 1));
+        for (let y = 0; y < height; y++)
+            filtered.set(data.subarray(y * rowBytes, (y + 1) * rowBytes), y * (rowBytes + 1) + 1);
+    }
+    return compressAsync(filtered, level);
+}
+export async function encodeAnimation(frames, width, height, plays, level, text) {
+    if (!frames.length)
+        throw new Error('PNG: an animation needs at least one frame');
+    const first = frames[0];
+    if (first.x !== 0 || first.y !== 0 || first.width !== width || first.height !== height) {
+        const pixels = new Uint8Array(width * height * 4);
+        for (let y = 0; y < first.height && first.y + y < height; y++) {
+            const row = first.pixels.subarray(y * first.width * 4, (y * first.width + Math.min(first.width, width - first.x)) * 4);
+            pixels.set(row, ((first.y + y) * width + first.x) * 4);
+        }
+        frames = [{ ...first, x: 0, y: 0, width, height, pixels }, ...frames.slice(1)];
+    }
+    for (const f of frames)
+        if (f.x < 0 || f.y < 0 || f.x + f.width > width || f.y + f.height > height || !f.width || !f.height)
+            throw new RangeError('PNG: APNG frames have to lie within the canvas');
+    const images = frames.map(f => aligned(f.pixels.subarray(0, f.width * f.height * 4)));
+    const format = pixelFormat(images);
+    const { channels, depth, palette, transparency } = format;
+    const filterRows = level > 0 && !palette;
+    const header = new Uint8Array(13);
+    const hv = new DataView(header.buffer);
+    hv.setUint32(0, width);
+    hv.setUint32(4, height);
+    header[8] = depth;
+    header[9] = palette ? 3 : CHANNELS_TO_COLOR_TYPE[channels];
+    const actl = new Uint8Array(8);
+    new DataView(actl.buffer).setUint32(0, frames.length);
+    new DataView(actl.buffer).setUint32(4, plays);
+    const chunks = [chunk(IHDR, header), chunk(acTL, actl)];
+    if (palette)
+        chunks.push(chunk(PLTE, palette));
+    if (transparency)
+        chunks.push(chunk(tRNS, transparency));
+    chunks.push(...textChunks(text));
+    let sequence = 0;
+    for (let i = 0; i < frames.length; i++) {
+        const f = frames[i];
+        const fctl = new Uint8Array(26);
+        const v = new DataView(fctl.buffer);
+        v.setUint32(0, sequence++);
+        v.setUint32(4, f.width);
+        v.setUint32(8, f.height);
+        v.setUint32(12, f.x);
+        v.setUint32(16, f.y);
+        const ms = Math.max(0, Math.round(f.duration));
+        if (ms <= 65535) {
+            v.setUint16(20, ms);
+            v.setUint16(22, 1000);
+        }
+        else {
+            v.setUint16(20, Math.min(65535, Math.round(ms / 10)));
+            v.setUint16(22, 100);
+        }
+        fctl[24] = f.dispose;
+        fctl[25] = f.blend === false ? 0 : 1;
+        chunks.push(chunk(fcTL, fctl));
+        const data = await compressRows(format.convert(images[i], f.width, f.height), f.width, f.height, channels, depth, level, filterRows);
+        if (i === 0)
+            chunks.push(chunk(IDAT, data));
         else {
-            data[o++] = rgba[s];
-            data[o++] = rgba[s + 1];
-            data[o++] = rgba[s + 2];
+            const body = new Uint8Array(data.length + 4);
+            new DataView(body.buffer).setUint32(0, sequence++);
+            body.set(data, 4);
+            chunks.push(chunk(fdAT, body));
         }
-        if (!opaque)
-            data[o++] = rgba[s + 3];
     }
-    return encode(data, { ...options, channels });
+    chunks.push(chunk(IEND, new Uint8Array(0)));
+    return concat([HEAD, ...chunks]);
 }
-export async function decode(array) {
+function parse(array) {
     const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
     for (let i = 0; i < HEAD.length; i++)
         if (array[i] !== HEAD[i])
@@ -158,6 +302,11 @@ export async function decode(array) {
     const idat = [];
     let exif = null;
     const text = [];
+    let animation = null;
+    const frames = [];
+    let current = null;
+    let sequence = 0;
+    let animationError = false;
     let offset = 8;
     while (offset + 8 <= array.length) {
         const length = view.getUint32(offset);
@@ -193,8 +342,46 @@ export async function decode(array) {
                 throw new Error('PNG: tRNS can only occur once in an image');
             transparency = chunk;
         }
-        else if (type === IDAT)
+        else if (type === IDAT) {
             idat.push(chunk);
+            if (current && !frames.length)
+                frames.push(current);
+        }
+        else if (type === acTL) {
+            if (animation || idat.length || length < 8)
+                animationError = true;
+            else
+                animation = { frames: view.getUint32(start), plays: view.getUint32(start + 4) };
+        }
+        else if (type === fcTL) {
+            if (length < 26 || view.getUint32(start) !== sequence++)
+                animationError = true;
+            if (animationError) {
+                offset = end + 4;
+                continue;
+            }
+            const num = view.getUint16(start + 20), den = view.getUint16(start + 22) || 100;
+            current = {
+                control: {
+                    width: view.getUint32(start + 4),
+                    height: view.getUint32(start + 8),
+                    x: view.getUint32(start + 12),
+                    y: view.getUint32(start + 16),
+                    delay: num * 1000 / den,
+                    dispose: chunk[24],
+                    blend: chunk[25]
+                },
+                data: idat.length ? [] : idat
+            };
+            if (idat.length)
+                frames.push(current);
+        }
+        else if (type === fdAT) {
+            if (length < 4 || view.getUint32(start) !== sequence++ || !current || current.data === idat)
+                animationError = true;
+            else
+                current.data.push(chunk.subarray(4));
+        }
         else if (type === eXIf)
             exif ??= chunk;
         else if (type === tEXt || type === zTXt || type === iTXt)
@@ -207,7 +394,7 @@ export async function decode(array) {
         throw new Error('PNG: missing IHDR');
     if (!idat.length)
         throw new Error('PNG: missing IDAT');
-    const { width, height, depth, colorType, interlace } = header;
+    const { width, height, depth, colorType } = header;
     const channels = COLOR_TYPE_CHANNELS[colorType];
     if (!channels)
         throw new Error(`PNG: invalid color type ${colorType}`);
@@ -217,6 +404,17 @@ export async function decode(array) {
         throw new Error('PNG: invalid dimensions');
     if (colorType === 3 && !palette)
         throw new Error('PNG: indexed color image has no PLTE');
+    if (animation) {
+        if (frames.length > animation.frames)
+            frames.length = animation.frames;
+        if (!frames.length || frames.length < animation.frames || frames.some(f => !f.data.length))
+            animationError = true;
+    }
+    return { header, palette, transparency, idat, exif, text, animation, frames, animationError };
+}
+async function decodeImageData(p, chunks, width, height) {
+    const { depth, colorType, interlace } = p.header;
+    const channels = COLOR_TYPE_CHANNELS[colorType];
     const bitsPerPixel = channels * depth;
     const bpp = Math.max(1, bitsPerPixel >> 3);
     const passes = interlace ? ADAM7.map(([xs, ys, dx, dy]) => [xs, ys, dx, dy, Math.ceil((width - xs) / dx), Math.ceil((height - ys) / dy)]) : [[0, 0, 1, 1, width, height]];
@@ -226,11 +424,13 @@ export async function decode(array) {
         if (pw > 0 && ph > 0)
             expected += ph * (1 + Math.ceil(pw * bitsPerPixel / 8));
     }
-    const data = await decompressAsync(idat.length === 1 ? idat[0] : concat(idat), expected);
+    if (!chunks.length)
+        throw new Error('PNG: missing image data');
+    const data = await decompressAsync(chunks.length === 1 ? chunks[0] : concat(chunks), expected);
     if (data.length < expected)
         throw new Error('PNG: image data is truncated');
     const rgba = new Uint8Array(width * height * 4);
-    const toRGBA = createConverter(colorType, depth, palette, transparency);
+    const toRGBA = createConverter(colorType, depth, p.palette, p.transparency);
     let dataOffset = 0;
     for (const [xs, ys, dx, dy, pw, ph] of passes) {
         if (pw <= 0 || ph <= 0)
@@ -241,7 +441,73 @@ export async function decode(array) {
         dataOffset += size + ph;
         toRGBA(pixels, rowBytes, pw, ph, rgba, { row: y => ((ys + y * dy) * width + xs) * 4, step: dx * 4 });
     }
-    return { width, height, pixels: rgba, orientation: exif ? exifOrientation(exif) : await textOrientation(text) };
+    return rgba;
+}
+export async function decode(array) {
+    const p = parse(array);
+    const { width, height } = p.header;
+    const pixels = await decodeImageData(p, p.idat, width, height);
+    return { width, height, pixels, orientation: p.exif ? exifOrientation(p.exif) : await textOrientation(p.text) };
+}
+export function isAnimated(array) {
+    try {
+        const p = parse(array);
+        return p.animation !== null && !p.animationError;
+    }
+    catch {
+        return false;
+    }
+}
+export async function decodeAnimation(array, onlyFirstFrame = false) {
+    const p = parse(array);
+    const { width, height } = p.header;
+    if (!p.animation || p.animationError) {
+        const pixels = await decodeImageData(p, p.idat, width, height);
+        return { width, height, plays: 0, frames: [{ x: 0, y: 0, width, height, duration: 0, dispose: 0, blend: 0, pixels }] };
+    }
+    const frames = [];
+    for (const { control: c, data } of p.frames) {
+        if (!c.width || !c.height || c.x + c.width > width || c.y + c.height > height)
+            throw new Error('PNG: invalid APNG frame region');
+        frames.push({
+            x: c.x, y: c.y, width: c.width, height: c.height, duration: c.delay,
+            dispose: !frames.length && c.dispose === 2 ? 1 : c.dispose,
+            blend: c.blend,
+            pixels: await decodeImageData(p, data, c.width, c.height)
+        });
+        if (onlyFirstFrame)
+            break;
+    }
+    return { width, height, plays: p.animation.plays, frames };
+}
+export function compositeAnimation({ width, height, frames }) {
+    const canvas = new Uint8Array(width * height * 4);
+    const output = [];
+    for (const f of frames) {
+        const previous = f.dispose === 2 ? canvas.slice() : null;
+        for (let y = 0; y < f.height; y++)
+            for (let x = 0; x < f.width; x++) {
+                const s = (y * f.width + x) * 4, d = ((f.y + y) * width + f.x + x) * 4;
+                const sa = f.pixels[s + 3], da = canvas[d + 3];
+                if (f.blend === 0 || sa === 255 || da === 0) {
+                    if (f.blend === 0 || sa !== 0)
+                        canvas.set(f.pixels.subarray(s, s + 4), d);
+                }
+                else if (sa !== 0) {
+                    const u = sa * 255, v = (255 - sa) * da, al = u + v;
+                    for (let c = 0; c < 3; c++)
+                        canvas[d + c] = (f.pixels[s + c] * u + canvas[d + c] * v) / al | 0;
+                    canvas[d + 3] = al / 255 | 0;
+                }
+            }
+        output.push({ pixels: canvas.slice(), duration: f.duration });
+        if (f.dispose === 1)
+            for (let y = 0; y < f.height; y++)
+                canvas.fill(0, ((f.y + y) * width + f.x) * 4, ((f.y + y) * width + f.x + f.width) * 4);
+        else if (previous)
+            canvas.set(previous);
+    }
+    return output;
 }
 const RAW_EXIF = /^Raw profile type (exif|APP1)$/;
 const XMP = 'XML:com.adobe.xmp';
@@ -330,7 +596,8 @@ function unfilter(data, offset, height, rowBytes, bpp) {
                 for (let i = row + bpp; i < row + rowBytes; i++) {
                     const a = out[i - bpp], b = out[i - rowBytes], c = out[i - rowBytes - bpp];
                     const pa = Math.abs(b - c), pb = Math.abs(a - c), pc = Math.abs(a + b - 2 * c);
-                    out[i] = data[src + i] + (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
+                    const notA = (pb - pa | pc - pa) >> 31, takeC = (pc - pb) >> 31;
+                    out[i] = data[src + i] + (a ^ (a ^ b ^ (b ^ c) & takeC) & notA);
                 }
             }
         }
@@ -392,6 +659,20 @@ function createConverter(colorType, depth, palette, transparency) {
         const key = transparency && transparency.length >= 6
             ? [transparency[0] << 8 | transparency[1], transparency[2] << 8 | transparency[3], transparency[4] << 8 | transparency[5]].map(v => v & maxValue)
             : null;
+        if (depth === 8) {
+            const [kr, kg, kb] = key || [-1, -1, -1];
+            return (pixels, rowBytes, w, h, out, place) => {
+                for (let y = 0; y < h; y++) {
+                    for (let x = 0, s = y * rowBytes, o = place.row(y), step = place.step; x < w; x++, s += 3, o += step) {
+                        const r = pixels[s], g = pixels[s + 1], b = pixels[s + 2];
+                        out[o] = r;
+                        out[o + 1] = g;
+                        out[o + 2] = b;
+                        out[o + 3] = r === kr && g === kg && b === kb ? 0 : 0xff;
+                    }
+                }
+            };
+        }
         return (pixels, rowBytes, w, h, out, place) => {
             for (let y = 0; y < h; y++) {
                 const row = pixels.subarray(y * rowBytes, (y + 1) * rowBytes);
@@ -423,9 +704,14 @@ function createConverter(colorType, depth, palette, transparency) {
         return (pixels, rowBytes, w, h, out, place) => {
             if (place.step === 4 && w * 4 === rowBytes && place.row(0) === 0 && place.row(1) === rowBytes)
                 return out.set(pixels);
-            for (let y = 0; y < h; y++)
-                for (let x = 0, o = place.row(y); x < w; x++, o += place.step)
-                    out.set(pixels.subarray(y * rowBytes + x * 4, y * rowBytes + x * 4 + 4), o);
+            for (let y = 0; y < h; y++) {
+                for (let x = 0, s = y * rowBytes, o = place.row(y), step = place.step; x < w; x++, s += 4, o += step) {
+                    out[o] = pixels[s];
+                    out[o + 1] = pixels[s + 1];
+                    out[o + 2] = pixels[s + 2];
+                    out[o + 3] = pixels[s + 3];
+                }
+            }
         };
     }
     return (pixels, rowBytes, w, h, out, place) => {

package/dist/codecs/quantize.js

@@ -9,9 +9,9 @@ export function dominantColor(pixels, include, clusters = 8) {
             best = i;
     return [Math.round(palette[best * 3]), Math.round(palette[best * 3 + 1]), Math.round(palette[best * 3 + 2])];
 }
-export function quantize(pixels, width, { maxColors = 256, quality = 95 } = {}) {
+export function quantize(pixels, width, { maxColors = 256, quality = 95, transparent = false } = {}) {
     const length = pixels.length >> 2;
-    let hasTransparency = false;
+    let hasTransparency = transparent;
     for (let i = 3; i < pixels.length; i += 4)
         if (pixels[i] < 128) {
             hasTransparency = true;