imagescript 3.2.1 → 3.4.0

package/dist/codecs/netpbm.js

@@ -0,0 +1,239 @@
+import { MAX_PIXELS, checkPixels } from "../util/limits.js";
+import { toSRGB } from "./hdr.js";
+const isSpace = (c) => c === 0x20 || (c >= 0x09 && c <= 0x0d);
+export function isNetpbm(d) {
+    if (d.length < 3 || d[0] !== 0x50)
+        return false;
+    if (d[1] === 0x37)
+        return d[2] === 0x0a;
+    return (d[1] >= 0x31 && d[1] <= 0x36 || d[1] === 0x46 || d[1] === 0x66) && isSpace(d[2]);
+}
+class Reader {
+    d;
+    o;
+    constructor(d, o) {
+        this.d = d;
+        this.o = o;
+    }
+    skip() {
+        const d = this.d;
+        while (this.o < d.length) {
+            if (d[this.o] === 0x23)
+                while (this.o < d.length && d[this.o] !== 0x0a && d[this.o] !== 0x0d)
+                    this.o++;
+            else if (isSpace(d[this.o]))
+                this.o++;
+            else
+                break;
+        }
+    }
+    token() {
+        this.skip();
+        const start = this.o;
+        while (this.o < this.d.length && !isSpace(this.d[this.o]) && this.d[this.o] !== 0x23)
+            this.o++;
+        if (start === this.o)
+            throw new Error('Netpbm: truncated header');
+        return String.fromCharCode(...this.d.subarray(start, this.o));
+    }
+    integer(name) {
+        const token = this.token();
+        if (!/^\d{1,10}$/.test(token))
+            throw new Error(`Netpbm: invalid ${name} ${token.slice(0, 20)}`);
+        return +token;
+    }
+}
+function pamHeader(d) {
+    const fields = {};
+    const types = [];
+    let o = 3;
+    for (;;) {
+        let end = o;
+        while (end < d.length && d[end] !== 0x0a)
+            end++;
+        if (end >= d.length)
+            throw new Error('PAM: truncated header');
+        const line = String.fromCharCode(...d.subarray(o, end)).trim();
+        o = end + 1;
+        if (line === 'ENDHDR')
+            break;
+        if (!line || line[0] === '#')
+            continue;
+        const [name, ...value] = line.split(/\s+/);
+        if (name === 'TUPLTYPE')
+            types.push(value.join(' '));
+        else
+            fields[name] = value.join(' ');
+    }
+    const number = (name) => {
+        if (!/^\d{1,10}$/.test(fields[name] ?? ''))
+            throw new Error(`PAM: invalid ${name}`);
+        return +fields[name];
+    };
+    return { width: number('WIDTH'), height: number('HEIGHT'), depth: number('DEPTH'), maxval: number('MAXVAL'), tupleType: types.join(' '), data: o };
+}
+export function decode(d, maxPixels = MAX_PIXELS, toneMapping = 'reinhard') {
+    if (!isNetpbm(d))
+        throw new Error('Netpbm: invalid header');
+    const kind = String.fromCharCode(d[1]);
+    if (kind === 'F' || kind === 'f')
+        return decodePFM(d, kind === 'F' ? 3 : 1, maxPixels, toneMapping);
+    let header;
+    const reader = new Reader(d, 2);
+    if (kind === '7')
+        header = pamHeader(d);
+    else {
+        const width = reader.integer('width'), height = reader.integer('height');
+        const bitmap = kind === '1' || kind === '4';
+        const maxval = bitmap ? 1 : reader.integer('maxval');
+        if (kind >= '4' && reader.o >= d.length)
+            throw new Error('Netpbm: truncated header');
+        header = { width, height, depth: kind === '3' || kind === '6' ? 3 : 1, maxval, tupleType: bitmap ? 'PBM' : '', data: reader.o + 1 };
+    }
+    const { width, height, depth, maxval } = header;
+    if (!width || !height)
+        throw new Error(`Netpbm: invalid dimensions ${width}x${height}`);
+    if (!maxval || maxval > 65535)
+        throw new Error(`Netpbm: invalid maxval ${maxval}`);
+    if (depth < 1 || depth > 4)
+        throw new Error(`PAM: unsupported depth ${depth}`);
+    checkPixels(width, height, maxPixels);
+    const count = width * height, samples = new Uint8Array(count * depth);
+    const scale = (v) => v >= maxval ? 255 : Math.round(v * 255 / maxval);
+    if (kind === '1' || kind === '2' || kind === '3') {
+        let o = header.data - 1;
+        for (let i = 0; i < samples.length; i++) {
+            while (o < d.length && (isSpace(d[o]) || d[o] === 0x23)) {
+                if (d[o] === 0x23)
+                    while (o < d.length && d[o] !== 0x0a)
+                        o++;
+                else
+                    o++;
+            }
+            if (o >= d.length)
+                throw new Error('Netpbm: truncated image data');
+            let v = 0;
+            if (kind === '1')
+                v = d[o++] - 0x30;
+            else {
+                const start = o;
+                while (o < d.length && d[o] >= 0x30 && d[o] <= 0x39 && o - start < 6)
+                    v = v * 10 + d[o++] - 0x30;
+                if (start === o)
+                    throw new Error('Netpbm: invalid sample');
+            }
+            if (v < 0 || v > maxval)
+                throw new Error('Netpbm: invalid sample');
+            samples[i] = kind === '1' ? (v ? 0 : 255) : scale(v);
+        }
+    }
+    else if (kind === '4') {
+        const stride = width + 7 >> 3;
+        if (header.data + stride * height > d.length)
+            throw new Error('Netpbm: truncated image data');
+        for (let y = 0; y < height; y++)
+            for (let x = 0; x < width; x++)
+                samples[y * width + x] = d[header.data + y * stride + (x >> 3)] >> (7 - (x & 7)) & 1 ? 0 : 255;
+    }
+    else {
+        const wide = maxval > 255;
+        if (header.data + samples.length * (wide ? 2 : 1) > d.length)
+            throw new Error('Netpbm: truncated image data');
+        for (let i = 0, o = header.data; i < samples.length; i++, o += wide ? 2 : 1)
+            samples[i] = scale(wide ? d[o] << 8 | d[o + 1] : d[o]);
+    }
+    const pixels = new Uint8Array(count * 4);
+    for (let i = 0; i < count; i++) {
+        const s = i * depth, p = i * 4;
+        if (depth < 3) {
+            pixels[p] = pixels[p + 1] = pixels[p + 2] = samples[s];
+            pixels[p + 3] = depth === 2 ? samples[s + 1] : 255;
+        }
+        else {
+            pixels[p] = samples[s];
+            pixels[p + 1] = samples[s + 1];
+            pixels[p + 2] = samples[s + 2];
+            pixels[p + 3] = depth === 4 ? samples[s + 3] : 255;
+        }
+    }
+    return { width, height, pixels };
+}
+function decodePFM(d, channels, maxPixels, toneMapping) {
+    const reader = new Reader(d, 2);
+    const width = reader.integer('width'), height = reader.integer('height');
+    const scale = +reader.token();
+    if (!width || !height)
+        throw new Error(`PFM: invalid dimensions ${width}x${height}`);
+    if (!Number.isFinite(scale) || !scale)
+        throw new Error('PFM: invalid scale');
+    checkPixels(width, height, maxPixels);
+    const start = reader.o + 1;
+    if (start + width * height * channels * 4 > d.length)
+        throw new Error('PFM: truncated image data');
+    const view = new DataView(d.buffer, d.byteOffset + start);
+    const little = scale < 0;
+    const rgb = new Float32Array(width * height * 3);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const s = ((height - 1 - y) * width + x) * channels * 4, p = (y * width + x) * 3;
+            for (let c = 0; c < 3; c++)
+                rgb[p + c] = view.getFloat32(s + (channels === 3 ? c * 4 : 0), little);
+        }
+    }
+    return { width, height, pixels: toSRGB(rgb, toneMapping) };
+}
+export function encode(rgba, width, height) {
+    if (width < 1 || height < 1)
+        throw new RangeError('Netpbm: dimensions must be at least 1');
+    const count = width * height;
+    let opaque = true, grey = true, bitmap = true;
+    for (let p = 0; p < count * 4; p += 4) {
+        const r = rgba[p], g = rgba[p + 1], b = rgba[p + 2], a = rgba[p + 3];
+        if (a !== 255)
+            opaque = false;
+        if (r !== g || g !== b)
+            grey = false;
+        if (r !== 0 && r !== 255 || r !== g || g !== b)
+            bitmap = false;
+        if (!opaque && !grey)
+            break;
+    }
+    const ascii = (text) => Uint8Array.from(text, c => c.charCodeAt(0));
+    let header, depth;
+    if (!opaque) {
+        depth = grey ? 2 : 4;
+        header = ascii(`P7\nWIDTH ${width}\nHEIGHT ${height}\nDEPTH ${depth}\nMAXVAL 255\nTUPLTYPE ${grey ? 'GRAYSCALE_ALPHA' : 'RGB_ALPHA'}\nENDHDR\n`);
+    }
+    else if (bitmap) {
+        depth = 0;
+        header = ascii(`P4\n${width} ${height}\n`);
+    }
+    else {
+        depth = grey ? 1 : 3;
+        header = ascii(`P${grey ? 5 : 6}\n${width} ${height}\n255\n`);
+    }
+    const stride = depth ? width * depth : width + 7 >> 3;
+    const out = new Uint8Array(header.length + stride * height);
+    out.set(header);
+    let o = header.length;
+    if (!depth) {
+        for (let y = 0; y < height; y++, o += stride)
+            for (let x = 0; x < width; x++)
+                if (!rgba[(y * width + x) * 4])
+                    out[o + (x >> 3)] |= 128 >> (x & 7);
+    }
+    else {
+        for (let p = 0; p < count * 4; p += 4) {
+            if (depth === 1 || depth === 2)
+                out[o++] = rgba[p];
+            else {
+                out[o++] = rgba[p];
+                out[o++] = rgba[p + 1];
+                out[o++] = rgba[p + 2];
+            }
+            if (depth === 2 || depth === 4)
+                out[o++] = rgba[p + 3];
+        }
+    }
+    return out;
+}

package/dist/codecs/png.js

@@ -1,4 +1,5 @@
 import { crc32 } from "./crc.js";
+import { MAX_PIXELS, checkPixels } from "../util/limits.js";
 import { concat } from "../util/mem.js";
 import { encode as utf8, decode as utf8Decode } from "../util/utf8.js";
 import { orientation as exifOrientation, xmpOrientation } from "./exif.js";
@@ -437,15 +438,16 @@ async function decodeImageData(p, chunks, width, height) {
             continue;
         const rowBytes = Math.ceil(pw * bitsPerPixel / 8);
         const size = ph * rowBytes;
-        const pixels = unfilter(data, dataOffset, ph, rowBytes, bpp);
+        const pixels = unfilter(data, dataOffset, ph, rowBytes, bpp, !interlace);
         dataOffset += size + ph;
         toRGBA(pixels, rowBytes, pw, ph, rgba, { row: y => ((ys + y * dy) * width + xs) * 4, step: dx * 4 });
     }
     return rgba;
 }
-export async function decode(array) {
+export async function decode(array, maxPixels = MAX_PIXELS) {
     const p = parse(array);
     const { width, height } = p.header;
+    checkPixels(width, height, maxPixels);
     const pixels = await decodeImageData(p, p.idat, width, height);
     return { width, height, pixels, orientation: p.exif ? exifOrientation(p.exif) : await textOrientation(p.text) };
 }
@@ -458,9 +460,10 @@ export function isAnimated(array) {
         return false;
     }
 }
-export async function decodeAnimation(array, onlyFirstFrame = false) {
+export async function decodeAnimation(array, onlyFirstFrame = false, maxPixels = MAX_PIXELS) {
     const p = parse(array);
     const { width, height } = p.header;
+    checkPixels(width, height, maxPixels, !p.animation || p.animationError || onlyFirstFrame ? 1 : Math.max(1, p.frames.length));
     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 }] };
@@ -485,13 +488,21 @@ export function compositeAnimation({ width, height, frames }) {
     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 y = 0; y < f.height; y++) {
+            if (f.blend === 0) {
+                canvas.set(f.pixels.subarray(y * f.width * 4, (y + 1) * f.width * 4), ((f.y + y) * width + f.x) * 4);
+                continue;
+            }
             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);
+                if (sa === 255 || da === 0) {
+                    if (sa !== 0) {
+                        canvas[d] = f.pixels[s];
+                        canvas[d + 1] = f.pixels[s + 1];
+                        canvas[d + 2] = f.pixels[s + 2];
+                        canvas[d + 3] = sa;
+                    }
                 }
                 else if (sa !== 0) {
                     const u = sa * 255, v = (255 - sa) * da, al = u + v;
@@ -500,6 +511,7 @@ export function compositeAnimation({ width, height, frames }) {
                     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++)
@@ -550,11 +562,11 @@ function hexProfile(text) {
     const digits = match[2].replace(/\s+/g, '');
     const out = new Uint8Array(Math.min(+match[1], digits.length >> 1));
     for (let i = 0; i < out.length; i++)
-        out[i] = parseInt(digits.substr(i * 2, 2), 16);
+        out[i] = parseInt(digits.slice(i * 2, i * 2 + 2), 16);
     return out;
 }
-function unfilter(data, offset, height, rowBytes, bpp) {
-    const out = new Uint8Array(height * rowBytes);
+function unfilter(data, offset, height, rowBytes, bpp, inPlace = false) {
+    const out = inPlace ? data.subarray(offset, offset + height * rowBytes) : new Uint8Array(height * rowBytes);
     const first = Math.min(bpp, rowBytes);
     for (let y = 0; y < height; y++) {
         const filter = data[offset++];

package/dist/codecs/qoi.js

@@ -0,0 +1,150 @@
+/*!
+ * The Quite OK Image format (https://qoiformat.org/qoi-specification.pdf). The encoder makes the choices of the
+ * reference encoder qoi.h, so it writes the same bytes. Copyright (c) 2021 Dominic Szablewski, MIT License (see
+ * THIRD_PARTY_NOTICES.md)
+ */
+import { MAX_PIXELS, checkPixels } from "../util/limits.js";
+const OP_INDEX = 0x00, OP_DIFF = 0x40, OP_LUMA = 0x80, OP_RUN = 0xc0, OP_RGB = 0xfe, OP_RGBA = 0xff;
+export function isQOI(d) {
+    return d.length >= 14 && d[0] === 0x71 && d[1] === 0x6f && d[2] === 0x69 && d[3] === 0x66;
+}
+const hash = (r, g, b, a) => (r * 3 + g * 5 + b * 7 + a * 11) & 63;
+export function decode(d, maxPixels = MAX_PIXELS) {
+    if (!isQOI(d))
+        throw new Error('QOI: invalid header');
+    const view = new DataView(d.buffer, d.byteOffset, d.byteLength);
+    const width = view.getUint32(4), height = view.getUint32(8);
+    if (!width || !height)
+        throw new Error(`QOI: invalid dimensions ${width}x${height}`);
+    checkPixels(width, height, maxPixels);
+    const pixels = new Uint8Array(width * height * 4);
+    const index = new Uint8Array(256);
+    let r = 0, g = 0, b = 0, a = 255;
+    for (let p = 0, o = 14; p < pixels.length;) {
+        if (o >= d.length)
+            throw new Error('QOI: truncated image data');
+        const op = d[o++];
+        let run = 1;
+        if (op === OP_RGB) {
+            r = d[o];
+            g = d[o + 1];
+            b = d[o + 2];
+            o += 3;
+        }
+        else if (op === OP_RGBA) {
+            r = d[o];
+            g = d[o + 1];
+            b = d[o + 2];
+            a = d[o + 3];
+            o += 4;
+        }
+        else if ((op & 0xc0) === OP_INDEX) {
+            const i = op * 4;
+            r = index[i];
+            g = index[i + 1];
+            b = index[i + 2];
+            a = index[i + 3];
+        }
+        else if ((op & 0xc0) === OP_DIFF) {
+            r = r + (op >> 4 & 3) - 2 & 255;
+            g = g + (op >> 2 & 3) - 2 & 255;
+            b = b + (op & 3) - 2 & 255;
+        }
+        else if ((op & 0xc0) === OP_LUMA) {
+            const dg = (op & 63) - 32, next = d[o++];
+            r = r + dg - 8 + (next >> 4) & 255;
+            g = g + dg & 255;
+            b = b + dg - 8 + (next & 15) & 255;
+        }
+        else
+            run = (op & 63) + 1;
+        if (o > d.length)
+            throw new Error('QOI: truncated image data');
+        const i = hash(r, g, b, a) * 4;
+        index[i] = r;
+        index[i + 1] = g;
+        index[i + 2] = b;
+        index[i + 3] = a;
+        for (const stop = Math.min(pixels.length, p + run * 4); p < stop; p += 4) {
+            pixels[p] = r;
+            pixels[p + 1] = g;
+            pixels[p + 2] = b;
+            pixels[p + 3] = a;
+        }
+    }
+    return { width, height, pixels };
+}
+export function encode(rgba, width, height) {
+    if (width < 1 || height < 1)
+        throw new RangeError('QOI: dimensions must be at least 1');
+    const count = width * height;
+    let opaque = true;
+    for (let i = 3; i < count * 4; i += 4)
+        if (rgba[i] !== 255) {
+            opaque = false;
+            break;
+        }
+    const out = new Uint8Array(14 + count * (opaque ? 4 : 5) + 8);
+    const view = new DataView(out.buffer);
+    out.set([0x71, 0x6f, 0x69, 0x66]);
+    view.setUint32(4, width);
+    view.setUint32(8, height);
+    out[12] = opaque ? 3 : 4;
+    out[13] = 0;
+    const index = new Uint8Array(256);
+    let o = 14, run = 0;
+    let pr = 0, pg = 0, pb = 0, pa = 255;
+    for (let p = 0, last = count * 4 - 4; p <= last; p += 4) {
+        const r = rgba[p], g = rgba[p + 1], b = rgba[p + 2], a = rgba[p + 3];
+        if (r === pr && g === pg && b === pb && a === pa) {
+            run++;
+            if (run === 62 || p === last) {
+                out[o++] = OP_RUN | run - 1;
+                run = 0;
+            }
+            continue;
+        }
+        if (run) {
+            out[o++] = OP_RUN | run - 1;
+            run = 0;
+        }
+        const h = hash(r, g, b, a), i = h * 4;
+        if (index[i] === r && index[i + 1] === g && index[i + 2] === b && index[i + 3] === a)
+            out[o++] = OP_INDEX | h;
+        else {
+            index[i] = r;
+            index[i + 1] = g;
+            index[i + 2] = b;
+            index[i + 3] = a;
+            if (a === pa) {
+                const vr = (r - pr) << 24 >> 24, vg = (g - pg) << 24 >> 24, vb = (b - pb) << 24 >> 24;
+                const vgr = vr - vg, vgb = vb - vg;
+                if (vr > -3 && vr < 2 && vg > -3 && vg < 2 && vb > -3 && vb < 2)
+                    out[o++] = OP_DIFF | vr + 2 << 4 | vg + 2 << 2 | vb + 2;
+                else if (vgr > -9 && vgr < 8 && vg > -33 && vg < 32 && vgb > -9 && vgb < 8) {
+                    out[o++] = OP_LUMA | vg + 32;
+                    out[o++] = vgr + 8 << 4 | vgb + 8;
+                }
+                else {
+                    out[o++] = OP_RGB;
+                    out[o++] = r;
+                    out[o++] = g;
+                    out[o++] = b;
+                }
+            }
+            else {
+                out[o++] = OP_RGBA;
+                out[o++] = r;
+                out[o++] = g;
+                out[o++] = b;
+                out[o++] = a;
+            }
+        }
+        pr = r;
+        pg = g;
+        pb = b;
+        pa = a;
+    }
+    out[o + 7] = 1;
+    return out.slice(0, o + 8);
+}

package/dist/codecs/tga.js

@@ -1,4 +1,5 @@
 import { encode as utf8 } from "../util/utf8.js";
+import { MAX_PIXELS, checkPixels } from "../util/limits.js";
 const SIGNATURE = 'TRUEVISION-XFILE.\0';
 function readHeader(d) {
     if (d.length < 18)
@@ -69,11 +70,12 @@ function readColor(d, o, bits, alphaBits, out, p) {
         out[p + 3] = bits === 32 && alphaBits ? d[o + 3] : 255;
     }
 }
-export function decode(d) {
+export function decode(d, maxPixels = MAX_PIXELS) {
     const h = readHeader(d);
     if (!h || !isTGA(d))
         throw new Error('TGA: invalid header');
     const { width, height, depth } = h;
+    checkPixels(width, height, maxPixels);
     const base = h.imageType & ~8, rle = (h.imageType & 8) !== 0;
     const bytesPerPixel = Math.ceil(depth / 8);
     let offset = 18 + h.idLength;

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);