imagescript 1.3.1 → 3.1.0

package/LICENSE

@@ -9,4 +9,7 @@ mentioned licenses, but a license must be chosen.
 
 The corresponding license files can be found in the projects
 root directory, prefixed with LICENSE, suffixed with their
-corresponding SPDX identifier.
+corresponding SPDX identifier.
+
+Parts of this software are derived from third party projects under their
+own licenses (MIT, Apache-2.0 and the IJG license), see THIRD_PARTY_NOTICES.md.

package/README.md

@@ -3,49 +3,99 @@
 [![Discord Server](https://img.shields.io/discord/691713541262147687.svg?label=Discord&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2&style=for-the-badge)](https://discord.gg/8hPrwAH)
 [![Documentation](https://img.shields.io/badge/Documentation-informational?style=for-the-badge)](https://imagescript.matmen.dev/)
 [![Github](https://img.shields.io/badge/Github-Repository-181717?logo=github&style=for-the-badge)](https://github.com/matmen/ImageScript)
-[![deno.land](https://shields.io/badge/deno.land-gray?logo=deno&style=for-the-badge)](https://deno.land/x/imagescript)
 [![NPM](https://nodei.co/npm/imagescript.png)](https://www.npmjs.com/package/imagescript)
 
 ---
 
-**ImageScript** is a zero-dependency alternative to common JavaScript bitmap image manipulation tools. It can achieve
-much more performant results by utilizing lower-level memory access, less memory copying and WebAssembly / native
-binaries for decoding and encoding.
+**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 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
+npm install imagescript              # Node.js, Bun and bundlers
+deno add jsr:@matmen/imagescript     # Deno (npm:imagescript works too)
+```
 
 ---
 
 ### Features
 
-- [Decoding images](https://imagescript.matmen.dev/Image.html#.decode)
-  - PNGs (grayscale, RGB, indexed colors) with and without alpha channels
-  - JPEGs (grayscale, RGB, CMYK)
-  - TIFFs
-- [Decoding GIFs](https://imagescript.matmen.dev/GIF.html#.decode)
-- [Rendering SVGs](https://imagescript.matmen.dev/Image.html#.renderSVG)
-- [Rendering vector fonts](https://imagescript.matmen.dev/Image.html#.renderText)
-- Image manipulation functions ([crop](https://imagescript.matmen.dev/Image.html#crop)
-  , [rotate](https://imagescript.matmen.dev/Image.html#rotate)
-  , [composite](https://imagescript.matmen.dev/Image.html#composite), ...)
-- Color manipulation functions ([invert](https://imagescript.matmen.dev/Image.html##invert)
-  , [hueShift](https://imagescript.matmen.dev/Image.html##hueshift), ...)
-- Color information functions ([averageColor](https://imagescript.matmen.dev/Image.html#averageColor)
-  , [dominantColor](https://imagescript.matmen.dev/Image.html#dominantColor), ...)
-- Encoding images as [PNGs](https://imagescript.matmen.dev/Image.html#encode)
-  , [JPEGs](https://imagescript.matmen.dev/Image.html#encodejpeg)
-  , [WEBPs](https://imagescript.matmen.dev/Image.html#encodeWEBP)
-  and [GIFs](https://imagescript.matmen.dev/GIF.html#encode)
+- [Decoding images](https://imagescript.matmen.dev/classes/Image.html#decode)
+  - 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)
+  - 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,
+  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)
+  , [cropCircle](https://imagescript.matmen.dev/classes/Image.html#cropcircle)
+  , [roundCorners](https://imagescript.matmen.dev/classes/Image.html#roundcorners), ...)
+- Filters and color adjustments ([blur](https://imagescript.matmen.dev/classes/Image.html#blur)
+  , [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)),
+  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)
+  , 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)
 
 ---
 
 ### Example
 
-Check out one of these examples:
-* **NodeJS**: [README image generation](https://github.com/matmen/ImageScript/blob/master/tests/readme.js)
-* **Deno**: [README image generation](https://github.com/matmen/ImageScript/blob/deno/tests/readme.js)
-* **Browser**: [Grayscale Conversion Example Page](https://github.com/matmen/ImageScript/blob/browser/example/index.html) (via CDN)
+```js
+import { Image } from 'imagescript';
+import { readFile, writeFile } from 'node:fs/promises';
+
+const image = await Image.decode(await readFile('input.jpg'));
+image.resize(256, Image.RESIZE_AUTO).roundCorners(16);
+await writeFile('output.png', await image.encode());
+```
+
+With CommonJS:
+
+```js
+const { Image } = require('imagescript');
+```
+
+All coordinates are 0-based, `(0, 0)` is the top left pixel.
+
+A bigger example is the [README image generation](https://github.com/matmen/ImageScript/blob/master/tests/readme.js).
+Upgrading from 1.x? Version 3 has breaking changes (0-based coordinates, removed WebP encoding, Node.js 22.13+, ...),
+see the [changelog](https://github.com/matmen/ImageScript/blob/master/CHANGELOG.md). There is no 2.x release, the number was skipped because of the old experimental
+`imagescript/v2` API.
 
 [![Example](https://github.com/matmen/ImageScript/raw/master/tests/targets/readme.png)](https://github.com/matmen/ImageScript/blob/master/tests/readme.js)
 
 ---
 
+### Credits
+
+The deflate/inflate implementation is derived from [fflate](https://github.com/101arrowz/fflate) and the CRC-32 from
+[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). 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.
+
+---
+
 If you have any additional questions, feel free to join the [discord support server](https://discord.gg/8hPrwAH).

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,156 @@
+# Third party notices
+
+ImageScript is licensed under AGPL-3.0-or-later OR MIT (see [LICENSE](LICENSE)). Parts of it are derived from the
+following projects, under their own licenses. Each derived file says so in its header.
+
+| Project | Used in | License |
+|---|---|---|
+| [fflate](https://github.com/101arrowz/fflate) by Arjun Barrett | `src/codecs/zlib.ts` (deflate/inflate) | MIT |
+| [Fast CRC32 in JavaScript](https://gist.github.com/101arrowz/e58695f7ccfdf74f60ba22018093edea) by Arjun Barrett | `src/codecs/crc.ts` (slice-by-16 CRC-32) | MIT |
+| [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
+
+```
+MIT License
+
+Copyright (c) 2020 Arjun Barrett (fflate)
+Copyright (c) 2021 Arjun Barrett (Fast CRC32 in JavaScript)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## libjpeg / libjpeg-turbo
+
+This software is based in part on the work of the Independent JPEG Group.
+
+The JPEG codec translates parts of libjpeg (as shipped by libjpeg-turbo) to TypeScript: the integer inverse DCT
+(`jidctint.c`), the floating point forward DCT (`jfdctflt.c`), fancy upsampling (`jdsample.c`), the YCbCr to RGB
+tables (`jdcolor.c`), the progressive AC refinement (`jdphuff.c`) and the optimal Huffman table generation
+(`jcphuff.c`/`jchuff.c`). The translations were rewritten for TypeScript's numbers and typed arrays; the rest of the
+codec is ImageScript's own. libjpeg's README with its copyright and terms is included unaltered as
+[licenses/README.ijg](licenses/README.ijg).
+
+## pdf.js, font-rs
+
+```
+pdf.js: Copyright 2014 Mozilla Foundation
+font-rs: Copyright 2015 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+The scan decoder of `src/codecs/jpeg.ts` follows the structure of pdf.js' `src/core/jpg.js` (block and MCU layout,
+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/crc.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Slice-by-16 CRC-32, derived from "Fast CRC32 in JavaScript" (https://gist.github.com/101arrowz/e58695f7ccfdf74f60ba22018093edea)
+ * Copyright (c) 2021 Arjun Barrett, MIT License (see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * CRC-32 (ISO 3309), as used by PNG and zlib. Processes 16 bytes per step (slice-by-16, see #12), byte by byte so
+ * it doesn't depend on alignment or endianness
+ */
+export declare function crc32(buffer: Uint8Array): number;

package/dist/codecs/crc.js

@@ -0,0 +1,29 @@
+/*!
+ * Slice-by-16 CRC-32, derived from "Fast CRC32 in JavaScript" (https://gist.github.com/101arrowz/e58695f7ccfdf74f60ba22018093edea)
+ * Copyright (c) 2021 Arjun Barrett, MIT License (see THIRD_PARTY_NOTICES.md)
+ */
+const TABLE = new Int32Array(16 * 256);
+for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++)
+        c = c & 1 ? 0xedb88320 ^ c >>> 1 : c >>> 1;
+    TABLE[n] = c;
+}
+for (let n = 0; n < 256; n++) {
+    let c = TABLE[n];
+    for (let k = 256; k < TABLE.length; k += 256)
+        c = TABLE[k + n] = TABLE[c & 0xff] ^ c >>> 8;
+}
+export function crc32(buffer) {
+    let crc = -1, i = 0;
+    for (const end = buffer.length - 16; i <= end; i += 16) {
+        crc = TABLE[3840 + ((buffer[i] ^ crc) & 0xff)] ^ TABLE[3584 + ((buffer[i + 1] ^ crc >> 8) & 0xff)]
+            ^ TABLE[3328 + ((buffer[i + 2] ^ crc >> 16) & 0xff)] ^ TABLE[3072 + (buffer[i + 3] ^ crc >>> 24)]
+            ^ TABLE[2816 + buffer[i + 4]] ^ TABLE[2560 + buffer[i + 5]] ^ TABLE[2304 + buffer[i + 6]] ^ TABLE[2048 + buffer[i + 7]]
+            ^ TABLE[1792 + buffer[i + 8]] ^ TABLE[1536 + buffer[i + 9]] ^ TABLE[1280 + buffer[i + 10]] ^ TABLE[1024 + buffer[i + 11]]
+            ^ TABLE[768 + buffer[i + 12]] ^ TABLE[512 + buffer[i + 13]] ^ TABLE[256 + buffer[i + 14]] ^ TABLE[buffer[i + 15]];
+    }
+    for (; i < buffer.length; i++)
+        crc = TABLE[(crc ^ buffer[i]) & 0xff] ^ crc >>> 8;
+    return (crc ^ -1) >>> 0;
+}

package/dist/codecs/exif.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Reads the orientation tag (0x0112) from the first IFD of Exif data
+ * @param data a TIFF header and IFDs, optionally preceded by "Exif\0\0" (as in JPEG's APP1)
+ * @return the orientation (1-8), 1 if it is missing or invalid
+ */
+export declare function orientation(data: Uint8Array): number;
+/**
+ * Reads tiff:Orientation from an XMP packet, as attribute or element
+ * @return the orientation (1-8), 1 if it is missing or invalid
+ */
+export declare function xmpOrientation(xmp: string): number;

package/dist/codecs/exif.js

@@ -0,0 +1,27 @@
+export function orientation(data) {
+    if (data.length >= 6 && data[0] === 0x45 && data[1] === 0x78 && data[2] === 0x69 && data[3] === 0x66 && data[4] === 0 && data[5] === 0)
+        data = data.subarray(6);
+    if (data.length < 8)
+        return 1;
+    const tiff = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const little = tiff.getUint16(0) === 0x4949;
+    if (!little && tiff.getUint16(0) !== 0x4d4d)
+        return 1;
+    const ifd = tiff.getUint32(4, little);
+    if (ifd + 2 > tiff.byteLength)
+        return 1;
+    for (let i = 0, count = tiff.getUint16(ifd, little); i < count; i++) {
+        const entry = ifd + 2 + i * 12;
+        if (entry + 12 > tiff.byteLength)
+            break;
+        if (tiff.getUint16(entry, little) !== 0x0112)
+            continue;
+        const value = tiff.getUint16(entry + 8, little);
+        return value >= 1 && value <= 8 ? value : 1;
+    }
+    return 1;
+}
+export function xmpOrientation(xmp) {
+    const match = /tiff:Orientation\s*(?:=\s*["']|>\s*)([1-8])\b/.exec(xmp);
+    return match ? +match[1] : 1;
+}

package/dist/codecs/gif.d.ts

@@ -0,0 +1,44 @@
+export interface GIFFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Frame delay in centiseconds */
+    delay: number;
+    /** ImageScript disposal mode (0 any, 1 keep, 2 previous, 3 background) */
+    dispose: number;
+    /** RGBA pixel data */
+    pixels: Uint8Array;
+}
+export interface GIFData {
+    width: number;
+    height: number;
+    /** -1 loops forever, 0 plays once, n repeats n times */
+    loopCount: number;
+    frames: GIFFrame[];
+}
+/**
+ * Encodes frames into a GIF
+ * @param {{width: number, height: number, loopCount?: number, frames: GIFFrame[]}} gif loopCount -1 loops forever, 0 plays once, n repeats n times
+ * @param {number} [quality=95] 1-100, scales the palette size (1 = 8 colors, 50 = 55, 90 and above = 256)
+ * @return {Uint8Array}
+ */
+export declare function encode({ width, height, loopCount, frames }: Omit<GIFData, 'loopCount'> & {
+    loopCount?: number;
+}, quality?: number): Uint8Array;
+/**
+ * Decodes a GIF into its individual (uncomposited) frames, zero-sized images are skipped
+ * @param {Uint8Array} data
+ * @param {boolean} [onlyFirstFrame=false]
+ * @return {{width: number, height: number, loopCount: number, frames: GIFFrame[]}}
+ */
+export declare function decode(data: Uint8Array, onlyFirstFrame?: boolean): GIFData;
+/**
+ * Composites decoded frames onto the logical screen, applying their disposal modes
+ * @param {{width: number, height: number, frames: GIFFrame[]}} gif output of {@link decode}
+ * @return {Array<{pixels: Uint8Array, delay: number}>} full screen RGBA frames
+ */
+export declare function composite({ width, height, frames }: GIFData): Array<{
+    pixels: Uint8Array;
+    delay: number;
+}>;