@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.6

package/bundled-test-harness/assets/image-metadata-extractor-test-CakSBPZ_.js

@@ -0,0 +1,1109 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Xt as readBytesUntil } from "./runtime-common-BTaLJEw-.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { lt as setupRenderingTest } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/unit/image-metadata-extractor-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var ASCII = 2;
+var SHORT = 3;
+var LONG = 4;
+var RATIONAL = 5;
+var TAG_EXIF_IFD_POINTER = 34665;
+var TAG_GPS_IFD_POINTER = 34853;
+function payloadFor(spec, littleEndian) {
+	if (typeof spec.values === "string") {
+		let text = spec.values;
+		let bytes = new Uint8Array(text.length + 1);
+		for (let index = 0; index < text.length; index++) bytes[index] = text.charCodeAt(index) & 255;
+		return {
+			bytes,
+			count: bytes.length
+		};
+	}
+	let values = spec.values;
+	if (spec.type === SHORT) {
+		let bytes = new Uint8Array(values.length * 2);
+		let view = new DataView(bytes.buffer);
+		values.forEach((value, index) => view.setUint16(index * 2, value, littleEndian));
+		return {
+			bytes,
+			count: values.length
+		};
+	}
+	if (spec.type === LONG) {
+		let bytes = new Uint8Array(values.length * 4);
+		let view = new DataView(bytes.buffer);
+		values.forEach((value, index) => view.setUint32(index * 4, value, littleEndian));
+		return {
+			bytes,
+			count: values.length
+		};
+	}
+	if (spec.type === RATIONAL) {
+		let bytes = new Uint8Array(values.length * 4);
+		let view = new DataView(bytes.buffer);
+		values.forEach((value, index) => view.setUint32(index * 4, value, littleEndian));
+		return {
+			bytes,
+			count: values.length / 2
+		};
+	}
+	throw new Error(`unsupported fixture field type ${spec.type}`);
+}
+function buildTiffBlock(fixture) {
+	let littleEndian = fixture.littleEndian ?? true;
+	let ifd0 = [...fixture.ifd0 ?? []];
+	let hasExif = (fixture.exif?.length ?? 0) > 0;
+	let hasGps = (fixture.gps?.length ?? 0) > 0;
+	let directorySize = (count) => 2 + count * 12 + 4;
+	let ifd0Count = ifd0.length + (hasExif ? 1 : 0) + (hasGps ? 1 : 0);
+	let ifd0Offset = 8;
+	let exifOffset = ifd0Offset + directorySize(ifd0Count);
+	let gpsOffset = exifOffset + (hasExif ? directorySize(fixture.exif.length) : 0);
+	let heapOffset = gpsOffset + (hasGps ? directorySize(fixture.gps.length) : 0);
+	if (hasExif) ifd0.push({
+		tag: TAG_EXIF_IFD_POINTER,
+		type: LONG,
+		values: [exifOffset]
+	});
+	if (hasGps) ifd0.push({
+		tag: TAG_GPS_IFD_POINTER,
+		type: LONG,
+		values: [gpsOffset]
+	});
+	let heap = [];
+	let writeDirectory = (target, entries) => {
+		let bytes = new Uint8Array(directorySize(entries.length));
+		let view = new DataView(bytes.buffer);
+		view.setUint16(0, entries.length, littleEndian);
+		entries.forEach((spec, index) => {
+			let { bytes: payload, count } = payloadFor(spec, littleEndian);
+			let entryStart = 2 + index * 12;
+			view.setUint16(entryStart, spec.tag, littleEndian);
+			view.setUint16(entryStart + 2, spec.type, littleEndian);
+			view.setUint32(entryStart + 4, count, littleEndian);
+			if (payload.length <= 4) bytes.set(payload, entryStart + 8);
+			else {
+				view.setUint32(entryStart + 8, heapOffset + heap.length, littleEndian);
+				heap.push(...payload);
+			}
+		});
+		view.setUint32(2 + entries.length * 12, 0, littleEndian);
+		target.push(...bytes);
+	};
+	let directories = [];
+	writeDirectory(directories, ifd0);
+	if (hasExif) writeDirectory(directories, fixture.exif);
+	if (hasGps) writeDirectory(directories, fixture.gps);
+	let header = new Uint8Array(8);
+	let headerView = new DataView(header.buffer);
+	headerView.setUint16(0, littleEndian ? 18761 : 19789);
+	headerView.setUint16(2, 42, littleEndian);
+	headerView.setUint32(4, ifd0Offset, littleEndian);
+	return new Uint8Array([
+		...header,
+		...directories,
+		...heap
+	]);
+}
+function buildJpeg(app1Segments, frame = {}) {
+	let out = [255, 216];
+	for (let segment of app1Segments) {
+		let identifier = [...segment.identifier].map((c) => c.charCodeAt(0));
+		let length = 2 + identifier.length + segment.body.length;
+		out.push(255, 225, length >> 8 & 255, length & 255);
+		out.push(...identifier, ...segment.body);
+	}
+	let components = frame.components ?? 3;
+	let sofLength = 8 + components * 3;
+	out.push(255, 192, sofLength >> 8 & 255, sofLength & 255);
+	out.push(frame.precision ?? 8);
+	out.push(0, 64);
+	out.push(0, 32);
+	out.push(components);
+	for (let index = 0; index < components; index++) out.push(index + 1, 17, 0);
+	out.push(255, 217);
+	return new Uint8Array(out);
+}
+function jpegWithExif(fixture) {
+	return buildJpeg([{
+		identifier: "Exif\0\0",
+		body: buildTiffBlock(fixture)
+	}]);
+}
+function buildPng(bitDepth, colorType) {
+	let out = [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	];
+	out.push(0, 0, 0, 13);
+	out.push(73, 72, 68, 82);
+	out.push(0, 0, 0, 8);
+	out.push(0, 0, 0, 8);
+	out.push(bitDepth, colorType, 0, 0, 0);
+	out.push(0, 0, 0, 0);
+	return new Uint8Array(out);
+}
+function buildGif(hasGlobalColorTable, colorTableSizeExponent) {
+	let out = [
+		71,
+		73,
+		70,
+		56,
+		57,
+		97
+	];
+	out.push(8, 0, 8, 0);
+	out.push((hasGlobalColorTable ? 128 : 0) | colorTableSizeExponent & 7);
+	out.push(0, 0);
+	return new Uint8Array(out);
+}
+function buildWebp(fourCC, payload) {
+	let out = [
+		82,
+		73,
+		70,
+		70
+	];
+	out.push(0, 0, 0, 0);
+	out.push(87, 69, 66, 80);
+	out.push(...[...fourCC].map((c) => c.charCodeAt(0)));
+	out.push(0, 0, 0, 0);
+	out.push(...payload);
+	while (out.length < 30) out.push(0);
+	return new Uint8Array(out);
+}
+function box(type, body) {
+	let size = 8 + body.length;
+	return [
+		size >>> 24 & 255,
+		size >>> 16 & 255,
+		size >>> 8 & 255,
+		size & 255,
+		...[...type].map((c) => c.charCodeAt(0)),
+		...body
+	];
+}
+function buildAvif(properties) {
+	let ftyp = box("ftyp", [
+		...[..."avif"].map((c) => c.charCodeAt(0)),
+		0,
+		0,
+		0,
+		0
+	]);
+	let ipcoBody = [...box("ispe", [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		32,
+		0,
+		0,
+		0,
+		32
+	])];
+	if (properties.pixi) ipcoBody.push(...box("pixi", [
+		0,
+		0,
+		0,
+		0,
+		properties.pixi.length,
+		...properties.pixi
+	]));
+	if (properties.colr) ipcoBody.push(...box("colr", properties.colr));
+	if (properties.auxC) ipcoBody.push(...box("auxC", [
+		0,
+		0,
+		0,
+		0,
+		...[...properties.auxC].map((c) => c.charCodeAt(0)),
+		0
+	]));
+	let meta = box("meta", [
+		0,
+		0,
+		0,
+		0,
+		...box("iprp", box("ipco", ipcoBody))
+	]);
+	return new Uint8Array([...ftyp, ...meta]);
+}
+function buildGifBody(blocks, { trailer = true, globalColorTableExponent = 1 } = {}) {
+	let out = [
+		71,
+		73,
+		70,
+		56,
+		57,
+		97
+	];
+	out.push(8, 0, 8, 0);
+	out.push(128 | globalColorTableExponent, 0, 0);
+	out.push(...new Array(3 * 2 ** (globalColorTableExponent + 1)).fill(0));
+	for (let block of blocks) {
+		if (block.kind === "extension") {
+			out.push(33, block.label, block.dataBytes);
+			out.push(...new Array(block.dataBytes).fill(44));
+			out.push(0);
+			continue;
+		}
+		let lct = block.localColorTableExponent;
+		out.push(44, 0, 0, 0, 0, 8, 0, 8, 0);
+		out.push(lct === void 0 ? 0 : 128 | lct);
+		if (lct !== void 0) out.push(...new Array(3 * 2 ** (lct + 1)).fill(44));
+		let dataBytes = block.dataBytes ?? 4;
+		out.push(2);
+		out.push(dataBytes, ...new Array(dataBytes).fill(44), 0);
+	}
+	if (trailer) out.push(59);
+	return new Uint8Array(out);
+}
+function buildPngChunks(chunks) {
+	let out = [...buildPng(8, 6)];
+	for (let { type, dataBytes = 4 } of chunks) {
+		out.push(dataBytes >>> 24 & 255, dataBytes >>> 16 & 255, dataBytes >>> 8 & 255, dataBytes & 255);
+		out.push(...[...type].map((c) => c.charCodeAt(0)));
+		out.push(...new Array(dataBytes).fill(0));
+		out.push(0, 0, 0, 0);
+	}
+	return new Uint8Array(out);
+}
+function buildFtyp(major, compatible) {
+	let brand = (b) => [...b].map((c) => c.charCodeAt(0));
+	return new Uint8Array(box("ftyp", [
+		...brand(major),
+		0,
+		0,
+		0,
+		0,
+		...compatible.flatMap(brand)
+	]));
+}
+(0, import_qunit.module)("Unit | image metadata extractors", function(hooks) {
+	setupRenderingTest(hooks);
+	let loader;
+	let extractExifFromJpeg;
+	let parseExifTiffBlock;
+	let extractPngColorProfile;
+	let extractJpgColorProfile;
+	let extractGifColorProfile;
+	let extractWebpColorProfile;
+	let extractAvifColorProfile;
+	let extractGifAnimated;
+	let gifAnimationVerdict;
+	let pngAnimationVerdict;
+	let extractPngAnimated;
+	let extractWebpAnimated;
+	let extractAvifAnimated;
+	let rasterImageAttributes;
+	hooks.beforeEach(async function() {
+		loader = getService("loader-service").loader;
+		({extractExifFromJpeg, parseExifTiffBlock} = await loader.import("@cardstack/base/exif-meta-extractor"));
+		({extractPngColorProfile, extractPngAnimated, pngAnimationVerdict} = await loader.import("@cardstack/base/png-meta-extractor"));
+		({extractJpgColorProfile} = await loader.import("@cardstack/base/jpg-meta-extractor"));
+		({extractGifColorProfile, extractGifAnimated, gifAnimationVerdict} = await loader.import("@cardstack/base/gif-meta-extractor"));
+		({extractWebpColorProfile, extractWebpAnimated} = await loader.import("@cardstack/base/webp-meta-extractor"));
+		({extractAvifColorProfile, extractAvifAnimated} = await loader.import("@cardstack/base/avif-meta-extractor"));
+		({rasterImageAttributes} = await loader.import("@cardstack/base/image-file-def"));
+	});
+	(0, import_qunit.module)("EXIF", function() {
+		(0, import_qunit.test)("reads the camera, lens, and exposure a photograph was taken with", function(assert) {
+			let exif = extractExifFromJpeg(jpegWithExif({
+				ifd0: [
+					{
+						tag: 271,
+						type: ASCII,
+						values: "Canon"
+					},
+					{
+						tag: 272,
+						type: ASCII,
+						values: "Canon EOS R5"
+					},
+					{
+						tag: 305,
+						type: ASCII,
+						values: "Darkroom 4.2"
+					},
+					{
+						tag: 274,
+						type: SHORT,
+						values: [6]
+					}
+				],
+				exif: [
+					{
+						tag: 42036,
+						type: ASCII,
+						values: "RF 50mm F1.2 L USM"
+					},
+					{
+						tag: 37386,
+						type: RATIONAL,
+						values: [50, 1]
+					},
+					{
+						tag: 33437,
+						type: RATIONAL,
+						values: [14, 10]
+					},
+					{
+						tag: 33434,
+						type: RATIONAL,
+						values: [1, 250]
+					},
+					{
+						tag: 34855,
+						type: SHORT,
+						values: [400]
+					},
+					{
+						tag: 37385,
+						type: SHORT,
+						values: [25]
+					}
+				]
+			}));
+			assert.strictEqual(exif?.capture?.make, "Canon");
+			assert.strictEqual(exif?.capture?.cameraModel, "Canon EOS R5");
+			assert.strictEqual(exif?.capture?.lensModel, "RF 50mm F1.2 L USM");
+			assert.strictEqual(exif?.capture?.software, "Darkroom 4.2");
+			assert.strictEqual(exif?.capture?.iso, 400);
+			assert.deepEqual(exif?.capture?.focalLength, {
+				value: 50,
+				unit: "mm"
+			});
+			assert.deepEqual(exif?.capture?.aperture, {
+				value: 1.4,
+				displayText: "ƒ/1.4"
+			});
+			assert.strictEqual(exif?.capture?.exposureTime?.displayText, "1/250 s", "a sub-second shutter speed reads as the fraction a photographer recognizes");
+			assert.deepEqual(exif?.capture?.flash, {
+				code: "25",
+				scheme: "exif-flash"
+			});
+			assert.deepEqual(exif?.capture?.orientation, {
+				code: "6",
+				scheme: "exif-orientation"
+			});
+		});
+		(0, import_qunit.test)("a shutter speed of a second or longer reads as a decimal, not a fraction", function(assert) {
+			let exif = extractExifFromJpeg(jpegWithExif({ exif: [{
+				tag: 33434,
+				type: RATIONAL,
+				values: [4, 1]
+			}] }));
+			assert.strictEqual(exif?.capture?.exposureTime?.displayText, "4 s");
+		});
+		(0, import_qunit.test)("converts an EXIF timestamp to ISO 8601 and honors a recorded UTC offset", function(assert) {
+			let naive = extractExifFromJpeg(jpegWithExif({ exif: [{
+				tag: 36867,
+				type: ASCII,
+				values: "2024:03:15 14:22:08"
+			}] }));
+			assert.strictEqual(naive?.capture?.capturedAt, "2024-03-15T14:22:08", "without an offset tag the wall-clock time is preserved rather than shifted to UTC");
+			let zoned = extractExifFromJpeg(jpegWithExif({ exif: [{
+				tag: 36867,
+				type: ASCII,
+				values: "2024:03:15 14:22:08"
+			}, {
+				tag: 36881,
+				type: ASCII,
+				values: "-04:00"
+			}] }));
+			assert.strictEqual(zoned?.capture?.capturedAt, "2024-03-15T14:22:08-04:00");
+		});
+		(0, import_qunit.test)("falls back to IFD0 DateTime when the original-capture tag is absent", function(assert) {
+			let exif = extractExifFromJpeg(jpegWithExif({ ifd0: [{
+				tag: 306,
+				type: ASCII,
+				values: "2019:11:02 08:00:00"
+			}] }));
+			assert.strictEqual(exif?.capture?.capturedAt, "2019-11-02T08:00:00");
+		});
+		(0, import_qunit.test)("accepts either ISO-speed tag, since EXIF 2.3 renamed it", function(assert) {
+			let renamed = extractExifFromJpeg(jpegWithExif({ exif: [{
+				tag: 34867,
+				type: LONG,
+				values: [3200]
+			}] }));
+			assert.strictEqual(renamed?.capture?.iso, 3200);
+		});
+		(0, import_qunit.test)("a malformed timestamp is dropped rather than persisted unparsed", function(assert) {
+			let exif = extractExifFromJpeg(jpegWithExif({ exif: [{
+				tag: 36867,
+				type: ASCII,
+				values: "not a date"
+			}] }));
+			assert.strictEqual(exif?.capture?.capturedAt, void 0);
+		});
+		(0, import_qunit.test)("converts GPS coordinates to signed decimal degrees", function(assert) {
+			let exif = extractExifFromJpeg(jpegWithExif({ gps: [
+				{
+					tag: 1,
+					type: ASCII,
+					values: "N"
+				},
+				{
+					tag: 2,
+					type: RATIONAL,
+					values: [
+						40,
+						1,
+						44,
+						1,
+						5454,
+						100
+					]
+				},
+				{
+					tag: 3,
+					type: ASCII,
+					values: "W"
+				},
+				{
+					tag: 4,
+					type: RATIONAL,
+					values: [
+						73,
+						1,
+						59,
+						1,
+						852,
+						100
+					]
+				},
+				{
+					tag: 6,
+					type: RATIONAL,
+					values: [1024, 10]
+				}
+			] }));
+			assert.strictEqual(exif?.location?.latitude, 40.7484833);
+			assert.strictEqual(exif?.location?.longitude, -73.9857, "a western hemisphere reference makes the longitude negative");
+			assert.deepEqual(exif?.location?.altitude, {
+				value: 102.4,
+				unit: "m"
+			});
+			assert.deepEqual(exif?.location?.source, {
+				code: "exif-gps",
+				scheme: "geo-source"
+			});
+		});
+		(0, import_qunit.test)("a below-sea-level altitude reference negates the stored magnitude", function(assert) {
+			let exif = extractExifFromJpeg(jpegWithExif({ gps: [{
+				tag: 5,
+				type: SHORT,
+				values: [1]
+			}, {
+				tag: 6,
+				type: RATIONAL,
+				values: [430, 10]
+			}] }));
+			assert.deepEqual(exif?.location?.altitude, {
+				value: -43,
+				unit: "m"
+			});
+		});
+		(0, import_qunit.test)("drops a coordinate missing its other half instead of placing it on the prime meridian", function(assert) {
+			let exif = extractExifFromJpeg(jpegWithExif({ gps: [{
+				tag: 1,
+				type: ASCII,
+				values: "N"
+			}, {
+				tag: 2,
+				type: RATIONAL,
+				values: [
+					40,
+					1,
+					44,
+					1,
+					0,
+					1
+				]
+			}] }));
+			assert.strictEqual(exif?.location?.latitude, void 0);
+			assert.strictEqual(exif?.location?.longitude, void 0);
+		});
+		(0, import_qunit.test)("drops an out-of-range coordinate rather than clamping it", function(assert) {
+			let exif = extractExifFromJpeg(jpegWithExif({ gps: [
+				{
+					tag: 1,
+					type: ASCII,
+					values: "N"
+				},
+				{
+					tag: 2,
+					type: RATIONAL,
+					values: [
+						200,
+						1,
+						0,
+						1,
+						0,
+						1
+					]
+				},
+				{
+					tag: 3,
+					type: ASCII,
+					values: "E"
+				},
+				{
+					tag: 4,
+					type: RATIONAL,
+					values: [
+						10,
+						1,
+						0,
+						1,
+						0,
+						1
+					]
+				}
+			] }));
+			assert.strictEqual(exif?.location?.latitude, void 0);
+		});
+		(0, import_qunit.test)("reads big-endian EXIF identically to little-endian", function(assert) {
+			let fixture = {
+				ifd0: [{
+					tag: 272,
+					type: ASCII,
+					values: "X-T4"
+				}],
+				exif: [{
+					tag: 37386,
+					type: RATIONAL,
+					values: [23, 1]
+				}]
+			};
+			let little = extractExifFromJpeg(jpegWithExif({
+				...fixture,
+				littleEndian: true
+			}));
+			let big = extractExifFromJpeg(jpegWithExif({
+				...fixture,
+				littleEndian: false
+			}));
+			assert.deepEqual(big, little, "byte order does not change the result");
+			assert.strictEqual(big?.capture?.cameraModel, "X-T4");
+		});
+		(0, import_qunit.test)("normalizes the EXIF color-space code onto the shared vocabulary", function(assert) {
+			let srgb = extractExifFromJpeg(jpegWithExif({ exif: [{
+				tag: 40961,
+				type: SHORT,
+				values: [1]
+			}] }));
+			assert.strictEqual(srgb?.colorSpace, "srgb");
+			let uncalibrated = extractExifFromJpeg(jpegWithExif({ exif: [{
+				tag: 40961,
+				type: SHORT,
+				values: [65535]
+			}] }));
+			assert.strictEqual(uncalibrated?.colorSpace, "uncalibrated");
+			let unknownCode = extractExifFromJpeg(jpegWithExif({ exif: [{
+				tag: 40961,
+				type: SHORT,
+				values: [42]
+			}] }));
+			assert.strictEqual(unknownCode?.colorSpace, void 0, "a code with no vocabulary entry is left unset rather than guessed at");
+		});
+		(0, import_qunit.test)("a JPEG with no EXIF yields no metadata rather than empty branches", function(assert) {
+			assert.strictEqual(extractExifFromJpeg(buildJpeg([])), void 0);
+		});
+		(0, import_qunit.test)("skips an APP1 segment that is XMP rather than EXIF", function(assert) {
+			let xmpOnly = buildJpeg([{
+				identifier: "http://ns.adobe.com/xap/1.0/\0",
+				body: new Uint8Array([
+					60,
+					120,
+					58,
+					120
+				])
+			}]);
+			assert.strictEqual(extractExifFromJpeg(xmpOnly), void 0);
+		});
+		(0, import_qunit.test)("finds the EXIF segment when an XMP segment precedes it", function(assert) {
+			let bytes = buildJpeg([{
+				identifier: "http://ns.adobe.com/xap/1.0/\0",
+				body: new Uint8Array([60, 120])
+			}, {
+				identifier: "Exif\0\0",
+				body: buildTiffBlock({ ifd0: [{
+					tag: 271,
+					type: ASCII,
+					values: "Nikon"
+				}] })
+			}]);
+			assert.strictEqual(extractExifFromJpeg(bytes)?.capture?.make, "Nikon");
+		});
+		(0, import_qunit.test)("a truncated EXIF block degrades to partial metadata without throwing", function(assert) {
+			let block = buildTiffBlock({
+				ifd0: [{
+					tag: 271,
+					type: ASCII,
+					values: "Panasonic"
+				}],
+				exif: [{
+					tag: 37386,
+					type: RATIONAL,
+					values: [12, 1]
+				}]
+			});
+			let exif = parseExifTiffBlock(block.subarray(0, block.length - 6), 0);
+			assert.strictEqual(exif?.capture?.make, "Panasonic", "a payload still inside the buffer is read");
+			assert.strictEqual(exif?.capture?.focalLength, void 0, "a payload past the end is omitted rather than read from adjacent bytes");
+		});
+		(0, import_qunit.test)("a garbage TIFF block is rejected without throwing", function(assert) {
+			assert.strictEqual(parseExifTiffBlock(new Uint8Array([
+				1,
+				2,
+				3,
+				4,
+				5,
+				6,
+				7,
+				8
+			]), 0), void 0, "an invalid byte-order marker is not EXIF");
+			assert.strictEqual(parseExifTiffBlock(new Uint8Array([73, 73]), 0), void 0, "a block too short to hold a header is rejected on bounds");
+			assert.strictEqual(parseExifTiffBlock(new Uint8Array(64), 200), void 0, "an out-of-range start offset is rejected rather than read");
+		});
+		(0, import_qunit.test)("an implausible directory entry count is refused", function(assert) {
+			let bytes = buildTiffBlock({ ifd0: [{
+				tag: 271,
+				type: ASCII,
+				values: "Sony"
+			}] });
+			new DataView(bytes.buffer).setUint16(8, 4e4, true);
+			assert.strictEqual(parseExifTiffBlock(bytes, 0), void 0);
+		});
+	});
+	(0, import_qunit.module)("PNG color profile", function() {
+		(0, import_qunit.test)("reads bit depth, channels, and alpha from each legal color type", function(assert) {
+			assert.deepEqual(extractPngColorProfile(buildPng(8, 0)), {
+				colorSpace: "grayscale",
+				bitDepth: 8,
+				channels: 1,
+				hasAlpha: false
+			});
+			assert.deepEqual(extractPngColorProfile(buildPng(8, 2)), {
+				bitDepth: 8,
+				channels: 3,
+				hasAlpha: false
+			});
+			assert.deepEqual(extractPngColorProfile(buildPng(4, 3)), {
+				colorSpace: "indexed",
+				bitDepth: 4,
+				channels: 3,
+				hasAlpha: false
+			});
+			assert.deepEqual(extractPngColorProfile(buildPng(16, 4)), {
+				colorSpace: "grayscale-alpha",
+				bitDepth: 16,
+				channels: 2,
+				hasAlpha: true
+			});
+			assert.deepEqual(extractPngColorProfile(buildPng(8, 6)), {
+				bitDepth: 8,
+				channels: 4,
+				hasAlpha: true
+			});
+		});
+		(0, import_qunit.test)("drops an illegal bit depth and an undefined color type", function(assert) {
+			let profile = extractPngColorProfile(buildPng(7, 5));
+			assert.strictEqual(profile, void 0, "neither 7-bit samples nor color type 5 exist in PNG, so nothing is reported");
+		});
+		(0, import_qunit.test)("a buffer too short to hold IHDR reports nothing", function(assert) {
+			assert.strictEqual(extractPngColorProfile(buildPng(8, 6).subarray(0, 24)), void 0);
+		});
+	});
+	(0, import_qunit.module)("JPEG color profile", function() {
+		(0, import_qunit.test)("maps the frame component count onto a color model", function(assert) {
+			assert.deepEqual(extractJpgColorProfile(buildJpeg([], { components: 1 })), {
+				colorSpace: "grayscale",
+				bitDepth: 8,
+				channels: 1,
+				hasAlpha: false
+			});
+			assert.deepEqual(extractJpgColorProfile(buildJpeg([], { components: 3 })), {
+				bitDepth: 8,
+				channels: 3,
+				hasAlpha: false
+			});
+			assert.deepEqual(extractJpgColorProfile(buildJpeg([], { components: 4 })), {
+				bitDepth: 8,
+				channels: 4,
+				hasAlpha: false
+			});
+		});
+		(0, import_qunit.test)("reports a 12-bit extended-mode frame precision", function(assert) {
+			assert.strictEqual(extractJpgColorProfile(buildJpeg([], { precision: 12 }))?.bitDepth, 12);
+		});
+		(0, import_qunit.test)("a file with no frame header reports nothing instead of throwing", function(assert) {
+			assert.strictEqual(extractJpgColorProfile(new Uint8Array([
+				255,
+				216,
+				255,
+				217
+			])), void 0);
+		});
+	});
+	(0, import_qunit.module)("GIF color profile", function() {
+		(0, import_qunit.test)("derives bit depth from the global color table size", function(assert) {
+			assert.deepEqual(extractGifColorProfile(buildGif(true, 7)), {
+				colorSpace: "indexed",
+				bitDepth: 8,
+				channels: 3
+			});
+			assert.deepEqual(extractGifColorProfile(buildGif(true, 3)), {
+				colorSpace: "indexed",
+				bitDepth: 4,
+				channels: 3
+			});
+		});
+		(0, import_qunit.test)("omits bit depth when there is no global color table", function(assert) {
+			assert.deepEqual(extractGifColorProfile(buildGif(false, 0)), {
+				colorSpace: "indexed",
+				channels: 3
+			});
+		});
+		(0, import_qunit.test)("never claims to know whether a GIF is transparent", function(assert) {
+			assert.strictEqual(extractGifColorProfile(buildGif(true, 7))?.hasAlpha, void 0);
+		});
+	});
+	(0, import_qunit.module)("WebP color profile", function() {
+		(0, import_qunit.test)("lossy WebP has no alpha channel", function(assert) {
+			let profile = extractWebpColorProfile(buildWebp("VP8 ", []));
+			assert.false(profile?.hasAlpha);
+			assert.strictEqual(profile?.channels, 3);
+		});
+		(0, import_qunit.test)("reads the lossless alpha bit out of the VP8L header word", function(assert) {
+			let withAlpha = new Uint8Array(4);
+			new DataView(withAlpha.buffer).setUint32(0, 1 << 28, true);
+			assert.true(extractWebpColorProfile(buildWebp("VP8L", [47, ...withAlpha]))?.hasAlpha);
+			let withoutAlpha = new Uint8Array(4);
+			new DataView(withoutAlpha.buffer).setUint32(0, 0, true);
+			assert.false(extractWebpColorProfile(buildWebp("VP8L", [47, ...withoutAlpha]))?.hasAlpha);
+		});
+		(0, import_qunit.test)("reads the extended-format alpha and ICC flags", function(assert) {
+			let alphaAndIcc = extractWebpColorProfile(buildWebp("VP8X", [48]));
+			assert.true(alphaAndIcc?.hasAlpha);
+			assert.strictEqual(alphaAndIcc?.channels, 4);
+			assert.strictEqual(alphaAndIcc?.iccProfile, "embedded");
+			let plain = extractWebpColorProfile(buildWebp("VP8X", [0]));
+			assert.false(plain?.hasAlpha);
+			assert.strictEqual(plain?.iccProfile, void 0);
+		});
+		(0, import_qunit.test)("an unrecognized first chunk reports nothing", function(assert) {
+			assert.strictEqual(extractWebpColorProfile(buildWebp("ANIM", [0])), void 0);
+		});
+	});
+	(0, import_qunit.module)("AVIF color profile", function() {
+		(0, import_qunit.test)("reads bit depth and channel count from the pixi property", function(assert) {
+			let profile = extractAvifColorProfile(buildAvif({ pixi: [
+				10,
+				10,
+				10
+			] }));
+			assert.strictEqual(profile?.bitDepth, 10);
+			assert.strictEqual(profile?.channels, 3);
+		});
+		(0, import_qunit.test)("maps CICP colour primaries onto the shared vocabulary", function(assert) {
+			let p3 = extractAvifColorProfile(buildAvif({ colr: [
+				110,
+				99,
+				108,
+				120,
+				0,
+				12,
+				0,
+				13,
+				0,
+				1,
+				128
+			] }));
+			assert.strictEqual(p3?.colorSpace, "display-p3");
+			let rec709 = extractAvifColorProfile(buildAvif({ colr: [
+				110,
+				99,
+				108,
+				120,
+				0,
+				1,
+				0,
+				13,
+				0,
+				1,
+				128
+			] }));
+			assert.strictEqual(rec709?.colorSpace, "srgb");
+		});
+		(0, import_qunit.test)("records an embedded ICC profile without naming it", function(assert) {
+			let profile = extractAvifColorProfile(buildAvif({ colr: [
+				112,
+				114,
+				111,
+				102,
+				0,
+				0,
+				0,
+				0
+			] }));
+			assert.strictEqual(profile?.iccProfile, "embedded");
+		});
+		(0, import_qunit.test)("detects alpha from an auxiliary-image property", function(assert) {
+			let profile = extractAvifColorProfile(buildAvif({
+				pixi: [
+					8,
+					8,
+					8
+				],
+				auxC: "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha"
+			}));
+			assert.true(profile?.hasAlpha);
+		});
+		(0, import_qunit.test)("treats a non-alpha auxiliary image as no alpha evidence", function(assert) {
+			let profile = extractAvifColorProfile(buildAvif({
+				pixi: [
+					8,
+					8,
+					8
+				],
+				auxC: "urn:mpeg:mpegB:cicp:systems:auxiliary:depth"
+			}));
+			assert.strictEqual(profile?.hasAlpha, void 0);
+		});
+		(0, import_qunit.test)("a single-channel image with no colr box reads as grayscale", function(assert) {
+			assert.strictEqual(extractAvifColorProfile(buildAvif({ pixi: [12] }))?.colorSpace, "grayscale");
+		});
+		(0, import_qunit.test)("an unreachable box tree reports nothing", function(assert) {
+			assert.strictEqual(extractAvifColorProfile(new Uint8Array(24)), void 0);
+		});
+	});
+	(0, import_qunit.module)("animation", function() {
+		(0, import_qunit.test)("a GIF with one frame and a trailer is a still", function(assert) {
+			assert.false(extractGifAnimated(buildGifBody([{ kind: "frame" }])));
+		});
+		(0, import_qunit.test)("a second image descriptor makes a GIF animated", function(assert) {
+			assert.true(extractGifAnimated(buildGifBody([{ kind: "frame" }, { kind: "frame" }], { trailer: false })), "the walk answers at the second frame without needing the trailer");
+		});
+		(0, import_qunit.test)("the GIF walk skips extensions and local color tables without counting them", function(assert) {
+			let still = buildGifBody([
+				{
+					kind: "extension",
+					label: 255,
+					dataBytes: 11
+				},
+				{
+					kind: "extension",
+					label: 249,
+					dataBytes: 4
+				},
+				{
+					kind: "frame",
+					localColorTableExponent: 2,
+					dataBytes: 40
+				}
+			]);
+			assert.false(extractGifAnimated(still));
+			let animated = buildGifBody([
+				{
+					kind: "extension",
+					label: 249,
+					dataBytes: 4
+				},
+				{
+					kind: "frame",
+					localColorTableExponent: 2
+				},
+				{
+					kind: "extension",
+					label: 249,
+					dataBytes: 4
+				},
+				{ kind: "frame" }
+			]);
+			assert.true(extractGifAnimated(animated));
+		});
+		(0, import_qunit.test)("a GIF cut off before a second frame or the trailer is unknown", function(assert) {
+			let full = buildGifBody([{
+				kind: "frame",
+				dataBytes: 200
+			}]);
+			assert.strictEqual(extractGifAnimated(full.subarray(0, full.length - 50)), void 0, "a read window ending mid-frame says nothing either way");
+			assert.strictEqual(extractGifAnimated(full.subarray(0, full.length - 1)), void 0, "one frame with no trailer in view could still be followed by more");
+		});
+		(0, import_qunit.test)("an unrecognized GIF block is unknown rather than a still", function(assert) {
+			let bytes = buildGifBody([{ kind: "frame" }], { trailer: false });
+			assert.strictEqual(extractGifAnimated(new Uint8Array([...bytes, 153])), void 0);
+		});
+		(0, import_qunit.test)("a walker separates a prefix too short to decide from bytes it can never decide", function(assert) {
+			let gif = buildGifBody([{
+				kind: "frame",
+				dataBytes: 200
+			}]);
+			assert.strictEqual(gifAnimationVerdict(gif.subarray(0, 100)), "needs-bytes", "a GIF cut off mid-frame may still be decided by more bytes");
+			assert.strictEqual(gifAnimationVerdict(new TextEncoder().encode("plain text, not a GIF")), "undecidable", "bytes without a GIF signature never become decidable");
+			let unknownBlock = buildGifBody([{ kind: "frame" }], { trailer: false });
+			assert.strictEqual(gifAnimationVerdict(new Uint8Array([...unknownBlock, 153])), "undecidable");
+			let png = buildPngChunks([{
+				type: "iCCP",
+				dataBytes: 3e3
+			}, { type: "IDAT" }]);
+			assert.strictEqual(pngAnimationVerdict(png.subarray(0, 1e3)), "needs-bytes");
+			assert.strictEqual(pngAnimationVerdict(new TextEncoder().encode("plain text, not a PNG")), "undecidable");
+			let garbledChunk = new Uint8Array([
+				...png.subarray(0, 33),
+				0,
+				0,
+				0,
+				4,
+				255,
+				0,
+				19,
+				55
+			]);
+			assert.strictEqual(pngAnimationVerdict(garbledChunk), "undecidable", "a chunk type that is not four letters means the framing is lost");
+		});
+		(0, import_qunit.test)("an undecidable file stops the streamed read at the first chunk", async function(assert) {
+			let pulled = 0;
+			let text = new TextEncoder().encode("plain text, not a GIF ".repeat(100));
+			let bytes = await readBytesUntil(new ReadableStream({ pull(controller) {
+				pulled++;
+				if (pulled > 50) {
+					controller.close();
+					return;
+				}
+				controller.enqueue(text);
+			} }), 1048576, (prefix) => gifAnimationVerdict(prefix) !== "needs-bytes");
+			assert.strictEqual(bytes.length, text.length, "one chunk was enough to give up");
+			assert.ok(pulled <= 2, `the stream was not drained (pulled ${pulled})`);
+		});
+		(0, import_qunit.test)("an acTL chunk before the image data makes a PNG animated", function(assert) {
+			assert.true(extractPngAnimated(buildPngChunks([
+				{
+					type: "iCCP",
+					dataBytes: 3e3
+				},
+				{
+					type: "acTL",
+					dataBytes: 8
+				},
+				{ type: "IDAT" }
+			])));
+		});
+		(0, import_qunit.test)("a PNG whose image data arrives with no acTL is a still", function(assert) {
+			assert.false(extractPngAnimated(buildPngChunks([
+				{
+					type: "sRGB",
+					dataBytes: 1
+				},
+				{
+					type: "pHYs",
+					dataBytes: 9
+				},
+				{ type: "IDAT" },
+				{
+					type: "acTL",
+					dataBytes: 8
+				}
+			])));
+		});
+		(0, import_qunit.test)("a PNG window that ends inside an ancillary chunk is unknown", function(assert) {
+			let bytes = buildPngChunks([{
+				type: "iCCP",
+				dataBytes: 3e3
+			}, { type: "IDAT" }]);
+			assert.strictEqual(extractPngAnimated(bytes.subarray(0, 1e3)), void 0);
+		});
+		(0, import_qunit.test)("only the extended WebP flavor can animate, per its animation flag", function(assert) {
+			assert.false(extractWebpAnimated(buildWebp("VP8 ", [])));
+			assert.false(extractWebpAnimated(buildWebp("VP8L", [47])));
+			assert.true(extractWebpAnimated(buildWebp("VP8X", [2])));
+			assert.true(extractWebpAnimated(buildWebp("VP8X", [18])), "the alpha flag alongside it does not mask the animation flag");
+			assert.false(extractWebpAnimated(buildWebp("VP8X", [48])));
+			assert.strictEqual(extractWebpAnimated(buildWebp("ANIM", [2])), void 0);
+		});
+		(0, import_qunit.test)("the avis brand marks an AVIF image sequence", function(assert) {
+			assert.true(extractAvifAnimated(buildFtyp("avis", ["avif", "msf1"])));
+			assert.true(extractAvifAnimated(buildFtyp("mif1", [
+				"avif",
+				"avis",
+				"miaf"
+			])), "a compatible brand counts as much as the major brand");
+			assert.false(extractAvifAnimated(buildFtyp("avif", ["mif1", "miaf"])));
+		});
+		(0, import_qunit.test)("an AVIF without a readable ftyp box is unknown", function(assert) {
+			assert.strictEqual(extractAvifAnimated(new Uint8Array(24)), void 0);
+			let ftyp = buildFtyp("avif", ["mif1", "miaf"]);
+			assert.strictEqual(extractAvifAnimated(ftyp.subarray(0, ftyp.length - 4)), void 0, "a truncated ftyp could still list avis in the brands it lost");
+		});
+	});
+	(0, import_qunit.module)("attribute assembly", function() {
+		(0, import_qunit.test)("the container header outranks the EXIF color-space tag", function(assert) {
+			let attributes = rasterImageAttributes({ colorSpace: "srgb" }, {
+				colorSpace: "display-p3",
+				bitDepth: 10
+			});
+			assert.deepEqual(attributes.colorProfile, {
+				bitDepth: 10,
+				colorSpace: {
+					code: "display-p3",
+					scheme: "color-space"
+				}
+			});
+		});
+		(0, import_qunit.test)("the EXIF tag supplies a color space the header did not", function(assert) {
+			let attributes = rasterImageAttributes({ colorSpace: "adobe-rgb" }, {
+				bitDepth: 8,
+				channels: 3
+			});
+			assert.deepEqual(attributes.colorProfile, {
+				bitDepth: 8,
+				channels: 3,
+				colorSpace: {
+					code: "adobe-rgb",
+					scheme: "color-space"
+				}
+			});
+		});
+		(0, import_qunit.test)("a color space is enough on its own to produce the field", function(assert) {
+			let attributes = rasterImageAttributes({ colorSpace: "srgb" }, void 0);
+			assert.deepEqual(attributes.colorProfile, { colorSpace: {
+				code: "srgb",
+				scheme: "color-space"
+			} });
+		});
+		(0, import_qunit.test)("an image that revealed nothing adds no attributes at all", function(assert) {
+			assert.deepEqual(rasterImageAttributes(void 0, void 0), {}, "no empty exif or colorProfile object reaches the index row");
+		});
+		(0, import_qunit.test)("the EXIF color-space tag never becomes part of the exif attribute", function(assert) {
+			let attributes = rasterImageAttributes({
+				capture: { make: "Leica" },
+				colorSpace: "srgb"
+			}, void 0);
+			assert.deepEqual(attributes.exif, { capture: { make: "Leica" } });
+		});
+		(0, import_qunit.test)("a false alpha flag survives assembly rather than being pruned as empty", function(assert) {
+			let attributes = rasterImageAttributes(void 0, { hasAlpha: false });
+			assert.deepEqual(attributes.colorProfile, { hasAlpha: false }, "knowing a format has no alpha channel is a fact worth persisting");
+		});
+		(0, import_qunit.test)("a still verdict is persisted, and an undetermined one adds nothing", function(assert) {
+			assert.deepEqual(rasterImageAttributes(void 0, void 0, false), { animation: "still" });
+			assert.deepEqual(rasterImageAttributes(void 0, void 0, true), { animation: "animated" });
+			assert.deepEqual(rasterImageAttributes(void 0, void 0, void 0), {});
+		});
+	});
+});
+//#endregion