imagescript 3.3.0 → 3.4.0

package/dist/codecs/bmp.js

@@ -0,0 +1,317 @@
+import { MAX_PIXELS, checkPixels } from "../util/limits.js";
+const BI_RGB = 0, BI_RLE8 = 1, BI_RLE4 = 2, BI_BITFIELDS = 3, BI_JPEG = 4, BI_PNG = 5, BI_ALPHABITFIELDS = 6;
+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 i32 = (d, o) => d[o] | d[o + 1] << 8 | d[o + 2] << 16 | d[o + 3] << 24;
+const WINDOWS_HEADERS = [40, 52, 56, 108, 124];
+const isHeaderSize = (size) => size === 12 || WINDOWS_HEADERS.includes(size) || (size >= 16 && size <= 64 && size % 4 === 0);
+export function isBMP(d) {
+    return d.length >= 26 && d[0] === 0x42 && d[1] === 0x4d && isHeaderSize(u32(d, 14));
+}
+function channel(mask) {
+    mask >>>= 0;
+    let shift = 0;
+    if (mask)
+        while (!(mask >>> shift & 1))
+            shift++;
+    const max = mask >>> shift;
+    let table = null;
+    if (max && max < 65536) {
+        table = new Uint8Array(max + 1);
+        for (let v = 0; v <= max; v++)
+            table[v] = Math.round(v * 255 / max);
+    }
+    return { mask, shift, max, table };
+}
+function sample(c, v) {
+    if (!c.max)
+        return 0;
+    const x = (v & c.mask) >>> c.shift;
+    return c.table ? c.table[x] : Math.round(x * 255 / c.max);
+}
+function readInfo(d, o) {
+    const size = u32(d, o);
+    if (!isHeaderSize(size))
+        throw new Error(`BMP: unknown header size ${size}`);
+    if (o + size > d.length)
+        throw new Error('BMP: truncated header');
+    if (size === 12) {
+        return { width: u16(d, o + 4), height: u16(d, o + 6), topDown: false, bits: u16(d, o + 10), compression: BI_RGB, headerEnd: o + 12, entryBytes: 3, colors: 0, masks: null };
+    }
+    const os2 = !WINDOWS_HEADERS.includes(size);
+    const width = i32(d, o + 4), rawHeight = i32(d, o + 8);
+    const bits = u16(d, o + 14);
+    let compression = size >= 20 ? u32(d, o + 16) : BI_RGB;
+    if (os2 && (compression === 3 || compression === 4))
+        throw new Error(`BMP: unsupported OS/2 compression (${compression === 3 ? 'Huffman 1D' : 'RLE24'})`);
+    const colors = size >= 36 ? u32(d, o + 32) : 0;
+    let masks = null;
+    let headerEnd = o + size;
+    if (compression === BI_BITFIELDS || compression === BI_ALPHABITFIELDS) {
+        if (size >= 52)
+            masks = [u32(d, o + 40), u32(d, o + 44), u32(d, o + 48), size >= 56 ? u32(d, o + 52) : 0];
+        else {
+            const count = compression === BI_ALPHABITFIELDS ? 4 : 3;
+            if (headerEnd + count * 4 > d.length)
+                throw new Error('BMP: truncated bit fields');
+            masks = [u32(d, headerEnd), u32(d, headerEnd + 4), u32(d, headerEnd + 8), count === 4 ? u32(d, headerEnd + 12) : 0];
+            headerEnd += count * 4;
+        }
+        compression = BI_BITFIELDS;
+    }
+    if (width <= 0 || rawHeight === 0 || rawHeight === -0x80000000)
+        throw new Error(`BMP: invalid dimensions ${width}x${rawHeight}`);
+    return { width, height: Math.abs(rawHeight), topDown: rawHeight < 0, bits, compression, headerEnd, entryBytes: 4, colors, masks };
+}
+function readPalette(d, info, end) {
+    const { bits, entryBytes, headerEnd } = info;
+    if (bits > 8)
+        return null;
+    let count = info.colors || 1 << bits;
+    count = Math.max(0, Math.min(count, Math.floor((Math.min(end, d.length) - headerEnd) / entryBytes)));
+    const palette = new Uint32Array(Math.max(count, 1 << bits));
+    palette.fill(0xff000000);
+    for (let i = 0; i < count; i++) {
+        const p = headerEnd + i * entryBytes;
+        palette[i] = (0xff000000 | d[p] << 16 | d[p + 1] << 8 | d[p + 2]) >>> 0;
+    }
+    return palette;
+}
+export function decodeDIB(d, o, pixelOffset, maxPixels, ico = false) {
+    const info = readInfo(d, o);
+    const { width, bits, compression, topDown } = info;
+    const height = ico ? info.height >> 1 : info.height;
+    if (!height)
+        throw new Error('BMP: invalid dimensions');
+    if (compression === BI_JPEG || compression === BI_PNG) {
+        const start = pixelOffset ?? info.headerEnd;
+        return { embedded: compression === BI_JPEG ? 'jpeg' : 'png', data: d.subarray(start) };
+    }
+    if (![1, 2, 4, 8, 16, 24, 32, 64].includes(bits))
+        throw new Error(`BMP: unsupported bit depth ${bits}`);
+    if (compression === BI_RLE8 && bits !== 8 || compression === BI_RLE4 && bits !== 4)
+        throw new Error('BMP: RLE compression of the wrong bit depth');
+    if (compression === BI_BITFIELDS && bits !== 16 && bits !== 32)
+        throw new Error('BMP: bit fields need 16 or 32 bit pixels');
+    if (compression > BI_PNG)
+        throw new Error(`BMP: unsupported compression ${compression}`);
+    checkPixels(width, height, maxPixels);
+    const palette = readPalette(d, info, pixelOffset ?? d.length);
+    const start = pixelOffset ?? info.headerEnd + (bits <= 8 ? info.colors || 1 << bits : info.colors) * info.entryBytes;
+    const pixels = new Uint8Array(width * height * 4);
+    const out = new Uint32Array(pixels.buffer);
+    const row = (y) => (topDown ? y : height - 1 - y) * width;
+    if (compression === BI_RLE8 || compression === BI_RLE4) {
+        decodeRLE(d, start, width, height, compression === BI_RLE4, palette, out, row);
+        return { width, height, pixels };
+    }
+    const stride = (width * bits + 31 >>> 5) * 4;
+    if (start + stride * (height - 1) + Math.ceil(width * bits / 8) > d.length)
+        throw new Error('BMP: truncated pixel data');
+    if (palette) {
+        const mask = (1 << bits) - 1;
+        for (let y = 0; y < height; y++) {
+            const r = start + y * stride, o = row(y);
+            for (let x = 0; x < width; x++) {
+                const bit = x * bits;
+                out[o + x] = palette[d[r + (bit >> 3)] >> (8 - bits - (bit & 7)) & mask];
+            }
+        }
+    }
+    else if (bits === 24) {
+        for (let y = 0; y < height; y++) {
+            const r = start + y * stride, o = row(y);
+            for (let x = 0; x < width; x++) {
+                const p = r + x * 3;
+                out[o + x] = (0xff000000 | d[p] << 16 | d[p + 1] << 8 | d[p + 2]) >>> 0;
+            }
+        }
+    }
+    else if (bits === 64) {
+        const srgb = (v) => {
+            const c = Math.min(1, Math.max(0, v / 8192));
+            return Math.round(255 * (c <= 0.0031308 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055));
+        };
+        const s16 = (p) => d[p] | d[p + 1] << 8 << 16 >> 16;
+        for (let y = 0; y < height; y++) {
+            const r = start + y * stride, o = row(y) * 4;
+            for (let x = 0; x < width; x++) {
+                const p = r + x * 8, q = o + x * 4;
+                pixels[q] = srgb(s16(p + 4));
+                pixels[q + 1] = srgb(s16(p + 2));
+                pixels[q + 2] = srgb(s16(p));
+                pixels[q + 3] = Math.round(Math.min(1, Math.max(0, s16(p + 6) / 8192)) * 255);
+            }
+        }
+    }
+    else {
+        const masks = info.masks ?? (bits === 16 ? [0x7c00, 0x3e0, 0x1f, 0] : [0xff0000, 0xff00, 0xff, ico && bits === 32 ? 0xff000000 : 0]);
+        const [cr, cg, cb, ca] = masks.map(channel);
+        const fast = bits === 32 && cr.mask === 0xff0000 && cg.mask === 0xff00 && cb.mask === 0xff;
+        let alphaSeen = false;
+        for (let y = 0; y < height; y++) {
+            const r = start + y * stride, o = row(y);
+            for (let x = 0; x < width; x++) {
+                const v = bits === 16 ? u16(d, r + x * 2) : u32(d, r + x * 4);
+                const a = ca.max ? sample(ca, v) : 255;
+                if (ca.max && a)
+                    alphaSeen = true;
+                out[o + x] = fast
+                    ? (a << 24 | (v & 0xff) << 16 | v & 0xff00 | v >> 16 & 0xff) >>> 0
+                    : (a << 24 | sample(cb, v) << 16 | sample(cg, v) << 8 | sample(cr, v)) >>> 0;
+            }
+        }
+        if (ca.max && !alphaSeen)
+            for (let i = 0; i < out.length; i++)
+                out[i] |= 0xff000000;
+        if (ico && bits === 32 && alphaSeen)
+            return { width, height, pixels };
+    }
+    if (ico) {
+        const maskStart = start + stride * height, maskStride = (width + 31 >>> 5) * 4;
+        if (maskStart + maskStride * (height - 1) + Math.ceil(width / 8) <= d.length) {
+            for (let y = 0; y < height; y++) {
+                const r = maskStart + y * maskStride, o = row(y);
+                for (let x = 0; x < width; x++)
+                    if (d[r + (x >> 3)] >> (7 - (x & 7)) & 1)
+                        out[o + x] = 0;
+            }
+        }
+    }
+    return { width, height, pixels };
+}
+function decodeRLE(d, o, width, height, four, palette, out, row) {
+    let x = 0, y = 0;
+    const put = (index) => {
+        if (x < width && y < height)
+            out[row(y) + x] = palette[index];
+        x++;
+    };
+    while (y < height) {
+        if (o + 1 >= d.length)
+            throw new Error('BMP: truncated RLE data');
+        const n = d[o], v = d[o + 1];
+        o += 2;
+        if (n) {
+            for (let i = 0; i < n; i++)
+                put(four ? (i & 1 ? v & 15 : v >> 4) : v);
+        }
+        else if (v === 0) {
+            x = 0;
+            y++;
+        }
+        else if (v === 1) {
+            break;
+        }
+        else if (v === 2) {
+            if (o + 1 >= d.length)
+                throw new Error('BMP: truncated RLE data');
+            x += d[o];
+            y += d[o + 1];
+            o += 2;
+        }
+        else {
+            const bytes = four ? v + 1 >> 1 : v;
+            if (o + bytes > d.length)
+                throw new Error('BMP: truncated RLE data');
+            for (let i = 0; i < v; i++)
+                put(four ? (i & 1 ? d[o + (i >> 1)] & 15 : d[o + (i >> 1)] >> 4) : d[o + i]);
+            o += bytes + (bytes & 1);
+        }
+    }
+}
+export function decode(d, maxPixels = MAX_PIXELS) {
+    if (!isBMP(d))
+        throw new Error('BMP: invalid header');
+    const offset = u32(d, 10);
+    return decodeDIB(d, 14, offset >= 26 && offset < d.length ? offset : null, maxPixels);
+}
+export function encode(rgba, width, height) {
+    if (width < 1 || height < 1)
+        throw new RangeError('BMP: dimensions must be at least 1');
+    const count = width * height;
+    if (rgba.byteOffset % 4)
+        rgba = rgba.slice(0, count * 4);
+    const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, count);
+    let opaque = true;
+    for (let i = 3; i < count * 4; i += 4)
+        if (rgba[i] !== 255) {
+            opaque = false;
+            break;
+        }
+    let colors = null;
+    if (opaque) {
+        colors = new Map();
+        for (let i = 0; i < count && colors; i++) {
+            if (!colors.has(pixels[i])) {
+                if (colors.size === 256)
+                    colors = null;
+                else
+                    colors.set(pixels[i], colors.size);
+            }
+        }
+    }
+    const bits = colors ? colors.size <= 2 ? 1 : colors.size <= 16 ? 4 : 8 : opaque ? 24 : 32;
+    const headerSize = bits === 32 ? 108 : 40;
+    const paletteSize = colors ? (1 << bits) * 4 : 0;
+    const stride = (width * bits + 31 >>> 5) * 4;
+    const offset = 14 + headerSize + paletteSize;
+    const size = offset + stride * height;
+    if (size > 0xffffffff)
+        throw new RangeError('BMP: image too large');
+    const out = new Uint8Array(size);
+    const view = new DataView(out.buffer);
+    out[0] = 0x42;
+    out[1] = 0x4d;
+    view.setUint32(2, size, true);
+    view.setUint32(10, offset, true);
+    view.setUint32(14, headerSize, true);
+    view.setInt32(18, width, true);
+    view.setInt32(22, height, true);
+    view.setUint16(26, 1, true);
+    view.setUint16(28, bits, true);
+    view.setUint32(30, bits === 32 ? BI_BITFIELDS : BI_RGB, true);
+    view.setUint32(34, stride * height, true);
+    view.setUint32(38, 2835, true);
+    view.setUint32(42, 2835, true);
+    if (bits === 32) {
+        view.setUint32(54, 0x00ff0000, true);
+        view.setUint32(58, 0x0000ff00, true);
+        view.setUint32(62, 0x000000ff, true);
+        view.setUint32(66, 0xff000000, true);
+        view.setUint32(70, 0x73524742, true);
+    }
+    if (colors)
+        for (const [color, index] of colors) {
+            const p = 14 + headerSize + index * 4;
+            out[p] = color >> 16 & 255;
+            out[p + 1] = color >> 8 & 255;
+            out[p + 2] = color & 255;
+        }
+    for (let y = 0; y < height; y++) {
+        const r = offset + (height - 1 - y) * stride, s = y * width * 4;
+        if (colors) {
+            const map = colors;
+            for (let x = 0; x < width; x++)
+                out[r + (x * bits >> 3)] |= map.get(pixels[y * width + x]) << (8 - bits - (x * bits & 7));
+        }
+        else if (bits === 24) {
+            for (let x = 0; x < width; x++) {
+                const p = r + x * 3, q = s + x * 4;
+                out[p] = rgba[q + 2];
+                out[p + 1] = rgba[q + 1];
+                out[p + 2] = rgba[q];
+            }
+        }
+        else {
+            for (let x = 0; x < width; x++) {
+                const p = r + x * 4, q = s + x * 4;
+                out[p] = rgba[q + 2];
+                out[p + 1] = rgba[q + 1];
+                out[p + 2] = rgba[q];
+                out[p + 3] = rgba[q + 3];
+            }
+        }
+    }
+    return out;
+}

package/dist/codecs/hdr.d.ts

@@ -0,0 +1,25 @@
+/** How linear light brighter than white becomes 8 bit sRGB: tone mapped by Reinhard's operator, or clamped */
+export type ToneMapping = 'reinhard' | 'clamp';
+/**
+ * Linear light RGB (3 values per pixel) as sRGB RGBA. Reinhard's extended operator ("Photographic Tone Reproduction
+ * for Digital Images", 2002, equation 4) without its automatic exposure, which makes dark scenes like nights grey:
+ * the luminance L becomes L (1 + L / Lw²) / (1 + L), the brightest pixel's (at least 1) Lw white, and the channels are
+ * scaled by that, keeping their hue; images no brighter than white stay as they are
+ */
+export declare function toSRGB(rgb: Float32Array, toneMapping: ToneMapping): Uint8Array;
+/** the white of SDR content in HDR (BT.2408, cd/m²): linear light 1 */
+export declare const REFERENCE_WHITE = 203;
+/**
+ * Non-linear PQ (SMPTE ST 2084, transfer 16) or HLG (BT.2100, 18) RGB (3 values per pixel, primaries as CICP codes) as
+ * linear light (in place) with BT.709 primaries, 1 being the reference white (203 cd/m²): HLG is displayed as on a
+ * 1000 cd/m² display (BT.2100's OOTF, gamma 1.2)
+ */
+export declare function hdrToLinear(rgb: Float32Array, transfer: number, primaries: number): Float32Array;
+/** Whether the data starts like a Radiance HDR */
+export declare function isHDR(d: Uint8Array): boolean;
+/** Decodes a Radiance HDR into RGBA */
+export declare function decode(d: Uint8Array, maxPixels?: number, toneMapping?: ToneMapping): {
+    width: number;
+    height: number;
+    pixels: Uint8Array;
+};

package/dist/codecs/hdr.js

@@ -0,0 +1,201 @@
+import { MAX_PIXELS, checkPixels } from "../util/limits.js";
+function linearToSRGB(v) {
+    if (!(v > 0))
+        return 0;
+    if (v >= 1)
+        return 255;
+    return Math.round(255 * (v <= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055));
+}
+export function toSRGB(rgb, toneMapping) {
+    const count = rgb.length / 3;
+    const luminance = (i) => 0.2126 * rgb[i] + 0.7152 * rgb[i + 1] + 0.0722 * rgb[i + 2];
+    let white = 1;
+    if (toneMapping === 'reinhard')
+        for (let i = 0; i < rgb.length; i += 3)
+            white = Math.max(white, luminance(i));
+    const white2 = white * white;
+    const pixels = new Uint8Array(count * 4);
+    for (let i = 0, p = 0; i < rgb.length; i += 3, p += 4) {
+        let scale = 1;
+        if (white > 1) {
+            const l = Math.max(0, luminance(i));
+            scale = (1 + l / white2) / (1 + l);
+        }
+        pixels[p] = linearToSRGB(rgb[i] * scale);
+        pixels[p + 1] = linearToSRGB(rgb[i + 1] * scale);
+        pixels[p + 2] = linearToSRGB(rgb[i + 2] * scale);
+        pixels[p + 3] = 255;
+    }
+    return pixels;
+}
+const PRIMARIES_BT2020 = 9, PRIMARIES_P3 = 12;
+export const REFERENCE_WHITE = 203;
+export function hdrToLinear(rgb, transfer, primaries) {
+    const m1 = 2610 / 16384, m2 = 2523 / 4096 * 128, c1 = 3424 / 4096, c2 = 2413 / 4096 * 32, c3 = 2392 / 4096 * 32;
+    const pq = (v) => {
+        const e = (v <= 0 ? 0 : v >= 1 ? 1 : v) ** (1 / m2);
+        return 10000 / REFERENCE_WHITE * (Math.max(e - c1, 0) / (c2 - c3 * e)) ** (1 / m1);
+    };
+    const a = 0.17883277, b = 1 - 4 * a, c = 0.5 - a * Math.log(4 * a);
+    const hlg = (v) => {
+        const e = v <= 0 ? 0 : v >= 1 ? 1 : v;
+        return e <= 0.5 ? e * e / 3 : (Math.exp((e - c) / a) + b) / 12;
+    };
+    const matrix = primaries === PRIMARIES_BT2020 ? [1.660491, -0.587641, -0.072850, -0.124550, 1.132900, -0.008349, -0.018151, -0.100579, 1.118730] :
+        primaries === PRIMARIES_P3 ? [1.224940, -0.224940, 0, -0.042057, 1.042057, 0, -0.019638, -0.078636, 1.098274] : null;
+    for (let i = 0; i < rgb.length; i += 3) {
+        let r, g, bl;
+        if (transfer === 16) {
+            r = pq(rgb[i]);
+            g = pq(rgb[i + 1]);
+            bl = pq(rgb[i + 2]);
+        }
+        else {
+            r = hlg(rgb[i]);
+            g = hlg(rgb[i + 1]);
+            bl = hlg(rgb[i + 2]);
+            const ys = 0.2627 * r + 0.6780 * g + 0.0593 * bl;
+            const gain = ys > 0 ? 1000 / REFERENCE_WHITE * ys ** 0.2 : 0;
+            r *= gain;
+            g *= gain;
+            bl *= gain;
+        }
+        if (matrix) {
+            rgb[i] = matrix[0] * r + matrix[1] * g + matrix[2] * bl;
+            rgb[i + 1] = matrix[3] * r + matrix[4] * g + matrix[5] * bl;
+            rgb[i + 2] = matrix[6] * r + matrix[7] * g + matrix[8] * bl;
+        }
+        else {
+            rgb[i] = r;
+            rgb[i + 1] = g;
+            rgb[i + 2] = bl;
+        }
+    }
+    return rgb;
+}
+const ascii = (d, start, end) => String.fromCharCode(...d.subarray(start, end));
+export function isHDR(d) {
+    const start = ascii(d, 0, 10);
+    return start === '#?RADIANCE' || start.startsWith('#?RGBE');
+}
+const XYZ_TO_RGB = (() => {
+    const inverse = ([a, b, c, d, e, f, g, h, i]) => {
+        const det = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
+        return [e * i - f * h, c * h - b * i, b * f - c * e, f * g - d * i, a * i - c * g, c * d - a * f, d * h - e * g, b * g - a * h, a * e - b * d].map(v => v / det);
+    };
+    const [r, g, b] = [[0.640, 0.330], [0.290, 0.600], [0.150, 0.060]].map(([x, y]) => [x / y, 1, (1 - x - y) / y]);
+    const primaries = [r[0], g[0], b[0], r[1], g[1], b[1], r[2], g[2], b[2]];
+    const inv = inverse(primaries);
+    const scale = [0, 1, 2].map(row => inv[row * 3] + inv[row * 3 + 1] + inv[row * 3 + 2]);
+    return inverse(primaries.map((v, i) => v * scale[i % 3]));
+})();
+export function decode(d, maxPixels = MAX_PIXELS, toneMapping = 'reinhard') {
+    if (!isHDR(d))
+        throw new Error('HDR: invalid header');
+    let o = 0, xyz = false;
+    for (;;) {
+        let end = o;
+        while (end < d.length && d[end] !== 0x0a)
+            end++;
+        if (end >= d.length)
+            throw new Error('HDR: truncated header');
+        const line = ascii(d, o, end);
+        o = end + 1;
+        if (!line)
+            break;
+        if (line.startsWith('FORMAT=')) {
+            const format = line.slice(7).trim();
+            if (format !== '32-bit_rle_rgbe' && format !== '32-bit_rle_xyze')
+                throw new Error(`HDR: unsupported format ${format}`);
+            xyz = format === '32-bit_rle_xyze';
+        }
+    }
+    let end = o;
+    while (end < d.length && d[end] !== 0x0a)
+        end++;
+    const resolution = /^([-+])([XY]) (\d+) ([-+])([XY]) (\d+)$/.exec(ascii(d, o, Math.min(end, o + 64)).trim());
+    if (!resolution || resolution[2] === resolution[5])
+        throw new Error('HDR: invalid resolution');
+    o = end + 1;
+    const [, sign1, axis1, n1, sign2, , n2] = resolution;
+    const lines = +n1, length = +n2;
+    const columns = axis1 === 'X';
+    const width = columns ? lines : length, height = columns ? length : lines;
+    if (!width || !height)
+        throw new Error(`HDR: invalid dimensions ${width}x${height}`);
+    checkPixels(width, height, maxPixels);
+    const rgb = new Float32Array(width * height * 3);
+    const line = new Uint8Array(length * 4);
+    for (let s = 0; s < lines; s++) {
+        o = readLine(d, o, line, length);
+        for (let i = 0; i < length; i++) {
+            const x = columns ? (sign1 === '+' ? s : width - 1 - s) : sign2 === '+' ? i : width - 1 - i;
+            const y = columns ? (sign2 === '-' ? i : height - 1 - i) : sign1 === '-' ? s : height - 1 - s;
+            const p = (y * width + x) * 3, e = line[i * 4 + 3];
+            if (e) {
+                const f = 2 ** (e - 136);
+                let r = line[i * 4] * f, g = line[i * 4 + 1] * f, b = line[i * 4 + 2] * f;
+                if (xyz) {
+                    const m = XYZ_TO_RGB;
+                    [r, g, b] = [m[0] * r + m[1] * g + m[2] * b, m[3] * r + m[4] * g + m[5] * b, m[6] * r + m[7] * g + m[8] * b];
+                }
+                rgb[p] = r;
+                rgb[p + 1] = g;
+                rgb[p + 2] = b;
+            }
+        }
+    }
+    return { width, height, pixels: toSRGB(rgb, toneMapping) };
+}
+function readLine(d, o, line, length) {
+    if (o + 4 > d.length)
+        throw new Error('HDR: truncated image data');
+    if (length >= 8 && length < 0x8000 && d[o] === 2 && d[o + 1] === 2 && !(d[o + 2] & 0x80)) {
+        if ((d[o + 2] << 8 | d[o + 3]) !== length)
+            throw new Error('HDR: scan line of the wrong length');
+        o += 4;
+        for (let c = 0; c < 4; c++) {
+            for (let i = 0; i < length;) {
+                if (o >= d.length)
+                    throw new Error('HDR: truncated image data');
+                let n = d[o++];
+                if (n > 128) {
+                    n -= 128;
+                    if (i + n > length || o >= d.length)
+                        throw new Error('HDR: invalid run');
+                    const v = d[o++];
+                    for (; n; n--)
+                        line[i++ * 4 + c] = v;
+                }
+                else {
+                    if (!n || i + n > length || o + n > d.length)
+                        throw new Error('HDR: invalid run');
+                    for (; n; n--)
+                        line[i++ * 4 + c] = d[o++];
+                }
+            }
+        }
+        return o;
+    }
+    for (let i = 0, shift = 0; i < length;) {
+        if (o + 4 > d.length)
+            throw new Error('HDR: truncated image data');
+        if (d[o] === 1 && d[o + 1] === 1 && d[o + 2] === 1) {
+            if (!i)
+                throw new Error('HDR: repetition without a pixel');
+            const n = d[o + 3] * 2 ** shift;
+            if (i + n > length)
+                throw new Error('HDR: invalid run');
+            for (let k = 0; k < n; k++, i++)
+                line.copyWithin(i * 4, i * 4 - 4, i * 4);
+            shift += 8;
+        }
+        else {
+            line.set(d.subarray(o, o + 4), i * 4);
+            i++;
+            shift = 0;
+        }
+        o += 4;
+    }
+    return o;
+}

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

@@ -931,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;