imagescript 3.3.0 → 3.4.0

package/README.md

@@ -26,11 +26,23 @@ deno add jsr:@matmen/imagescript     # Deno (npm:imagescript works too)
   - 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)
+  - BMPs (1-64 bit, with any channel masks, alpha, RLE4 and RLE8, embedded JPEGs and PNGs; also OS/2 bitmaps)
+  - ICOs and CURs (the largest image: bitmaps with their masks, or PNGs)
+  - QOIs
+  - Netpbm images: PBM, PGM, PPM (plain and raw, up to 16 bits), PAM and PFM
+  - Radiance HDRs (RGBE and XYZE, every orientation), tone mapped to sRGB like Reinhard's operator does (or clamped,
+    `toneMapping`)
   - TGAs (color mapped, truecolor and greyscale; uncompressed and run length encoded)
+  - AVIFs (4:2:0, 4:2:2, 4:4:4 and monochrome, 8-12 bit; grids, alpha, crop, rotation and mirroring; the first frame
+    of image sequences; bit-exact with dav1d and libavif), HDR ones (PQ, HLG) tone mapped to sRGB
+  - JPEG XLs (Modular and VarDCT, lossless and lossy, every coding tool: progressive passes and LF frames, patches,
+    splines, noise, restoration filters, upsampling, JPEG recompression, layers and blending, alpha and spot colors,
+    CMYK; animations; within 1 of libjxl's djxl on the conformance suite), XYB ones as sRGB, HDR ones tone mapped to
+    sRGB
   - JPEGs, TIFFs, PNGs and WebPs are rotated as their Exif (or, for PNGs, XMP) orientation says
   - images larger than 268 megapixels (`maxPixels`) are rejected before decoding, so small files declaring huge images
     can't exhaust the memory
-- [Decoding animations](https://imagescript.matmen.dev/classes/Animation.html#decode) (GIF, APNG and WebP) with all
+- [Decoding animations](https://imagescript.matmen.dev/classes/Animation.html#decode) (GIF, APNG, WebP and JPEG XL) 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)
@@ -53,10 +65,15 @@ deno add jsr:@matmen/imagescript     # Deno (npm:imagescript works too)
   , [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)
+  , lossless and lossy [WebPs](https://imagescript.matmen.dev/classes/Image.html#encodewebp) (lossy ones byte for
+  byte like libwebp's cwebp)
+  , [BMPs](https://imagescript.matmen.dev/classes/Image.html#encodebmp)
+  , [QOIs](https://imagescript.matmen.dev/classes/Image.html#encodeqoi)
+  , [Netpbm images](https://imagescript.matmen.dev/classes/Image.html#encodepnm) (PBM, PGM, PPM or PAM, whichever is
+  smallest)
   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
+  [APNG](https://imagescript.matmen.dev/classes/Animation.html#encodeapng) and lossless or lossy
   [WebP](https://imagescript.matmen.dev/classes/Animation.html#encodewebp), storing only what changes from frame to frame
 
 ---
@@ -81,9 +98,8 @@ 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 lossy 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.
+Upgrading from 1.x? Version 3 has breaking changes (0-based coordinates, lossy WebP encoding as `encodeWebP({ quality })`,
+Node.js 22.13+, ...), see the [changelog](https://github.com/matmen/ImageScript/blob/master/CHANGELOG.md).
 
 [![Example](https://github.com/matmen/ImageScript/raw/master/tests/targets/readme.png)](https://github.com/matmen/ImageScript/blob/master/tests/readme.js)
 
@@ -103,10 +119,14 @@ The deflate/inflate implementation is derived from [fflate](https://github.com/1
 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
+and reproduce [libwebp](https://chromium.googlesource.com/webm/libwebp)'s color conversion, the lossy WebP encoder is
+ported from libwebp's, the TrueType hinting follows
 [FreeType](https://freetype.org)'s interpreter (portions of this software are copyright © 2026 The FreeType Project),
 the text shaping is ported from [HarfBuzz](https://github.com/harfbuzz/harfbuzz) and uses data of the
-[Unicode Character Database](https://www.unicode.org/ucd/).
+[Unicode Character Database](https://www.unicode.org/ucd/). The AV1 decoder is ported from
+[dav1d](https://code.videolan.org/videolan/dav1d), AVIFs are converted to RGB like
+[libavif](https://github.com/AOMediaCodec/libavif) does, the JPEG XL decoder is ported from
+[jxl-oxide](https://github.com/tirr-c/jxl-oxide) and [libjxl](https://github.com/libjxl/libjxl).
 See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for their licenses.
 
 ---

package/THIRD_PARTY_NOTICES.md

@@ -12,8 +12,14 @@ following projects, under their own licenses. Each derived file says so in its h
 | [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 |
+| [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), `src/codecs/vp8-enc.ts`, `src/codecs/vp8-enc-dsp.ts` (the lossy encoder: RGB to YUV conversion, analysis, segments, rate-distortion optimized mode decisions, quantization, token probabilities, bitstream, alpha filtering), `src/codecs/vp8-enc-tables.ts` (its tables, generated from libwebp by `scripts/vp8-enc-tables.py`) | BSD-3-Clause |
+| [dav1d](https://code.videolan.org/videolan/dav1d) by VideoLAN, the dav1d authors and Two Orioles | `src/codecs/av1/*` (the AV1 decoder: bitstream parsing, symbol decoding, prediction, inverse transforms, loop filters, film grain; the tables in `src/codecs/av1/data.ts`, generated from dav1d by `scripts/av1-tables.c`) | BSD-2-Clause |
+| [libavif](https://github.com/AOMediaCodec/libavif) by Joe Drago | `src/codecs/avif.ts` (YUV to RGB conversion with bilinear chroma upsampling, alpha range expansion and unpremultiplication) | BSD-2-Clause |
+| [jxl-oxide](https://github.com/tirr-c/jxl-oxide) by Wonwoo Choi | `src/codecs/jxl/*` (the JPEG XL decoder: bit reader, header and frame header fields, entropy decoding, VarDCT, dequantization matrices, transforms, restoration filters, upsampling, the parsing of patches, splines and noise) | MIT (or Apache-2.0) |
+| [libjxl](https://github.com/libjxl/libjxl) by the JPEG XL Project Authors | `src/codecs/jxl/modular.ts` (Modular decoding: MA trees, predictors, the self-correcting predictor, transforms), `src/codecs/jxl/frame.ts` (the sections of frames, the order of the rendering stages, reference frames), `src/codecs/jxl/blend.ts`, `src/codecs/jxl/color.ts` (XYB to RGB), `src/codecs/jxl/features.ts` (rendering patches, splines and noise) | BSD-3-Clause |
+| [JPEG XL conformance](https://github.com/libjxl/conformance) by the JPEG XL Project Authors | `tests/jxl/alpha-*.jxl`, `animation-spline.jxl`, `blendmodes.jxl`, `mul-no-extra-channels.jxl` (test files) | BSD-3-Clause |
 | [FreeType](https://freetype.org) | `src/render/hinting.ts` (behavior and parts of the logic of the TrueType interpreter) | FreeType License |
+| [QOI](https://github.com/phoboslab/qoi) by Dominic Szablewski | `src/codecs/qoi.ts` (the reference encoder's choices of operations) | MIT |
 | [Pillow](https://github.com/python-pillow/Pillow) | `src/util/resample.ts` (filter coefficients, box, bilinear and bicubic filters) | MIT-CMU |
 | [HarfBuzz](https://github.com/harfbuzz/harfbuzz) | `src/render/buffer.ts`, `src/render/layout.ts`, `src/render/shape.ts`, `src/render/shapers/*` (OpenType shaping: buffer, GSUB/GPOS, normalization, fallback positioning, the script shapers and syllable grammars), `scripts/unicode.js` (shaping category tables) | Old MIT |
 | [Universal Shaping Engine data](https://github.com/harfbuzz/harfbuzz/tree/main/src/ms-use) by Microsoft | `scripts/ms-use` (category overrides, invalid vowel sequences), the tables generated from them in `src/render/unicode-data.ts` | MIT |
@@ -85,7 +91,8 @@ one decode function per scan type). The `Rasterizer` class in `src/render/text.t
 
 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.
+frames reproduce libwebp's integer arithmetic. The lossy encoder is ported from libwebp's (version 1.6.0, its default
+settings) and writes the same VP8 bitstreams as cwebp.
 
 ```
 RFC 6386 reference decoder: Copyright (c) 2010, 2011, Google Inc. All rights reserved.
@@ -148,6 +155,138 @@ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWIS
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ```
 
+## dav1d
+
+The AV1 decoder is ported from dav1d 1.5.1 and decodes exactly like it (the frames of its intra coding tools, with
+every post filter and film grain); its tables are generated from dav1d's. The ported files are Copyright © 2018-2021,
+VideoLAN and dav1d authors, and Copyright © 2018, Two Orioles, LLC, under dav1d's license. AV1 is covered by the
+[Alliance for Open Media Patent License 1.0](https://aomedia.org/license/patent-license/).
+
+```
+Copyright © 2018-2019, VideoLAN and dav1d authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. 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.
+
+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.
+```
+
+## libavif
+
+The conversion of decoded AVIFs to RGB reproduces libavif's reference conversion (in floating point, with bilinear
+chroma upsampling), so the pixels are the ones libavif gives.
+
+```
+Copyright 2019 Joe Drago. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. 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.
+
+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.
+```
+
+## jxl-oxide
+
+The structure of the JPEG XL decoder and most of its parts are ported from jxl-oxide (which may be used under the MIT
+or the Apache-2.0 license; the MIT license applies here).
+
+```
+Copyright (c) Wonwoo Choi
+
+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.
+```
+
+## libjxl, JPEG XL conformance
+
+The Modular decoding, the rendering pipeline, blending, the XYB conversion and the rendering of patches, splines and
+noise follow libjxl, the JPEG XL reference implementation; tests/jxl includes files of its conformance suite. JPEG XL
+is covered by Google's patent grant for libjxl (the "Additional IP Rights Grant" in libjxl's PATENTS file).
+
+```
+Copyright (c) the JPEG XL Project Authors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. 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.
+
+3. Neither the name of the copyright holder 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.
+```
+
 ## FreeType
 
 Portions of this software are copyright © 2026 The FreeType Project (https://freetype.org). All rights reserved.
@@ -159,6 +298,32 @@ interpolation of untouched points (IUP), the handling of near-perpendicular free
 tolerance of invalid references. FreeType is used under the FreeType License, included as
 [licenses/FTL.txt](licenses/FTL.txt).
 
+## QOI
+
+```
+MIT License
+
+Copyright (c) 2021, 2022 Dominic Szablewski
+
+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.
+```
+
 ## Pillow
 
 ```

package/dist/animation.d.ts

@@ -18,7 +18,7 @@ export interface AnimationDecodeOptions {
      */
     maxPixels?: number;
 }
-/** Options of {@link Animation.encodeWebP}, and those all animation encoders have */
+/** The options all animation encoders have */
 export interface AnimationEncodeOptions {
     /** Metadata to include, see {@link Metadata} */
     metadata?: Metadata;
@@ -29,6 +29,16 @@ export interface AnimationEncodeOptions {
      */
     optimize?: boolean;
 }
+/** Options of {@link Animation.encodeWebP} */
+export interface WebPAnimationEncodeOptions extends AnimationEncodeOptions {
+    /**
+     * Lossy frames (0-100, like libwebp's quality: 75 is its default), much smaller than lossless ones. Without it the
+     * frames are lossless
+     */
+    quality?: number;
+    /** How much effort lossy frames take (0-6), see {@link WebPEncodeOptions.effort}. Default: `4` */
+    effort?: number;
+}
 /** Options of {@link Animation.encodeGIF} */
 export interface GIFEncodeOptions extends AnimationEncodeOptions {
     /** 1-100, scales the palette size from 8 colors (1) to 256 colors (90 and above). Default: `95` */
@@ -126,20 +136,20 @@ export declare class Animation extends Array<Frame> {
      */
     encodeAPNG(compression?: number): Promise<Uint8Array>;
     /**
-     * Encodes the animation as lossless animated WebP. Each frame is stored as the area that changed since the frame
-     * before, identical frames are merged (unless the `optimize` option is false): the file shows exactly the same
-     * animation, but doesn't necessarily decode to the same frames
-     * @param options See {@link AnimationEncodeOptions}
+     * Encodes the animation as animated WebP, lossless or (with a quality) lossy. Each frame is stored as the area that
+     * changed since the frame before, identical frames are merged (unless the `optimize` option is false): the file
+     * shows the same animation, but doesn't necessarily decode to the same frames
+     * @param options See {@link WebPAnimationEncodeOptions}
      */
-    encodeWebP({ metadata, optimize }?: AnimationEncodeOptions): Promise<Uint8Array>;
+    encodeWebP({ metadata, optimize, quality, effort }?: WebPAnimationEncodeOptions): Promise<Uint8Array>;
     /**
-     * Decodes an animated GIF, APNG or WebP into fully composited frames (still images become a single frame)
+     * Decodes an animated GIF, APNG, WebP or JPEG XL into fully composited frames (still images become a single frame)
      * @param input The binary data to decode
      * @param options See {@link AnimationDecodeOptions}
      */
     static decode(input: BinaryData, options?: AnimationDecodeOptions): Promise<Animation>;
     /**
-     * Decodes an animated GIF, APNG or WebP into fully composited frames (still images become a single frame)
+     * Decodes an animated GIF, APNG, WebP or JPEG XL 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
      */

package/dist/animation.js

@@ -1,6 +1,7 @@
 import * as gifCodec from "./codecs/gif.js";
 import * as png from "./codecs/png.js";
 import * as webp from "./codecs/webp.js";
+import * as jxl from "./codecs/jxl.js";
 import { view } from "./util/mem.js";
 import { Image } from "./image.js";
 import { Frame } from "./frame.js";
@@ -123,12 +124,19 @@ export class Animation extends Array {
             : this.__apngFrames__().map(({ blend: _, ...f }) => f);
         return png.encodeAnimation(frames, this.width, this.height, toPlays(this.loopCount), compression, pngText(resolveMetadata(metadata)));
     }
-    async encodeWebP({ metadata = {}, optimize = true } = {}) {
+    async encodeWebP({ metadata = {}, optimize = true, quality, effort = 4 } = {}) {
         this.__validate__();
         if (!this.length)
             throw new Error('An animation needs at least one frame');
+        if (quality !== undefined) {
+            const q = finite(quality, 'quality');
+            if (q < 0 || q > 100)
+                throw new RangeError(`quality must be 0-100, not ${q}`);
+            if (!Number.isInteger(effort) || effort < 0 || effort > 6)
+                throw new RangeError(`effort must be an integer 0-6, not ${effort}`);
+        }
         const frames = optimize ? this.__optimized__({ replace: true, even: true, alpha: 'frame' }) : this.__webpFrames__();
-        return webp.encodeAnimation(frames, this.width, this.height, toPlays(this.loopCount), exifData(resolveMetadata(metadata)));
+        return webp.encodeAnimation(frames, this.width, this.height, toPlays(this.loopCount), exifData(resolveMetadata(metadata)), quality, effort);
     }
     __webpFrames__() {
         const width = this.width, height = this.height;
@@ -192,6 +200,19 @@ export class Animation extends Array {
             const frames = canvasFrames(decoded.width, decoded.height, png.compositeAnimation(decoded));
             return new Animation(frames, decoded.frames.length > 1 ? fromPlays(decoded.plays) : -1);
         }
+        if (type === 'jxl') {
+            const frames = [];
+            let loopCount = -1;
+            for (const decoded of jxl.frames(data, maxPixels)) {
+                const frame = new Frame(decoded.width, decoded.height, decoded.duration, 0, 0, Frame.DISPOSAL_BACKGROUND);
+                frame.bitmap = decoded.pixels;
+                frames.push(frame.__orient__(decoded.orientation));
+                loopCount = fromPlays(decoded.loopCount);
+                if (onlyExtractFirstFrame)
+                    break;
+            }
+            return new Animation(frames, frames.length > 1 ? loopCount : -1);
+        }
         if (type)
             return new Animation([Frame.from(await Image.decode(data, { maxPixels }), 0)]);
         throw new Error('Unsupported image type');

package/dist/codecs/av1/cdef.js

@@ -0,0 +1,197 @@
+/*!
+ * The AV1 constrained directional enhancement filter, as the AV1 specification describes it (section 7.15) and dav1d
+ * implements it (src/cdef_tmpl.c). Copyright (c) 2018-2021, VideoLAN and dav1d authors, Copyright (c) 2018, Two
+ * Orioles, LLC, BSD-2-Clause License (see THIRD_PARTY_NOTICES.md)
+ */
+const DIV_TABLE = [0, 840, 420, 280, 210, 168, 140, 120, 105];
+const UV_DIR = [[[0, 1, 2, 3, 4, 5, 6, 7], [1, 2, 2, 2, 3, 4, 6, 0]], [[7, 0, 2, 4, 5, 6, 6, 6], [0, 1, 2, 3, 4, 5, 6, 7]]];
+const PRI_TAPS = [[4, 2], [3, 3]], SEC_TAPS = [2, 1];
+const floorLog2 = (v) => 31 - Math.clz32(v);
+export function cdefActive(f) {
+    const c = f.hdr.cdef;
+    return f.seq.cdef && (c.yStrengths.some(s => s) || c.uvStrengths.some(s => s));
+}
+export function cdef(f, src) {
+    const c = f.hdr.cdef;
+    const coeffShift = f.bitdepth - 8;
+    const s4 = f.b4Stride;
+    for (let r = 0; r < f.bh; r += 2) {
+        for (let col = 0; col < f.bw; col += 2) {
+            const idx = f.cdefIdx[(r >> 4) * (s4 >> 4) + (col >> 4)];
+            if (idx === -1)
+                continue;
+            const o = r * s4 + col;
+            if (f.skip[o] && f.skip[o + s4] && f.skip[o + 1] && f.skip[o + s4 + 1])
+                continue;
+            const usesDirection = c.yStrengths[idx] >> 2 || (f.planes.length > 1 && c.uvStrengths[idx] >> 2);
+            const yDir = usesDirection ? direction(src[0], r * 4 * f.strides[0] + col * 4, f.strides[0], coeffShift) : 0;
+            const variance = usesDirection ? directionVariance : 0;
+            const ys = c.yStrengths[idx];
+            let priStr = (ys >> 2) << coeffShift;
+            const secY = ys & 3;
+            const secStr = (secY === 3 ? 4 : secY) << coeffShift;
+            const dir = priStr ? yDir : 0;
+            const varStr = variance >> 6 ? Math.min(floorLog2(variance >> 6), 12) : 0;
+            priStr = variance ? (priStr * (4 + varStr) + 8) >> 4 : 0;
+            filterBlock(f, src, 0, r, col, priStr, secStr, c.damping + coeffShift, dir);
+            if (f.planes.length === 1)
+                continue;
+            const uvs = c.uvStrengths[idx];
+            const uvPri = (uvs >> 2) << coeffShift, secUv = uvs & 3;
+            const uvSec = (secUv === 3 ? 4 : secUv) << coeffShift;
+            const uvDir = uvPri ? UV_DIR[f.ssx][f.ssy][yDir] : 0;
+            for (let p = 1; p < 3; p++)
+                filterBlock(f, src, p, r, col, uvPri, uvSec, c.damping + coeffShift - 1, uvDir);
+        }
+    }
+}
+const partial = new Int32Array(8 * 15), cost = new Float64Array(8);
+let directionVariance = 0;
+function direction(luma, o, ls, coeffShift) {
+    partial.fill(0);
+    for (let i = 0; i < 8; i++) {
+        const row = o + i * ls, ih = i >> 1;
+        for (let j = 0; j < 8; j++) {
+            const x = (luma[row + j] >> coeffShift) - 128, jh = j >> 1;
+            partial[i + j] += x;
+            partial[15 + i + jh] += x;
+            partial[30 + i] += x;
+            partial[45 + 3 + i - jh] += x;
+            partial[60 + 7 + i - j] += x;
+            partial[75 + 3 - ih + j] += x;
+            partial[90 + j] += x;
+            partial[105 + ih + j] += x;
+        }
+    }
+    cost.fill(0);
+    for (let i = 0; i < 8; i++) {
+        cost[2] += partial[30 + i] * partial[30 + i];
+        cost[6] += partial[90 + i] * partial[90 + i];
+    }
+    cost[2] *= DIV_TABLE[8];
+    cost[6] *= DIV_TABLE[8];
+    for (let i = 0; i < 7; i++) {
+        cost[0] += (partial[i] * partial[i] + partial[14 - i] * partial[14 - i]) * DIV_TABLE[i + 1];
+        cost[4] += (partial[60 + i] * partial[60 + i] + partial[60 + 14 - i] * partial[60 + 14 - i]) * DIV_TABLE[i + 1];
+    }
+    cost[0] += partial[7] * partial[7] * DIV_TABLE[8];
+    cost[4] += partial[67] * partial[67] * DIV_TABLE[8];
+    for (let i = 1; i < 8; i += 2) {
+        const p = i * 15;
+        for (let j = 0; j < 5; j++)
+            cost[i] += partial[p + 3 + j] * partial[p + 3 + j];
+        cost[i] *= DIV_TABLE[8];
+        for (let j = 0; j < 3; j++)
+            cost[i] += (partial[p + j] * partial[p + j] + partial[p + 10 - j] * partial[p + 10 - j]) * DIV_TABLE[2 * j + 2];
+    }
+    let bestCost = 0, yDir = 0;
+    for (let i = 0; i < 8; i++) {
+        if (cost[i] > bestCost) {
+            bestCost = cost[i];
+            yDir = i;
+        }
+    }
+    directionVariance = Math.floor((bestCost - cost[(yDir + 4) & 7]) / 1024);
+    return yDir;
+}
+function filterBlock(f, src, plane, r, c, priStr, secStr, damping, dir) {
+    if (!priStr && !secStr)
+        return;
+    const subX = plane ? f.ssx : 0, subY = plane ? f.ssy : 0;
+    const s = src[plane], dst = f.planes[plane], stride = f.strides[plane];
+    const x0 = (c * 4) >> subX, y0 = (r * 4) >> subY, w = 8 >> subX, h = 8 >> subY;
+    const maxX = (f.bw * 4) >> subX, maxY = (f.bh * 4) >> subY;
+    const priTaps = PRI_TAPS[(priStr >> (f.bitdepth - 8)) & 1];
+    const priShift = priStr ? Math.max(0, damping - floorLog2(priStr)) : 0, secShift = secStr ? Math.max(0, damping - floorLog2(secStr)) : 0;
+    for (let n = 0; n < 6; n++) {
+        const t = n >> 1, k = n & 1;
+        const d = (t === 0 ? dir : t === 1 ? dir + 6 : dir + 2) & 7;
+        const dy = DIRECTIONS[d * 4 + k * 2], dx = DIRECTIONS[d * 4 + k * 2 + 1];
+        offsets[n] = dy * stride + dx;
+        dys[n] = dy;
+        dxs[n] = dx;
+        taps[n] = t ? SEC_TAPS[k] : priTaps[k];
+        strengths[n] = t ? secStr : priStr;
+        shifts[n] = t ? secShift : priShift;
+    }
+    if (x0 >= 2 && y0 >= 2 && x0 + w + 2 <= maxX && y0 + h + 2 <= maxY) {
+        const p0 = offsets[0], p1 = offsets[1], s0 = offsets[2], s1 = offsets[3], s2 = offsets[4], s3 = offsets[5];
+        const t0 = priTaps[0], t1 = priTaps[1];
+        const off = (1 << f.bitdepth) - 1;
+        const P = constrainTable(priStr, priShift, f.bitdepth), S = constrainTable(secStr, secShift, f.bitdepth);
+        for (let i = 0; i < h; i++) {
+            for (let j = 0, o = (y0 + i) * stride + x0; j < w; j++, o++) {
+                const x = s[o];
+                const a0 = s[o + p0], b0 = s[o - p0], a1 = s[o + p1], b1 = s[o - p1];
+                const c0 = s[o + s0], d0 = s[o - s0], c1 = s[o + s1], d1 = s[o - s1];
+                const e0 = s[o + s2], f0 = s[o - s2], e1 = s[o + s3], f1 = s[o - s3];
+                const ox = off - x;
+                const sum = t0 * (P[a0 + ox] + P[b0 + ox]) + t1 * (P[a1 + ox] + P[b1 + ox]) +
+                    2 * (S[c0 + ox] + S[d0 + ox] + S[e0 + ox] + S[f0 + ox]) + S[c1 + ox] + S[d1 + ox] + S[e1 + ox] + S[f1 + ox];
+                let v = x + ((8 + sum - (sum < 0 ? 1 : 0)) >> 4);
+                if (v > x) {
+                    if (v > a0 && v > b0 && v > a1 && v > b1 && v > c0 && v > d0 && v > c1 && v > d1 && v > e0 && v > f0 && v > e1 && v > f1)
+                        v = Math.max(x, a0, b0, a1, b1, c0, d0, c1, d1, e0, f0, e1, f1);
+                }
+                else if (v < x) {
+                    if (v < a0 && v < b0 && v < a1 && v < b1 && v < c0 && v < d0 && v < c1 && v < d1 && v < e0 && v < f0 && v < e1 && v < f1)
+                        v = Math.min(x, a0, b0, a1, b1, c0, d0, c1, d1, e0, f0, e1, f1);
+                }
+                dst[o] = v;
+            }
+        }
+        return;
+    }
+    for (let i = 0; i < h; i++) {
+        const y = y0 + i;
+        for (let j = 0; j < w; j++) {
+            const xx = x0 + j, o = y * stride + xx;
+            const x = s[o];
+            let sum = 0, max = x, min = x;
+            for (let t = 0; t < 6; t++) {
+                for (let sign = -1; sign <= 1; sign += 2) {
+                    const py = y + sign * dys[t], px = xx + sign * dxs[t];
+                    if (py < 0 || px < 0 || py >= maxY || px >= maxX)
+                        continue;
+                    const p = s[o + sign * offsets[t]];
+                    sum += taps[t] * constrain(p - x, strengths[t], shifts[t]);
+                    if (p > max)
+                        max = p;
+                    if (p < min)
+                        min = p;
+                }
+            }
+            const v = x + ((8 + sum - (sum < 0 ? 1 : 0)) >> 4);
+            dst[o] = v < min ? min : v > max ? max : v;
+        }
+    }
+}
+const tables = new Map();
+function constrainTable(strength, shift, bitdepth) {
+    const key = (strength * 32 + shift) * 16 + bitdepth;
+    let t = tables.get(key);
+    if (!t) {
+        const off = (1 << bitdepth) - 1;
+        t = new Int16Array(2 * off + 1);
+        for (let d = -off; d <= off; d++)
+            t[d + off] = constrain(d, strength, shift);
+        tables.set(key, t);
+    }
+    return t;
+}
+function constrain(diff, strength, shift) {
+    if (!strength)
+        return 0;
+    const a = diff < 0 ? -diff : diff;
+    let v = strength - (a >> shift);
+    if (v > a)
+        v = a;
+    if (v <= 0)
+        return 0;
+    return diff < 0 ? -v : v;
+}
+const DIRECTIONS = new Int8Array([
+    -1, 1, -2, 2, 0, 1, -1, 2, 0, 1, 0, 2, 0, 1, 1, 2,
+    1, 1, 2, 2, 1, 0, 2, 1, 1, 0, 2, 0, 1, 0, 2, -1
+]);
+const offsets = new Int32Array(6), dys = new Int32Array(6), dxs = new Int32Array(6), taps = new Int32Array(6), strengths = new Int32Array(6), shifts = new Int32Array(6);