imagescript 3.0.0 → 3.1.0

package/README.md

@@ -9,7 +9,7 @@
 
 **ImageScript** is a zero-dependency alternative to common JavaScript bitmap image manipulation tools. Every codec and
 renderer is written in TypeScript: no WebAssembly, no native binaries, no npm dependencies, no install scripts. The
-package is about 120 kB (compressed) and runs in Node.js 22.13 or newer (including Alpine/musl, ARM and bundled
+package is about 140 kB (compressed) and runs in Node.js 22.13 or newer (including Alpine/musl, ARM and bundled
 serverless functions), Deno, Bun and browsers. It works with both `import` and `require()`, type definitions are included.
 
 ```sh
@@ -25,11 +25,15 @@ deno add jsr:@matmen/imagescript     # Deno (npm:imagescript works too)
   - PNGs (grayscale, RGB, indexed colors, 1-16 bit, interlaced) with and without alpha channels
   - JPEGs (baseline and progressive; grayscale, RGB, CMYK)
   - TIFFs (strips and tiles; uncompressed, LZW, deflate, PackBits and JPEG compressed; BigTIFF)
-  - JPEGs, TIFFs and PNGs are rotated as their Exif (or, for PNGs, XMP) orientation says
-- [Decoding GIFs](https://imagescript.matmen.dev/classes/GIF.html#decode) with all frames, durations and disposal modes
+  - WebPs (lossy, lossless and with alpha; bit-exact with libwebp)
+  - TGAs (color mapped, truecolor and greyscale; uncompressed and run length encoded)
+  - JPEGs, TIFFs, PNGs and WebPs are rotated as their Exif (or, for PNGs, XMP) orientation says
+- [Decoding animations](https://imagescript.matmen.dev/classes/Animation.html#decode) (GIF, APNG and WebP) with all
+  frames, durations and disposal modes
 - [Rendering SVGs](https://imagescript.matmen.dev/classes/Image.html#rendersvg) (shapes, paths, gradients, strokes, clip paths,
   masks, CSS; no text, images or filters)
-- [Rendering vector fonts](https://imagescript.matmen.dev/classes/Image.html#rendertext) (TrueType and OpenType, with kerning and outlines)
+- [Rendering vector fonts](https://imagescript.matmen.dev/classes/Image.html#rendertext) (TrueType and OpenType, with kerning,
+  outlines and TrueType hinting)
 - [Resizing](https://imagescript.matmen.dev/classes/Image.html#resize) (bilinear, bicubic, area averaging and nearest neighbor)
 - Image manipulation functions ([crop](https://imagescript.matmen.dev/classes/Image.html#crop)
   , [rotate](https://imagescript.matmen.dev/classes/Image.html#rotate)
@@ -39,12 +43,17 @@ deno add jsr:@matmen/imagescript     # Deno (npm:imagescript works too)
   , [sharpen](https://imagescript.matmen.dev/classes/Image.html#sharpen)
   , [brightness](https://imagescript.matmen.dev/classes/Image.html#brightness)
   , [hueShift](https://imagescript.matmen.dev/classes/Image.html#hueshift), ...)
-- Compositing with opacity and blend modes ([composite](https://imagescript.matmen.dev/classes/Image.html#composite))
+- Compositing with opacity and blend modes ([composite](https://imagescript.matmen.dev/classes/Image.html#composite)),
+  removing backgrounds ([colorToAlpha](https://imagescript.matmen.dev/classes/Image.html#colortoalpha))
 - Color information functions ([averageColor](https://imagescript.matmen.dev/classes/Image.html#averagecolor)
   , [dominantColor](https://imagescript.matmen.dev/classes/Image.html#dominantcolor), ...)
 - Encoding images as [PNGs](https://imagescript.matmen.dev/classes/Image.html#encode) (smallest lossless color type)
   , [JPEGs](https://imagescript.matmen.dev/classes/Image.html#encodejpeg)
-  and animated [GIFs](https://imagescript.matmen.dev/classes/GIF.html#encode)
+  , lossless [WebPs](https://imagescript.matmen.dev/classes/Image.html#encodewebp)
+  and [TGAs](https://imagescript.matmen.dev/classes/Image.html#encodetga)
+- Encoding animations as [GIF](https://imagescript.matmen.dev/classes/Animation.html#encodegif),
+  [APNG](https://imagescript.matmen.dev/classes/Animation.html#encodeapng) and lossless
+  [WebP](https://imagescript.matmen.dev/classes/Animation.html#encodewebp)
 
 ---
 
@@ -82,7 +91,10 @@ The deflate/inflate implementation is derived from [fflate](https://github.com/1
 [Fast CRC32 in JavaScript](https://gist.github.com/101arrowz/e58695f7ccfdf74f60ba22018093edea), both by Arjun Barrett.
 The JPEG codec is based in part on the work of the Independent JPEG Group (libjpeg) and on
 [pdf.js](https://github.com/mozilla/pdf.js), the glyph rasterizer is translated from
-[font-rs](https://github.com/raphlinus/font-rs). See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for their licenses.
+[font-rs](https://github.com/raphlinus/font-rs). The WebP codecs follow [RFC 9649](https://www.rfc-editor.org/rfc/rfc9649) and [RFC 6386](https://www.rfc-editor.org/rfc/rfc6386)
+and reproduce [libwebp](https://chromium.googlesource.com/webm/libwebp)'s color conversion, the TrueType hinting follows
+[FreeType](https://freetype.org)'s interpreter (portions of this software are copyright © 2026 The FreeType Project).
+See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for their licenses.
 
 ---
 

package/THIRD_PARTY_NOTICES.md

@@ -10,6 +10,10 @@ following projects, under their own licenses. Each derived file says so in its h
 | [libjpeg](https://ijg.org/) / [libjpeg-turbo](https://libjpeg-turbo.org/) by the Independent JPEG Group | `src/codecs/jpeg.ts` (IDCT, FDCT, upsampling, color conversion, progressive refinement, optimal Huffman tables) | IJG |
 | [pdf.js](https://github.com/mozilla/pdf.js) (forked from [jpgjs](https://github.com/notmasteryet/jpgjs) by notmasteryet) | `src/codecs/jpeg.ts` (structure of the scan decoder) | Apache-2.0 |
 | [font-rs](https://github.com/raphlinus/font-rs) by Raph Levien | `src/render/text.ts` (the `Rasterizer` class, also used for SVGs) | Apache-2.0 |
+| [RFC 9649](https://www.rfc-editor.org/rfc/rfc9649) (WebP Image Format) | `src/codecs/vp8l.ts` (lossless bitstream, short distance code table), `src/codecs/webp.ts` (container) | BSD-3-Clause (Revised BSD) |
+| [RFC 6386](https://www.rfc-editor.org/rfc/rfc6386) (VP8 Data Format and Decoding Guide, with the libvpx reference decoder) | `src/codecs/vp8-tables.ts` (probability and quantizer tables), `src/codecs/vp8.ts` (decoding procedures) | BSD-3-Clause |
+| [libwebp](https://chromium.googlesource.com/webm/libwebp) | `src/codecs/vp8.ts` (YUV to RGB conversion, "fancy" chroma upsampling), `src/codecs/webp.ts` (animation frame blending) | BSD-3-Clause |
+| [FreeType](https://freetype.org) | `src/render/hinting.ts` (behavior and parts of the logic of the TrueType interpreter) | FreeType License |
 
 ## fflate, Fast CRC32 in JavaScript
 
@@ -72,3 +76,81 @@ The scan decoder of `src/codecs/jpeg.ts` follows the structure of pdf.js' `src/c
 one decode function per scan type). The `Rasterizer` class in `src/render/text.ts` is a translation of font-rs'
 `Raster` from Rust to TypeScript (`draw_line`, `draw_quad`, `accumulate`); its `cubic` method is adapted from
 `draw_quad`. The full license text is in [licenses/Apache-2.0.txt](licenses/Apache-2.0.txt).
+
+## RFC 6386, libwebp
+
+The VP8 decoder follows the procedures of RFC 6386 and its reference decoder, its constant tables are extracted from
+the RFC. To decode exactly like libwebp, the YUV to RGB conversion, the chroma upsampling and the blending of animation
+frames reproduce libwebp's integer arithmetic.
+
+```
+RFC 6386 reference decoder: Copyright (c) 2010, 2011, Google Inc. All rights reserved.
+libwebp: Copyright (c) 2010, Google Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+  * Neither the name of Google nor the names of its contributors may
+    be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```
+
+The RFC's reference decoder additionally comes with Google's patent grant for VP8 (RFC 6386 section 20.27).
+
+## RFC 9649
+
+The WebP container and the lossless (VP8L) codec follow RFC 9649, the short distance code table is taken from it.
+
+```
+Copyright (c) 2024 IETF Trust and the persons identified as authors of the code. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+  disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other materials provided with the distribution.
+- Neither the name of Internet Society, IETF or IETF Trust, nor the names of specific contributors, may be used to
+  endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```
+
+## FreeType
+
+Portions of this software are copyright © 2026 The FreeType Project (https://freetype.org). All rights reserved.
+
+The TrueType hinting interpreter in `src/render/hinting.ts` is written after the TrueType instruction specification.
+Where the specification leaves details open, its behavior and parts of its logic follow FreeType's interpreter
+(`src/truetype/ttinterp.c`): the fixed point rounding, measuring original distances on the unscaled outline, the
+interpolation of untouched points (IUP), the handling of near-perpendicular freedom and projection vectors, and the
+tolerance of invalid references. FreeType is used under the FreeType License, included as
+[licenses/FTL.txt](licenses/FTL.txt).

package/dist/animation.d.ts

@@ -0,0 +1,55 @@
+import { BinaryData } from './util/mem.js';
+import { ResizeMode } from './image.js';
+import { Frame } from './frame.js';
+/**
+ * An animation: an array of frames that can be decoded from and encoded to GIF, APNG and WebP.
+ * Array methods like map and filter return plain arrays.
+ */
+export declare class Animation extends Array<Frame> {
+    /** How many times to repeat the animation (-1 = forever, 0 = play once) */
+    loopCount: number;
+    /**
+     * Creates a new animation
+     * @param frames The frames to create the animation from
+     * @param loopCount How many times to repeat the animation (-1 = forever, 0 = play once)
+     */
+    constructor(frames: Frame[], loopCount?: number);
+    /** The animation's width */
+    get width(): number;
+    /** The animation's height */
+    get height(): number;
+    /** The animation's duration (in ms) */
+    get duration(): number;
+    toString(): string;
+    /**
+     * Returns a new animation of the same class containing a range of this one's frames
+     * (same semantics as Array.prototype.slice)
+     */
+    slice(start?: number, end?: number): this;
+    /**
+     * Resizes the animation to the given dimensions, scaling every frame and its offsets proportionally.
+     * Use {@link Image.RESIZE_AUTO} as either width or height to automatically preserve the aspect ratio.
+     */
+    resize(width: number, height: number, mode?: ResizeMode): this;
+    /**
+     * Encodes the animation as GIF
+     * @param quality 1-100, scales the palette size from 8 colors (1) to 256 colors (90 and above)
+     */
+    encodeGIF(quality?: number): Promise<Uint8Array>;
+    /**
+     * Encodes the animation as APNG (animated PNG, lossless and with full alpha). Viewers without APNG support show
+     * the first frame
+     * @param compression The zlib compression level (0-9), higher is smaller but slower
+     */
+    encodeAPNG(compression?: number): Promise<Uint8Array>;
+    /**
+     * Encodes the animation as lossless animated WebP
+     */
+    encodeWebP(): Promise<Uint8Array>;
+    /**
+     * Decodes an animated GIF, APNG or WebP into fully composited frames (still images become a single frame)
+     * @param input The binary data to decode
+     * @param onlyExtractFirstFrame Whether to stop decoding after the first frame
+     */
+    static decode(input: BinaryData, onlyExtractFirstFrame?: boolean): Promise<Animation>;
+}

package/dist/animation.js

@@ -0,0 +1,167 @@
+import * as gifCodec from "./codecs/gif.js";
+import * as png from "./codecs/png.js";
+import * as webp from "./codecs/webp.js";
+import { view } from "./util/mem.js";
+import { Image } from "./image.js";
+import { Frame } from "./frame.js";
+import { ImageType } from "./image-type.js";
+const toPlays = (loopCount) => loopCount < 0 ? 0 : loopCount + 1;
+const fromPlays = (plays) => plays === 0 ? -1 : plays - 1;
+function canvasFrames(width, height, frames) {
+    return frames.map(({ pixels, duration }) => {
+        const frame = new Frame(width, height, duration, 0, 0, Frame.DISPOSAL_BACKGROUND);
+        frame.bitmap.set(pixels);
+        return frame;
+    });
+}
+export class Animation extends Array {
+    loopCount;
+    constructor(frames, loopCount = -1) {
+        super();
+        for (const frame of frames)
+            this.push(frame);
+        for (let i = 0; i < this.length; i++)
+            if (!(this[i] instanceof Frame))
+                throw new TypeError(`Frame ${i} is not an instance of Frame`);
+        if (loopCount < -1 || isNaN(loopCount))
+            throw new RangeError('Invalid loop count');
+        this.loopCount = loopCount;
+    }
+    static get [Symbol.species]() {
+        return Array;
+    }
+    get width() {
+        let max = 0;
+        for (const frame of this)
+            max = Math.max(max, frame.width + frame.xOffset);
+        return max;
+    }
+    get height() {
+        let max = 0;
+        for (const frame of this)
+            max = Math.max(max, frame.height + frame.yOffset);
+        return max;
+    }
+    get duration() {
+        let duration = 0;
+        for (const frame of this)
+            duration += frame.duration;
+        return duration;
+    }
+    toString() {
+        return `Animation<${this.width}x${this.height}x${this.duration}ms>`;
+    }
+    slice(start, end) {
+        const Class = this.constructor;
+        return new Class(Array.prototype.slice.call(this, start, end), this.loopCount);
+    }
+    resize(width, height, mode = Image.RESIZE_BILINEAR) {
+        const originalWidth = this.width, originalHeight = this.height;
+        if (width === Image.RESIZE_AUTO && height === Image.RESIZE_AUTO)
+            throw new Error('RESIZE_AUTO can only be used for either width or height, not for both');
+        if (width === Image.RESIZE_AUTO)
+            width = originalWidth / originalHeight * height;
+        if (height === Image.RESIZE_AUTO)
+            height = originalHeight / originalWidth * width;
+        const sx = width / originalWidth, sy = height / originalHeight;
+        for (const frame of this) {
+            const left = Math.round(frame.xOffset * sx), top = Math.round(frame.yOffset * sy);
+            const right = Math.round((frame.xOffset + frame.width) * sx), bottom = Math.round((frame.yOffset + frame.height) * sy);
+            Image.prototype.resize.call(frame, Math.max(1, right - left), Math.max(1, bottom - top), mode);
+            frame.xOffset = left;
+            frame.yOffset = top;
+        }
+        return this;
+    }
+    __validate__() {
+        for (const frame of this)
+            if (!(frame instanceof Frame))
+                throw new Error('Animation contains invalid frames');
+    }
+    async encodeGIF(quality = 95) {
+        this.__validate__();
+        const frames = [];
+        for (const frame of this)
+            frames.push({
+                x: frame.xOffset,
+                y: frame.yOffset,
+                width: frame.width,
+                height: frame.height,
+                delay: Math.round(frame.duration / 10),
+                dispose: frame.__disposal_id__,
+                pixels: new Uint8Array(frame.bitmap.buffer, frame.bitmap.byteOffset, frame.bitmap.byteLength)
+            });
+        return gifCodec.encode({ width: this.width, height: this.height, loopCount: this.loopCount, frames }, quality);
+    }
+    async encodeAPNG(compression = 1) {
+        this.__validate__();
+        if (!this.length)
+            throw new Error('An animation needs at least one frame');
+        return png.encodeAnimation(this.__apngFrames__(), this.width, this.height, toPlays(this.loopCount), compression);
+    }
+    async encodeWebP() {
+        this.__validate__();
+        if (!this.length)
+            throw new Error('An animation needs at least one frame');
+        const width = this.width, height = this.height;
+        const fullFrames = this.some(f => f.disposalMode === 'previous' || (f.disposalMode === 'background' && (f.xOffset & 1 || f.yOffset & 1)));
+        if (fullFrames) {
+            const canvases = png.compositeAnimation({ width, height, frames: this.__apngFrames__() });
+            return webp.encodeAnimation(canvases.map(c => ({ x: 0, y: 0, width, height, duration: c.duration, dispose: true, pixels: c.pixels })), width, height, toPlays(this.loopCount));
+        }
+        const frames = Array.from(this, frame => {
+            let { xOffset: x, yOffset: y, width: w, height: h } = frame;
+            let pixels = new Uint8Array(frame.bitmap.buffer, frame.bitmap.byteOffset, frame.bitmap.byteLength);
+            if (x & 1 || y & 1) {
+                const dx = x & 1, dy = y & 1;
+                const padded = new Uint8Array((w + dx) * (h + dy) * 4);
+                for (let row = 0; row < h; row++)
+                    padded.set(pixels.subarray(row * w * 4, (row + 1) * w * 4), ((row + dy) * (w + dx) + dx) * 4);
+                pixels = padded;
+                x -= dx;
+                y -= dy;
+                w += dx;
+                h += dy;
+            }
+            return { x, y, width: w, height: h, duration: frame.duration, dispose: frame.disposalMode === 'background', pixels };
+        });
+        return webp.encodeAnimation(frames, width, height, toPlays(this.loopCount));
+    }
+    __apngFrames__() {
+        const dispose = [0, 0, 2, 1];
+        return Array.from(this, frame => ({
+            x: frame.xOffset,
+            y: frame.yOffset,
+            width: frame.width,
+            height: frame.height,
+            duration: frame.duration,
+            dispose: dispose[frame.__disposal_id__],
+            blend: 1,
+            pixels: new Uint8Array(frame.bitmap.buffer, frame.bitmap.byteOffset, frame.bitmap.byteLength)
+        }));
+    }
+    static async decode(input, onlyExtractFirstFrame = false) {
+        const data = view(input);
+        const type = ImageType.getType(data);
+        if (type === 'gif')
+            return Animation.__fromGIF__(data, onlyExtractFirstFrame, Animation);
+        if (type === 'webp') {
+            const decoded = webp.decodeAnimation(data, onlyExtractFirstFrame);
+            const frames = canvasFrames(decoded.width, decoded.height, webp.composite(decoded));
+            return new Animation(frames, fromPlays(decoded.loopCount));
+        }
+        if (type === 'png') {
+            const decoded = await png.decodeAnimation(data, onlyExtractFirstFrame);
+            const frames = canvasFrames(decoded.width, decoded.height, png.compositeAnimation(decoded));
+            return new Animation(frames, decoded.frames.length > 1 ? fromPlays(decoded.plays) : -1);
+        }
+        if (type)
+            return new Animation([Frame.from(await Image.decode(data), 0)]);
+        throw new Error('Unsupported image type');
+    }
+    static __fromGIF__(data, onlyExtractFirstFrame, Class) {
+        const decoded = gifCodec.decode(data, onlyExtractFirstFrame);
+        const frames = gifCodec.composite(decoded).map(({ pixels, delay }) => ({ pixels, duration: 10 * delay }));
+        return new Class(canvasFrames(decoded.width, decoded.height, frames), decoded.loopCount);
+    }
+}

package/dist/codecs/png.d.ts

@@ -27,18 +27,71 @@ export interface Decoded {
  */
 export declare function encode(data: Uint8Array, { text, width, height, channels, depth, level, palette, transparency, filter: filterRows }: EncodeOptions): Promise<Uint8Array>;
 /**
- * Encodes 8-bit RGBA pixels into a PNG with the smallest lossless color type:
- * a palette for up to 256 colors, otherwise greyscale or RGB, with alpha only if a pixel isn't opaque.
+ * Encodes 8-bit RGBA pixels into a PNG with the smallest lossless color type (see {@link pixelFormat}).
  * Rows of non-palette images are paeth filtered (unless the data isn't compressed), palette indices aren't
  * filtered (like libpng recommends)
  */
 export declare function encodeRGBA(rgba: Uint8Array, width: number, height: number, level: number, text?: EncodeOptions['text']): Promise<Uint8Array>;
+export interface APNGEncodeFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** milliseconds (stored as a fraction of up to 65535/65535 seconds) */
+    duration: number;
+    /** 0 none, 1 background (transparent), 2 previous */
+    dispose: number;
+    /** RGBA */
+    pixels: Uint8Array;
+}
+/**
+ * Encodes frames into an APNG. Frames are alpha blended onto the canvas ("over"); the first frame is also the
+ * default image that viewers without APNG support show
+ * @param plays How often to play the animation, 0 = forever
+ */
+export declare function encodeAnimation(frames: APNGEncodeFrame[], width: number, height: number, plays: number, level: number): Promise<Uint8Array>;
 /**
- * Decodes a PNG into 8-bit RGBA pixel data
+ * Decodes a PNG into 8-bit RGBA pixel data (for APNGs, the default image)
  * Supports all color types, bit depths, tRNS transparency and adam7 interlacing
  * The orientation comes from the eXIf chunk, or, if there is none, from the Exif text ImageMagick wrote before eXIf
  * existed ("Raw profile type exif") or from the XMP packet
- * @param {Uint8Array} array The PNG data
- * @return {{width: number, height: number, pixels: Uint8Array, orientation: number}}
  */
 export declare function decode(array: Uint8Array): Promise<Decoded>;
+export interface APNGFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** milliseconds */
+    duration: number;
+    /** 0 none, 1 background (transparent), 2 previous */
+    dispose: number;
+    /** 0 source (replace), 1 over */
+    blend: number;
+    pixels: Uint8Array;
+}
+/** Whether the PNG is an APNG (has an acTL chunk) */
+export declare function isAnimated(array: Uint8Array): boolean;
+/**
+ * Decodes an APNG (https://wiki.mozilla.org/APNG_Specification) into its (uncomposited) frames; a plain PNG becomes
+ * a single frame
+ * @return plays: 0 = forever
+ */
+export declare function decodeAnimation(array: Uint8Array, onlyFirstFrame?: boolean): Promise<{
+    width: number;
+    height: number;
+    plays: number;
+    frames: APNGFrame[];
+}>;
+/**
+ * Composites APNG frames onto the canvas, as the APNG specification describes (the integer "over" operation of its
+ * blend_op section, https://wiki.mozilla.org/APNG_Specification)
+ */
+export declare function compositeAnimation({ width, height, frames }: {
+    width: number;
+    height: number;
+    frames: APNGFrame[];
+}): Array<{
+    pixels: Uint8Array;
+    duration: number;
+}>;