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

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

@@ -1,1109 +0,0 @@
-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-Dd8k0DNa.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