imagescript 3.2.1 → 3.4.0

package/dist/codecs/ico.js

@@ -0,0 +1,48 @@
+import { MAX_PIXELS } from "../util/limits.js";
+import { decodeDIB } from "./bmp.js";
+const u16 = (d, o) => d[o] | d[o + 1] << 8;
+const u32 = (d, o) => (d[o] | d[o + 1] << 8 | d[o + 2] << 16 | d[o + 3] << 24) >>> 0;
+const isPNG = (d, o) => d[o] === 0x89 && d[o + 1] === 0x50 && d[o + 2] === 0x4e && d[o + 3] === 0x47;
+export function iconType(d) {
+    if (d.length < 22 || u16(d, 0) !== 0 || (u16(d, 2) !== 1 && u16(d, 2) !== 2))
+        return null;
+    const count = u16(d, 4);
+    if (!count || d.length < 6 + count * 16 || d[9] !== 0)
+        return null;
+    const offset = u32(d, 18);
+    if (offset < 6 + count * 16 || offset + 24 > d.length)
+        return null;
+    return isPNG(d, offset) || [12, 40, 52, 56, 108, 124].includes(u32(d, offset)) ? u16(d, 2) === 1 ? 'ico' : 'cur' : null;
+}
+export function decode(d, maxPixels = MAX_PIXELS) {
+    if (!iconType(d))
+        throw new Error('ICO: invalid header');
+    let best = null;
+    for (let i = 0, count = u16(d, 4); i < count; i++) {
+        const e = 6 + i * 16;
+        const offset = u32(d, e + 12);
+        let size = u32(d, e + 8);
+        if (offset + 24 > d.length)
+            continue;
+        if (size < 16 || offset + size > d.length)
+            size = d.length - offset;
+        let area, bits;
+        if (isPNG(d, offset)) {
+            const view = new DataView(d.buffer, d.byteOffset + offset);
+            area = view.getUint32(16) * view.getUint32(20);
+            bits = 32;
+        }
+        else {
+            area = Math.abs(u32(d, offset + 4) * (u32(d, offset + 8) >> 1));
+            bits = u16(d, offset + 14);
+        }
+        if (!best || area > best.area || area === best.area && bits > best.bits)
+            best = { offset, size, area, bits };
+    }
+    if (!best)
+        throw new Error('ICO: no image inside the data');
+    const data = d.subarray(best.offset, best.offset + best.size);
+    if (isPNG(data, 0))
+        return { embedded: 'png', data };
+    return decodeDIB(data, 0, null, maxPixels, true);
+}

package/dist/codecs/jpeg.js

@@ -4,13 +4,15 @@
  * (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
  */
+import { ByteWriter } from "../util/bytes.js";
+import { MAX_PIXELS, checkPixels } from "../util/limits.js";
 import { orientation as exifOrientation } from "./exif.js";
 import { concat } from "../util/mem.js";
 const ZIGZAG = Int32Array.of(0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63);
 function clamp8(v) {
     return v < 0 ? 0 : v > 255 ? 255 : v;
 }
-export function decode(data, { transform } = {}) {
+export function decode(data, { transform, maxPixels = MAX_PIXELS } = {}) {
     if (data[0] !== 0xff || data[1] !== 0xd8)
         throw new Error('JPEG: invalid signature');
     const quantizationTables = [];
@@ -84,6 +86,7 @@ export function decode(data, { transform } = {}) {
                     throw new Error('JPEG: multiple frames are not supported');
                 if (data[start] !== 8)
                     throw new Error(`JPEG: ${data[start]}-bit precision is not supported`);
+                checkPixels(u16(start + 3), u16(start + 1), maxPixels);
                 frame = createFrame(marker === 0xc2, u16(start + 1), u16(start + 3), data.subarray(start + 5, end));
                 break;
             }
@@ -158,6 +161,8 @@ function createFrame(progressive, height, width, componentData) {
     }
     if (!width || !sampling.length)
         throw new Error('JPEG: invalid dimensions');
+    if (sampling.length > 4)
+        throw new Error(`JPEG: ${sampling.length} components are not supported`);
     const hmax = Math.max(...sampling.map(c => c.h));
     const vmax = Math.max(...sampling.map(c => c.v));
     const mcusPerLine = Math.ceil(width / (8 * hmax));
@@ -926,7 +931,8 @@ function fdctPass(d, o, s) {
     const tmp1 = d[o + s] + d[o + 6 * s], tmp6 = d[o + s] - d[o + 6 * s];
     const tmp2 = d[o + 2 * s] + d[o + 5 * s], tmp5 = d[o + 2 * s] - d[o + 5 * s];
     const tmp3 = d[o + 3 * s] + d[o + 4 * s], tmp4 = d[o + 3 * s] - d[o + 4 * s];
-    let tmp10 = tmp0 + tmp3, tmp13 = tmp0 - tmp3;
+    let tmp10 = tmp0 + tmp3;
+    const tmp13 = tmp0 - tmp3;
     let tmp11 = tmp1 + tmp2, tmp12 = tmp1 - tmp2;
     d[o] = tmp10 + tmp11;
     d[o + 4 * s] = tmp10 - tmp11;
@@ -946,29 +952,9 @@ function fdctPass(d, o, s) {
     d[o + s] = z11 + z4;
     d[o + 7 * s] = z11 - z4;
 }
-class BitWriter {
-    buffer;
-    length;
-    bits;
-    count;
-    constructor(capacity) {
-        this.buffer = new Uint8Array(Math.max(1024, capacity));
-        this.length = 0;
-        this.bits = 0;
-        this.count = 0;
-    }
-    reserve(size) {
-        if (this.length + size <= this.buffer.length)
-            return;
-        const buffer = new Uint8Array(Math.max(this.buffer.length * 2, this.length + size));
-        buffer.set(this.buffer.subarray(0, this.length));
-        this.buffer = buffer;
-    }
-    bytes(...values) {
-        this.reserve(values.length);
-        for (const value of values)
-            this.buffer[this.length++] = value;
-    }
+class BitWriter extends ByteWriter {
+    bits = 0;
+    count = 0;
     write(value, size) {
         this.bits = this.bits << size | value & (1 << size) - 1;
         this.count += size;
@@ -986,7 +972,4 @@ class BitWriter {
         if (this.count)
             this.write((1 << 8 - this.count) - 1, 8 - this.count);
     }
-    finish() {
-        return this.buffer.slice(0, this.length);
-    }
 }

package/dist/codecs/jxl/bits.js

@@ -0,0 +1,126 @@
+/*!
+ * The JPEG XL bit reader and the field types of its headers (ISO/IEC 18181-1), ported from jxl-oxide
+ * (crates/jxl-bitstream). Copyright (c) Wonwoo Choi, MIT License (see THIRD_PARTY_NOTICES.md)
+ */
+export class BitReader {
+    d;
+    start;
+    end;
+    buf = 0;
+    n = 0;
+    pos;
+    constructor(d, start = 0, end = d.length) {
+        this.d = d;
+        this.start = start;
+        this.end = end;
+        this.pos = start;
+    }
+    get bitPosition() {
+        return (this.pos - this.start) * 8 - this.n;
+    }
+    refill() {
+        while (this.n <= 24) {
+            if (this.pos >= this.end) {
+                if (this.pos >= this.end + 8)
+                    throw new Error('JPEG XL: truncated data');
+                this.pos++;
+            }
+            else
+                this.buf = (this.buf | this.d[this.pos++] << this.n) >>> 0;
+            this.n += 8;
+        }
+    }
+    peek(n) {
+        if (this.n < n)
+            this.refill();
+        return this.buf & ((1 << n) - 1);
+    }
+    skip(n) {
+        this.buf >>>= n;
+        this.n -= n;
+    }
+    bits(n) {
+        if (n > 24) {
+            const low = this.bits(16);
+            return low + this.bits(n - 16) * 65536;
+        }
+        if (this.n < n)
+            this.refill();
+        const v = this.buf & ((1 << n) - 1);
+        this.buf >>>= n;
+        this.n -= n;
+        return v;
+    }
+    bool() {
+        return this.bits(1) === 1;
+    }
+    u32(d0, d1, d2, d3) {
+        const sel = this.bits(2);
+        const d = sel === 0 ? d0 : sel === 1 ? d1 : sel === 2 ? d2 : d3;
+        return typeof d === 'number' ? d : d[0] + this.bits(d[1]);
+    }
+    u64() {
+        const sel = this.bits(2);
+        if (sel === 0)
+            return 0;
+        if (sel === 1)
+            return 1 + this.bits(4);
+        if (sel === 2)
+            return 17 + this.bits(8);
+        let value = this.bits(12), shift = 12;
+        while (this.bool()) {
+            if (shift === 60) {
+                value += this.bits(4) * 2 ** shift;
+                break;
+            }
+            value += this.bits(8) * 2 ** shift;
+            shift += 8;
+        }
+        if (value > Number.MAX_SAFE_INTEGER)
+            throw new Error('JPEG XL: value too large');
+        return value;
+    }
+    f16() {
+        const v = this.bits(16);
+        const sign = v & 0x8000 ? -1 : 1, exponent = v >> 10 & 31, mantissa = v & 1023;
+        if (exponent === 31)
+            throw new Error('JPEG XL: invalid float');
+        if (exponent === 0)
+            return sign * mantissa / 1024 / 16384;
+        return sign * (1 + mantissa / 1024) * 2 ** (exponent - 15);
+    }
+    enum() {
+        const v = this.u32(0, 1, [2, 4], [18, 6]);
+        if (v > 63)
+            throw new Error('JPEG XL: invalid enum value');
+        return v;
+    }
+    skipBits(n) {
+        while (n > 24) {
+            this.bits(24);
+            n -= 24;
+        }
+        this.bits(n);
+    }
+    zeroPadToByte() {
+        const pad = (8 - this.bitPosition % 8) % 8;
+        if (this.bits(pad) !== 0)
+            throw new Error('JPEG XL: non-zero padding');
+    }
+    get bytePosition() {
+        return this.start + Math.ceil(this.bitPosition / 8);
+    }
+    checkEnd() {
+        if (this.bitPosition > (this.end - this.start) * 8)
+            throw new Error('JPEG XL: truncated data');
+    }
+}
+export const unpackSigned = (v) => v % 2 ? -(v + 1) / 2 : v / 2;
+export function extensions(r) {
+    const bits = r.u64();
+    let lengths = 0;
+    for (let i = 0; i < 64; i++)
+        if (Math.floor(bits / 2 ** i) % 2)
+            lengths += r.u64();
+    r.skipBits(lengths);
+}

package/dist/codecs/jxl/blend.js

@@ -0,0 +1,117 @@
+import { EXTRA_ALPHA } from "./headers.js";
+export const PB_NONE = 0, PB_REPLACE = 1, PB_ADD = 2, PB_MUL = 3, PB_BLEND_ABOVE = 4, PB_BLEND_BELOW = 5, PB_ADD_ABOVE = 6, PB_ADD_BELOW = 7;
+const clamp01 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
+let rows = [];
+export function performBlending(bg, bi, fg, fi, out, oi, n, numColor, color, ec, extra) {
+    const hasAlpha = extra.some(e => e.type === EXTRA_ALPHA), numEc = extra.length, nc = numColor + numEc;
+    if (rows.length < nc || rows[0].length < n)
+        rows = Array.from({ length: Math.max(nc, rows.length) }, () => new Float32Array(Math.max(n, rows[0]?.length ?? 0)));
+    for (let i = 0; i < numEc; i++) {
+        const c = numColor + i, e = ec[i], a = numColor + e.alpha, t = rows[c], B = bg[c], F = fg[c], BA = bg[a], FA = fg[a];
+        const isAlpha = c === a, premultiplied = extra[e.alpha].alphaAssociated;
+        switch (e.mode) {
+            case PB_ADD:
+                for (let k = 0; k < n; k++)
+                    t[k] = B[bi + k] + F[fi + k];
+                break;
+            case PB_BLEND_ABOVE:
+                for (let k = 0; k < n; k++)
+                    t[k] = alphaBlend1(B[bi + k], BA[bi + k], F[fi + k], FA[fi + k], isAlpha, premultiplied, e.clamp);
+                break;
+            case PB_BLEND_BELOW:
+                for (let k = 0; k < n; k++)
+                    t[k] = alphaBlend1(F[fi + k], FA[fi + k], B[bi + k], BA[bi + k], isAlpha, premultiplied, e.clamp);
+                break;
+            case PB_ADD_ABOVE:
+                for (let k = 0; k < n; k++)
+                    t[k] = isAlpha ? B[bi + k] : B[bi + k] + F[fi + k] * (e.clamp ? clamp01(FA[fi + k]) : FA[fi + k]);
+                break;
+            case PB_ADD_BELOW:
+                for (let k = 0; k < n; k++)
+                    t[k] = isAlpha ? F[fi + k] : F[fi + k] + B[bi + k] * (e.clamp ? clamp01(BA[bi + k]) : BA[bi + k]);
+                break;
+            case PB_MUL:
+                for (let k = 0; k < n; k++)
+                    t[k] = B[bi + k] * (e.clamp ? clamp01(F[fi + k]) : F[fi + k]);
+                break;
+            case PB_REPLACE:
+                t.set(F.subarray(fi, fi + n));
+                break;
+            default: t.set(B.subarray(bi, bi + n));
+        }
+    }
+    const a = numColor + color.alpha;
+    switch (color.mode) {
+        case PB_ADD:
+            for (let c = 0; c < numColor; c++) {
+                const t = rows[c], B = bg[c], F = fg[c];
+                for (let k = 0; k < n; k++)
+                    t[k] = B[bi + k] + F[fi + k];
+            }
+            break;
+        case PB_ADD_ABOVE:
+        case PB_ADD_BELOW: {
+            const [lo, li, hi, hj] = color.mode === PB_ADD_ABOVE ? [bg, bi, fg, fi] : [fg, fi, bg, bi];
+            for (let c = 0; c < numColor; c++) {
+                const t = rows[c], L = lo[c], H = hi[c];
+                if (!hasAlpha) {
+                    for (let k = 0; k < n; k++)
+                        t[k] = bg[c][bi + k] + fg[c][fi + k];
+                    continue;
+                }
+                const HA = hi[a];
+                for (let k = 0; k < n; k++)
+                    t[k] = L[li + k] + H[hj + k] * (color.clamp ? clamp01(HA[hj + k]) : HA[hj + k]);
+            }
+            break;
+        }
+        case PB_BLEND_ABOVE:
+        case PB_BLEND_BELOW: {
+            if (!hasAlpha) {
+                for (let c = 0; c < numColor; c++)
+                    rows[c].set(fg[c].subarray(fi, fi + n));
+                break;
+            }
+            const [lo, li, hi, hj] = color.mode === PB_BLEND_ABOVE ? [bg, bi, fg, fi] : [fg, fi, bg, bi];
+            const premultiplied = extra[color.alpha].alphaAssociated, HA = hi[a], LA = lo[a], ta = rows[a];
+            for (let k = 0; k < n; k++) {
+                const fa = color.clamp ? clamp01(HA[hj + k]) : HA[hj + k], ba = LA[li + k], na = 1 - (1 - fa) * (1 - ba);
+                if (premultiplied)
+                    for (let c = 0; c < numColor; c++)
+                        rows[c][k] = hi[c][hj + k] + lo[c][li + k] * (1 - fa);
+                else {
+                    const rna = na > 0 ? 1 / na : 0;
+                    for (let c = 0; c < numColor; c++)
+                        rows[c][k] = (hi[c][hj + k] * fa + lo[c][li + k] * ba * (1 - fa)) * rna;
+                }
+                ta[k] = na;
+            }
+            break;
+        }
+        case PB_MUL:
+            for (let c = 0; c < numColor; c++) {
+                const t = rows[c], B = bg[c], F = fg[c];
+                for (let k = 0; k < n; k++)
+                    t[k] = B[bi + k] * (color.clamp ? clamp01(F[fi + k]) : F[fi + k]);
+            }
+            break;
+        case PB_REPLACE:
+            for (let c = 0; c < numColor; c++)
+                rows[c].set(fg[c].subarray(fi, fi + n));
+            break;
+        default:
+            for (let c = 0; c < numColor; c++)
+                rows[c].set(bg[c].subarray(bi, bi + n));
+    }
+    for (let c = 0; c < nc; c++)
+        out[c].set(rows[c].subarray(0, n), oi);
+}
+function alphaBlend1(bg, bga, fg, fga, isAlpha, premultiplied, clamp) {
+    const fa = clamp ? fga : clamp01(fga);
+    if (isAlpha)
+        return 1 - (1 - fa) * (1 - bga);
+    if (premultiplied)
+        return fg + bg * (1 - fa);
+    const na = 1 - (1 - fa) * (1 - bga);
+    return (fg * fa + bg * bga * (1 - fa)) * (na > 0 ? 1 / na : 0);
+}

package/dist/codecs/jxl/color.js

@@ -0,0 +1,116 @@
+import { TF_PQ, TF_HLG, PRI_BT2100, PRI_P3, EXTRA_ALPHA, EXTRA_SPOT, EXTRA_BLACK } from "./headers.js";
+import { toSRGB, hdrToLinear, REFERENCE_WHITE } from "../hdr.js";
+const srgbEncode = (v) => v <= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055;
+export class ColorOutput {
+    image;
+    toneMapping;
+    linear;
+    hdrSignal;
+    scale;
+    constructor(image, toneMapping) {
+        this.image = image;
+        this.toneMapping = toneMapping;
+        const c = image.colour, hdr = !c.wantICC && (c.transfer === TF_PQ || c.transfer === TF_HLG);
+        this.linear = image.xybEncoded && (hdr || image.toneMapping.intensityTarget > 255);
+        this.hdrSignal = !image.xybEncoded && hdr;
+        this.scale = this.linear ? image.toneMapping.intensityTarget / REFERENCE_WHITE : 1;
+    }
+    transform(p, ycbcr) {
+        const image = this.image, n = p.width * p.height, ch = p.channels.slice();
+        if (ycbcr) {
+            const [cb, y, cr] = ch, r = new Float32Array(n), g = new Float32Array(n), b = new Float32Array(n);
+            for (let i = 0; i < n; i++) {
+                const Y = y[i] + 128 / 255;
+                r[i] = Y + 1.402 * cr[i];
+                g[i] = Y - 0.299 * 1.402 / 0.587 * cr[i] - 0.114 * 1.772 / 0.587 * cb[i];
+                b[i] = Y + 1.772 * cb[i];
+            }
+            ch.splice(0, 3, r, g, b);
+        }
+        else if (image.xybEncoded) {
+            const [x, y, b] = ch, m = image.opsinInverse, bias = image.opsinBias, cbrt = bias.map(Math.cbrt);
+            const k = 255 / image.toneMapping.intensityTarget * this.scale;
+            const R = new Float32Array(n), G = new Float32Array(n), B = new Float32Array(n);
+            for (let i = 0; i < n; i++) {
+                const gr = y[i] + x[i] - cbrt[0], gg = y[i] - x[i] - cbrt[1], gb = b[i] - cbrt[2];
+                const mr = gr * gr * gr + bias[0], mg = gg * gg * gg + bias[1], mb = gb * gb * gb + bias[2];
+                let r = (m[0] * mr + m[1] * mg + m[2] * mb) * k, g = (m[3] * mr + m[4] * mg + m[5] * mb) * k, bl = (m[6] * mr + m[7] * mg + m[8] * mb) * k;
+                if (!this.linear) {
+                    r = srgbEncode(r);
+                    g = srgbEncode(g);
+                    bl = srgbEncode(bl);
+                }
+                R[i] = r;
+                G[i] = g;
+                B[i] = bl;
+            }
+            ch.splice(0, 3, R, G, B);
+        }
+        return { width: p.width, height: p.height, channels: ch };
+    }
+    toRGBA(p) {
+        const n = p.width * p.height, ch = p.channels, image = this.image;
+        const numColor = ch.length - image.extraChannels.length, grey = numColor === 1;
+        let [r, g, b] = grey ? [ch[0], ch[0], ch[0]] : ch;
+        const black = image.extraChannels.findIndex(e => e.type === EXTRA_BLACK);
+        if (black >= 0) {
+            const k = ch[numColor + black];
+            if (grey)
+                r = g = b = r.slice();
+            else
+                [r, g, b] = [r.slice(), g.slice(), b.slice()];
+            for (let i = 0; i < n; i++) {
+                r[i] *= k[i];
+                if (!grey) {
+                    g[i] *= k[i];
+                    b[i] *= k[i];
+                }
+            }
+        }
+        image.extraChannels.forEach((e, i) => {
+            if (e.type !== EXTRA_SPOT || grey)
+                return;
+            const s = ch[numColor + i], [sr, sg, sb, solidity] = e.spot;
+            if (r === ch[0])
+                [r, g, b] = [r.slice(), g.slice(), b.slice()];
+            for (let k = 0; k < n; k++) {
+                const mix = solidity * s[k];
+                r[k] = mix * sr + (1 - mix) * r[k];
+                g[k] = mix * sg + (1 - mix) * g[k];
+                b[k] = mix * sb + (1 - mix) * b[k];
+            }
+        });
+        const alphaIndex = image.extraChannels.findIndex(e => e.type === EXTRA_ALPHA);
+        const alpha = alphaIndex >= 0 ? ch[ch.length - image.extraChannels.length + alphaIndex] : null;
+        const premultiplied = alphaIndex >= 0 && image.extraChannels[alphaIndex].alphaAssociated;
+        let out;
+        if (this.linear || this.hdrSignal) {
+            const rgb = new Float32Array(3 * n);
+            for (let i = 0; i < n; i++) {
+                const a = premultiplied ? Math.max(alpha[i], 2 ** -26) : 1;
+                rgb[3 * i] = r[i] / a;
+                rgb[3 * i + 1] = g[i] / a;
+                rgb[3 * i + 2] = b[i] / a;
+            }
+            const c = image.colour;
+            if (this.hdrSignal)
+                hdrToLinear(rgb, c.transfer, c.primaries === PRI_BT2100 ? 9 : c.primaries === PRI_P3 ? 12 : 1);
+            out = toSRGB(rgb, this.toneMapping);
+        }
+        else {
+            out = new Uint8Array(4 * n);
+            const byte = (v) => v <= 0 ? 0 : v >= 1 ? 255 : Math.round(v * 255);
+            for (let i = 0; i < n; i++) {
+                const a = premultiplied ? Math.max(alpha[i], 2 ** -26) : 1;
+                out[4 * i] = byte(r[i] / a);
+                out[4 * i + 1] = byte(g[i] / a);
+                out[4 * i + 2] = byte(b[i] / a);
+                out[4 * i + 3] = 255;
+            }
+        }
+        if (alpha)
+            for (let i = 0; i < n; i++)
+                out[4 * i + 3] = alpha[i] <= 0 ? 0 : alpha[i] >= 1 ? 255 : Math.round(alpha[i] * 255);
+        return out;
+    }
+}