@@ -1,5 +1,14 @@
 # Changelog
 
+## 3.11.0
+
+### Changes
+
+- JPEG XLs with an embedded ICC profile whose pixels are in its color space (lossless ones and recompressed JPEGs, not
+  XYB) are converted to sRGB when decoding, like the other formats' (`applyColorProfile: false` keeps the stored
+  values): the profile's stream is decoded (ported from jxl-oxide; the same profiles as libjxl's), then applied like
+  PNGs' and JPEGs'. Lossy (XYB) JPEG XLs already decode to sRGB, their profiles only say what the image was before.
+
 ## 3.10.0
 
 ### Performance
 
@@ -16,7 +16,7 @@ following projects, under their own licenses. Each derived file says so in its h
 | [dav1d](https://code.videolan.org/videolan/dav1d) by VideoLAN, the dav1d authors and Two Orioles | `src/codecs/av1/*` (the AV1 decoder, and the encoder's syntax, contexts and reconstruction mirrored from it: bitstream parsing, symbol decoding, prediction, inverse transforms, loop filters, film grain; the tables in `src/codecs/av1/data.ts`, generated from dav1d by `scripts/av1-tables.c`) | BSD-2-Clause |
 | [libaom](https://aomedia.googlesource.com/aom/) by the Alliance for Open Media | `src/codecs/av1/msac-enc.ts` (the symbol encoder), `src/codecs/av1/fdct.ts` (the forward Walsh-Hadamard transform), `src/codecs/av1/encode.ts` (the loop filter level from the quantizer), `src/codecs/avif-enc.ts` (the quantizer to qindex table) | BSD-2-Clause |
 | [libavif](https://github.com/AOMediaCodec/libavif) by Joe Drago | `src/codecs/avif.ts` (YUV to RGB conversion with bilinear chroma upsampling, alpha range expansion and unpremultiplication) | BSD-2-Clause |
-| [jxl-oxide](https://github.com/tirr-c/jxl-oxide) by Wonwoo Choi | `src/codecs/jxl/*` (the JPEG XL decoder: bit reader, header and frame header fields, entropy decoding, VarDCT, dequantization matrices, transforms, restoration filters, upsampling, the parsing of patches, splines and noise) | MIT (or Apache-2.0) |
+| [jxl-oxide](https://github.com/tirr-c/jxl-oxide) by Wonwoo Choi | `src/codecs/jxl/*` (the JPEG XL decoder: bit reader, header and frame header fields, entropy decoding, VarDCT, dequantization matrices, transforms, restoration filters, upsampling, the parsing of patches, splines and noise, the ICC profile stream) | MIT (or Apache-2.0) |
 | [libjxl](https://github.com/libjxl/libjxl) by the JPEG XL Project Authors | `src/codecs/jxl/modular.ts` (Modular decoding: MA trees, predictors, the self-correcting predictor, transforms), `src/codecs/jxl/frame.ts` (the sections of frames, the order of the rendering stages, reference frames), `src/codecs/jxl/blend.ts`, `src/codecs/jxl/color.ts` (XYB to RGB), `src/codecs/jxl/features.ts` (rendering patches, splines and noise), `src/codecs/jxl/fast-lossless.ts` (the lossless encoder: palette detection, YCoCg, the gradient predictor, prefix codes, runs as LZ77, the headers), `src/codecs/jxl/patches-enc.ts` (finding text-like patches, packing them into a reference frame, quantizing it like Modular XYB, the patch dictionary) | BSD-3-Clause |
 | [JPEG XL conformance](https://github.com/libjxl/conformance) by the JPEG XL Project Authors | `tests/jxl/alpha-*.jxl`, `animation-spline.jxl`, `blendmodes.jxl`, `mul-no-extra-channels.jxl` (test files) | BSD-3-Clause |
 | [Various smartphones - Android, Blackberry, Windows Phone, and iOS.jpg](https://commons.wikimedia.org/wiki/File:Various_smartphones_-_Android,_Blackberry,_Windows_Phone,_and_iOS.jpg) by Carlos Varela | `tests/targets/external.png` and `external.jpg` (a square of it, scaled to 638x638), the test files made from them (`tests/avif`, `tests/jxl`, `tests/ico`, `tests/hdr`, `tests/qoi`, `tests/tiffs`) and the test targets showing them; `bench/inputs/photo.jpg` (unmodified) | [CC BY 2.0](https://creativecommons.org/licenses/by/2.0/) |
 
@@ -3,9 +3,11 @@
 # ImageCms) converts them to, relative colorimetric to sRGB, as PNGs: from the source pixels for the lossless formats,
 # from what Pillow decodes for JPEG and AVIF. The profiles are matrix/TRC ones written here (Display P3 with a
 # parametric curve, Adobe RGB with a gamma, P3 with a table curve, Rec. 2020 with a type 4 parametric curve, gray), and
-# one that is sRGB (its pixels stay as they are), and a gray one on a color image (not applied). Needs Pillow (with AVIF) and numpy:
-#   python scripts/icc-fixtures.py
-import io, struct
+# one that is sRGB (its pixels stay as they are), and a gray one on a color image (not applied). Also JPEG XLs by
+# cjxl: lossless ones (their pixels are in the profile's space) and a lossy one (XYB, decoded to sRGB: its profile is
+# only what the image was before). Needs Pillow (with AVIF), numpy and cjxl (libjxl):
+#   CJXL=path/to/cjxl python scripts/icc-fixtures.py
+import io, os, struct, subprocess
 from pathlib import Path
 import numpy as np
 from PIL import Image, ImageCms
@@ -129,3 +131,8 @@ def convert(im, icc):
 convert(gray, gray_profile).save(out / 'gray.ref.png')
 # a gray profile on a color image (invalid, like libpng says: not applied)
 source.save(out / 'gray-on-rgb.png', icc_profile=gray_profile)
+
+# JPEG XLs: lossless (the pixels in the profile's space, compared with the PNGs' references) and lossy (XYB with the
+# profile, decoded to sRGB without it)
+for name, distance in [('display-p3', 0), ('gray', 0), ('rec2020', 1)]:
+    subprocess.run([os.environ.get('CJXL', 'cjxl'), '-d', str(distance), str(out / f'{name}.png'), str(out / f'{name}{"-xyb" if distance else ""}.jxl')], check=True, capture_output=True)
@@ -451,15 +451,16 @@ export class Animation extends Array<Frame> {
 
         if (type === 'jxl') {
             const frames: Frame[] = [];
-            let loopCount = -1;
+            let loopCount = -1, icc: Uint8Array | undefined;
             for await (const decoded of jxl.frames(data, maxPixels, 'reinhard', threads)) {
                 const frame = new Frame(decoded.width, decoded.height, decoded.duration, 0, 0, Frame.DISPOSAL_BACKGROUND);
                 frame.bitmap = decoded.pixels;
                 frames.push(frame.__orient__(decoded.orientation));
                 loopCount = fromPlays(decoded.loopCount);
+                icc = decoded.icc;
                 if (onlyExtractFirstFrame) break;
             }
-            return new Animation(frames, frames.length > 1 ? loopCount : -1);
+            return new Animation(profile(frames, icc), frames.length > 1 ? loopCount : -1);
         }
 
         if (type) return new Animation([Frame.from(await Image.decode(data, { maxPixels, applyColorProfile }), 0)]);
 
@@ -7,7 +7,7 @@
 import { startThreads } from '../util/threads.ts';
 import { MAX_PIXELS, checkPixels } from '../util/limits.ts';
 import { BitReader } from './jxl/bits.ts';
-import { imageHeader, skipICC } from './jxl/headers.ts';
+import { decodeICC, imageHeader, readICC } from './jxl/headers.ts';
 import { frameHeader, toc } from './jxl/frame-header.ts';
 import { decodeFrame, DecoderState, type FrameThreads } from './jxl/frame.ts';
 import { ColorOutput } from './jxl/color.ts';
@@ -73,12 +73,15 @@ function codestream(d: Uint8Array): Uint8Array {
 }
 
 /** The frames shown (composited, as RGBA), their durations in milliseconds */
-export async function* frames(data: Uint8Array, maxPixels = MAX_PIXELS, toneMapping: ToneMapping = 'reinhard', threads = 1): AsyncGenerator<{ width: number, height: number, pixels: Uint8Array, duration: number, orientation: number, loopCount: number }> {
+export async function* frames(data: Uint8Array, maxPixels = MAX_PIXELS, toneMapping: ToneMapping = 'reinhard', threads = 1): AsyncGenerator<{ width: number, height: number, pixels: Uint8Array, duration: number, orientation: number, loopCount: number, icc?: Uint8Array }> {
     const d = codestream(data);
     const r = new BitReader(d);
     const image = imageHeader(r);
     checkPixels(image.width, image.height, maxPixels);
-    if (image.colour.wantICC) skipICC(r);
+    // the embedded ICC profile: what the pixels are in unless they're XYB (which decodes to sRGB here; its profile only
+    // says what the image was before)
+    const stream = image.colour.wantICC ? readICC(r) : null;
+    const icc = stream && !image.xybEncoded ? decodeICC(stream) ?? undefined : undefined;
     r.zeroPadToByte();
     let at = r.bytePosition;
     if (image.preview) {
@@ -111,7 +114,7 @@ export async function* frames(data: Uint8Array, maxPixels = MAX_PIXELS, toneMapp
                 shown++;
                 yield {
                     width: image.width, height: image.height, pixels: state.output.toRGBA(frame.canvas), duration: frame.header.duration * tick,
-                    orientation: image.orientation, loopCount: a ? a.numLoops : 1
+                    orientation: image.orientation, loopCount: a ? a.numLoops : 1, icc
                 };
             }
             if (frame.header.isLast) return;
@@ -122,7 +125,7 @@ export async function* frames(data: Uint8Array, maxPixels = MAX_PIXELS, toneMapp
 }
 
 /** Decodes the first frame shown */
-export async function decode(data: Uint8Array, maxPixels = MAX_PIXELS, toneMapping: ToneMapping = 'reinhard', threads = 1): Promise<{ width: number, height: number, pixels: Uint8Array, orientation: number }> {
+export async function decode(data: Uint8Array, maxPixels = MAX_PIXELS, toneMapping: ToneMapping = 'reinhard', threads = 1): Promise<{ width: number, height: number, pixels: Uint8Array, orientation: number, icc?: Uint8Array }> {
     for await (const frame of frames(data, maxPixels, toneMapping, threads)) return frame;
     throw new Error('JPEG XL: no frame shown');
 }
@@ -241,12 +241,13 @@ export function imageHeader(r: BitReader): ImageHeader {
 }
 
 /** Reads (and skips) the embedded ICC profile's stream */
-export function skipICC(r: BitReader): void {
+export function readICC(r: BitReader): Uint8Array {
     const size = r.u64();
     if (size > 1 << 28) throw new Error('JPEG XL: ICC profile too large');
     const dec = new EntropyDecoder(r, 41);
     dec.begin(r);
     const kind = (b: number): number => b >= 97 && b <= 122 || b >= 65 && b <= 90 ? 0 : b >= 48 && b <= 57 || b === 46 || b === 44 ? 1 : -1;
+    const out = new Uint8Array(size);
     let b1 = 0, b2 = 0;
     for (let i = 0; i < size; i++) {
         let ctx = 0;
@@ -258,10 +259,180 @@ export function skipICC(r: BitReader): void {
         }
         const b = dec.read(r, ctx);
         if (b > 255) throw new Error('JPEG XL: invalid ICC profile');
+        out[i] = b;
         b2 = b1;
         b1 = b;
     }
     dec.finish();
+    return out;
+}
+
+// the tags and tag types the ICC stream's commands abbreviate
+const COMMON_TAGS = ['rTRC', 'rXYZ', 'cprt', 'wtpt', 'bkpt', 'rXYZ', 'gXYZ', 'bXYZ', 'kXYZ', 'rTRC', 'gTRC', 'bTRC', 'kTRC', 'chad', 'desc', 'chrm', 'dmnd', 'dmdd', 'lumi'];
+const COMMON_DATA = ['XYZ ', 'desc', 'text', 'mluc', 'para', 'curv', 'sf32', 'gbd '];
+
+/** The ICC profile an encoded ICC stream (see readICC) describes, null if the stream is invalid */
+export function decodeICC(stream: Uint8Array): Uint8Array | null {
+    let at = 0;
+    const fail = (): never => {
+        throw new RangeError('invalid ICC stream');
+    };
+    const varint = (s: Uint8Array, pos: { at: number }): number => {
+        let value = 0;
+        for (let shift = 0; shift < 63; shift += 7) {
+            if (pos.at >= s.length) fail();
+            const b = s[pos.at++];
+            value += (b & 127) * 2 ** shift;
+            if (!(b & 128)) break;
+        }
+        return value;
+    };
+    try {
+        const head = { at: 0 };
+        const outputSize = varint(stream, head), commandsSize = varint(stream, head);
+        at = head.at;
+        if (at + commandsSize > stream.length || outputSize > 1 << 28) fail();
+        const commands = stream.subarray(at, at + commandsSize), cmd = { at: 0 };
+        let data = stream.subarray(at + commandsSize);
+        const headerSize = Math.min(outputSize, 128);
+        if (data.length < headerSize) fail();
+        const out = new Uint8Array(outputSize);
+        let o = 0;
+        const push = (...bytes: number[]): void => pushBytes(bytes);
+        const pushBytes = (bytes: ArrayLike<number>): void => {
+            if (o + bytes.length > outputSize) fail();
+            out.set(bytes, o);
+            o += bytes.length;
+        };
+        const pushText = (t: string): void => pushBytes([...t].map(c => c.charCodeAt(0)));
+        const u32 = (v: number): number[] => [v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255];
+        const take = (n: number): Uint8Array => {
+            if (n > data.length) fail();
+            const bytes = data.subarray(0, n);
+            data = data.subarray(n);
+            return bytes;
+        };
+
+        // the header: predicted, the stream has the differences
+        const header = take(headerSize);
+        const predict = (i: number): number => {
+            const h40 = String.fromCharCode(header[40]), h41 = String.fromCharCode(header[41]);
+            if (i <= 3) return u32(outputSize)[i];
+            if (i === 8) return 4;
+            if (i >= 12 && i <= 23) return 'mntrRGB XYZ '.charCodeAt(i - 12);
+            if (i >= 36 && i <= 39) return 'acsp'.charCodeAt(i - 36);
+            if (h40 === 'A' && i >= 41 && i <= 43) return 'PPL'.charCodeAt(i - 41);
+            if (h40 === 'M' && i >= 41 && i <= 43) return 'SFT'.charCodeAt(i - 41);
+            if (h40 === 'S' && h41 === 'G' && (i === 42 || i === 43)) return 'I '.charCodeAt(i - 42);
+            if (h40 === 'S' && h41 === 'U' && (i === 42 || i === 43)) return 'NW'.charCodeAt(i - 42);
+            if (i === 70) return 246;
+            if (i === 71) return 214;
+            if (i === 73) return 1;
+            if (i === 78) return 211;
+            if (i === 79) return 45;
+            if (i >= 80 && i <= 83) return header[4 + i - 80];
+            return 0;
+        };
+        for (let i = 0; i < headerSize; i++) push(predict(i) + header[i] & 255);
+        if (outputSize <= 128) return out;
+
+        // the tag table
+        const v = varint(commands, cmd);
+        if (v > 0) {
+            const numTags = v - 1;
+            if ((outputSize - 128) / 12 < numTags) fail();
+            push(...u32(numTags));
+            let prevStart = numTags * 12 + 128, prevSize = 0;
+            for (; ;) {
+                // (like jxl-oxide: the commands may end here)
+                if (cmd.at >= commands.length) return out.subarray(0, o);
+                const command = commands[cmd.at++], code = command & 63;
+                if (code === 0) break;
+                let tag: string;
+                if (code === 1) tag = String.fromCharCode(...take(4));
+                else if (code <= 20) tag = COMMON_TAGS[code - 2];
+                else return fail();
+                const start = command & 64 ? varint(commands, cmd) : prevStart + prevSize;
+                const size = command & 128 ? varint(commands, cmd) : ['rXYZ', 'gXYZ', 'bXYZ', 'kXYZ', 'wtpt', 'bkpt', 'lumi'].includes(tag) ? 20 : prevSize;
+                if (start + size > outputSize) fail();
+                prevStart = start;
+                prevSize = size;
+                pushText(tag);
+                push(...u32(start), ...u32(size));
+                if (code === 2) {
+                    pushText('gTRC');
+                    push(...u32(start), ...u32(size));
+                    pushText('bTRC');
+                    push(...u32(start), ...u32(size));
+                } else if (code === 3) {
+                    pushText('gXYZ');
+                    push(...u32(start + size), ...u32(size));
+                    pushText('bXYZ');
+                    push(...u32(start + 2 * size), ...u32(size));
+                }
+            }
+        }
+
+        // the rest: copies, shuffled copies, predicted numbers, abbreviated XYZ values and tag types
+        const shuffle = (bytes: Uint8Array, width: number): Uint8Array => {
+            const n = bytes.length, shuffled = new Uint8Array(n);
+            if (width === 2) {
+                const half = n >> 1, odd = n & 1;
+                let k = 0;
+                for (let i = 0; i < half; i++) {
+                    shuffled[k++] = bytes[i];
+                    shuffled[k++] = bytes[i + half + odd];
+                }
+                if (odd) shuffled[k] = bytes[half];
+            } else {
+                const step = n >> 2, wide = n & 3;
+                let k = 0;
+                for (let i = 0; i < step; i++) {
+                    let base = i;
+                    for (let j = 0; j < wide; j++, base += step + 1) shuffled[k++] = bytes[base];
+                    for (let j = wide; j < 4; j++, base += step) shuffled[k++] = bytes[base];
+                }
+                for (let i = 1; i <= wide; i++) shuffled[k++] = bytes[(step + 1) * i - 1];
+            }
+            return shuffled;
+        };
+        while (cmd.at < commands.length) {
+            const command = commands[cmd.at++];
+            if (command === 1) pushBytes(take(varint(commands, cmd)));
+            else if (command === 2 || command === 3) pushBytes(shuffle(take(varint(commands, cmd)), command === 2 ? 2 : 4));
+            else if (command === 4) {
+                if (cmd.at >= commands.length) fail();
+                const flags = commands[cmd.at++], width = (flags & 3) + 1, order = flags >> 2 & 3;
+                if (width === 3 || order === 3) fail();
+                const stride = flags & 16 ? varint(commands, cmd) : width;
+                if (stride < width || stride * 4 >= o) fail();
+                const num = varint(commands, cmd), raw = take(num), bytes = width === 1 ? raw : shuffle(raw, width);
+                for (let i = 0; i < num; i += width) {
+                    const prev = [0, 0, 0];
+                    for (let j = 0; j <= order; j++) {
+                        const from = o - stride * (j + 1);
+                        let value = 0;
+                        for (let k = 0; k < width; k++) value = (value << 8 | out[from + k]) >>> 0;
+                        prev[j] = value;
+                    }
+                    const p = order === 0 ? prev[0] : order === 1 ? 2 * prev[0] - prev[1] >>> 0 : 3 * (prev[0] - prev[1]) + prev[2] >>> 0;
+                    for (let j = 0; j < Math.min(width, num - i); j++) push(bytes[i + j] + (p >>> 8 * (width - 1 - j)) & 255);
+                }
+            } else if (command === 10) {
+                pushText('XYZ ');
+                push(0, 0, 0, 0);
+                pushBytes(take(12));
+            }
+            else if (command >= 16 && command <= 23) {
+                pushText(COMMON_DATA[command - 16]);
+                push(0, 0, 0, 0);
+            } else fail();
+        }
+        return o === outputSize ? out : null;
+    } catch (e) {
+        if (e instanceof RangeError) return null;
+        throw e;
+    }
 }
 
 // the default upsampling weights