imagescript 3.0.0 → 3.1.0

package/dist/codecs/png.js

@@ -13,6 +13,9 @@ const eXIf = 0x65584966;
 const tEXt = 0x74455874;
 const zTXt = 0x7a545874;
 const iTXt = 0x69545874;
+const acTL = 0x6163544c;
+const fcTL = 0x6663544c;
+const fdAT = 0x66644154;
 const COLOR_TYPE_CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
 const CHANNELS_TO_COLOR_TYPE = { 1: 0, 2: 4, 3: 2, 4: 6 };
 const VALID_DEPTHS = { 0: [1, 2, 4, 8, 16], 2: [8, 16], 3: [1, 2, 4, 8], 4: [8, 16], 6: [8, 16] };
@@ -77,32 +80,30 @@ function chunk(type, body) {
     view.setUint32(body.length + 8, crc32(out.subarray(4, body.length + 8)));
     return out;
 }
-export async function encodeRGBA(rgba, width, height, level, text) {
-    const count = width * height;
-    if (rgba.byteOffset % 4)
-        rgba = rgba.slice(0, count * 4);
-    const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, count);
+function pixelFormat(images) {
     let opaque = true, grey = true;
     let colors = new Map();
-    let previous = -1;
-    for (let i = 0; i < count; i++) {
-        const value = pixels[i];
-        if (value === previous)
-            continue;
-        previous = value;
-        const o = i * 4;
-        if (rgba[o + 3] !== 255)
-            opaque = false;
-        if (rgba[o] !== rgba[o + 1] || rgba[o] !== rgba[o + 2])
-            grey = false;
-        if (colors && !colors.has(value)) {
-            if (colors.size === 256)
-                colors = null;
-            else
-                colors.set(value, colors.size);
+    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] !== 255)
+                opaque = false;
+            if (rgba[o] !== rgba[o + 1] || rgba[o] !== rgba[o + 2])
+                grey = false;
+            if (colors && !colors.has(value)) {
+                if (colors.size === 256)
+                    colors = null;
+                else
+                    colors.set(value, colors.size);
+            }
         }
     }
-    const options = { width, height, level, text, filter: level > 0 };
     if (colors) {
         const entries = [...colors.keys()].map(value => new Uint8Array(new Uint32Array([value]).buffer));
         entries.sort((a, b) => a[3] - b[3]);
@@ -113,41 +114,140 @@ export async function encodeRGBA(rgba, width, height, level, text) {
         const translucent = entries.filter(bytes => bytes[3] !== 255).length;
         const transparency = translucent ? Uint8Array.from(entries.slice(0, translucent), bytes => bytes[3]) : undefined;
         const depth = entries.length <= 2 ? 1 : entries.length <= 4 ? 2 : entries.length <= 16 ? 4 : 8;
-        const rowBytes = Math.ceil(width * depth / 8);
-        const perByte = 8 / depth;
-        const data = new Uint8Array(rowBytes * height);
-        let last = -1, lastIndex = 0;
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                const value = pixels[y * width + x];
-                if (value !== last) {
-                    last = value;
-                    lastIndex = index.get(value);
+        return {
+            channels: 1, depth, palette, transparency,
+            convert(rgba, width, height) {
+                const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, width * height);
+                const rowBytes = Math.ceil(width * depth / 8);
+                const perByte = 8 / depth;
+                const data = new Uint8Array(rowBytes * height);
+                let last = -1, lastIndex = 0;
+                for (let y = 0; y < height; y++) {
+                    for (let x = 0; x < width; x++) {
+                        const value = pixels[y * width + x];
+                        if (value !== last) {
+                            last = value;
+                            lastIndex = index.get(value);
+                        }
+                        data[y * rowBytes + (x / perByte | 0)] |= lastIndex << (8 - depth - (x % perByte) * depth);
+                    }
                 }
-                data[y * rowBytes + (x / perByte | 0)] |= lastIndex << (8 - depth - (x % perByte) * depth);
+                return data;
             }
-        }
-        return encode(data, { ...options, channels: 1, depth, palette, transparency, filter: false });
+        };
     }
     const channels = (grey ? 1 : 3) + (opaque ? 0 : 1);
-    if (channels === 4)
-        return encode(rgba, { ...options, channels });
-    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];
+    return {
+        channels, depth: 8,
+        convert(rgba, width, height) {
+            if (channels === 4)
+                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 (!opaque)
+                    data[o++] = rgba[s + 3];
+            }
+            return data;
+        }
+    };
+}
+const aligned = (rgba) => rgba.byteOffset % 4 ? rgba.slice() : rgba;
+export async function encodeRGBA(rgba, width, height, level, text) {
+    rgba = aligned(rgba.subarray(0, width * height * 4));
+    const format = pixelFormat([rgba]);
+    const { channels, depth, palette, transparency } = format;
+    return encode(format.convert(rgba, width, height), { width, height, level, text, channels, depth, palette, transparency, filter: level > 0 && !palette });
+}
+async function compressRows(data, width, height, channels, depth, level, filterRows) {
+    const rowBytes = Math.ceil(width * channels * depth / 8);
+    let filtered;
+    if (filterRows)
+        filtered = filter(data, rowBytes, height, Math.max(1, channels * depth / 8));
+    else {
+        filtered = new Uint8Array(height * (rowBytes + 1));
+        for (let y = 0; y < height; y++)
+            filtered.set(data.subarray(y * rowBytes, (y + 1) * rowBytes), y * (rowBytes + 1) + 1);
+    }
+    return compressAsync(filtered, level);
+}
+export async function encodeAnimation(frames, width, height, plays, level) {
+    if (!frames.length)
+        throw new Error('PNG: an animation needs at least one frame');
+    const first = frames[0];
+    if (first.x !== 0 || first.y !== 0 || first.width !== width || first.height !== height) {
+        const pixels = new Uint8Array(width * height * 4);
+        for (let y = 0; y < first.height && first.y + y < height; y++) {
+            const row = first.pixels.subarray(y * first.width * 4, (y * first.width + Math.min(first.width, width - first.x)) * 4);
+            pixels.set(row, ((first.y + y) * width + first.x) * 4);
+        }
+        frames = [{ ...first, x: 0, y: 0, width, height, pixels }, ...frames.slice(1)];
+    }
+    for (const f of frames)
+        if (f.x < 0 || f.y < 0 || f.x + f.width > width || f.y + f.height > height || !f.width || !f.height)
+            throw new RangeError('PNG: APNG frames have to lie within the canvas');
+    const images = frames.map(f => aligned(f.pixels.subarray(0, f.width * f.height * 4)));
+    const format = pixelFormat(images);
+    const { channels, depth, palette, transparency } = format;
+    const filterRows = level > 0 && !palette;
+    const header = new Uint8Array(13);
+    const hv = new DataView(header.buffer);
+    hv.setUint32(0, width);
+    hv.setUint32(4, height);
+    header[8] = depth;
+    header[9] = palette ? 3 : CHANNELS_TO_COLOR_TYPE[channels];
+    const actl = new Uint8Array(8);
+    new DataView(actl.buffer).setUint32(0, frames.length);
+    new DataView(actl.buffer).setUint32(4, plays);
+    const chunks = [chunk(IHDR, header), chunk(acTL, actl)];
+    if (palette)
+        chunks.push(chunk(PLTE, palette));
+    if (transparency)
+        chunks.push(chunk(tRNS, transparency));
+    let sequence = 0;
+    for (let i = 0; i < frames.length; i++) {
+        const f = frames[i];
+        const fctl = new Uint8Array(26);
+        const v = new DataView(fctl.buffer);
+        v.setUint32(0, sequence++);
+        v.setUint32(4, f.width);
+        v.setUint32(8, f.height);
+        v.setUint32(12, f.x);
+        v.setUint32(16, f.y);
+        const ms = Math.max(0, Math.round(f.duration));
+        if (ms <= 65535) {
+            v.setUint16(20, ms);
+            v.setUint16(22, 1000);
+        }
+        else {
+            v.setUint16(20, Math.min(65535, Math.round(ms / 10)));
+            v.setUint16(22, 100);
+        }
+        fctl[24] = f.dispose;
+        fctl[25] = 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)
+            chunks.push(chunk(IDAT, data));
         else {
-            data[o++] = rgba[s];
-            data[o++] = rgba[s + 1];
-            data[o++] = rgba[s + 2];
+            const body = new Uint8Array(data.length + 4);
+            new DataView(body.buffer).setUint32(0, sequence++);
+            body.set(data, 4);
+            chunks.push(chunk(fdAT, body));
         }
-        if (!opaque)
-            data[o++] = rgba[s + 3];
     }
-    return encode(data, { ...options, channels });
+    chunks.push(chunk(IEND, new Uint8Array(0)));
+    return concat([HEAD, ...chunks]);
 }
-export async function decode(array) {
+function parse(array) {
     const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
     for (let i = 0; i < HEAD.length; i++)
         if (array[i] !== HEAD[i])
@@ -158,6 +258,11 @@ export async function decode(array) {
     const idat = [];
     let exif = null;
     const text = [];
+    let animation = null;
+    const frames = [];
+    let current = null;
+    let sequence = 0;
+    let animationError = false;
     let offset = 8;
     while (offset + 8 <= array.length) {
         const length = view.getUint32(offset);
@@ -193,8 +298,46 @@ export async function decode(array) {
                 throw new Error('PNG: tRNS can only occur once in an image');
             transparency = chunk;
         }
-        else if (type === IDAT)
+        else if (type === IDAT) {
             idat.push(chunk);
+            if (current && !frames.length)
+                frames.push(current);
+        }
+        else if (type === acTL) {
+            if (animation || idat.length || length < 8)
+                animationError = true;
+            else
+                animation = { frames: view.getUint32(start), plays: view.getUint32(start + 4) };
+        }
+        else if (type === fcTL) {
+            if (length < 26 || view.getUint32(start) !== sequence++)
+                animationError = true;
+            if (animationError) {
+                offset = end + 4;
+                continue;
+            }
+            const num = view.getUint16(start + 20), den = view.getUint16(start + 22) || 100;
+            current = {
+                control: {
+                    width: view.getUint32(start + 4),
+                    height: view.getUint32(start + 8),
+                    x: view.getUint32(start + 12),
+                    y: view.getUint32(start + 16),
+                    delay: num * 1000 / den,
+                    dispose: chunk[24],
+                    blend: chunk[25]
+                },
+                data: idat.length ? [] : idat
+            };
+            if (idat.length)
+                frames.push(current);
+        }
+        else if (type === fdAT) {
+            if (length < 4 || view.getUint32(start) !== sequence++ || !current || current.data === idat)
+                animationError = true;
+            else
+                current.data.push(chunk.subarray(4));
+        }
         else if (type === eXIf)
             exif ??= chunk;
         else if (type === tEXt || type === zTXt || type === iTXt)
@@ -207,7 +350,7 @@ export async function decode(array) {
         throw new Error('PNG: missing IHDR');
     if (!idat.length)
         throw new Error('PNG: missing IDAT');
-    const { width, height, depth, colorType, interlace } = header;
+    const { width, height, depth, colorType } = header;
     const channels = COLOR_TYPE_CHANNELS[colorType];
     if (!channels)
         throw new Error(`PNG: invalid color type ${colorType}`);
@@ -217,6 +360,17 @@ export async function decode(array) {
         throw new Error('PNG: invalid dimensions');
     if (colorType === 3 && !palette)
         throw new Error('PNG: indexed color image has no PLTE');
+    if (animation) {
+        if (frames.length > animation.frames)
+            frames.length = animation.frames;
+        if (!frames.length || frames.length < animation.frames || frames.some(f => !f.data.length))
+            animationError = true;
+    }
+    return { header, palette, transparency, idat, exif, text, animation, frames, animationError };
+}
+async function decodeImageData(p, chunks, width, height) {
+    const { depth, colorType, interlace } = p.header;
+    const channels = COLOR_TYPE_CHANNELS[colorType];
     const bitsPerPixel = channels * depth;
     const bpp = Math.max(1, bitsPerPixel >> 3);
     const passes = interlace ? ADAM7.map(([xs, ys, dx, dy]) => [xs, ys, dx, dy, Math.ceil((width - xs) / dx), Math.ceil((height - ys) / dy)]) : [[0, 0, 1, 1, width, height]];
@@ -226,11 +380,13 @@ export async function decode(array) {
         if (pw > 0 && ph > 0)
             expected += ph * (1 + Math.ceil(pw * bitsPerPixel / 8));
     }
-    const data = await decompressAsync(idat.length === 1 ? idat[0] : concat(idat), expected);
+    if (!chunks.length)
+        throw new Error('PNG: missing image data');
+    const data = await decompressAsync(chunks.length === 1 ? chunks[0] : concat(chunks), expected);
     if (data.length < expected)
         throw new Error('PNG: image data is truncated');
     const rgba = new Uint8Array(width * height * 4);
-    const toRGBA = createConverter(colorType, depth, palette, transparency);
+    const toRGBA = createConverter(colorType, depth, p.palette, p.transparency);
     let dataOffset = 0;
     for (const [xs, ys, dx, dy, pw, ph] of passes) {
         if (pw <= 0 || ph <= 0)
@@ -241,7 +397,73 @@ export async function decode(array) {
         dataOffset += size + ph;
         toRGBA(pixels, rowBytes, pw, ph, rgba, { row: y => ((ys + y * dy) * width + xs) * 4, step: dx * 4 });
     }
-    return { width, height, pixels: rgba, orientation: exif ? exifOrientation(exif) : await textOrientation(text) };
+    return rgba;
+}
+export async function decode(array) {
+    const p = parse(array);
+    const { width, height } = p.header;
+    const pixels = await decodeImageData(p, p.idat, width, height);
+    return { width, height, pixels, orientation: p.exif ? exifOrientation(p.exif) : await textOrientation(p.text) };
+}
+export function isAnimated(array) {
+    try {
+        const p = parse(array);
+        return p.animation !== null && !p.animationError;
+    }
+    catch {
+        return false;
+    }
+}
+export async function decodeAnimation(array, onlyFirstFrame = false) {
+    const p = parse(array);
+    const { width, height } = p.header;
+    if (!p.animation || p.animationError) {
+        const pixels = await decodeImageData(p, p.idat, width, height);
+        return { width, height, plays: 0, frames: [{ x: 0, y: 0, width, height, duration: 0, dispose: 0, blend: 0, pixels }] };
+    }
+    const frames = [];
+    for (const { control: c, data } of p.frames) {
+        if (!c.width || !c.height || c.x + c.width > width || c.y + c.height > height)
+            throw new Error('PNG: invalid APNG frame region');
+        frames.push({
+            x: c.x, y: c.y, width: c.width, height: c.height, duration: c.delay,
+            dispose: !frames.length && c.dispose === 2 ? 1 : c.dispose,
+            blend: c.blend,
+            pixels: await decodeImageData(p, data, c.width, c.height)
+        });
+        if (onlyFirstFrame)
+            break;
+    }
+    return { width, height, plays: p.animation.plays, frames };
+}
+export function compositeAnimation({ width, height, frames }) {
+    const canvas = new Uint8Array(width * height * 4);
+    const output = [];
+    for (const f of frames) {
+        const previous = f.dispose === 2 ? canvas.slice() : null;
+        for (let y = 0; y < f.height; y++)
+            for (let x = 0; x < f.width; x++) {
+                const s = (y * f.width + x) * 4, d = ((f.y + y) * width + f.x + x) * 4;
+                const sa = f.pixels[s + 3], da = canvas[d + 3];
+                if (f.blend === 0 || sa === 255 || da === 0) {
+                    if (f.blend === 0 || sa !== 0)
+                        canvas.set(f.pixels.subarray(s, s + 4), d);
+                }
+                else if (sa !== 0) {
+                    const u = sa * 255, v = (255 - sa) * da, al = u + v;
+                    for (let c = 0; c < 3; c++)
+                        canvas[d + c] = (f.pixels[s + c] * u + canvas[d + c] * v) / al | 0;
+                    canvas[d + 3] = al / 255 | 0;
+                }
+            }
+        output.push({ pixels: canvas.slice(), duration: f.duration });
+        if (f.dispose === 1)
+            for (let y = 0; y < f.height; y++)
+                canvas.fill(0, ((f.y + y) * width + f.x) * 4, ((f.y + y) * width + f.x + f.width) * 4);
+        else if (previous)
+            canvas.set(previous);
+    }
+    return output;
 }
 const RAW_EXIF = /^Raw profile type (exif|APP1)$/;
 const XMP = 'XML:com.adobe.xmp';

package/dist/codecs/tga.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Whether the data looks like a TGA. Older TGAs have no signature, so this checks that the header is consistent
+ */
+export declare function isTGA(d: Uint8Array): boolean;
+/**
+ * Decodes a TGA into RGBA
+ */
+export declare function decode(d: Uint8Array): {
+    width: number;
+    height: number;
+    pixels: Uint8Array;
+};
+/**
+ * Encodes RGBA pixels into a run length encoded TGA (32 bit with alpha, 24 bit if opaque), top left origin
+ */
+export declare function encode(rgba: Uint8Array, width: number, height: number): Uint8Array;

package/dist/codecs/tga.js

@@ -0,0 +1,203 @@
+const SIGNATURE = 'TRUEVISION-XFILE.\0';
+function readHeader(d) {
+    if (d.length < 18)
+        return null;
+    return {
+        idLength: d[0],
+        colorMapType: d[1],
+        imageType: d[2],
+        mapFirst: d[3] | d[4] << 8,
+        mapLength: d[5] | d[6] << 8,
+        mapEntrySize: d[7],
+        width: d[12] | d[13] << 8,
+        height: d[14] | d[15] << 8,
+        depth: d[16],
+        alphaBits: d[17] & 15,
+        rightToLeft: (d[17] & 16) !== 0,
+        topToBottom: (d[17] & 32) !== 0
+    };
+}
+function hasFooter(d) {
+    if (d.length < 44)
+        return false;
+    for (let i = 0; i < SIGNATURE.length; i++)
+        if (d[d.length - 18 + i] !== SIGNATURE.charCodeAt(i))
+            return false;
+    return true;
+}
+export function isTGA(d) {
+    const h = readHeader(d);
+    if (!h)
+        return false;
+    if (hasFooter(d))
+        return true;
+    const base = h.imageType & ~8;
+    if (h.colorMapType > 1 || ![1, 2, 3].includes(base) || h.imageType > 11 || (h.imageType & 4))
+        return false;
+    if (!h.width || !h.height || d[17] & 0xc0)
+        return false;
+    if (base === 1 && (h.colorMapType !== 1 || (h.depth !== 8 && h.depth !== 16)))
+        return false;
+    if (base === 2 && ![15, 16, 24, 32].includes(h.depth))
+        return false;
+    if (base === 3 && h.depth !== 8 && h.depth !== 16)
+        return false;
+    if (h.colorMapType === 1 && ![8, 15, 16, 24, 32].includes(h.mapEntrySize))
+        return false;
+    const mapBytes = h.colorMapType ? h.mapLength * Math.ceil(h.mapEntrySize / 8) : 0;
+    const dataStart = 18 + h.idLength + mapBytes;
+    const pixelBytes = h.width * h.height * Math.ceil(h.depth / 8);
+    return h.imageType & 8 ? d.length > dataStart : d.length >= dataStart + pixelBytes;
+}
+function readColor(d, o, bits, alphaBits, out, p) {
+    if (bits === 8) {
+        out[p] = out[p + 1] = out[p + 2] = d[o];
+        out[p + 3] = 255;
+    }
+    else if (bits === 15 || bits === 16) {
+        const v = d[o] | d[o + 1] << 8;
+        out[p] = (v >> 10 & 31) * 255 / 31 | 0;
+        out[p + 1] = (v >> 5 & 31) * 255 / 31 | 0;
+        out[p + 2] = (v & 31) * 255 / 31 | 0;
+        out[p + 3] = 255;
+    }
+    else {
+        out[p] = d[o + 2];
+        out[p + 1] = d[o + 1];
+        out[p + 2] = d[o];
+        out[p + 3] = bits === 32 && alphaBits ? d[o + 3] : 255;
+    }
+}
+export function decode(d) {
+    const h = readHeader(d);
+    if (!h || !isTGA(d))
+        throw new Error('TGA: invalid header');
+    const { width, height, depth } = h;
+    const base = h.imageType & ~8, rle = (h.imageType & 8) !== 0;
+    const bytesPerPixel = Math.ceil(depth / 8);
+    let offset = 18 + h.idLength;
+    let palette = null;
+    if (h.colorMapType === 1) {
+        const entryBytes = Math.ceil(h.mapEntrySize / 8);
+        palette = new Uint8Array((h.mapFirst + h.mapLength) * 4);
+        for (let i = 0; i < h.mapLength; i++) {
+            if (offset + entryBytes > d.length)
+                throw new Error('TGA: truncated color map');
+            readColor(d, offset, h.mapEntrySize, h.alphaBits, palette, (h.mapFirst + i) * 4);
+            offset += entryBytes;
+        }
+    }
+    if (base === 1 && !palette)
+        throw new Error('TGA: color mapped image without color map');
+    const count = width * height;
+    const stored = new Uint8Array(count * 4);
+    const pixel = (o, p) => {
+        if (base === 1) {
+            const index = depth === 16 ? d[o] | d[o + 1] << 8 : d[o];
+            const pal = palette;
+            if (index * 4 + 3 < pal.length)
+                stored.set(pal.subarray(index * 4, index * 4 + 4), p);
+            else
+                stored[p + 3] = 255;
+        }
+        else if (base === 3) {
+            stored[p] = stored[p + 1] = stored[p + 2] = d[o];
+            stored[p + 3] = depth === 16 ? d[o + 1] : 255;
+        }
+        else
+            readColor(d, o, depth, h.alphaBits, stored, p);
+    };
+    if (!rle) {
+        if (offset + count * bytesPerPixel > d.length)
+            throw new Error('TGA: truncated image data');
+        for (let i = 0; i < count; i++)
+            pixel(offset + i * bytesPerPixel, i * 4);
+    }
+    else {
+        for (let i = 0; i < count;) {
+            if (offset >= d.length)
+                throw new Error('TGA: truncated image data');
+            const header = d[offset++];
+            const n = (header & 127) + 1;
+            if (offset + (header & 128 ? 1 : n) * bytesPerPixel > d.length)
+                throw new Error('TGA: truncated image data');
+            if (header & 128) {
+                pixel(offset, i * 4);
+                for (let k = 1; k < n && i + k < count; k++)
+                    stored.copyWithin((i + k) * 4, i * 4, i * 4 + 4);
+                offset += bytesPerPixel;
+            }
+            else {
+                for (let k = 0; k < n && i + k < count; k++)
+                    pixel(offset + k * bytesPerPixel, (i + k) * 4);
+                offset += n * bytesPerPixel;
+            }
+            i += n;
+        }
+    }
+    if (!h.topToBottom || h.rightToLeft) {
+        const pixels = new Uint8Array(count * 4);
+        const src = new Uint32Array(stored.buffer), dst = new Uint32Array(pixels.buffer);
+        for (let y = 0; y < height; y++) {
+            const sy = h.topToBottom ? y : height - 1 - y;
+            for (let x = 0; x < width; x++)
+                dst[y * width + x] = src[sy * width + (h.rightToLeft ? width - 1 - x : x)];
+        }
+        return { width, height, pixels };
+    }
+    return { width, height, pixels: stored };
+}
+export function encode(rgba, width, height) {
+    if (width < 1 || height < 1 || width > 65535 || height > 65535)
+        throw new RangeError('TGA: dimensions must be 1-65535');
+    let opaque = true;
+    for (let i = 3; i < rgba.length; i += 4)
+        if (rgba[i] !== 255) {
+            opaque = false;
+            break;
+        }
+    const bpp = opaque ? 3 : 4;
+    const count = 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);
+    out[2] = 10;
+    out[12] = width & 255;
+    out[13] = width >> 8;
+    out[14] = height & 255;
+    out[15] = height >> 8;
+    out[16] = bpp * 8;
+    out[17] = 32 | (opaque ? 0 : 8);
+    let o = 18;
+    const put = (i) => {
+        const p = i * 4;
+        out[o++] = rgba[p + 2];
+        out[o++] = rgba[p + 1];
+        out[o++] = rgba[p];
+        if (bpp === 4)
+            out[o++] = rgba[p + 3];
+    };
+    for (let i = 0; i < count;) {
+        let run = 1;
+        while (run < 128 && i + run < count && pixels[i + run] === pixels[i])
+            run++;
+        if (run >= 2) {
+            out[o++] = 128 | run - 1;
+            put(i);
+            i += run;
+            continue;
+        }
+        let raw = 1;
+        while (raw < 128 && i + raw < count && !(i + raw + 1 < count && pixels[i + raw] === pixels[i + raw + 1]))
+            raw++;
+        out[o++] = raw - 1;
+        for (let k = 0; k < raw; k++)
+            put(i + k);
+        i += raw;
+    }
+    o += 8;
+    for (let i = 0; i < SIGNATURE.length; i++)
+        out[o++] = SIGNATURE.charCodeAt(i);
+    return out.slice(0, o);
+}

package/dist/codecs/vp8-tables.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * VP8 constant tables, extracted from RFC 6386 ("VP8 Data Format and Decoding Guide", sections 9.6, 11.5, 13.4,
+ * 13.5 and 14.1). Copyright (c) 2010, 2011 Google Inc., BSD license (see THIRD_PARTY_NOTICES.md)
+ */
+export declare const KF_BMODE_PROBS: Uint8Array<ArrayBuffer>;
+export declare const COEFF_UPDATE_PROBS: Uint8Array<ArrayBuffer>;
+export declare const DEFAULT_COEFF_PROBS: Uint8Array<ArrayBuffer>;
+export declare const DC_QLOOKUP: Uint8Array<ArrayBuffer>;
+export declare const AC_QLOOKUP: Int16Array<ArrayBuffer>;
+export declare const PCAT: Uint8Array<ArrayBuffer>[];