imagescript 3.3.0 → 3.4.0

package/dist/codecs/jxl/features.js

@@ -0,0 +1,325 @@
+import { unpackSigned } from "./bits.js";
+import { EntropyDecoder } from "./entropy.js";
+import { EXTRA_ALPHA } from "./headers.js";
+import { performBlending } from "./blend.js";
+import { mirror } from "./upsample.js";
+export function readPatches(r, extra, frameWidth, frameHeight) {
+    const alphas = extra.map((e, i) => e.type === EXTRA_ALPHA ? i : -1).filter(i => i >= 0);
+    const dec = new EntropyDecoder(r, 10);
+    dec.begin(r);
+    const maxRefs = Math.min(1 << 24, Math.floor(frameWidth * frameHeight / 16));
+    const numRefs = dec.read(r, 0);
+    if (numRefs > maxRefs)
+        throw new Error('JPEG XL: too many patches');
+    const patches = [];
+    let total = 0;
+    for (let p = 0; p < numRefs; p++) {
+        const ref = dec.read(r, 1);
+        if (ref >= 4)
+            throw new Error('JPEG XL: invalid patch reference');
+        const x0 = dec.read(r, 3), y0 = dec.read(r, 3), w = dec.read(r, 2) + 1, h = dec.read(r, 2) + 1, count = dec.read(r, 7) + 1;
+        total += count;
+        if (total > maxRefs * 4)
+            throw new Error('JPEG XL: too many patches');
+        const targets = [];
+        for (let i = 0; i < count; i++) {
+            let x, y;
+            if (i) {
+                x = targets[i - 1].x + unpackSigned(dec.read(r, 6));
+                y = targets[i - 1].y + unpackSigned(dec.read(r, 6));
+            }
+            else {
+                x = dec.read(r, 4);
+                y = dec.read(r, 4);
+            }
+            const blending = [];
+            for (let c = 0; c <= extra.length; c++) {
+                const mode = dec.read(r, 5);
+                if (mode > 7)
+                    throw new Error('JPEG XL: invalid patch blend mode');
+                const alpha = mode >= 4 && alphas.length >= 2 ? dec.read(r, 8) : alphas[0] ?? 0;
+                if (mode >= 4 && alpha >= extra.length)
+                    throw new Error('JPEG XL: invalid patch alpha channel');
+                const clamp = mode >= 3 ? dec.read(r, 9) !== 0 : false;
+                blending.push({ mode, alpha, clamp });
+            }
+            targets.push({ x, y, blending });
+        }
+        patches.push({ ref, x0, y0, w, h, targets });
+    }
+    dec.finish();
+    return patches;
+}
+export function applyPatches(p, numColor, patches, references, extra) {
+    for (const patch of patches) {
+        const ref = references[patch.ref];
+        if (!ref)
+            throw new Error('JPEG XL: a patch of a missing reference');
+        if (patch.x0 + patch.w > ref.width || patch.y0 + patch.h > ref.height)
+            throw new Error('JPEG XL: a patch outside its reference');
+        for (const t of patch.targets) {
+            const x0 = Math.max(t.x, 0), x1 = Math.min(t.x + patch.w, p.width);
+            if (x1 <= x0)
+                continue;
+            for (let y = Math.max(t.y, 0); y < Math.min(t.y + patch.h, p.height); y++) {
+                const ri = (patch.y0 + y - t.y) * ref.width + patch.x0 + x0 - t.x, i = y * p.width + x0;
+                performBlending(p.channels, i, ref.channels, ri, p.channels, i, x1 - x0, numColor, t.blending[0], t.blending.slice(1), extra);
+            }
+        }
+    }
+}
+export function readSplines(r, frameWidth, frameHeight) {
+    const dec = new EntropyDecoder(r, 6);
+    dec.begin(r);
+    const pixels = frameWidth * frameHeight, maxPoints = Math.min(1 << 20, Math.floor(pixels / 2));
+    const n = dec.read(r, 2) + 1;
+    if (n > maxPoints)
+        throw new Error('JPEG XL: too many splines');
+    const starts = [];
+    for (let i = 0; i < n; i++) {
+        let x = dec.read(r, 1), y = dec.read(r, 1);
+        if (i) {
+            x = unpackSigned(x) + starts[2 * i - 2];
+            y = unpackSigned(y) + starts[2 * i - 1];
+        }
+        starts.push(x, y);
+    }
+    const quantAdjust = unpackSigned(dec.read(r, 0));
+    const splines = [];
+    let totalPoints = n;
+    for (let s = 0; s < n; s++) {
+        const count = dec.read(r, 3);
+        totalPoints += count;
+        if (totalPoints > maxPoints)
+            throw new Error('JPEG XL: too many spline points');
+        const points = [starts[2 * s], starts[2 * s + 1]];
+        let dx = 0, dy = 0;
+        for (let i = 0; i < count; i++) {
+            dx += unpackSigned(dec.read(r, 4));
+            dy += unpackSigned(dec.read(r, 4));
+            const x = points[points.length - 2] + dx, y = points[points.length - 1] + dy;
+            if (x === points[points.length - 2] && y === points[points.length - 1])
+                throw new Error('JPEG XL: identical successive spline points');
+            points.push(x, y);
+        }
+        const read32 = () => Int32Array.from({ length: 32 }, () => unpackSigned(dec.read(r, 5)));
+        const color = [read32(), read32(), read32()];
+        splines.push({ points, color, sigma: read32() });
+    }
+    dec.finish();
+    return { quantAdjust, splines };
+}
+const CHANNEL_WEIGHT = [0.0042, 0.075, 0.07, 0.3333];
+const llround = (x) => x < 0 ? -Math.round(-x) : Math.round(x);
+function continuousIDCT(dct, t) {
+    let sum = 0;
+    for (let i = 0; i < 32; i++)
+        sum += Math.SQRT2 * dct[i] * Math.cos(Math.PI / 32 * i * (t + 0.5));
+    return sum;
+}
+function erf(x) {
+    const ax = Math.abs(x);
+    const d = (((ax * 7.77394369e-02 + 2.05260015e-04) * ax + 2.32120216e-01) * ax + 2.77820801e-01) * ax + 1;
+    const inv = 1 / (d * d), r = 1 - inv * inv;
+    return x <= 0 ? -r : r;
+}
+function catmullRom(p) {
+    const n = p.length / 2;
+    if (n === 1)
+        return p.slice();
+    const pts = [2 * p[0] - p[2], 2 * p[1] - p[3], ...p, 2 * p[2 * n - 2] - p[2 * n - 4], 2 * p[2 * n - 1] - p[2 * n - 3]];
+    const out = [];
+    for (let s = 0; s + 3 < pts.length / 2; s++) {
+        const P = (k) => [pts[2 * (s + k)], pts[2 * (s + k) + 1]];
+        out.push(...P(1));
+        const d = [], t = [0];
+        for (let k = 0; k < 3; k++) {
+            const [ax, ay] = P(k), [bx, by] = P(k + 1);
+            d.push(Math.sqrt(Math.hypot(bx - ax, by - ay)));
+            t.push(t[k] + d[k]);
+        }
+        for (let i = 1; i < 16; i++) {
+            const tt = d[0] + i / 16 * d[1];
+            const a = [];
+            for (let k = 0; k < 3; k++) {
+                const [ax, ay] = P(k), [bx, by] = P(k + 1), m = (tt - t[k]) / d[k];
+                a.push([ax + m * (bx - ax), ay + m * (by - ay)]);
+            }
+            const b = [];
+            for (let k = 0; k < 2; k++) {
+                const m = (tt - t[k]) / (d[k] + d[k + 1]);
+                b.push([a[k][0] + m * (a[k + 1][0] - a[k][0]), a[k][1] + m * (a[k + 1][1] - a[k][1])]);
+            }
+            const m = (tt - t[1]) / d[1];
+            out.push(b[0][0] + m * (b[1][0] - b[0][0]), b[0][1] + m * (b[1][1] - b[0][1]));
+        }
+    }
+    out.push(pts[pts.length - 4], pts[pts.length - 3]);
+    return out;
+}
+export function renderSplines(p, s, baseX, baseB) {
+    const inv = s.quantAdjust >= 0 ? 1 / (1 + 0.125 * s.quantAdjust) : 1 - 0.125 * s.quantAdjust;
+    const [cx, cy, cb] = p.channels, W = p.width, H = p.height;
+    for (const spline of s.splines) {
+        const color = [0, 1, 2].map(c => Float64Array.from(spline.color[c], (v, i) => v * (i ? 1 : Math.SQRT1_2) * CHANNEL_WEIGHT[c] * inv));
+        for (let i = 0; i < 32; i++) {
+            color[0][i] += baseX * color[1][i];
+            color[2][i] += baseB * color[1][i];
+        }
+        const sigmaDct = Float64Array.from(spline.sigma, (v, i) => v * (i ? 1 : Math.SQRT1_2) * CHANNEL_WEIGHT[3] * inv);
+        const curve = catmullRom(spline.points), points = [];
+        let px = curve[0], py = curve[1];
+        points.push(px, py, 1);
+        for (let next = 0; next < curve.length / 2;) {
+            let prevX = px, prevY = py, along = 0;
+            for (;;) {
+                if (next >= curve.length / 2) {
+                    points.push(prevX, prevY, along);
+                    next = Infinity;
+                    break;
+                }
+                const nx = curve[2 * next], ny = curve[2 * next + 1], toNext = Math.sqrt((nx - prevX) ** 2 + (ny - prevY) ** 2);
+                if (along + toNext >= 1) {
+                    const m = (1 - along) / toNext;
+                    px = prevX + m * (nx - prevX);
+                    py = prevY + m * (ny - prevY);
+                    points.push(px, py, 1);
+                    break;
+                }
+                along += toNext;
+                prevX = nx;
+                prevY = ny;
+                next++;
+            }
+        }
+        const count = points.length / 3, arcLength = count - 2 + points[points.length - 1];
+        if (arcLength <= 0)
+            continue;
+        for (let k = 0; k < count; k++) {
+            const x = points[3 * k], y = points[3 * k + 1], intensity = points[3 * k + 2];
+            const progress = Math.min(1, k / arcLength);
+            const c = [0, 1, 2].map(ch => continuousIDCT(color[ch], 31 * progress));
+            const sigma = continuousIDCT(sigmaDct, 31 * progress);
+            if (!(Number.isFinite(sigma) && sigma !== 0 && Number.isFinite(1 / sigma) && Number.isFinite(intensity)))
+                continue;
+            let maxColor = 0.01;
+            for (let ch = 0; ch < 3; ch++)
+                maxColor = Math.max(maxColor, Math.abs(c[ch] * intensity));
+            const maxDistance = Math.sqrt(-2 * sigma * sigma * (Math.log(0.1) * 3 - Math.log(maxColor)));
+            const invSigma = 1 / sigma, k4 = 0.25 * sigma * intensity;
+            const y0 = Math.max(llround(y - maxDistance), 0), y1 = Math.min(llround(y + maxDistance) + 1, H);
+            const x0 = Math.max(llround(x - maxDistance), 0), x1 = Math.min(llround(x + maxDistance) + 1, W);
+            for (let yy = y0; yy < y1; yy++) {
+                const dy = yy - y;
+                for (let xx = x0; xx < x1; xx++) {
+                    const dx = xx - x, distance = Math.sqrt(dx * dx + dy * dy);
+                    const f = erf((distance * 0.5 + 0.353553391) * invSigma) - erf((distance * 0.5 - 0.353553391) * invSigma);
+                    const local = k4 * f * f, i = yy * W + xx;
+                    cx[i] += c[0] * local;
+                    cy[i] += c[1] * local;
+                    cb[i] += c[2] * local;
+                }
+            }
+        }
+    }
+}
+export function readNoise(r) {
+    return Array.from({ length: 8 }, () => r.bits(10) / 1024);
+}
+const M64 = (1n << 64n) - 1n;
+function splitMix64(z) {
+    z = ((z ^ (z >> 30n)) * 0xbf58476d1ce4e5b9n) & M64;
+    z = ((z ^ (z >> 27n)) * 0x94d049bb133111ebn) & M64;
+    return z ^ (z >> 31n);
+}
+class Xorshift128Plus {
+    s0 = new Uint32Array(16);
+    s1 = new Uint32Array(16);
+    constructor(seed1, seed2, seed3, seed4) {
+        const s0 = [splitMix64(((BigInt(seed1) << 32n) + BigInt(seed2) + 0x9e3779b97f4a7c15n) & M64)];
+        const s1 = [splitMix64(((BigInt(seed3) << 32n) + BigInt(seed4) + 0x9e3779b97f4a7c15n) & M64)];
+        for (let i = 1; i < 8; i++) {
+            s0.push(splitMix64(s0[i - 1]));
+            s1.push(splitMix64(s1[i - 1]));
+        }
+        for (let i = 0; i < 8; i++) {
+            this.s0[2 * i] = Number(s0[i] & 0xffffffffn);
+            this.s0[2 * i + 1] = Number(s0[i] >> 32n);
+            this.s1[2 * i] = Number(s1[i] & 0xffffffffn);
+            this.s1[2 * i + 1] = Number(s1[i] >> 32n);
+        }
+    }
+    fill(out) {
+        for (let i = 0; i < 8; i++) {
+            let aLo = this.s0[2 * i], aHi = this.s0[2 * i + 1];
+            const bLo = this.s1[2 * i], bHi = this.s1[2 * i + 1];
+            const lo = (aLo + bLo) >>> 0;
+            out[2 * i] = lo;
+            out[2 * i + 1] = (aHi + bHi + (lo < aLo ? 1 : 0)) >>> 0;
+            this.s0[2 * i] = bLo;
+            this.s0[2 * i + 1] = bHi;
+            aHi = (aHi ^ ((aHi << 23) | (aLo >>> 9))) >>> 0;
+            aLo = (aLo ^ (aLo << 23)) >>> 0;
+            const a18Lo = ((aLo >>> 18) | (aHi << 14)) >>> 0, a18Hi = aHi >>> 18;
+            const b5Lo = ((bLo >>> 5) | (bHi << 27)) >>> 0, b5Hi = bHi >>> 5;
+            this.s1[2 * i] = (aLo ^ bLo ^ a18Lo ^ b5Lo) >>> 0;
+            this.s1[2 * i + 1] = (aHi ^ bHi ^ a18Hi ^ b5Hi) >>> 0;
+        }
+    }
+}
+const f32 = new Float32Array(1), u32 = new Uint32Array(f32.buffer);
+export function renderNoise(p, lut, groupDim, visible, invisible, baseX, baseB) {
+    const W = p.width, H = p.height;
+    const rnd = [new Float32Array(W * H), new Float32Array(W * H), new Float32Array(W * H)], batch = new Uint32Array(16);
+    for (let ty = 0; ty < H; ty += groupDim) {
+        for (let tx = 0; tx < W; tx += groupDim) {
+            const rng = new Xorshift128Plus(visible, invisible, tx, ty), tw = Math.min(groupDim, W - tx);
+            for (const plane of rnd) {
+                for (let y = ty; y < Math.min(ty + groupDim, H); y++) {
+                    for (let x = 0; x < tw; x += 16) {
+                        rng.fill(batch);
+                        for (let k = 0; k < 16 && x + k < tw; k++) {
+                            u32[0] = (batch[k] >>> 9) | 0x3f800000;
+                            plane[y * W + tx + x + k] = f32[0];
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const conv = rnd.map(src => {
+        const out = new Float32Array(W * H);
+        for (let y = 0; y < H; y++) {
+            for (let x = 0; x < W; x++) {
+                let others = 0;
+                for (let dy = -2; dy <= 2; dy++) {
+                    const row = mirror(y + dy, H) * W;
+                    for (let dx = -2; dx <= 2; dx++)
+                        if (dx || dy)
+                            others += src[row + mirror(x + dx, W)];
+                }
+                out[y * W + x] = others * 0.16 - src[y * W + x] * 3.84;
+            }
+        }
+        return out;
+    });
+    const strength = (v) => {
+        const scaled = Math.max(0, v * 6);
+        let floor = Math.floor(scaled), frac = scaled - floor;
+        if (scaled >= 7) {
+            floor = 6;
+            frac = 1;
+        }
+        const s = (lut[floor + 1] - lut[floor]) * frac + lut[floor];
+        return s < 0 ? 0 : s > 1 ? 1 : s;
+    };
+    const [X, Y, B] = p.channels;
+    for (let i = 0; i < W * H; i++) {
+        const sg = strength((Y[i] - X[i]) * 0.5), sr = strength((Y[i] + X[i]) * 0.5);
+        const r = conv[0][i] * 0.22, g = conv[1][i] * 0.22, c = conv[2][i] * 0.22;
+        const red = sr * (0.0078125 * r + 0.9921875 * c), green = sg * (0.0078125 * g + 0.9921875 * c), rg = red + green;
+        X[i] += baseX * rg + red - green;
+        Y[i] += rg;
+        B[i] += baseB * rg;
+    }
+}

package/dist/codecs/jxl/filters.js

@@ -0,0 +1,119 @@
+import { mirror } from "./upsample.js";
+export function gaborish(channels, w, h, weights) {
+    return channels.map((src, c) => {
+        const w0 = weights[2 * c], w1 = weights[2 * c + 1], norm = 1 / (1 + 4 * w0 + 4 * w1);
+        const out = new Float32Array(w * h);
+        for (let y = 0; y < h; y++) {
+            const t = mirror(y - 1, h) * w, m = y * w, b = mirror(y + 1, h) * w;
+            for (let x = 0; x < w; x++) {
+                const l = mirror(x - 1, w), r = mirror(x + 1, w);
+                out[m + x] = (src[m + x] + (src[t + x] + src[b + x] + src[m + l] + src[m + r]) * w0 + (src[t + l] + src[t + r] + src[b + l] + src[b + r]) * w1) * norm;
+            }
+        }
+        return out;
+    });
+}
+const STEPS = [
+    { u: [0, 1, 0, 2, 1, 0, 2, 0, 1, 1, -1, 1], plus: true },
+    { u: [0, 1, 1, 0], plus: true },
+    { u: [0, 1, 1, 0], plus: false }
+];
+const STRIP = 128;
+function diffRow(i0, i1, i2, ry, ruy, xs, ux, d, o, pw, s0, s1, s2) {
+    const lo = Math.max(3, 3 - ux), hi = Math.min(pw - 3, pw - 3 - ux);
+    for (let px = 0; px < pw; px++) {
+        if (px === lo && lo < hi) {
+            for (let a = ry + px - 3, b = ruy + px - 3 + ux; px < hi; px++, a++, b++) {
+                d[o + px] = s0 * Math.abs(i0[b] - i0[a]) + s1 * Math.abs(i1[b] - i1[a]) + s2 * Math.abs(i2[b] - i2[a]);
+            }
+            if (px >= pw)
+                break;
+        }
+        const a = ry + xs[px + 2], b = ruy + xs[px + 2 + ux];
+        d[o + px] = s0 * Math.abs(i0[b] - i0[a]) + s1 * Math.abs(i1[b] - i1[a]) + s2 * Math.abs(i2[b] - i2[a]);
+    }
+}
+function plusRow(d, sum, o, pw) {
+    for (let px = 1, k = o + 1; px < pw - 1; px++, k++)
+        sum[k] = d[k] + d[k - 1] + d[k + 1] + d[k - pw] + d[k + pw];
+}
+function outputRow(cur, out, y, w, sums, p0, pw, u, rows, xs, sigma, sigmaRow, sigmaModular, stepMul, borderMul) {
+    const [i0, i1, i2] = cur, [o0, o1, o2] = out, n = u.length / 2, yBorder = ((y + 1) & 6) === 0;
+    const innerRow = rows[0] === (y - 2) * w && rows[4] === (y + 2) * w;
+    const row = y * w;
+    for (let x = 0; x < w; x++) {
+        const i = row + x;
+        const sg = sigma ? sigma[sigmaRow + (x >> 3)] : sigmaModular;
+        if (sg < 0.3) {
+            o0[i] = i0[i];
+            o1[i] = i1[i];
+            o2[i] = i2[i];
+            continue;
+        }
+        const sm = yBorder || (x & 7) === 0 || (x & 7) === 7 ? stepMul * borderMul : stepMul;
+        const negInvSigma = 6.6 * (Math.SQRT1_2 - 1) / sg * sm;
+        let sumW = 1, sum0 = i0[i], sum1 = i1[i], sum2 = i2[i];
+        const p = p0 + x, inner = innerRow && x >= 2 && x < w - 2;
+        for (let k = 0; k < n; k++) {
+            const ux = u[2 * k], uy = u[2 * k + 1], sum = sums[k];
+            let weight = 1 + sum[p] * negInvSigma;
+            if (weight > 0) {
+                const t = inner ? i + uy * w + ux : rows[2 + uy] + xs[x + 5 + ux];
+                sumW += weight;
+                sum0 += weight * i0[t];
+                sum1 += weight * i1[t];
+                sum2 += weight * i2[t];
+            }
+            weight = 1 + sum[p - uy * pw - ux] * negInvSigma;
+            if (weight > 0) {
+                const t = inner ? i - uy * w - ux : rows[2 - uy] + xs[x + 5 - ux];
+                sumW += weight;
+                sum0 += weight * i0[t];
+                sum1 += weight * i1[t];
+                sum2 += weight * i2[t];
+            }
+        }
+        o0[i] = sum0 / sumW;
+        o1[i] = sum1 / sumW;
+        o2[i] = sum2 / sumW;
+    }
+}
+export function epf(channels, w, h, e, sigma, bw) {
+    let cur = channels;
+    const steps = e.iters === 3 ? [0, 1, 2] : e.iters === 2 ? [1, 2] : [1];
+    const pw = w + 6, ph = STRIP + 6;
+    const diffs = Array.from({ length: 6 }, () => new Float64Array(pw * ph)), sums = Array.from({ length: 6 }, () => new Float64Array(pw * ph));
+    const xs = new Int32Array(w + 10);
+    for (let x = 0; x < xs.length; x++)
+        xs[x] = mirror(x - 5, w);
+    const rows = new Int32Array(5);
+    for (const step of steps) {
+        const out = [new Float32Array(w * h), new Float32Array(w * h), new Float32Array(w * h)];
+        const { u, plus } = STEPS[step], n = u.length / 2;
+        const stepMul = step === 0 ? e.pass0SigmaScale : step === 2 ? e.pass2SigmaScale : 1;
+        const [s0, s1, s2] = e.channelScale;
+        const [i0, i1, i2] = cur;
+        for (let y0 = 0; y0 < h; y0 += STRIP) {
+            const strip = Math.min(STRIP, h - y0);
+            for (let k = 0; k < n; k++) {
+                const ux = u[2 * k], uy = u[2 * k + 1], d = diffs[k], sum = sums[k];
+                for (let py = 0; py < strip + 6; py++) {
+                    diffRow(i0, i1, i2, mirror(y0 + py - 3, h) * w, mirror(y0 + py - 3 + uy, h) * w, xs, ux, d, py * pw, pw, s0, s1, s2);
+                }
+                if (!plus)
+                    sum.set(d);
+                else
+                    for (let py = 1; py < strip + 5; py++)
+                        plusRow(d, sum, py * pw, pw);
+            }
+            for (let ry = 0; ry < strip; ry++) {
+                const y = y0 + ry;
+                for (let k = 0; k < 5; k++)
+                    rows[k] = mirror(y + k - 2, h) * w;
+                outputRow(cur, out, y, w, sums, (ry + 3) * pw + 3, pw, u, rows, xs, sigma, (y >> 3) * bw, e.sigmaForModular, stepMul, e.borderSadMul);
+            }
+        }
+        cur = out;
+    }
+    return cur;
+}

package/dist/codecs/jxl/frame-header.js

@@ -0,0 +1,195 @@
+import { extensions, unpackSigned } from "./bits.js";
+import { EntropyDecoder, readPermutation } from "./entropy.js";
+export const FRAME_REGULAR = 0, FRAME_LF = 1, FRAME_REFERENCE = 2, FRAME_SKIP_PROGRESSIVE = 3;
+export const BLEND_REPLACE = 0, BLEND_ADD = 1, BLEND_BLEND = 2, BLEND_MULADD = 3, BLEND_MUL = 4;
+export const FLAG_NOISE = 1, FLAG_PATCHES = 2, FLAG_SPLINES = 16, FLAG_USE_LF_FRAME = 32, FLAG_SKIP_ADAPTIVE_LF_SMOOTHING = 128;
+const DEFAULT_EPF = () => ({
+    iters: 2, sharpLut: [0, 1 / 7, 2 / 7, 3 / 7, 4 / 7, 5 / 7, 6 / 7, 1], channelScale: [40, 5, 3.5],
+    quantMul: 0.46, pass0SigmaScale: 0.9, pass2SigmaScale: 6.5, borderSadMul: 2 / 3, sigmaForModular: 1
+});
+const DEFAULT_GAB = [0.115169525, 0.061248592, 0.115169525, 0.061248592, 0.115169525, 0.061248592];
+function blendingInfo(r, haveExtra, resets, mainMode = -1) {
+    const mode = r.u32(0, 1, 2, [3, 2]);
+    if (mode > 4)
+        throw new Error('JPEG XL: invalid blend mode');
+    const usesAlpha = haveExtra && (mode === BLEND_BLEND || mode === BLEND_MULADD);
+    const alphaChannel = usesAlpha ? r.u32(0, 1, 2, [3, 3]) : 0;
+    const clamp = usesAlpha || mode === BLEND_MUL ? r.bool() : false;
+    const source = resets(mainMode >= 0 ? mainMode : mode) ? 0 : r.bits(2);
+    return { mode, alphaChannel, clamp, source };
+}
+function epf(r, modular) {
+    const iters = r.bits(2);
+    if (!iters)
+        return null;
+    const e = DEFAULT_EPF();
+    e.iters = iters;
+    if (!modular && r.bool())
+        e.sharpLut = Array.from({ length: 8 }, () => r.f16());
+    if (r.bool()) {
+        e.channelScale = [r.f16(), r.f16(), r.f16()];
+        r.bits(32);
+    }
+    if (r.bool()) {
+        if (!modular)
+            e.quantMul = r.f16();
+        e.pass0SigmaScale = r.f16();
+        e.pass2SigmaScale = r.f16();
+        e.borderSadMul = r.f16();
+    }
+    if (modular)
+        e.sigmaForModular = r.f16();
+    return e;
+}
+export function frameHeader(r, image) {
+    const numExtra = image.extraChannels.length;
+    const allDefault = r.bool();
+    const type = allDefault ? FRAME_REGULAR : r.bits(2);
+    const modular = allDefault ? false : r.bool();
+    const flags = allDefault ? 0 : r.u64();
+    const doYCbCr = !allDefault && !image.xybEncoded ? r.bool() : false;
+    const useLfFrame = (flags & FLAG_USE_LF_FRAME) !== 0;
+    const grey = image.colour.colourSpace === 1;
+    const encodedColorChannels = modular && !doYCbCr && !image.xybEncoded && grey ? 1 : 3;
+    const jpegUpsampling = doYCbCr && !useLfFrame ? [r.bits(2), r.bits(2), r.bits(2)] : [0, 0, 0];
+    let upsampling = 1, ecUpsampling = image.extraChannels.map(e => 1 << e.dimShift);
+    if (!allDefault && !useLfFrame) {
+        upsampling = r.u32(1, 2, 4, 8);
+        ecUpsampling = image.extraChannels.map(e => r.u32(1, 2, 4, 8) << e.dimShift);
+    }
+    const groupSizeShift = modular ? r.bits(2) : 1;
+    let xqmScale = image.xybEncoded && !modular ? 3 : 2, bqmScale = 2;
+    if (!allDefault && image.xybEncoded && !modular) {
+        xqmScale = r.bits(3);
+        bqmScale = r.bits(3);
+    }
+    let numPasses = 1, passShift = [];
+    const downsample = [], lastPass = [];
+    if (!allDefault && type !== FRAME_REFERENCE) {
+        numPasses = r.u32(1, 2, 3, [4, 3]);
+        if (numPasses !== 1) {
+            const numDs = r.u32(0, 1, 2, [3, 1]);
+            if (numDs >= numPasses)
+                throw new Error('JPEG XL: invalid passes');
+            for (let i = 0; i < numPasses - 1; i++)
+                passShift.push(r.bits(2));
+            for (let i = 0; i < numDs; i++)
+                downsample.push(r.u32(1, 2, 4, 8));
+            for (let i = 0; i < numDs; i++)
+                lastPass.push(r.u32(0, 1, 2, [0, 3]));
+        }
+        else
+            passShift = [];
+    }
+    if (passShift.length < numPasses - 1)
+        passShift = new Array(numPasses - 1).fill(0);
+    const lfLevel = type === FRAME_LF ? 1 + r.bits(2) : 0;
+    const haveCrop = !allDefault && type !== FRAME_LF ? r.bool() : false;
+    let x0 = 0, y0 = 0, width = image.width, height = image.height;
+    if (haveCrop) {
+        const d = [[0, 8], [256, 11], [2304, 14], [18688, 30]];
+        if (type !== FRAME_REFERENCE) {
+            x0 = unpackSigned(r.u32(...d));
+            y0 = unpackSigned(r.u32(...d));
+        }
+        width = r.u32(...d);
+        height = r.u32(...d);
+    }
+    const resets = (mode) => mode === BLEND_REPLACE && (!haveCrop || (x0 <= 0 && y0 <= 0 && x0 + width >= image.width && y0 + height >= image.height));
+    const normal = type === FRAME_REGULAR || type === FRAME_SKIP_PROGRESSIVE;
+    let blending = { mode: BLEND_REPLACE, alphaChannel: 0, clamp: false, source: 0 };
+    const ecBlending = [];
+    if (!allDefault && normal) {
+        blending = blendingInfo(r, numExtra > 0, resets);
+        for (let i = 0; i < numExtra; i++)
+            ecBlending.push(blendingInfo(r, true, resets, blending.mode));
+    }
+    else
+        for (let i = 0; i < numExtra; i++)
+            ecBlending.push({ ...blending });
+    let duration = 0, isLast = type === FRAME_REGULAR, saveAsReference = 0;
+    if (!allDefault && normal) {
+        if (image.animation) {
+            duration = r.u32(0, 1, [0, 8], [0, 32]);
+            if (image.animation.haveTimecodes)
+                r.bits(32);
+        }
+        isLast = r.bool();
+    }
+    if (!allDefault && type !== FRAME_LF && !isLast)
+        saveAsReference = r.bits(2);
+    const resetsCanvas = resets(blending.mode);
+    let saveBeforeCT = !normal;
+    if (!allDefault && (type === FRAME_REFERENCE || (resetsCanvas && !isLast && (duration === 0 || saveAsReference !== 0) && type !== FRAME_LF)))
+        saveBeforeCT = r.bool();
+    let gab = DEFAULT_GAB, filter = DEFAULT_EPF();
+    if (!allDefault) {
+        r.skipBits(8 * r.u32(0, [0, 4], [16, 5], [48, 10]));
+        if (!r.bool()) {
+            gab = null;
+            if (r.bool()) {
+                gab = r.bool() ? Array.from({ length: 6 }, () => r.f16()) : DEFAULT_GAB;
+                for (let c = 0; c < 3; c++)
+                    if (Math.abs(1 + 4 * (gab[2 * c] + gab[2 * c + 1])) < 1.1920929e-7)
+                        throw new Error('JPEG XL: invalid Gaborish weights');
+            }
+            filter = epf(r, modular);
+            extensions(r);
+        }
+        extensions(r);
+    }
+    if (ecUpsampling.some(u => u < upsampling || u > 8))
+        throw new Error('JPEG XL: invalid extra channel upsampling');
+    const upsampledWidth = Math.ceil(width / 8 ** lfLevel), upsampledHeight = Math.ceil(height / 8 ** lfLevel);
+    const sampleWidth = Math.ceil(upsampledWidth / upsampling), sampleHeight = Math.ceil(upsampledHeight / upsampling);
+    const groupDim = 128 << groupSizeShift, groupsPerRow = Math.ceil(sampleWidth / groupDim), lfGroupsPerRow = Math.ceil(sampleWidth / (groupDim * 8));
+    return {
+        type, modular, flags, doYCbCr, encodedColorChannels, jpegUpsampling, upsampling, ecUpsampling, groupSizeShift, xqmScale, bqmScale,
+        numPasses, passShift, downsample, lastPass, lfLevel, haveCrop, x0, y0, width, height, blending, ecBlending, duration, isLast,
+        saveAsReference, resetsCanvas, saveBeforeCT, gab, epf: filter, upsampledWidth, upsampledHeight, sampleWidth, sampleHeight, groupDim, groupsPerRow,
+        numGroups: groupsPerRow * Math.ceil(sampleHeight / groupDim), lfGroupsPerRow, numLfGroups: lfGroupsPerRow * Math.ceil(sampleHeight / (groupDim * 8))
+    };
+}
+export function passShifts(f, pass) {
+    let max = 2, min = 3;
+    for (let i = 0;; i++) {
+        for (let j = 0; j < f.downsample.length; j++) {
+            if (i === f.lastPass[j])
+                min = [0, 0, 1, 0, 2, 0, 0, 0, 3][f.downsample[j]];
+        }
+        if (i === f.numPasses - 1)
+            min = 0;
+        if (i === pass)
+            return [min, max];
+        max = min - 1;
+    }
+}
+export function toc(r, f) {
+    const single = f.numGroups === 1 && f.numPasses === 1;
+    const count = single ? 1 : 1 + f.numLfGroups + 1 + f.numGroups * f.numPasses;
+    if (count > 65536)
+        throw new Error('JPEG XL: too many sections');
+    let permutation = null;
+    if (r.bool()) {
+        const dec = new EntropyDecoder(r, 8);
+        dec.begin(r);
+        permutation = readPermutation(r, dec, count, 0);
+        dec.finish();
+    }
+    r.zeroPadToByte();
+    const sizes = [];
+    for (let i = 0; i < count; i++)
+        sizes.push(r.u32([0, 10], [1024, 14], [17408, 22], [4211712, 30]));
+    r.zeroPadToByte();
+    const offsets = [];
+    let at = r.bytePosition;
+    for (const size of sizes) {
+        offsets.push(at);
+        at += size;
+    }
+    if (permutation) {
+        const p = permutation;
+        return { offsets: p.map(i => offsets[i]), sizes: p.map(i => sizes[i]), end: at };
+    }
+    return { offsets, sizes, end: at };
+}