imagescript 3.2.0 → 3.3.0

package/dist/codecs/tiff.js

@@ -1,5 +1,6 @@
 import { decompressAsync } from "./zlib.js";
 import * as jpeg from "./jpeg.js";
+import { MAX_PIXELS, checkPixels, checkBytes } from "../util/limits.js";
 const TYPE_SIZES = { 1: 1, 2: 1, 3: 2, 4: 4, 5: 8, 6: 1, 7: 1, 8: 2, 9: 4, 10: 8, 11: 4, 12: 8, 13: 4, 16: 8, 17: 8, 18: 8 };
 const TAGS = {
     ImageWidth: 256,
@@ -28,7 +29,7 @@ const TAGS = {
     ReferenceBlackWhite: 532
 };
 const COMPRESSION_NAMES = { 2: 'CCITT RLE', 3: 'CCITT fax 3', 4: 'CCITT fax 4', 6: 'old-style JPEG', 32809: 'ThunderScan', 34676: 'SGI LogLuv', 34677: 'SGI LogL' };
-export async function decode(data) {
+export async function decode(data, maxPixels = MAX_PIXELS) {
     const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
     let little;
     if (data[0] === 0x49 && data[1] === 0x49)
@@ -154,9 +155,13 @@ export async function decode(data) {
             throw new Error('TIFF: missing image data');
         return data.subarray(offset, Math.min(data.length, offset + count));
     };
+    checkPixels(width, height, maxPixels);
+    checkPixels(segmentWidth, segmentHeight, Math.max(4 * width * height, 1 << 20));
+    checkBytes(Math.ceil(width * samplesPerPixel * bps / 8) * height, maxPixels);
     const pixels = new Uint8Array(width * height * 4);
     if (compression === 7) {
-        const tables = tags.has(TAGS.JPEGTables) ? data.subarray(tags.get(TAGS.JPEGTables).offset, tags.get(TAGS.JPEGTables).offset + tags.get(TAGS.JPEGTables).count) : null;
+        const jpegTables = tags.get(TAGS.JPEGTables);
+        const tables = jpegTables ? data.subarray(jpegTables.offset, jpegTables.offset + jpegTables.count) : null;
         const transform = photometric === 6 ? 'ycc' : photometric === 2 ? 'rgb' : photometric === 5 ? 'cmyk' : null;
         for (let s = 0; s < segmentsPerPlane; s++) {
             let stream = segment(s);

package/dist/codecs/vp8.js

@@ -1,4 +1,5 @@
 import { KF_BMODE_PROBS, COEFF_UPDATE_PROBS, DEFAULT_COEFF_PROBS, DC_QLOOKUP, AC_QLOOKUP, PCAT } from "./vp8-tables.js";
+import { MAX_PIXELS, checkPixels } from "../util/limits.js";
 class BoolDecoder {
     data;
     pos;
@@ -161,9 +162,10 @@ function readHeader(data) {
     };
 }
 const clamp255 = (v) => v < 0 ? 0 : v > 255 ? 255 : v;
-export function decode(data) {
+export function decode(data, maxPixels = MAX_PIXELS) {
     const { header: h, first: d } = readHeader(data);
     const { width, height } = h;
+    checkPixels(width, height, maxPixels);
     const mbw = (width + 15) >> 4, mbh = (height + 15) >> 4;
     const ys = mbw * 16 + 1, cs = mbw * 8 + 1;
     const Y = new Uint8Array(ys * (mbh * 16 + 1));

package/dist/codecs/vp8l.js

@@ -3,6 +3,8 @@
  * table of short distance codes. Copyright (c) 2024 IETF Trust and the persons identified as the document authors,
  * Revised BSD License (see THIRD_PARTY_NOTICES.md)
  */
+import { ByteWriter } from "../util/bytes.js";
+import { MAX_PIXELS, checkPixels } from "../util/limits.js";
 const SIGNATURE = 0x2f;
 const CODE_LENGTH_ORDER = [17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
 const DISTANCE_MAP = Int8Array.of(0, 1, 1, 0, 1, 1, -1, 1, 0, 2, 2, 0, 1, 2, -1, 2, 2, 1, -2, 1, 2, 2, -2, 2, 0, 3, 3, 0, 1, 3, -1, 3, 3, 1, -3, 1, 2, 3, -2, 3, 3, 2, -3, 2, 0, 4, 4, 0, 1, 4, -1, 4, 4, 1, -4, 1, 3, 3, -3, 3, 2, 4, -2, 4, 4, 2, -4, 2, 0, 5, 3, 4, -3, 4, 4, 3, -4, 3, 5, 0, 1, 5, -1, 5, 5, 1, -5, 1, 2, 5, -2, 5, 5, 2, -5, 2, 4, 4, -4, 4, 3, 5, -3, 5, 5, 3, -5, 3, 0, 6, 6, 0, 1, 6, -1, 6, 6, 1, -6, 1, 2, 6, -2, 6, 6, 2, -6, 2, 4, 5, -4, 5, 5, 4, -5, 4, 3, 6, -3, 6, 6, 3, -6, 3, 0, 7, 7, 0, 1, 7, -1, 7, 5, 5, -5, 5, 7, 1, -7, 1, 4, 6, -4, 6, 6, 4, -6, 4, 2, 7, -2, 7, 7, 2, -7, 2, 3, 7, -3, 7, 7, 3, -7, 3, 5, 6, -5, 6, 6, 5, -6, 5, 8, 0, 4, 7, -4, 7, 7, 4, -7, 4, 8, 1, 8, 2, 6, 6, -6, 6, 8, 3, 5, 7, -5, 7, 7, 5, -7, 5, 8, 4, 6, 7, -6, 7, 7, 6, -7, 6, 8, 5, 7, 7, -7, 7, 8, 6, 8, 7);
@@ -314,24 +316,82 @@ function select(l, t, tl) {
     return pl < pt ? l : t;
 }
 const addPixels = (a, b) => ((a & 0xff00ff00) + (b & 0xff00ff00) & 0xff00ff00 | (a & 0x00ff00ff) + (b & 0x00ff00ff) & 0x00ff00ff) >>> 0;
-function predict(mode, p, i, width) {
-    const l = p[i - 1], t = p[i - width], tl = p[i - width - 1], tr = p[i - width + 1];
+function predictRun(mode, p, i, n, width, out, o) {
+    const restore = out === p;
+    const end = i + n;
     switch (mode) {
-        case 0: return 0xff000000;
-        case 1: return l;
-        case 2: return t;
-        case 3: return tr;
-        case 4: return tl;
-        case 5: return average2(average2(l, tr), t);
-        case 6: return average2(l, tl);
-        case 7: return average2(l, t);
-        case 8: return average2(tl, t);
-        case 9: return average2(t, tr);
-        case 10: return average2(average2(l, tl), average2(t, tr));
-        case 11: return select(l, t, tl);
-        case 12: return clampAddSubtractFull(l, t, tl);
-        case 13: return clampAddSubtractHalf(average2(l, t), tl);
-        default: return 0xff000000;
+        case 1:
+            for (; i < end; i++, o++)
+                out[o] = restore ? addPixels(p[i], p[i - 1]) : p[i - 1];
+            return;
+        case 2:
+            for (; i < end; i++, o++)
+                out[o] = restore ? addPixels(p[i], p[i - width]) : p[i - width];
+            return;
+        case 3:
+            for (; i < end; i++, o++)
+                out[o] = restore ? addPixels(p[i], p[i - width + 1]) : p[i - width + 1];
+            return;
+        case 4:
+            for (; i < end; i++, o++)
+                out[o] = restore ? addPixels(p[i], p[i - width - 1]) : p[i - width - 1];
+            return;
+        case 5:
+            for (; i < end; i++, o++) {
+                const v = average2(average2(p[i - 1], p[i - width + 1]), p[i - width]);
+                out[o] = restore ? addPixels(p[i], v) : v;
+            }
+            return;
+        case 6:
+            for (; i < end; i++, o++) {
+                const v = average2(p[i - 1], p[i - width - 1]);
+                out[o] = restore ? addPixels(p[i], v) : v;
+            }
+            return;
+        case 7:
+            for (; i < end; i++, o++) {
+                const v = average2(p[i - 1], p[i - width]);
+                out[o] = restore ? addPixels(p[i], v) : v;
+            }
+            return;
+        case 8:
+            for (; i < end; i++, o++) {
+                const v = average2(p[i - width - 1], p[i - width]);
+                out[o] = restore ? addPixels(p[i], v) : v;
+            }
+            return;
+        case 9:
+            for (; i < end; i++, o++) {
+                const v = average2(p[i - width], p[i - width + 1]);
+                out[o] = restore ? addPixels(p[i], v) : v;
+            }
+            return;
+        case 10:
+            for (; i < end; i++, o++) {
+                const v = average2(average2(p[i - 1], p[i - width - 1]), average2(p[i - width], p[i - width + 1]));
+                out[o] = restore ? addPixels(p[i], v) : v;
+            }
+            return;
+        case 11:
+            for (; i < end; i++, o++) {
+                const v = select(p[i - 1], p[i - width], p[i - width - 1]);
+                out[o] = restore ? addPixels(p[i], v) : v;
+            }
+            return;
+        case 12:
+            for (; i < end; i++, o++) {
+                const v = clampAddSubtractFull(p[i - 1], p[i - width], p[i - width - 1]);
+                out[o] = restore ? addPixels(p[i], v) : v;
+            }
+            return;
+        case 13:
+            for (; i < end; i++, o++) {
+                const v = clampAddSubtractHalf(average2(p[i - 1], p[i - width]), p[i - width - 1]);
+                out[o] = restore ? addPixels(p[i], v) : v;
+            }
+            return;
+        default: for (; i < end; i++, o++)
+            out[o] = restore ? addPixels(p[i], 0xff000000) : 0xff000000;
     }
 }
 function inversePredictor(p, width, height, bits, modes) {
@@ -343,10 +403,10 @@ function inversePredictor(p, width, height, bits, modes) {
         const row = y * width;
         p[row] = addPixels(p[row], p[row - width]);
         const modeRow = (y >> bits) * blocksPerRow;
-        for (let x = 1; x < width; x++) {
-            const mode = modes[modeRow + (x >> bits)] >> 8 & 15;
-            const i = row + x;
-            p[i] = addPixels(p[i], predict(mode, p, i, width));
+        for (let x = 1; x < width;) {
+            const end = Math.min(width, (x >> bits) + 1 << bits);
+            predictRun(modes[modeRow + (x >> bits)] >> 8 & 15, p, row + x, end - x, width, p, row + x);
+            x = end;
         }
     }
 }
@@ -400,8 +460,9 @@ export function readHeader(data) {
         throw new Error('VP8L: unsupported version');
     return { width, height, hasAlpha };
 }
-export function decode(data) {
+export function decode(data, maxPixels = MAX_PIXELS) {
     const { width, height, hasAlpha } = readHeader(data);
+    checkPixels(width, height, maxPixels);
     const reader = new BitReader(data, 5);
     return { width, height, hasAlpha, argb: decodeStream(reader, width, height) };
 }
@@ -446,26 +507,22 @@ export function decodeStream(reader, width, height) {
     }
     return pixels;
 }
-class BitWriter {
-    bytes = new Uint8Array(1 << 16);
-    length = 0;
-    buffer = 0;
+class BitWriter extends ByteWriter {
+    bits = 0;
     count = 0;
-    write(value, bits) {
-        while (bits > 0) {
-            const take = Math.min(bits, 24 - this.count);
-            this.buffer |= (value & (1 << take) - 1) << this.count;
+    constructor() {
+        super(1 << 16);
+    }
+    write(value, size) {
+        while (size > 0) {
+            const take = Math.min(size, 24 - this.count);
+            this.bits |= (value & (1 << take) - 1) << this.count;
             this.count += take;
             value >>>= take;
-            bits -= take;
+            size -= take;
             while (this.count >= 8) {
-                if (this.length === this.bytes.length) {
-                    const grown = new Uint8Array(this.bytes.length * 2);
-                    grown.set(this.bytes);
-                    this.bytes = grown;
-                }
-                this.bytes[this.length++] = this.buffer & 255;
-                this.buffer >>>= 8;
+                this.byte(this.bits & 255);
+                this.bits >>>= 8;
                 this.count -= 8;
             }
         }
@@ -473,7 +530,7 @@ class BitWriter {
     finish() {
         if (this.count > 0)
             this.write(0, 8 - this.count);
-        return this.bytes.slice(0, this.length);
+        return super.finish();
     }
 }
 function codeLengths(counts, maxLength) {
@@ -686,11 +743,13 @@ function tokenize(pixels, width, cacheBits) {
     const HASH_BITS = 15, CHAIN = 24, MAX_LENGTH = 4096, MIN_LENGTH = 3, WINDOW = (1 << 20) - 120;
     const head = new Int32Array(1 << HASH_BITS).fill(-1);
     const chain = new Int32Array(n);
-    const hash = (i) => Math.imul(Math.imul(pixels[i], 0x1e35a7bd) ^ pixels[i + 1], 0x9e3779b1) >>> 32 - HASH_BITS;
+    const hashes = new Int32Array(n);
+    for (let i = 0; i + 1 < n; i++)
+        hashes[i] = Math.imul(Math.imul(pixels[i], 0x1e35a7bd) ^ pixels[i + 1], 0x9e3779b1) >>> 32 - HASH_BITS;
     const insert = (i) => {
         if (i + 1 >= n)
             return;
-        const h = hash(i);
+        const h = hashes[i];
         chain[i] = head[h];
         head[h] = i;
     };
@@ -721,7 +780,7 @@ function tokenize(pixels, width, cacheBits) {
             }
         }
         if (i + 1 < n && bestLength < MAX_LENGTH) {
-            for (let j = head[hash(i)], k = 0; j >= 0 && k < CHAIN && i - j <= WINDOW; j = chain[j], k++) {
+            for (let j = head[hashes[i]], k = 0; j >= 0 && k < CHAIN && i - j <= WINDOW; j = chain[j], k++) {
                 if (i - j >= bestDistance && (i + bestLength >= n || pixels[j + bestLength] !== pixels[i + bestLength]))
                     continue;
                 const l = matchLength(i, j);
@@ -810,38 +869,47 @@ function writeImage(w, pixels, width, isMain) {
     }
 }
 const subPixels = (a, b) => ((a | 0x00ff00ff) - (b & 0xff00ff00) & 0xff00ff00 | (a | 0xff00ff00) - (b & 0x00ff00ff) & 0x00ff00ff) >>> 0;
-function residualCost(r) {
-    const c0 = r & 255, c1 = r >>> 8 & 255, c2 = r >>> 16 & 255, c3 = r >>> 24;
-    return (c0 < 128 ? c0 : 256 - c0) + (c1 < 128 ? c1 : 256 - c1) + (c2 < 128 ? c2 : 256 - c2) + (c3 < 128 ? c3 : 256 - c3);
-}
+const BYTE_COST = Uint8Array.from({ length: 256 }, (_, c) => c < 128 ? c : 256 - c);
+const residualCost = (r) => BYTE_COST[r & 255] + BYTE_COST[r >>> 8 & 255] + BYTE_COST[r >>> 16 & 255] + BYTE_COST[r >>> 24];
 function applyPredictor(p, width, height, bits) {
     const blocksX = subSize(width, bits), blocksY = subSize(height, bits);
     const modes = new Uint32Array(blocksX * blocksY);
     const size = 1 << bits;
-    const src = p.slice();
-    const predictAt = (mode, i, x, y) => y === 0 ? (x === 0 ? 0xff000000 : src[i - 1]) : x === 0 ? src[i - width] : predict(mode, src, i, width);
+    const src = p.slice(), predicted = new Uint32Array(size);
+    const predictRow = (mode, x0, x1, y) => {
+        const row = y * width;
+        if (y === 0) {
+            for (let x = x0; x < x1; x++)
+                predicted[x - x0] = x === 0 ? 0xff000000 : src[row + x - 1];
+            return;
+        }
+        let x = x0;
+        if (x === 0)
+            predicted[x++] = src[row - width];
+        predictRun(mode, src, row + x, x1 - x, width, predicted, x - x0);
+    };
     for (let by = 0; by < blocksY; by++)
         for (let bx = 0; bx < blocksX; bx++) {
             let best = 0, bestCost = Infinity;
             const x0 = bx * size, y0 = by * size, x1 = Math.min(width, x0 + size), y1 = Math.min(height, y0 + size);
             for (let mode = 0; mode < 14; mode++) {
                 let cost = 0;
-                for (let y = y0; y < y1 && cost < bestCost; y++)
-                    for (let x = x0; x < x1; x++) {
-                        const i = y * width + x;
-                        cost += residualCost(subPixels(src[i], predictAt(mode, i, x, y)));
-                    }
+                for (let y = y0; y < y1 && cost < bestCost; y++) {
+                    predictRow(mode, x0, x1, y);
+                    for (let x = x0, i = y * width + x0; x < x1; x++, i++)
+                        cost += residualCost(subPixels(src[i], predicted[x - x0]));
+                }
                 if (cost < bestCost) {
                     bestCost = cost;
                     best = mode;
                 }
             }
             modes[by * blocksX + bx] = (0xff000000 | best << 8) >>> 0;
-            for (let y = y0; y < y1; y++)
-                for (let x = x0; x < x1; x++) {
-                    const i = y * width + x;
-                    p[i] = subPixels(src[i], predictAt(best, i, x, y));
-                }
+            for (let y = y0; y < y1; y++) {
+                predictRow(best, x0, x1, y);
+                for (let x = x0, i = y * width + x0; x < x1; x++, i++)
+                    p[i] = subPixels(src[i], predicted[x - x0]);
+            }
         }
     return modes;
 }

package/dist/codecs/webp.js

@@ -5,6 +5,7 @@
 import * as vp8l from "./vp8l.js";
 import * as vp8 from "./vp8.js";
 import { orientation as exifOrientation } from "./exif.js";
+import { MAX_PIXELS, checkPixels } from "../util/limits.js";
 const fourCC = (s) => s.charCodeAt(0) | s.charCodeAt(1) << 8 | s.charCodeAt(2) << 16 | s.charCodeAt(3) << 24;
 const RIFF = fourCC('RIFF'), WEBP = fourCC('WEBP');
 const VP8 = fourCC('VP8 '), VP8L = fourCC('VP8L'), VP8X = fourCC('VP8X');
@@ -32,13 +33,13 @@ function container(data) {
     return chunks(data, 12, Math.min(data.length, 8 + size));
 }
 const u24 = (d, o) => d[o] | d[o + 1] << 8 | d[o + 2] << 16;
-function decodeBitstream(list) {
+function decodeBitstream(list, maxPixels) {
     let alpha = null;
     for (const chunk of list) {
         if (chunk.type === ALPH)
             alpha ??= chunk;
         else if (chunk.type === VP8L) {
-            const { width, height, argb } = vp8l.decode(chunk.data);
+            const { width, height, argb } = vp8l.decode(chunk.data, maxPixels);
             const pixels = new Uint8Array(width * height * 4);
             const out = new DataView(pixels.buffer);
             for (let i = 0; i < argb.length; i++) {
@@ -48,7 +49,7 @@ function decodeBitstream(list) {
             return { width, height, pixels };
         }
         else if (chunk.type === VP8) {
-            const image = vp8.decode(chunk.data);
+            const image = vp8.decode(chunk.data, maxPixels);
             if (alpha)
                 applyAlpha(image.pixels, image.width, image.height, alpha.data);
             return image;
@@ -109,7 +110,7 @@ export function isAnimated(data) {
     const header = list[0];
     return header && header.type === VP8X && header.data.length >= 10 && (header.data[0] & 2) !== 0 && list.some(c => c.type === ANMF);
 }
-export function decode(data) {
+export function decode(data, maxPixels = MAX_PIXELS) {
     const list = container(data);
     if (!list.length)
         throw new Error('WebP: no image data');
@@ -118,11 +119,11 @@ export function decode(data) {
     if (exif)
         orientation = exifOrientation(exif.data);
     if (list.some(c => c.type === ANMF)) {
-        const animation = decodeAnimation(data, true);
+        const animation = decodeAnimation(data, true, maxPixels);
         const frame = composite(animation)[0];
         return { width: animation.width, height: animation.height, pixels: frame.pixels, orientation };
     }
-    const image = decodeBitstream(list);
+    const image = decodeBitstream(list, maxPixels);
     if (list[0].type === VP8X && list[0].data.length >= 10) {
         const width = u24(list[0].data, 4) + 1, height = u24(list[0].data, 7) + 1;
         if (width !== image.width || height !== image.height)
@@ -130,16 +131,17 @@ export function decode(data) {
     }
     return { ...image, orientation };
 }
-export function decodeAnimation(data, onlyFirstFrame = false) {
+export function decodeAnimation(data, onlyFirstFrame = false, maxPixels = MAX_PIXELS) {
     const list = container(data);
     const header = list[0];
     if (!header || header.type !== VP8X || !list.some(c => c.type === ANMF)) {
-        const { width, height, pixels } = decodeBitstream(list);
+        const { width, height, pixels } = decodeBitstream(list, maxPixels);
         return { width, height, loopCount: 0, background: 0, frames: [{ x: 0, y: 0, width, height, duration: 0, blend: false, dispose: false, pixels }] };
     }
     if (header.data.length < 10)
         throw new Error('WebP: invalid VP8X chunk');
     const width = u24(header.data, 4) + 1, height = u24(header.data, 7) + 1;
+    checkPixels(width, height, maxPixels, onlyFirstFrame ? 1 : list.filter(c => c.type === ANMF).length);
     let loopCount = 0, background = 0;
     const frames = [];
     for (const chunk of list) {
@@ -152,7 +154,7 @@ export function decodeAnimation(data, onlyFirstFrame = false) {
             const d = chunk.data;
             if (d.length < 16)
                 throw new Error('WebP: invalid ANMF chunk');
-            const frame = decodeBitstream(chunks(d, 16, d.length));
+            const frame = decodeBitstream(chunks(d, 16, d.length), maxPixels);
             frames.push({
                 x: u24(d, 0) * 2,
                 y: u24(d, 3) * 2,

package/dist/codecs/zlib.js

@@ -94,75 +94,73 @@ function inflate(dat, buf) {
         return buf.subarray(0, 0);
     const tbts = sl * 8;
     let final = 0, pos = 0, bt = 0;
-    let lm = null, dm = null, lbt = 0, dbt = 0;
     do {
-        if (!lm) {
-            final = bits(dat, pos, 1);
-            const type = bits(dat, pos + 1, 3);
-            pos += 3;
-            if (!type) {
-                const s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
-                if (t > sl)
-                    throw new Error('zlib: unexpected end of data');
-                if (bt < buf.length)
-                    buf.set(dat.subarray(s, Math.min(t, s + buf.length - bt)), bt);
-                bt += l;
-                pos = t * 8;
-                continue;
-            }
-            else if (type === 1) {
-                lm = flrm;
-                dm = fdrm;
-                lbt = 9;
-                dbt = 5;
-            }
-            else if (type === 2) {
-                const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
-                const tl = hLit + bits(dat, pos + 5, 31) + 1;
-                pos += 14;
-                const ldt = new u8(tl);
-                const clt = new u8(19);
-                for (let i = 0; i < hcLen; ++i)
-                    clt[clim[i]] = bits(dat, pos + i * 3, 7);
-                pos += hcLen * 3;
-                const clb = max(clt), clbmsk = (1 << clb) - 1;
-                const clm = hMap(clt, clb, true);
-                for (let i = 0; i < tl;) {
-                    const r = clm[bits(dat, pos, clbmsk)];
-                    pos += r & 15;
-                    const s = r >> 4;
-                    if (s < 16)
-                        ldt[i++] = s;
-                    else {
-                        let c = 0, n = 0;
-                        if (s === 16) {
-                            n = 3 + bits(dat, pos, 3);
-                            pos += 2;
-                            c = ldt[i - 1];
-                        }
-                        else if (s === 17) {
-                            n = 3 + bits(dat, pos, 7);
-                            pos += 3;
-                        }
-                        else if (s === 18) {
-                            n = 11 + bits(dat, pos, 127);
-                            pos += 7;
-                        }
-                        while (n--)
-                            ldt[i++] = c;
+        let lm, dm, lbt, dbt;
+        final = bits(dat, pos, 1);
+        const type = bits(dat, pos + 1, 3);
+        pos += 3;
+        if (!type) {
+            const s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+            if (t > sl)
+                throw new Error('zlib: unexpected end of data');
+            if (bt < buf.length)
+                buf.set(dat.subarray(s, Math.min(t, s + buf.length - bt)), bt);
+            bt += l;
+            pos = t * 8;
+            continue;
+        }
+        else if (type === 1) {
+            lm = flrm;
+            dm = fdrm;
+            lbt = 9;
+            dbt = 5;
+        }
+        else if (type === 2) {
+            const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+            const tl = hLit + bits(dat, pos + 5, 31) + 1;
+            pos += 14;
+            const ldt = new u8(tl);
+            const clt = new u8(19);
+            for (let i = 0; i < hcLen; ++i)
+                clt[clim[i]] = bits(dat, pos + i * 3, 7);
+            pos += hcLen * 3;
+            const clb = max(clt), clbmsk = (1 << clb) - 1;
+            const clm = hMap(clt, clb, true);
+            for (let i = 0; i < tl;) {
+                const r = clm[bits(dat, pos, clbmsk)];
+                pos += r & 15;
+                const s = r >> 4;
+                if (s < 16)
+                    ldt[i++] = s;
+                else {
+                    let c = 0, n = 0;
+                    if (s === 16) {
+                        n = 3 + bits(dat, pos, 3);
+                        pos += 2;
+                        c = ldt[i - 1];
+                    }
+                    else if (s === 17) {
+                        n = 3 + bits(dat, pos, 7);
+                        pos += 3;
                     }
+                    else if (s === 18) {
+                        n = 11 + bits(dat, pos, 127);
+                        pos += 7;
+                    }
+                    while (n--)
+                        ldt[i++] = c;
                 }
-                const lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
-                lbt = max(lt);
-                dbt = max(dt);
-                lm = hMap(lt, lbt, true);
-                dm = hMap(dt, dbt, true);
             }
-            else
-                throw new Error('zlib: invalid block type');
-            if (pos > tbts)
-                throw new Error('zlib: unexpected end of data');
+            const lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+            lbt = max(lt);
+            dbt = max(dt);
+            lm = hMap(lt, lbt, true);
+            dm = hMap(dt, dbt, true);
         }
+        else
+            throw new Error('zlib: invalid block type');
+        if (pos > tbts)
+            throw new Error('zlib: unexpected end of data');
         const lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
         for (;;) {
             const c = lm[bits16(dat, pos) & lms], sym = c >> 4;
@@ -173,10 +171,8 @@ function inflate(dat, buf) {
                 throw new Error('zlib: invalid length/literal');
             if (sym < 256)
                 buf[bt++] = sym;
-            else if (sym === 256) {
-                lm = null;
+            else if (sym === 256)
                 break;
-            }
             else {
                 let add = sym - 254;
                 if (sym > 264) {
@@ -557,8 +553,8 @@ export function decompress(data, limit) {
         throw new Error('zlib: preset dictionaries are not supported');
     return inflate(data.subarray(2), new u8(limit));
 }
-const { process: runtime, DecompressionStream: NativeDecompression, Blob: NativeBlob } = globalThis;
-const nodeZlib = (() => {
+const { process: runtime, CompressionStream: NativeCompression, DecompressionStream: NativeDecompression, Blob: NativeBlob } = globalThis;
+export const nodeZlib = (() => {
     try {
         return (runtime && runtime.getBuiltinModule && runtime.getBuiltinModule('node:zlib')) || null;
     }
@@ -571,6 +567,22 @@ export async function compressAsync(data, level) {
     level = Math.min(9, Math.max(0, level | 0));
     if (nodeZlib)
         return plain(nodeZlib.deflateSync(data, { level }));
+    if (NativeCompression && NativeBlob && level >= 1 && level <= 6) {
+        const reader = new NativeBlob([data]).stream().pipeThrough(new NativeCompression('deflate')).getReader();
+        const parts = [];
+        let length = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done || !value)
+                break;
+            parts.push(value);
+            length += value.length;
+        }
+        const out = new Uint8Array(length);
+        for (let i = 0, offset = 0; i < parts.length; offset += parts[i++].length)
+            out.set(parts[i], offset);
+        return out;
+    }
     return compress(data, level);
 }
 export async function decompressAsync(data, limit) {

package/dist/frame.d.ts

@@ -52,6 +52,7 @@ export declare class Frame extends Image {
     get disposalMode(): FrameDisposalModeName;
     /** Sets the disposal mode by name or id (0-3) */
     set disposalMode(disposalMode: FrameDisposalModeName | FrameDisposalModeId);
+    /** A short description for debugging, e.g. `Frame<64x64x100ms>` */
     toString(): string;
     /**
      * Converts an Image instance to a Frame, cloning it in the process

package/dist/frame.js

@@ -1,5 +1,5 @@
 import { Image } from "./image.js";
-import { isOptions } from "./util/options.js";
+import { isOptions, finite } from "./util/options.js";
 const DISPOSAL_MODES = ['any', 'keep', 'previous', 'background'];
 export class Frame extends Image {
     duration;
@@ -26,8 +26,10 @@ export class Frame extends Image {
     }
     constructor(width, height, durationOrOptions, xOffset, yOffset, disposalMode) {
         const { duration = 100, xOffset: x = 0, yOffset: y = 0, disposalMode: disposal = Frame.DISPOSAL_KEEP } = isOptions(durationOrOptions) ? durationOrOptions : { duration: durationOrOptions, xOffset, yOffset, disposalMode };
-        if (isNaN(duration) || duration < 0)
+        if (finite(duration, 'frame duration') < 0)
             throw new RangeError('Invalid frame duration');
+        finite(x, 'x offset');
+        finite(y, 'y offset');
         super(width, height);
         this.duration = duration;
         this.xOffset = x;

package/dist/gif.d.ts

@@ -15,6 +15,7 @@ export declare class GIF extends Animation {
      *     {@link AnimationOptions}
      */
     constructor(frames: Frame[], loopCountOrOptions?: number | AnimationOptions);
+    /** A short description for debugging, e.g. `GIF<64x64x1000ms>` */
     toString(): string;
     /**
      * Encodes the GIF

package/dist/gif.js

@@ -13,10 +13,10 @@ export class GIF extends Animation {
         return this.encodeGIF(qualityOrOptions);
     }
     static async decode(input, onlyFirstFrameOrOptions = false) {
-        const onlyExtractFirstFrame = isOptions(onlyFirstFrameOrOptions) ? onlyFirstFrameOrOptions.onlyFirstFrame ?? false : onlyFirstFrameOrOptions;
+        const { onlyFirstFrame = false, maxPixels } = isOptions(onlyFirstFrameOrOptions) ? onlyFirstFrameOrOptions : { onlyFirstFrame: onlyFirstFrameOrOptions };
         const data = view(input);
         if (!ImageType.isGIF(new DataView(data.buffer, data.byteOffset, data.byteLength)))
             throw new Error('Unsupported image type');
-        return Animation.__fromGIF__(data, onlyExtractFirstFrame, GIF);
+        return Animation.__fromGIF__(data, onlyFirstFrame, GIF, maxPixels);
     }
 }