maka-agent 0.2.0-dev.62.20260928 → 0.2.0-dev.67.20261002

package/node_modules/image-dimensions/types/jpeg.js

@@ -1,15 +1,20 @@
 import {isValidOffsetToRead, getUint16} from '../utilities.js';
 
-const SOF0 = 0xFF_C0;
-const SOF3 = 0xFF_C3;
+// Frame header markers (SOF0-SOF15, except DHT/JPG/DAC which are not frame headers).
+const isFrameMarker = marker =>
+	marker >= 0xFF_C0
+	&& marker <= 0xFF_CF
+	&& marker !== 0xFF_C4
+	&& marker !== 0xFF_C8
+	&& marker !== 0xFF_CC;
 
-const jsJpeg = bytes =>
+const isJpeg = bytes =>
 	bytes[0] === 0xFF
 	&& bytes[1] === 0xD8
 	&& bytes[2] === 0xFF;
 
 export default function jpeg(bytes) {
-	if (!jsJpeg(bytes)) {
+	if (!isJpeg(bytes)) {
 		return;
 	}
 
@@ -18,12 +23,28 @@ export default function jpeg(bytes) {
 	let offset = 2; // Start after the SOI marker.
 
 	while (isValidOffsetToRead(dataView, offset, 2)) {
+		// A marker is 0xFF followed by a non-0xFF byte. Skip fill bytes (0xFF) and any extraneous bytes before it, like libjpeg does.
+		if (dataView.getUint8(offset) !== 0xFF || dataView.getUint8(offset + 1) === 0xFF) {
+			offset++;
+			continue;
+		}
+
 		const marker = dataView.getUint16(offset);
 		offset += 2; // Move past the marker.
 
-		if (marker >= SOF0 && marker <= SOF3) {
-			const height = getUint16(dataView, offset + 3, false);
-			const width = getUint16(dataView, offset + 5, false);
+		// TEM is a standalone marker with no segment length.
+		if (marker === 0xFF_01) {
+			continue;
+		}
+
+		// SOS starts the entropy-coded data, which cannot be skipped by segment length. A frame header must precede it, so stop here instead of misreading scan data as markers.
+		if (marker === 0xFF_DA) {
+			return;
+		}
+
+		if (isFrameMarker(marker)) {
+			const height = getUint16(dataView, offset + 3);
+			const width = getUint16(dataView, offset + 5);
 
 			if (height === undefined || width === undefined) {
 				return;

package/node_modules/image-dimensions/types/png.js

@@ -17,6 +17,12 @@ const isAppleMinifiedPng = bytes =>
 	&& bytes[14] === 0x42
 	&& bytes[15] === 0x49;
 
+const isImageHeaderChunk = (bytes, offset) =>
+	bytes[offset] === 0x49 // I
+	&& bytes[offset + 1] === 0x48 // H
+	&& bytes[offset + 2] === 0x44 // D
+	&& bytes[offset + 3] === 0x52; // R
+
 export default function png(bytes) {
 	if (!isPng(bytes)) {
 		return;
@@ -24,9 +30,14 @@ export default function png(bytes) {
 
 	const dataView = new DataView(bytes.buffer);
 	const isAppleMinified = isAppleMinifiedPng(bytes);
+	const chunkTypeOffset = isAppleMinified ? 28 : 12;
+
+	if (!isImageHeaderChunk(bytes, chunkTypeOffset)) {
+		return;
+	}
 
-	const width = getUint32(dataView, isAppleMinified ? 32 : 16, false);
-	const height = getUint32(dataView, isAppleMinified ? 36 : 20, false);
+	const width = getUint32(dataView, chunkTypeOffset + 4);
+	const height = getUint32(dataView, chunkTypeOffset + 8);
 
 	if (width === undefined || height === undefined) {
 		return;

package/node_modules/image-dimensions/types/webp.js

@@ -1,39 +1,8 @@
-import {isValidOffsetToRead, getUint32} from '../utilities.js';
+import {isValidOffsetToRead, getUint32, getFourCC} from '../utilities.js';
 
 // Specification: https://developers.google.com/speed/webp/docs/riff_container
 
-const isWebp = bytes =>
-	// RIFF
-	bytes[0] === 0x52
-	&& bytes[1] === 0x49
-	&& bytes[2] === 0x46
-	&& bytes[3] === 0x46
-	// WEBP
-	&& bytes[8] === 0x57
-	&& bytes[9] === 0x45
-	&& bytes[10] === 0x42
-	&& bytes[11] === 0x50;
-
-const isVP8Lossy = bytes =>
-	// `VP8 ` (note the space)
-	bytes[12] === 0x56
-	&& bytes[13] === 0x50
-	&& bytes[14] === 0x38
-	&& bytes[15] === 0x20;
-
-const isVP8Lossless = bytes =>
-	// `VP8L`
-	bytes[12] === 0x56
-	&& bytes[13] === 0x50
-	&& bytes[14] === 0x38
-	&& bytes[15] === 0x4C;
-
-const isVP8Extended = bytes =>
-	// `VP8X`
-	bytes[12] === 0x56
-	&& bytes[13] === 0x50
-	&& bytes[14] === 0x38
-	&& bytes[15] === 0x58;
+const isWebp = bytes => getFourCC(bytes, 0) === 'RIFF' && getFourCC(bytes, 8) === 'WEBP';
 
 function readUInt24LE(dataView, offset) {
 	const byte1 = dataView.getUint8(offset);
@@ -51,9 +20,19 @@ export default function webp(bytes) {
 	}
 
 	const dataView = new DataView(bytes.buffer);
+	// The first chunk is `VP8 ` (lossy, note the space), `VP8L` (lossless), or `VP8X` (extended).
+	const chunkType = getFourCC(bytes, 12);
+	const chunkSize = getUint32(dataView, 16, true);
+
+	// The chunk payload is at least 5 bytes for VP8L and 10 bytes for VP8 and VP8X (32-bit chunk size at offset 16).
+	// A smaller chunk means the dimension fields would come from the next chunk. VP8X allows future fields, so larger sizes are fine.
+	if (chunkSize === undefined || chunkSize < (chunkType === 'VP8L' ? 5 : 10)) {
+		return;
+	}
+
 	const maxSize = 0x3F_FF;
 
-	if (isVP8Lossy(bytes)) {
+	if (chunkType === 'VP8 ') {
 		if (!isValidOffsetToRead(dataView, 28, 2)) {
 			return;
 		}
@@ -67,7 +46,12 @@ export default function webp(bytes) {
 		};
 	}
 
-	if (isVP8Lossless(bytes)) {
+	if (chunkType === 'VP8L') {
+		// The lossless bitstream starts with a 1-byte signature (0x2F) before the packed dimension bits.
+		if (bytes[20] !== 0x2F) {
+			return;
+		}
+
 		const bits = getUint32(dataView, 21, true);
 
 		if (bits === undefined) {
@@ -83,7 +67,7 @@ export default function webp(bytes) {
 		};
 	}
 
-	if (isVP8Extended(bytes)) {
+	if (chunkType === 'VP8X') {
 		if (!isValidOffsetToRead(dataView, 27, 3)) {
 			return;
 		}

package/node_modules/image-dimensions/utilities.js

@@ -14,40 +14,56 @@ export function getUint16(dataView, offset, littleEndian = false) {
 	}
 }
 
+// Read a 4-character code (4CC) such as a box type or a brand.
+export function getFourCC(bytes, offset) {
+	return String.fromCodePoint(...bytes.subarray(offset, offset + 4));
+}
+
 /*
-Parse the FileTypeBox (ftyp) at the start of an ISOBMFF container and return an array of 4CC brand strings (major brand first, followed by compatible brands).
+Get the dimensions of an ISOBMFF-based image (HEIF/HEIC or AVIF) when its file-type brands match.
 
-Applicable to ISOBMFF-based image formats like HEIF/HEIC and AVIF. Not applicable to PNG, JPEG, GIF, or WebP.
+Returns {width, height, type} or undefined when the brands do not match or the primary item has no `ispe` property.
 */
-export function getIsobmffFtypBrands(bytes) {
-	// Minimum size: 4 (size) + 4 ('ftyp') + 4 (major_brand) + 4 (minor_version)
-	if (bytes.length < 16) {
+export function getIsobmffImageDimensions(bytes, brands, type) {
+	const fileBrands = getIsobmffFtypBrands(bytes);
+
+	if (!fileBrands?.some(brand => brands.has(brand))) {
 		return;
 	}
 
-	// Validate 'ftyp' marker at offset 4
-	const isFtyp = bytes[4] === 0x66
-		&& bytes[5] === 0x74
-		&& bytes[6] === 0x79
-		&& bytes[7] === 0x70;
+	const size = getIsobmffImageSizeFromMeta(bytes);
 
-	if (!isFtyp) {
+	if (!size) {
 		return;
 	}
 
-	// Box size (Big-endian) at offset 0
-	const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	const size = getUint32(dataView, 0);
-	if (size === undefined || size < 16 || size > bytes.length) {
+	return {
+		...size,
+		type,
+	};
+}
+
+/*
+Parse the FileTypeBox (ftyp) at the start of an ISOBMFF container and return an array of 4CC brand strings (major brand first, followed by compatible brands).
+
+Applicable to ISOBMFF-based image formats like HEIF/HEIC and AVIF. Not applicable to PNG, JPEG, GIF, or WebP.
+*/
+export function getIsobmffFtypBrands(bytes) {
+	// Box size (Big-endian) at offset 0, including an optional extended size.
+	const box = unboxIsobmffBox(bytes, 0);
+
+	// Validate 'ftyp' marker at offset 4.
+	// Minimum payload size: 4 (major_brand) + 4 (minor_version).
+	if (!box || box.type !== 'ftyp' || box.data.length < 8) {
 		return;
 	}
 
-	const brands = [];
 	// Major brand
-	brands.push(String.fromCodePoint(...bytes.slice(8, 12)));
-	// Compatible brands start at offset 16
-	for (let i = 16; i + 4 <= size; i += 4) {
-		brands.push(String.fromCodePoint(...bytes.slice(i, i + 4)));
+	const brands = [getFourCC(box.data, 0)];
+
+	// Compatible brands start at payload offset 8.
+	for (let i = 8; i + 4 <= box.data.length; i += 4) {
+		brands.push(getFourCC(box.data, i));
 	}
 
 	return brands;
@@ -60,54 +76,106 @@ Returns an object with {type, data, tail} or undefined if invalid.
 
 Applicable to ISOBMFF-based image formats like HEIF/HEIC and AVIF.
 */
-export function unboxIsobmffBox(data, offset) {
+export function unboxIsobmffBox(data, offset, {isTopLevel = false} = {}) {
 	const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
-	const size = getUint32(dataView, offset);
+	let size = getUint32(dataView, offset);
+	let headerSize = 8; // 4 (size) + 4 (type)
 
 	if (size === undefined) {
 		return;
 	}
 
-	// Size includes the first 4 bytes (length)
-	if (data.length < size + offset || size < 8) {
+	// An extended size of 1 means the real size is a 64-bit value following the type (ISO/IEC 14496-12 §4.2.2).
+	if (size === 1) {
+		headerSize += 8;
+
+		if (!isValidOffsetToRead(dataView, offset, headerSize)) {
+			return;
+		}
+
+		const extendedSize = dataView.getBigUint64(offset + 8);
+		if (extendedSize > BigInt(data.length - offset)) {
+			return;
+		}
+
+		size = Number(extendedSize);
+	}
+
+	// A size of 0 is only valid for a top-level box and means it extends to the end of the file (ISO/IEC 14496-12 §4.2.2).
+	if (size === 0 && isTopLevel) {
+		size = data.length - offset;
+	}
+
+	// Size includes the header
+	if (data.length < size + offset || size < headerSize) {
 		return;
 	}
 
 	return {
-		type: String.fromCodePoint(...data.slice(offset + 4, offset + 8)),
-		data: data.slice(offset + 8, offset + size),
+		type: getFourCC(data, offset + 4),
+		data: data.subarray(offset + headerSize, offset + size),
 		tail: offset + size,
 	};
 }
 
 /*
-Traverse ISOBMFF boxes to collect image spatial extents from `ispe` properties under the `meta` → `iprp` → `ipco` hierarchy.
+Resolve the image dimensions of a HEIF/HEIC/AVIF file from its `meta` box.
+
+Follows the primary item (`pitm`) to its `ispe` property via the item-to-property associations (`ipma`), so thumbnails or secondary items do not leak in.
 
-Applicable to HEIF/HEIC and AVIF; codec-agnostic within ISOBMFF.
+Returns {width, height} or undefined when the primary item has no `ispe` property.
 */
-export function getIsobmffIspeSizesFromMeta(data) {
-	const sizes = [];
+function getIsobmffImageSizeFromMeta(data) {
+	const meta = findIsobmffTopLevelBox(data, 'meta');
+
+	if (!meta) {
+		return;
+	}
+
+	const {sizes, primaryItemId, associations} = parseIsobmffMetaBox(meta.data);
+
+	// Property indices in `ipma` are 1-based over `ipco` children.
+	const primaryAssociations = new Set(associations
+		.filter(association => association.itemId === primaryItemId)
+		.flatMap(association => association.propertyIndices));
+	const primarySize = sizes.find(size => primaryAssociations.has(size.propertyIndex));
+
+	if (!primarySize) {
+		return;
+	}
+
+	return {
+		width: primarySize.width,
+		height: primarySize.height,
+	};
+}
+
+function findIsobmffTopLevelBox(data, type) {
 	let offset = 0;
 
 	while (offset < data.length) {
-		const box = unboxIsobmffBox(data, offset);
+		const box = unboxIsobmffBox(data, offset, {isTopLevel: true});
 
 		if (!box) {
-			break;
+			return;
 		}
 
-		if (box.type === 'meta') {
-			parseIsobmffMetaBox(box.data, sizes);
+		if (box.type === type) {
+			return box;
 		}
 
 		offset = box.tail;
 	}
-
-	return sizes;
 }
 
 // Parses `meta` box
-function parseIsobmffMetaBox(data, sizes) {
+function parseIsobmffMetaBox(data) {
+	const info = {
+		sizes: [],
+		primaryItemId: undefined,
+		associations: [],
+	};
+
 	// Skip version (1 byte) and flags (3 bytes).
 	let offset = 4; // Version + flags
 
@@ -119,17 +187,83 @@ function parseIsobmffMetaBox(data, sizes) {
 		}
 
 		if (box.type === 'iprp') {
-			parseIsobmffIprpBox(box.data, sizes);
+			parseIsobmffIprpBox(box.data, info);
+		} else if (box.type === 'pitm') {
+			info.primaryItemId = parseIsobmffPitmBox(box.data);
 		}
 
 		offset = box.tail;
 	}
 
-	return sizes;
+	return info;
+}
+
+// Parses `meta.pitm` box (Primary Item), returns the primary item ID.
+function parseIsobmffPitmBox(data) {
+	if (data.length < 6 || data[0] > 1) {
+		return;
+	}
+
+	const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+	// Version 0 uses a 16-bit item ID, version 1 a 32-bit one.
+	return data[0] === 0 ? getUint16(dataView, 4) : getUint32(dataView, 4);
+}
+
+// Parses `meta.iprp.ipma` box (Item to Property Association), returns [{itemId, propertyIndices}].
+function parseIsobmffIpmaBox(data) {
+	if (data.length < 8 || data[0] > 1) {
+		return [];
+	}
+
+	const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const version = dataView.getUint8(0);
+	const flags = dataView.getUint8(3);
+	const entryCount = getUint32(dataView, 4);
+
+	if (entryCount === undefined) {
+		return [];
+	}
+
+	const itemIdSize = version === 0 ? 2 : 4;
+	// eslint-disable-next-line no-bitwise
+	const associationSize = (flags & 1) === 0 ? 1 : 2;
+	const essentialMask = associationSize === 1 ? 0x7F : 0x7F_FF;
+
+	const associations = [];
+	let offset = 8;
+
+	for (let entry = 0; entry < entryCount && offset + itemIdSize + 1 <= data.byteLength; entry++) {
+		const itemId = itemIdSize === 2 ? getUint16(dataView, offset) : getUint32(dataView, offset);
+		offset += itemIdSize;
+		const propertyCount = dataView.getUint8(offset);
+		offset++;
+
+		if (!isValidOffsetToRead(dataView, offset, propertyCount * associationSize)) {
+			return [];
+		}
+
+		const propertyIndices = [];
+		for (let index = 0; index < propertyCount; index++) {
+			const value = associationSize === 1 ? dataView.getUint8(offset) : dataView.getUint16(offset);
+			offset += associationSize;
+
+			// The essential bit is not part of the property index. Index 0 means "no property".
+			// eslint-disable-next-line no-bitwise
+			const propertyIndex = value & essentialMask;
+			if (propertyIndex > 0) {
+				propertyIndices.push(propertyIndex);
+			}
+		}
+
+		associations.push({itemId, propertyIndices});
+	}
+
+	return associations;
 }
 
 // Parses `meta.iprp` box (Item Properties)
-function parseIsobmffIprpBox(data, sizes) {
+function parseIsobmffIprpBox(data, info) {
 	let offset = 0;
 
 	while (offset < data.length) {
@@ -140,7 +274,9 @@ function parseIsobmffIprpBox(data, sizes) {
 		}
 
 		if (box.type === 'ipco') {
-			parseIsobmffIpcoBox(box.data, sizes);
+			parseIsobmffIpcoBox(box.data, info);
+		} else if (box.type === 'ipma') {
+			info.associations.push(...parseIsobmffIpmaBox(box.data));
 		}
 
 		offset = box.tail;
@@ -148,8 +284,10 @@ function parseIsobmffIprpBox(data, sizes) {
 }
 
 // Parses `meta.iprp.ipco` box (Item Property Container)
-function parseIsobmffIpcoBox(data, sizes) {
+function parseIsobmffIpcoBox(data, info) {
 	let offset = 0;
+	// Property indices are 1-based over the `ipco` children.
+	let propertyIndex = 0;
 
 	while (offset < data.length) {
 		const box = unboxIsobmffBox(data, offset);
@@ -158,6 +296,8 @@ function parseIsobmffIpcoBox(data, sizes) {
 			break;
 		}
 
+		propertyIndex++;
+
 		// Image Spatial Extent
 		if (box.type === 'ispe') {
 			const dataView = new DataView(box.data.buffer, box.data.byteOffset, box.data.byteLength);
@@ -168,29 +308,13 @@ function parseIsobmffIpcoBox(data, sizes) {
 				return;
 			}
 
-			sizes.push({
+			info.sizes.push({
 				width,
 				height,
+				propertyIndex,
 			});
 		}
 
 		offset = box.tail;
 	}
 }
-
-/*
-Return the size with the largest area from a list of {width, height}.
-
-Generic helper used by HEIF/HEIC and AVIF readers.
-*/
-export function getLargestAreaSize(sizes) {
-	let maxSize = sizes[0];
-
-	for (const size of sizes) {
-		if (size.width * size.height > maxSize.width * maxSize.height) {
-			maxSize = size;
-		}
-	}
-
-	return maxSize;
-}