imagescript 3.1.0 → 3.2.0

package/dist/util/optimize.js

@@ -0,0 +1,264 @@
+const ALPHA = new Int32Array(new Uint8Array([0, 0, 0, 255]).buffer)[0];
+const ALPHA_COST = 4 / 3;
+export function optimize(frames, width, height, { replace, even, alpha, palette, cover }) {
+    const size = width * height * 4;
+    const canvas = new Uint8Array(size), canvas32 = new Int32Array(canvas.buffer);
+    const shown = new Uint8Array(size), shown32 = new Int32Array(shown.buffer);
+    const output = [];
+    const state = { canvas32, shown32, width, replace };
+    let opaque = true, denseTotal = 0, chosenTotal = 0;
+    const add = (duration) => {
+        let changed = bounds(state, { x: 0, y: 0, width, height });
+        if (!changed) {
+            if (output.length)
+                output[output.length - 1].duration += duration;
+            else {
+                output.push(empty(duration));
+                opaque = false;
+            }
+            return;
+        }
+        if (even)
+            changed = evenArea(changed);
+        let area = sparse(state, changed);
+        let blend = true;
+        if (area.unblendable && replace)
+            blend = false;
+        else if (area.unblendable) {
+            const last = output[output.length - 1];
+            grow(last, union(last, area.unblendable));
+            last.dispose = true;
+            clear(shown, width, last);
+            changed = bounds(state, { x: 0, y: 0, width, height });
+            if (!changed)
+                return void output.push(empty(duration));
+            if (even)
+                changed = evenArea(changed);
+            area = sparse(state, changed);
+        }
+        const { x, y, width: w, height: h } = changed;
+        const pixels = area.pixels;
+        if (!output.length && (w !== width || h !== height))
+            opaque = false;
+        if (!area.denseOpaque)
+            opaque = false;
+        const sparseCost = alpha === 'frame' && area.denseOpaque ? area.sparseChanges * ALPHA_COST : area.sparseChanges;
+        const dense = !blend || area.denseChanges < sparseCost
+            || (palette !== undefined && colors(new Int32Array(pixels.buffer), w, { x: 0, y: 0, width: w, height: h }, palette + 1) > palette
+                && colors(canvas32, width, changed, palette + 1) <= palette);
+        denseTotal += area.denseChanges;
+        chosenTotal += dense ? area.denseChanges : area.sparseChanges;
+        if (dense) {
+            for (let row = 0; row < h; row++)
+                pixels.set(canvas.subarray(((y + row) * width + x) * 4, ((y + row) * width + x + w) * 4), row * w * 4);
+            if (replace)
+                blend = false;
+        }
+        for (let row = 0; row < h; row++) {
+            const start = ((y + row) * width + x) * 4;
+            shown.set(canvas.subarray(start, start + w * 4), start);
+        }
+        output.push({ x, y, width: w, height: h, duration, dispose: false, blend, pixels });
+    };
+    let cleared = { x: 0, y: 0, width, height };
+    for (const f of frames) {
+        const saved = f.dispose === 2 ? canvas.slice() : null;
+        const area = clip(f, width, height);
+        if (cleared && contains(cleared, area))
+            copy(canvas, width, f, area);
+        else
+            draw(canvas, width, height, f);
+        cleared = null;
+        add(f.duration);
+        if (f.dispose === 1) {
+            clear(canvas, width, area);
+            cleared = area;
+        }
+        else if (saved)
+            canvas.set(saved);
+    }
+    if (typeof alpha === 'function' && opaque && output.some(f => f.blend) && denseTotal < chosenTotal * alpha(output)) {
+        shown.fill(0);
+        for (const f of output) {
+            const pixels32 = new Int32Array(f.pixels.buffer, f.pixels.byteOffset, f.width * f.height);
+            for (let row = 0, k = 0; row < f.height; row++, k += f.width) {
+                const start = (f.y + row) * width + f.x;
+                if (!f.blend)
+                    shown32.set(pixels32.subarray(k, k + f.width), start);
+                else
+                    for (let i = k, p = start, end = k + f.width; i < end; i++, p++) {
+                        if ((pixels32[i] & ALPHA) === 0)
+                            pixels32[i] = shown32[p];
+                        else
+                            shown32[p] = pixels32[i];
+                    }
+            }
+            f.blend = false;
+        }
+    }
+    if (cover && output.length)
+        grow(output[0], { x: 0, y: 0, width, height });
+    return output;
+}
+function colors(image32, width, { x, y, width: w, height: h }, limit) {
+    const seen = new Set();
+    for (let row = y; row < y + h; row++) {
+        let previous;
+        for (let p = row * width + x, end = p + w; p < end; p++) {
+            const value = image32[p];
+            if (value === previous)
+                continue;
+            previous = value;
+            seen.add(value);
+            if (seen.size >= limit)
+                return seen.size;
+        }
+    }
+    return seen.size;
+}
+const empty = (duration) => ({ x: 0, y: 0, width: 1, height: 1, duration, dispose: false, blend: true, pixels: new Uint8Array(4) });
+function clip(r, width, height) {
+    const x = Math.max(0, r.x), y = Math.max(0, r.y);
+    return { x, y, width: Math.max(0, Math.min(width, r.x + r.width) - x), height: Math.max(0, Math.min(height, r.y + r.height) - y) };
+}
+function contains(a, b) {
+    return b.x >= a.x && b.y >= a.y && b.x + b.width <= a.x + a.width && b.y + b.height <= a.y + a.height;
+}
+function union(a, b) {
+    const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
+    return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+}
+function evenArea({ x, y, width, height }) {
+    return { x: x & ~1, y: y & ~1, width: width + (x & 1), height: height + (y & 1) };
+}
+function sparse({ canvas32, shown32, width, replace }, { x, y, width: w, height: h }) {
+    const pixels = new Uint8Array(w * h * 4), pixels32 = new Int32Array(pixels.buffer);
+    let sparseChanges = 0, denseChanges = 0, lastSparse = -1, lastDense = -1;
+    let left = w, right = -1, top = h, bottom = -1, translucent = 0;
+    for (let row = 0, k = 0; row < h; row++) {
+        const start = (y + row) * width + x;
+        for (let i = 0, p = start; i < w; i++, p++, k++) {
+            const value = canvas32[p], before = shown32[p];
+            if (value === before || ((value | before) & ALPHA) === 0) {
+                if (lastSparse !== 0)
+                    sparseChanges++;
+                lastSparse = 0;
+            }
+            else {
+                pixels32[k] = value;
+                if (value !== lastSparse)
+                    sparseChanges++;
+                lastSparse = value;
+                if ((value & ALPHA) !== ALPHA && (replace || (before & ALPHA) !== 0)) {
+                    if (i < left)
+                        left = i;
+                    if (i > right)
+                        right = i;
+                    if (row < top)
+                        top = row;
+                    bottom = row;
+                }
+            }
+            if (value !== lastDense) {
+                denseChanges++;
+                translucent |= ~value & ALPHA;
+            }
+            lastDense = value;
+        }
+    }
+    const unblendable = right < 0 ? null : { x: x + left, y: y + top, width: right - left + 1, height: bottom - top + 1 };
+    return { pixels, sparseChanges, denseChanges, unblendable, denseOpaque: translucent === 0 };
+}
+function bounds({ canvas32, shown32, width }, area) {
+    const x0 = area.x, x1 = area.x + area.width, y0 = area.y, y1 = area.y + area.height;
+    const test = (p) => {
+        const c = canvas32[p], s = shown32[p];
+        return c !== s && ((c | s) & ALPHA) !== 0;
+    };
+    const rowHas = (y, from, to) => {
+        for (let x = from, p = y * width + from; x < to; x++, p++)
+            if (test(p))
+                return x;
+        return -1;
+    };
+    let top = y0, first = -1;
+    for (; top < y1; top++)
+        if ((first = rowHas(top, x0, x1)) >= 0)
+            break;
+    if (top === y1)
+        return null;
+    let bottom = y1 - 1;
+    while (bottom > top && rowHas(bottom, x0, x1) < 0)
+        bottom--;
+    let left = first, right = first;
+    for (let y = top; y <= bottom; y++) {
+        if (left > x0) {
+            const x = rowHas(y, x0, left);
+            if (x >= 0)
+                left = x;
+        }
+        for (let x = x1 - 1, p = y * width + x; x > right; x--, p--)
+            if (test(p)) {
+                right = x;
+                break;
+            }
+    }
+    return { x: left, y: top, width: right - left + 1, height: bottom - top + 1 };
+}
+function draw(canvas, width, height, f) {
+    const { x: x0, y: y0, width: w, height: h } = clip(f, width, height);
+    const pixels = f.pixels.byteOffset % 4 ? f.pixels.slice() : f.pixels;
+    const src = new Int32Array(pixels.buffer, pixels.byteOffset, f.width * f.height);
+    const dst = new Int32Array(canvas.buffer, canvas.byteOffset, width * height);
+    for (let y = y0; y < y0 + h; y++)
+        for (let x = x0, s = (y - f.y) * f.width + x - f.x, d = y * width + x; x < x0 + w; x++, s++, d++) {
+            let n = 0;
+            while (n < x0 + w - x && (src[s + n] & ALPHA) === ALPHA)
+                n++;
+            if (n) {
+                if (n >= 16)
+                    dst.set(src.subarray(s, s + n), d);
+                else
+                    for (let i = 0; i < n; i++)
+                        dst[d + i] = src[s + i];
+                x += n - 1;
+                s += n - 1;
+                d += n - 1;
+                continue;
+            }
+            const value = src[s], alpha = value & ALPHA;
+            if (alpha === 0)
+                continue;
+            if (alpha === ALPHA || (dst[d] & ALPHA) === 0)
+                dst[d] = value;
+            else {
+                const sa = pixels[s * 4 + 3], da = canvas[d * 4 + 3];
+                const u = sa * 255, v = (255 - sa) * da, al = u + v;
+                for (let c = 0; c < 3; c++)
+                    canvas[d * 4 + c] = (pixels[s * 4 + c] * u + canvas[d * 4 + c] * v) / al | 0;
+                canvas[d * 4 + 3] = al / 255 | 0;
+            }
+        }
+}
+function copy(canvas, width, f, { x, y, width: w, height: h }) {
+    const canvas32 = new Int32Array(canvas.buffer, canvas.byteOffset, width * (y + h));
+    for (let row = y; row < y + h; row++) {
+        const s = ((row - f.y) * f.width + x - f.x) * 4, d = row * width + x;
+        canvas.set(f.pixels.subarray(s, s + w * 4), d * 4);
+        for (let p = d; p < d + w; p++)
+            if ((canvas32[p] & ALPHA) === 0)
+                canvas32[p] = 0;
+    }
+}
+function clear(canvas, width, r) {
+    for (let y = r.y; y < r.y + r.height; y++)
+        canvas.fill(0, (y * width + r.x) * 4, (y * width + r.x + r.width) * 4);
+}
+function grow(frame, area) {
+    if (area.x === frame.x && area.y === frame.y && area.width === frame.width && area.height === frame.height)
+        return;
+    const pixels = new Uint8Array(area.width * area.height * 4);
+    for (let row = 0; row < frame.height; row++)
+        pixels.set(frame.pixels.subarray(row * frame.width * 4, (row + 1) * frame.width * 4), ((frame.y - area.y + row) * area.width + frame.x - area.x) * 4);
+    Object.assign(frame, area, { pixels });
+}

package/dist/util/options.js

@@ -0,0 +1,3 @@
+export function isOptions(value) {
+    return typeof value === 'object' && value !== null && !ArrayBuffer.isView(value);
+}

package/dist/util/resample.js

@@ -40,33 +40,33 @@ function coefficients(inSize, outSize, filter) {
 }
 export function resample(src, width, height, outWidth, outHeight, filter, out) {
     let plane = new Float32Array(outWidth * height * 4);
-    const horizontal = outWidth !== width ? coefficients(width, outWidth, filter) : null;
-    for (let y = 0; y < height; y++) {
-        const row = y * width * 4;
-        for (let x = 0; x < outWidth; x++) {
-            let r = 0, g = 0, b = 0, a = 0;
-            if (horizontal) {
-                const { start, count, weights, size } = horizontal;
-                for (let k = 0, s = row + start[x] * 4; k < count[x]; k++, s += 4) {
-                    const wa = weights[x * size + k] * src[s + 3];
+    if (outWidth !== width) {
+        const { start, count, weights, size } = coefficients(width, outWidth, filter);
+        for (let y = 0, o = 0; y < height; y++) {
+            const row = y * width * 4;
+            for (let x = 0; x < outWidth; x++, o += 4) {
+                let r = 0, g = 0, b = 0, a = 0;
+                for (let k = 0, s = row + start[x] * 4, w = x * size, n = count[x]; k < n; k++, s += 4) {
+                    const wa = weights[w + k] * src[s + 3];
                     r += src[s] * wa;
                     g += src[s + 1] * wa;
                     b += src[s + 2] * wa;
                     a += wa;
                 }
+                plane[o] = r / 255;
+                plane[o + 1] = g / 255;
+                plane[o + 2] = b / 255;
+                plane[o + 3] = a;
             }
-            else {
-                const s = row + x * 4;
-                a = src[s + 3];
-                r = src[s] * a;
-                g = src[s + 1] * a;
-                b = src[s + 2] * a;
-            }
-            const o = (y * outWidth + x) * 4;
-            plane[o] = r / 255;
-            plane[o + 1] = g / 255;
-            plane[o + 2] = b / 255;
-            plane[o + 3] = a;
+        }
+    }
+    else {
+        for (let s = 0; s < plane.length; s += 4) {
+            const a = src[s + 3];
+            plane[s] = src[s] * a / 255;
+            plane[s + 1] = src[s + 1] * a / 255;
+            plane[s + 2] = src[s + 2] * a / 255;
+            plane[s + 3] = a;
         }
     }
     if (outHeight !== height) {
@@ -74,12 +74,30 @@ export function resample(src, width, height, outWidth, outHeight, filter, out) {
         const next = new Float32Array(outWidth * outHeight * 4);
         const stride = outWidth * 4;
         for (let y = 0; y < outHeight; y++) {
-            const o = y * stride;
-            for (let k = 0; k < count[y]; k++) {
-                const w = weights[y * size + k];
-                const s = (start[y] + k) * stride;
+            const o = y * stride, n = count[y], w = y * size;
+            const s0 = start[y] * stride, s1 = s0 + stride, s2 = s1 + stride, s3 = s2 + stride;
+            const w0 = weights[w], w1 = weights[w + 1], w2 = weights[w + 2], w3 = weights[w + 3];
+            if (n === 1)
+                for (let x = 0; x < stride; x++)
+                    next[o + x] = 0 + plane[s0 + x] * w0;
+            else if (n === 2)
+                for (let x = 0; x < stride; x++)
+                    next[o + x] = Math.fround(0 + plane[s0 + x] * w0) + plane[s1 + x] * w1;
+            else if (n === 3) {
                 for (let x = 0; x < stride; x++)
-                    next[o + x] += plane[s + x] * w;
+                    next[o + x] = Math.fround(Math.fround(0 + plane[s0 + x] * w0) + plane[s1 + x] * w1) + plane[s2 + x] * w2;
+            }
+            else if (n === 4) {
+                for (let x = 0; x < stride; x++)
+                    next[o + x] = Math.fround(Math.fround(Math.fround(0 + plane[s0 + x] * w0) + plane[s1 + x] * w1) + plane[s2 + x] * w2) + plane[s3 + x] * w3;
+            }
+            else {
+                for (let x = 0; x < stride; x++) {
+                    let sum = 0;
+                    for (let k = 0, s = s0 + x; k < n; k++, s += stride)
+                        sum = Math.fround(sum + plane[s] * weights[w + k]);
+                    next[o + x] = sum;
+                }
             }
         }
         plane = next;

package/dist/util/utf8.js

@@ -1,55 +1,8 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
 export function encode(text) {
-    const out = [];
-    for (const char of text) {
-        const c = char.codePointAt(0);
-        if (c < 0x80)
-            out.push(c);
-        else if (c < 0x800)
-            out.push(0xc0 | c >> 6, 0x80 | c & 63);
-        else if (c < 0x10000)
-            out.push(0xe0 | c >> 12, 0x80 | c >> 6 & 63, 0x80 | c & 63);
-        else
-            out.push(0xf0 | c >> 18, 0x80 | c >> 12 & 63, 0x80 | c >> 6 & 63, 0x80 | c & 63);
-    }
-    return Uint8Array.from(out);
+    return encoder.encode(text);
 }
 export function decode(bytes) {
-    let out = '';
-    let i = bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf ? 3 : 0;
-    while (i < bytes.length) {
-        const b = bytes[i++];
-        let c, extra;
-        if (b < 0x80) {
-            c = b;
-            extra = 0;
-        }
-        else if (b >= 0xc2 && b < 0xe0) {
-            c = b & 31;
-            extra = 1;
-        }
-        else if (b >= 0xe0 && b < 0xf0) {
-            c = b & 15;
-            extra = 2;
-        }
-        else if (b >= 0xf0 && b < 0xf5) {
-            c = b & 7;
-            extra = 3;
-        }
-        else {
-            out += '�';
-            continue;
-        }
-        let valid = true;
-        for (let k = 0; k < extra; k++) {
-            const next = bytes[i];
-            if (next === undefined || (next & 0xc0) !== 0x80) {
-                valid = false;
-                break;
-            }
-            c = c << 6 | next & 63;
-            i++;
-        }
-        out += valid && c <= 0x10ffff ? String.fromCodePoint(c) : '�';
-    }
-    return out;
+    return decoder.decode(bytes);
 }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '3.1.0';
+export const VERSION = '3.2.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imagescript",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "zero-dependency javascript image manipulation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -47,7 +47,14 @@
     "bitmap",
     "gif",
     "picture",
-    "thumbnail"
+    "thumbnail",
+    "webp",
+    "apng",
+    "tiff",
+    "tga",
+    "animation",
+    "text rendering",
+    "font"
   ],
   "author": "Mathis Mensing <mathis@matmen.dev>",
   "license": "(AGPL-3.0-or-later OR MIT)",

package/dist/codecs/crc.d.ts

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

package/dist/codecs/exif.d.ts

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

package/dist/codecs/gif.d.ts

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

package/dist/codecs/jpeg.d.ts

@@ -1,35 +0,0 @@
-/*!
- * JPEG codec. This software is based in part on the work of the Independent JPEG Group: the IDCT, FDCT, upsampling,
- * color conversion, progressive refinement and optimal Huffman tables are translated from libjpeg/libjpeg-turbo
- * (IJG license, see licenses/README.ijg). The scan decoder follows the structure of pdf.js' jpg.js
- * (Copyright 2014 Mozilla Foundation, Apache License 2.0). See THIRD_PARTY_NOTICES.md
- */
-export interface DecodeOptions {
-    /** overrides the color transform detected from JFIF/Adobe markers (used by TIFF) */
-    transform?: 'ycc' | 'rgb' | 'cmyk' | null;
-}
-/**
- * Decodes a JPEG into 8-bit RGBA pixel data
- * Supports baseline, extended and progressive huffman coded JPEGs with any
- * sampling factors, restart intervals and greyscale, YCbCr, RGB, CMYK and YCCK color
- * The output matches libjpeg's defaults (islow IDCT, fancy upsampling)
- * @param {Uint8Array} data
- * @param {{transform?: 'ycc'|'rgb'|'cmyk'}} [options] overrides the color transform detected from JFIF/Adobe markers (used by TIFF)
- * @return {{width: number, height: number, pixels: Uint8Array}}
- */
-export declare function decode(data: Uint8Array, { transform }?: DecodeOptions): {
-    width: number;
-    height: number;
-    pixels: Uint8Array;
-    orientation: number;
-};
-/**
- * Encodes RGBA pixel data into a baseline JPEG (alpha is ignored)
- * Uses 4:2:0 chroma subsampling up to quality 90 and 4:4:4 above, with optimized huffman tables
- * @param {Uint8Array} pixels
- * @param {number} width
- * @param {number} height
- * @param {number} [quality=90] 1-100
- * @return {Uint8Array}
- */
-export declare function encode(pixels: Uint8Array, width: number, height: number, quality?: number): Uint8Array;

package/dist/codecs/png.d.ts

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

package/dist/codecs/quantize.d.ts

@@ -1,25 +0,0 @@
-/**
- * Reduces RGBA pixel data to an indexed palette
- * Pixels with alpha < 128 are mapped to a dedicated transparent index
- * @param {Uint8Array} pixels RGBA pixel data
- * @param {number} width Image width in pixels (needed for dithering)
- * @param {{maxColors?: number, quality?: number}} [options] quality (1-100) scales the palette size exponentially (1 = 8 colors, 50 = 55, 90 and above = 256)
- * @return {{palette: Uint8Array, indices: Uint8Array, transparentIndex: number}} palette is packed RGB, transparentIndex is -1 if unused
- */
-export interface QuantizeOptions {
-    maxColors?: number;
-    quality?: number;
-}
-export interface Quantized {
-    /** packed RGB */
-    palette: Uint8Array;
-    indices: Uint8Array;
-    /** -1 if no pixel is transparent */
-    transparentIndex: number;
-}
-/**
- * Finds the color of the largest cluster among the opaque pixels that pass the filter
- * @return packed RGB, or null if no pixel qualifies
- */
-export declare function dominantColor(pixels: Uint8Array, include: (r: number, g: number, b: number) => boolean, clusters?: number): [number, number, number] | null;
-export declare function quantize(pixels: Uint8Array, width: number, { maxColors, quality }?: QuantizeOptions): Quantized;