imagescript 3.1.0 → 3.2.0

package/dist/codecs/png.js

@@ -41,15 +41,24 @@ export async function encode(data, { text, width, height, channels, depth = 8, l
         chunks.push(chunk(PLTE, palette));
     if (transparency)
         chunks.push(chunk(tRNS, transparency));
+    chunks.push(...textChunks(text));
     chunks.push(chunk(IDAT, await compressAsync(filtered, level)));
+    chunks.push(chunk(IEND, new Uint8Array(0)));
+    return concat([HEAD, ...chunks]);
+}
+function textChunks(text) {
+    const chunks = [];
+    const latin1 = (s) => Array.from(s, c => c.charCodeAt(0));
     for (const key in text) {
         const value = text[key];
         if (!value)
             continue;
-        chunks.push(chunk(0x74455874, concat([utf8(key), [0], utf8(value)])));
+        if (/^[\x00-\xff]*$/.test(value))
+            chunks.push(chunk(tEXt, concat([latin1(key), [0], latin1(value)])));
+        else
+            chunks.push(chunk(iTXt, concat([latin1(key), [0, 0, 0, 0, 0], utf8(value)])));
     }
-    chunks.push(chunk(IEND, new Uint8Array(0)));
-    return concat([HEAD, ...chunks]);
+    return chunks;
 }
 function filter(data, rowBytes, height, bpp) {
     const out = new Uint8Array(height * (rowBytes + 1));
@@ -66,7 +75,8 @@ function filter(data, rowBytes, height, bpp) {
         for (let i = bpp; i < rowBytes; i++) {
             const a = data[row + i - bpp], b = data[row + i - rowBytes], c = data[row + i - rowBytes - bpp];
             const pa = Math.abs(b - c), pb = Math.abs(a - c), pc = Math.abs(a + b - 2 * c);
-            out[o + i] = data[row + i] - (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
+            const notA = (pb - pa | pc - pa) >> 31, takeC = (pc - pb) >> 31;
+            out[o + i] = data[row + i] - (a ^ (a ^ b ^ (b ^ c) & takeC) & notA);
         }
     }
     return out;
@@ -80,10 +90,37 @@ function chunk(type, body) {
     view.setUint32(body.length + 8, crc32(out.subarray(4, body.length + 8)));
     return out;
 }
+export function alphaCost(images) {
+    let grey = true;
+    const colors = new Set();
+    scan: for (const rgba of images) {
+        const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, rgba.length >> 2);
+        let previous = -1;
+        for (let i = 0; i < pixels.length; i++) {
+            const value = pixels[i];
+            if (value === previous)
+                continue;
+            previous = value;
+            const o = i * 4;
+            if (rgba[o + 3] === 0)
+                continue;
+            if (rgba[o] !== rgba[o + 1] || rgba[o] !== rgba[o + 2])
+                grey = false;
+            if (colors.size <= 256)
+                colors.add(value);
+            else if (!grey)
+                break scan;
+        }
+    }
+    const palette = (entries) => (entries <= 2 ? 1 : entries <= 4 ? 2 : entries <= 16 ? 4 : 8) / 8;
+    const transparent = colors.size < 256 ? palette(colors.size + 1) : grey ? 2 : 4;
+    const opaque = colors.size <= 256 ? palette(colors.size) : grey ? 1 : 3;
+    return transparent / opaque;
+}
 function pixelFormat(images) {
     let opaque = true, grey = true;
     let colors = new Map();
-    for (const rgba of images) {
+    scan: for (const rgba of images) {
         const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, rgba.length >> 2);
         let previous = -1;
         for (let i = 0; i < pixels.length; i++) {
@@ -102,6 +139,8 @@ function pixelFormat(images) {
                 else
                     colors.set(value, colors.size);
             }
+            if (!colors && !opaque && !grey)
+                break scan;
         }
     }
     if (colors) {
@@ -144,18 +183,22 @@ function pixelFormat(images) {
                 return rgba;
             const count = width * height;
             const data = new Uint8Array(count * channels);
-            for (let i = 0, o = 0; i < count; i++) {
-                const s = i * 4;
-                if (grey)
-                    data[o++] = rgba[s];
-                else {
-                    data[o++] = rgba[s];
-                    data[o++] = rgba[s + 1];
-                    data[o++] = rgba[s + 2];
+            if (channels === 3) {
+                for (let s = 0, o = 0; o < data.length; s += 4, o += 3) {
+                    data[o] = rgba[s];
+                    data[o + 1] = rgba[s + 1];
+                    data[o + 2] = rgba[s + 2];
+                }
+            }
+            else if (channels === 2) {
+                for (let s = 0, o = 0; o < data.length; s += 4, o += 2) {
+                    data[o] = rgba[s];
+                    data[o + 1] = rgba[s + 3];
                 }
-                if (!opaque)
-                    data[o++] = rgba[s + 3];
             }
+            else
+                for (let s = 0, o = 0; o < data.length; s += 4, o++)
+                    data[o] = rgba[s];
             return data;
         }
     };
@@ -179,7 +222,7 @@ async function compressRows(data, width, height, channels, depth, level, filterR
     }
     return compressAsync(filtered, level);
 }
-export async function encodeAnimation(frames, width, height, plays, level) {
+export async function encodeAnimation(frames, width, height, plays, level, text) {
     if (!frames.length)
         throw new Error('PNG: an animation needs at least one frame');
     const first = frames[0];
@@ -212,6 +255,7 @@ export async function encodeAnimation(frames, width, height, plays, level) {
         chunks.push(chunk(PLTE, palette));
     if (transparency)
         chunks.push(chunk(tRNS, transparency));
+    chunks.push(...textChunks(text));
     let sequence = 0;
     for (let i = 0; i < frames.length; i++) {
         const f = frames[i];
@@ -232,7 +276,7 @@ export async function encodeAnimation(frames, width, height, plays, level) {
             v.setUint16(22, 100);
         }
         fctl[24] = f.dispose;
-        fctl[25] = 1;
+        fctl[25] = f.blend === false ? 0 : 1;
         chunks.push(chunk(fcTL, fctl));
         const data = await compressRows(format.convert(images[i], f.width, f.height), f.width, f.height, channels, depth, level, filterRows);
         if (i === 0)
@@ -552,7 +596,8 @@ function unfilter(data, offset, height, rowBytes, bpp) {
                 for (let i = row + bpp; i < row + rowBytes; i++) {
                     const a = out[i - bpp], b = out[i - rowBytes], c = out[i - rowBytes - bpp];
                     const pa = Math.abs(b - c), pb = Math.abs(a - c), pc = Math.abs(a + b - 2 * c);
-                    out[i] = data[src + i] + (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
+                    const notA = (pb - pa | pc - pa) >> 31, takeC = (pc - pb) >> 31;
+                    out[i] = data[src + i] + (a ^ (a ^ b ^ (b ^ c) & takeC) & notA);
                 }
             }
         }
@@ -614,6 +659,20 @@ function createConverter(colorType, depth, palette, transparency) {
         const key = transparency && transparency.length >= 6
             ? [transparency[0] << 8 | transparency[1], transparency[2] << 8 | transparency[3], transparency[4] << 8 | transparency[5]].map(v => v & maxValue)
             : null;
+        if (depth === 8) {
+            const [kr, kg, kb] = key || [-1, -1, -1];
+            return (pixels, rowBytes, w, h, out, place) => {
+                for (let y = 0; y < h; y++) {
+                    for (let x = 0, s = y * rowBytes, o = place.row(y), step = place.step; x < w; x++, s += 3, o += step) {
+                        const r = pixels[s], g = pixels[s + 1], b = pixels[s + 2];
+                        out[o] = r;
+                        out[o + 1] = g;
+                        out[o + 2] = b;
+                        out[o + 3] = r === kr && g === kg && b === kb ? 0 : 0xff;
+                    }
+                }
+            };
+        }
         return (pixels, rowBytes, w, h, out, place) => {
             for (let y = 0; y < h; y++) {
                 const row = pixels.subarray(y * rowBytes, (y + 1) * rowBytes);
@@ -645,9 +704,14 @@ function createConverter(colorType, depth, palette, transparency) {
         return (pixels, rowBytes, w, h, out, place) => {
             if (place.step === 4 && w * 4 === rowBytes && place.row(0) === 0 && place.row(1) === rowBytes)
                 return out.set(pixels);
-            for (let y = 0; y < h; y++)
-                for (let x = 0, o = place.row(y); x < w; x++, o += place.step)
-                    out.set(pixels.subarray(y * rowBytes + x * 4, y * rowBytes + x * 4 + 4), o);
+            for (let y = 0; y < h; y++) {
+                for (let x = 0, s = y * rowBytes, o = place.row(y), step = place.step; x < w; x++, s += 4, o += step) {
+                    out[o] = pixels[s];
+                    out[o + 1] = pixels[s + 1];
+                    out[o + 2] = pixels[s + 2];
+                    out[o + 3] = pixels[s + 3];
+                }
+            }
         };
     }
     return (pixels, rowBytes, w, h, out, place) => {

package/dist/codecs/quantize.js

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

package/dist/codecs/tga.js

@@ -1,3 +1,4 @@
+import { encode as utf8 } from "../util/utf8.js";
 const SIGNATURE = 'TRUEVISION-XFILE.\0';
 function readHeader(d) {
     if (d.length < 18)
@@ -147,7 +148,38 @@ export function decode(d) {
     }
     return { width, height, pixels: stored };
 }
-export function encode(rgba, width, height) {
+function pieces(value, max) {
+    const bytes = utf8(value);
+    const out = [];
+    for (let start = 0; start < bytes.length;) {
+        let end = Math.min(bytes.length, start + max);
+        while (end < bytes.length && end > start && (bytes[end] & 0xc0) === 0x80)
+            end--;
+        out.push(bytes.subarray(start, end));
+        start = end;
+    }
+    return out;
+}
+function extensionArea({ author, comment, time, software }, alpha) {
+    const area = new Uint8Array(495);
+    const view = new DataView(area.buffer);
+    view.setUint16(0, 495, true);
+    if (author)
+        area.set(pieces(author, 40)[0], 2);
+    if (comment) {
+        const lines = comment.split(/\r?\n/).flatMap(line => line ? pieces(line, 80) : [new Uint8Array(0)]).slice(0, 4);
+        lines.forEach((line, i) => area.set(line, 43 + i * 81));
+    }
+    if (time)
+        [time.getUTCMonth() + 1, time.getUTCDate(), time.getUTCFullYear(), time.getUTCHours(), time.getUTCMinutes(), time.getUTCSeconds()]
+            .forEach((v, i) => view.setUint16(367 + i * 2, v, true));
+    if (software)
+        area.set(pieces(software, 40)[0], 426);
+    area[469] = 0x20;
+    area[494] = alpha ? 3 : 0;
+    return area;
+}
+export function encode(rgba, width, height, extension) {
     if (width < 1 || height < 1 || width > 65535 || height > 65535)
         throw new RangeError('TGA: dimensions must be 1-65535');
     let opaque = true;
@@ -161,7 +193,7 @@ export function encode(rgba, width, height) {
     if (rgba.byteOffset % 4)
         rgba = rgba.slice(0, count * 4);
     const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, count);
-    const out = new Uint8Array(18 + count * bpp + Math.ceil(count / 128) + 26);
+    const out = new Uint8Array(18 + count * bpp + height * Math.ceil(width / 128) + 495 + 26);
     out[2] = 10;
     out[12] = width & 255;
     out[13] = width >> 8;
@@ -179,8 +211,9 @@ export function encode(rgba, width, height) {
             out[o++] = rgba[p + 3];
     };
     for (let i = 0; i < count;) {
+        const end = (Math.floor(i / width) + 1) * width;
         let run = 1;
-        while (run < 128 && i + run < count && pixels[i + run] === pixels[i])
+        while (run < 128 && i + run < end && pixels[i + run] === pixels[i])
             run++;
         if (run >= 2) {
             out[o++] = 128 | run - 1;
@@ -189,13 +222,23 @@ export function encode(rgba, width, height) {
             continue;
         }
         let raw = 1;
-        while (raw < 128 && i + raw < count && !(i + raw + 1 < count && pixels[i + raw] === pixels[i + raw + 1]))
+        while (raw < 128 && i + raw < end && !(i + raw + 1 < end && pixels[i + raw] === pixels[i + raw + 1]))
             raw++;
         out[o++] = raw - 1;
         for (let k = 0; k < raw; k++)
             put(i + k);
         i += raw;
     }
+    let extensionOffset = 0;
+    if (extension && (extension.author || extension.comment || extension.time || extension.software)) {
+        extensionOffset = o;
+        out.set(extensionArea(extension, bpp === 4), o);
+        o += 495;
+    }
+    out[o] = extensionOffset & 255;
+    out[o + 1] = extensionOffset >> 8 & 255;
+    out[o + 2] = extensionOffset >> 16 & 255;
+    out[o + 3] = extensionOffset >>> 24;
     o += 8;
     for (let i = 0; i < SIGNATURE.length; i++)
         out[o++] = SIGNATURE.charCodeAt(i);

package/dist/codecs/vp8l.js

@@ -293,30 +293,24 @@ function decodeImage(reader, width, height, isMain) {
     return pixels;
 }
 const average2 = (a, b) => (((a ^ b) & 0xfefefefe) >>> 1) + (a & b) >>> 0;
+const clamp255 = (v) => v < 0 ? 0 : v > 255 ? 255 : v;
 function clampAddSubtractFull(a, b, c) {
-    let out = 0;
-    for (let shift = 0; shift < 32; shift += 8) {
-        const v = (a >>> shift & 255) + (b >>> shift & 255) - (c >>> shift & 255);
-        out |= (v < 0 ? 0 : v > 255 ? 255 : v) << shift;
-    }
-    return out >>> 0;
+    return (clamp255((a & 255) + (b & 255) - (c & 255))
+        | clamp255((a >>> 8 & 255) + (b >>> 8 & 255) - (c >>> 8 & 255)) << 8
+        | clamp255((a >>> 16 & 255) + (b >>> 16 & 255) - (c >>> 16 & 255)) << 16
+        | clamp255((a >>> 24) + (b >>> 24) - (c >>> 24)) << 24) >>> 0;
 }
 function clampAddSubtractHalf(a, b) {
-    let out = 0;
-    for (let shift = 0; shift < 32; shift += 8) {
-        const ac = a >>> shift & 255, d = ac - (b >>> shift & 255);
-        const v = ac + (d / 2 | 0);
-        out |= (v < 0 ? 0 : v > 255 ? 255 : v) << shift;
-    }
-    return out >>> 0;
+    const a0 = a & 255, a1 = a >>> 8 & 255, a2 = a >>> 16 & 255, a3 = a >>> 24;
+    return (clamp255(a0 + ((a0 - (b & 255)) / 2 | 0))
+        | clamp255(a1 + ((a1 - (b >>> 8 & 255)) / 2 | 0)) << 8
+        | clamp255(a2 + ((a2 - (b >>> 16 & 255)) / 2 | 0)) << 16
+        | clamp255(a3 + ((a3 - (b >>> 24)) / 2 | 0)) << 24) >>> 0;
 }
 function select(l, t, tl) {
-    let pl = 0, pt = 0;
-    for (let shift = 0; shift < 32; shift += 8) {
-        const lc = l >>> shift & 255, tc = t >>> shift & 255, tlc = tl >>> shift & 255;
-        pl += Math.abs(tc - tlc);
-        pt += Math.abs(lc - tlc);
-    }
+    const tl0 = tl & 255, tl1 = tl >>> 8 & 255, tl2 = tl >>> 16 & 255, tl3 = tl >>> 24;
+    const pl = Math.abs((t & 255) - tl0) + Math.abs((t >>> 8 & 255) - tl1) + Math.abs((t >>> 16 & 255) - tl2) + Math.abs((t >>> 24) - tl3);
+    const pt = Math.abs((l & 255) - tl0) + Math.abs((l >>> 8 & 255) - tl1) + Math.abs((l >>> 16 & 255) - tl2) + Math.abs((l >>> 24) - tl3);
     return pl < pt ? l : t;
 }
 const addPixels = (a, b) => ((a & 0xff00ff00) + (b & 0xff00ff00) & 0xff00ff00 | (a & 0x00ff00ff) + (b & 0x00ff00ff) & 0x00ff00ff) >>> 0;
@@ -712,17 +706,24 @@ function tokenize(pixels, width, cacheBits) {
     let cached = 0;
     for (let i = 0; i < n;) {
         let bestLength = 0, bestDistance = 0;
-        for (const d of [1, width]) {
-            if (d > i)
-                continue;
-            const l = matchLength(i, i - d);
+        if (i >= 1) {
+            const l = matchLength(i, i - 1);
             if (l > bestLength) {
                 bestLength = l;
-                bestDistance = d;
+                bestDistance = 1;
+            }
+        }
+        if (width <= i) {
+            const l = matchLength(i, i - width);
+            if (l > bestLength) {
+                bestLength = l;
+                bestDistance = width;
             }
         }
         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++) {
+                if (i - j >= bestDistance && (i + bestLength >= n || pixels[j + bestLength] !== pixels[i + bestLength]))
+                    continue;
                 const l = matchLength(i, j);
                 if (l > bestLength || l === bestLength && l > 0 && i - j < bestDistance) {
                     bestLength = l;
@@ -810,12 +811,8 @@ function writeImage(w, pixels, width, isMain) {
 }
 const subPixels = (a, b) => ((a | 0x00ff00ff) - (b & 0xff00ff00) & 0xff00ff00 | (a | 0xff00ff00) - (b & 0x00ff00ff) & 0x00ff00ff) >>> 0;
 function residualCost(r) {
-    let cost = 0;
-    for (let shift = 0; shift < 32; shift += 8) {
-        const c = r >>> shift & 255;
-        cost += c < 128 ? c : 256 - c;
-    }
-    return cost;
+    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);
 }
 function applyPredictor(p, width, height, bits) {
     const blocksX = subSize(width, bits), blocksY = subSize(height, bits);

package/dist/codecs/webp.js

@@ -239,21 +239,32 @@ function toARGB(rgba, count) {
     return argb;
 }
 const set24 = (d, o, v) => { d[o] = v & 255; d[o + 1] = v >> 8 & 255; d[o + 2] = v >> 16 & 255; };
-export function encode(rgba, width, height) {
-    return riff([riffChunk('VP8L', vp8l.encode(toARGB(rgba, width * height), width, height))]);
+const hasAlpha = (rgba) => {
+    for (let i = 3; i < rgba.length; i += 4)
+        if (rgba[i] !== 255)
+            return true;
+    return false;
+};
+export function encode(rgba, width, height, exif) {
+    const bitstream = riffChunk('VP8L', vp8l.encode(toARGB(rgba, width * height), width, height));
+    if (!exif)
+        return riff([bitstream]);
+    const vp8x = new Uint8Array(10);
+    vp8x[0] = 8 | (hasAlpha(rgba.subarray(0, width * height * 4)) ? 16 : 0);
+    set24(vp8x, 4, width - 1);
+    set24(vp8x, 7, height - 1);
+    return riff([riffChunk('VP8X', vp8x), bitstream, riffChunk('EXIF', exif)]);
 }
-export function encodeAnimation(frames, width, height, plays) {
+export function encodeAnimation(frames, width, height, plays, exif) {
     if (!frames.length)
         throw new Error('WebP: an animation needs at least one frame');
     if (width > 1 << 24 || height > 1 << 24)
         throw new RangeError('WebP: canvas too large');
-    let alpha = false;
-    for (const f of frames)
-        for (let i = 3; i < f.pixels.length && !alpha; i += 4)
-            if (f.pixels[i] !== 255)
-                alpha = true;
+    const first = frames[0];
+    const alpha = first.x > 0 || first.y > 0 || first.width < width || first.height < height
+        || frames.some(f => f.dispose || hasAlpha(f.pixels));
     const vp8x = new Uint8Array(10);
-    vp8x[0] = 2 | (alpha ? 16 : 0);
+    vp8x[0] = 2 | (alpha ? 16 : 0) | (exif ? 8 : 0);
     set24(vp8x, 4, width - 1);
     set24(vp8x, 7, height - 1);
     const anim = new Uint8Array(6);
@@ -270,11 +281,13 @@ export function encodeAnimation(frames, width, height, plays) {
         set24(header, 6, f.width - 1);
         set24(header, 9, f.height - 1);
         set24(header, 12, Math.min(0xffffff, Math.max(0, Math.round(f.duration))));
-        header[15] = f.dispose ? 1 : 0;
+        header[15] = (f.blend === false ? 2 : 0) | (f.dispose ? 1 : 0);
         const body = new Uint8Array(16 + bitstream.length);
         body.set(header);
         body.set(bitstream, 16);
         chunks.push(riffChunk('ANMF', body));
     }
+    if (exif)
+        chunks.push(riffChunk('EXIF', exif));
     return riff(chunks);
 }

package/dist/frame.d.ts

@@ -1,8 +1,19 @@
-import { Image, ResizeMode } from './image.js';
+import { Image, ResizeMode, ResizeOptions, Color, TrimOptions } from './image.js';
 /** Names of the frame disposal modes, see {@link Frame.disposalMode} */
 export type FrameDisposalModeName = 'any' | 'keep' | 'previous' | 'background';
 /** Ids of the frame disposal modes, as GIFs store them (0 any, 1 keep, 2 previous, 3 background) */
 export type FrameDisposalModeId = 0 | 1 | 2 | 3;
+/** Options of {@link Frame} and {@link Frame.from} */
+export interface FrameOptions {
+    /** The frame's duration in milliseconds. Default: `100` */
+    duration?: number;
+    /** The frame's offset on the x-axis. Default: `0` */
+    xOffset?: number;
+    /** The frame's offset on the y-axis. Default: `0` */
+    yOffset?: number;
+    /** The frame's disposal mode, see {@link Frame.disposalMode}. Default: `'keep'` */
+    disposalMode?: FrameDisposalModeName | FrameDisposalModeId;
+}
 /**
  * Represents a frame of an {@link Animation}
  */
@@ -24,6 +35,11 @@ export declare class Frame extends Image {
     static get DISPOSAL_PREVIOUS(): 'previous';
     /** Frame disposal mode BACKGROUND. For use with {@link Frame} */
     static get DISPOSAL_BACKGROUND(): 'background';
+    /**
+     * Creates a new, blank frame
+     * @param options See {@link FrameOptions}
+     */
+    constructor(width: number, height: number, options?: FrameOptions);
     /**
      * Creates a new, blank frame
      * @param duration The frame's duration (in ms)
@@ -37,6 +53,12 @@ export declare class Frame extends Image {
     /** Sets the disposal mode by name or id (0-3) */
     set disposalMode(disposalMode: FrameDisposalModeName | FrameDisposalModeId);
     toString(): string;
+    /**
+     * Converts an Image instance to a Frame, cloning it in the process
+     * @param image The image to create the frame from
+     * @param options See {@link FrameOptions}
+     */
+    static from(image: Image, options?: FrameOptions): Frame;
     /**
      * Converts an Image instance to a Frame, cloning it in the process
      * @param image The image to create the frame from
@@ -50,8 +72,14 @@ export declare class Frame extends Image {
      * Clones the frame, including its duration, offsets and disposal mode
      */
     clone(): Frame;
+    /**
+     * Removes borders of one color, moving the frame's offsets so the remaining pixels stay in place
+     * @param color The border color, by default the color of the top left pixel
+     * @param options See {@link TrimOptions}
+     */
+    trim(color?: Color, options?: TrimOptions): this;
     /**
      * Resizes the frame, scaling its offsets along with it
      */
-    resize(width: number, height: number, mode?: ResizeMode): this;
+    resize(width: number, height: number, modeOrOptions?: ResizeMode | ResizeOptions): this;
 }

package/dist/frame.js

@@ -1,4 +1,5 @@
 import { Image } from "./image.js";
+import { isOptions } from "./util/options.js";
 const DISPOSAL_MODES = ['any', 'keep', 'previous', 'background'];
 export class Frame extends Image {
     duration;
@@ -23,14 +24,15 @@ export class Frame extends Image {
             throw new RangeError('Invalid disposal mode');
         return id;
     }
-    constructor(width, height, duration = 100, xOffset = 0, yOffset = 0, disposalMode = Frame.DISPOSAL_KEEP) {
+    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)
             throw new RangeError('Invalid frame duration');
         super(width, height);
         this.duration = duration;
-        this.xOffset = xOffset;
-        this.yOffset = yOffset;
-        this.disposalMode = disposalMode;
+        this.xOffset = x;
+        this.yOffset = y;
+        this.disposalMode = disposal;
     }
     get disposalMode() {
         return DISPOSAL_MODES[this.__disposalMode__];
@@ -44,20 +46,29 @@ export class Frame extends Image {
     toString() {
         return `Frame<${this.width}x${this.height}x${this.duration}ms>`;
     }
-    static from(image, duration, xOffset, yOffset, disposalMode = Frame.DISPOSAL_KEEP) {
+    static from(image, durationOrOptions, xOffset, yOffset, disposalMode) {
         if (!(image instanceof Image))
             throw new TypeError('Invalid image passed');
-        const frame = new Frame(image.width, image.height, duration, xOffset, yOffset, disposalMode);
+        const options = isOptions(durationOrOptions) ? durationOrOptions : { duration: durationOrOptions, xOffset, yOffset, disposalMode };
+        const frame = new Frame(image.width, image.height, options);
         frame.bitmap.set(image.bitmap);
         return frame;
     }
     clone() {
-        return Frame.from(this, this.duration, this.xOffset, this.yOffset, this.disposalMode);
+        return Frame.from(this, { duration: this.duration, xOffset: this.xOffset, yOffset: this.yOffset, disposalMode: this.disposalMode });
     }
-    resize(width, height, mode = Image.RESIZE_BILINEAR) {
+    trim(color, options = {}) {
+        const bounds = this.__trim_bounds__(color, options);
+        if (!bounds)
+            return this;
+        this.xOffset += bounds[0];
+        this.yOffset += bounds[1];
+        return this.__apply__(this.__crop__(...bounds));
+    }
+    resize(width, height, modeOrOptions) {
         const originalWidth = this.width;
         const originalHeight = this.height;
-        super.resize(width, height, mode);
+        super.resize(width, height, modeOrOptions);
         this.xOffset = Math.round(this.xOffset * this.width / originalWidth);
         this.yOffset = Math.round(this.yOffset * this.height / originalHeight);
         return this;

package/dist/gif.d.ts

@@ -1,6 +1,6 @@
 import { BinaryData } from './util/mem.js';
 import { Frame } from './frame.js';
-import { Animation } from './animation.js';
+import { Animation, AnimationDecodeOptions, AnimationOptions, GIFEncodeOptions } from './animation.js';
 /**
  * Represents a GIF image as an array of frames, an {@link Animation} whose `encode()` and `decode()` work with GIFs.
  * Array methods like map and filter return plain arrays.
@@ -11,21 +11,24 @@ export declare class GIF extends Animation {
     /**
      * Creates a new GIF image
      * @param frames The frames to create the GIF from
-     * @param loopCount How many times to repeat the GIF (-1 = forever, 0 = play once)
+     * @param loopCountOrOptions How many times to repeat the GIF (-1 = forever, 0 = play once), or see
+     *     {@link AnimationOptions}
      */
-    constructor(frames: Frame[], loopCount?: number);
+    constructor(frames: Frame[], loopCountOrOptions?: number | AnimationOptions);
     toString(): string;
     /**
      * Encodes the GIF
-     * @param quality 1-100, scales the palette size from 8 colors (1) to 256 colors (90 and above)
+     * @param qualityOrOptions 1-100, scales the palette size from 8 colors (1) to 256 colors (90 and above), or
+     *     see {@link GIFEncodeOptions}
      * @deprecated Use {@link Animation.encodeGIF}
      */
-    encode(quality?: number): Promise<Uint8Array>;
+    encode(qualityOrOptions?: number | GIFEncodeOptions): Promise<Uint8Array>;
     /**
      * Decodes a GIF into fully composited frames
      * @param input The binary data to decode
-     * @param onlyExtractFirstFrame Whether to end GIF decoding after the first frame
+     * @param onlyFirstFrameOrOptions Whether to end GIF decoding after the first frame, or see
+     *     {@link AnimationDecodeOptions}
      * @deprecated Use {@link Animation.decode}, which decodes APNGs too
      */
-    static decode(input: BinaryData, onlyExtractFirstFrame?: boolean): Promise<GIF>;
+    static decode(input: BinaryData, onlyFirstFrameOrOptions?: boolean | AnimationDecodeOptions): Promise<GIF>;
 }

package/dist/gif.js

@@ -1,17 +1,19 @@
 import { view } from "./util/mem.js";
 import { ImageType } from "./image-type.js";
 import { Animation } from "./animation.js";
+import { isOptions } from "./util/options.js";
 export class GIF extends Animation {
-    constructor(frames, loopCount = -1) {
-        super(frames, loopCount);
+    constructor(frames, loopCountOrOptions) {
+        super(frames, loopCountOrOptions);
     }
     toString() {
         return `GIF<${this.width}x${this.height}x${this.duration}ms>`;
     }
-    async encode(quality = 95) {
-        return this.encodeGIF(quality);
+    async encode(qualityOrOptions) {
+        return this.encodeGIF(qualityOrOptions);
     }
-    static async decode(input, onlyExtractFirstFrame = false) {
+    static async decode(input, onlyFirstFrameOrOptions = false) {
+        const onlyExtractFirstFrame = isOptions(onlyFirstFrameOrOptions) ? onlyFirstFrameOrOptions.onlyFirstFrame ?? false : onlyFirstFrameOrOptions;
         const data = view(input);
         if (!ImageType.isGIF(new DataView(data.buffer, data.byteOffset, data.byteLength)))
             throw new Error('Unsupported image type');

package/dist/image-type.d.ts

@@ -3,6 +3,7 @@ import { BinaryData } from './util/mem.js';
 export type ImageTypeName = 'png' | 'jpeg' | 'tiff' | 'gif' | 'webp' | 'tga';
 /** Detects image formats by their magic numbers */
 export declare class ImageType {
+    private constructor();
     /**
      * Gets an image's type from its magic number
      * @param data The image binary to get the type of

package/dist/image-type.js

@@ -18,6 +18,7 @@ function dataView(data) {
     return new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
 }
 export class ImageType {
+    constructor() { }
     static getType(data) {
         const view = dataView(data);
         if (this.isPNG(view))