emdash 0.40.1 → 0.41.0

package/dist/dist-FPR93_xf.mjs

@@ -0,0 +1,810 @@
+//#region ../../node_modules/.pnpm/image-size@2.0.2_patch_hash=77c12533e3a635c4066c55da8952f4912e8210416539dc1249550fa639271595/node_modules/image-size/dist/index.mjs
+var decoder = new TextDecoder();
+var toUTF8String = (input, start = 0, end = input.length) => decoder.decode(input.slice(start, end));
+var toHexString = (input, start = 0, end = input.length) => input.slice(start, end).reduce((memo, i) => memo + `0${i.toString(16)}`.slice(-2), "");
+var getView = (input, offset) => new DataView(input.buffer, input.byteOffset + offset);
+var readInt16LE = (input, offset = 0) => getView(input, offset).getInt16(0, true);
+var readUInt16BE = (input, offset = 0) => getView(input, offset).getUint16(0, false);
+var readUInt16LE = (input, offset = 0) => getView(input, offset).getUint16(0, true);
+var readUInt24LE = (input, offset = 0) => {
+	const view = getView(input, offset);
+	return view.getUint16(0, true) + (view.getUint8(2) << 16);
+};
+var readInt32LE = (input, offset = 0) => getView(input, offset).getInt32(0, true);
+var readUInt32BE = (input, offset = 0) => getView(input, offset).getUint32(0, false);
+var readUInt32LE = (input, offset = 0) => getView(input, offset).getUint32(0, true);
+var readUInt64 = (input, offset, isBigEndian) => getView(input, offset).getBigUint64(0, !isBigEndian);
+var methods = {
+	readUInt16BE,
+	readUInt16LE,
+	readUInt32BE,
+	readUInt32LE
+};
+function readUInt(input, bits, offset = 0, isBigEndian = false) {
+	return methods[`readUInt${bits}${isBigEndian ? "BE" : "LE"}`](input, offset);
+}
+function readBox(input, offset) {
+	if (input.length - offset < 4) return;
+	const boxSize = readUInt32BE(input, offset);
+	if (input.length - offset < boxSize) return;
+	return {
+		name: toUTF8String(input, 4 + offset, 8 + offset),
+		offset,
+		size: boxSize
+	};
+}
+function findBox(input, boxName, currentOffset) {
+	while (currentOffset < input.length) {
+		const box = readBox(input, currentOffset);
+		if (!box) break;
+		if (box.name === boxName) return box;
+		currentOffset += box.size > 0 ? box.size : 8;
+	}
+}
+var BMP = {
+	validate: (input) => toUTF8String(input, 0, 2) === "BM",
+	calculate: (input) => ({
+		height: Math.abs(readInt32LE(input, 22)),
+		width: readUInt32LE(input, 18)
+	})
+};
+var TYPE_ICON = 1;
+var SIZE_HEADER = 6;
+var SIZE_IMAGE_ENTRY = 16;
+function getSizeFromOffset(input, offset) {
+	const value = input[offset];
+	return value === 0 ? 256 : value;
+}
+function getImageSize(input, imageIndex) {
+	const offset = SIZE_HEADER + imageIndex * SIZE_IMAGE_ENTRY;
+	return {
+		height: getSizeFromOffset(input, offset + 1),
+		width: getSizeFromOffset(input, offset)
+	};
+}
+var ICO = {
+	validate(input) {
+		const reserved = readUInt16LE(input, 0);
+		const imageCount = readUInt16LE(input, 4);
+		if (reserved !== 0 || imageCount === 0) return false;
+		return readUInt16LE(input, 2) === TYPE_ICON;
+	},
+	calculate(input) {
+		const nbImages = readUInt16LE(input, 4);
+		const imageSize2 = getImageSize(input, 0);
+		if (nbImages === 1) return imageSize2;
+		const images = [];
+		for (let imageIndex = 0; imageIndex < nbImages; imageIndex += 1) images.push(getImageSize(input, imageIndex));
+		return {
+			width: imageSize2.width,
+			height: imageSize2.height,
+			images
+		};
+	}
+};
+var TYPE_CURSOR = 2;
+var CUR = {
+	validate(input) {
+		const reserved = readUInt16LE(input, 0);
+		const imageCount = readUInt16LE(input, 4);
+		if (reserved !== 0 || imageCount === 0) return false;
+		return readUInt16LE(input, 2) === TYPE_CURSOR;
+	},
+	calculate: (input) => ICO.calculate(input)
+};
+var DDS = {
+	validate: (input) => readUInt32LE(input, 0) === 542327876,
+	calculate: (input) => ({
+		height: readUInt32LE(input, 12),
+		width: readUInt32LE(input, 16)
+	})
+};
+var gifRegexp = /^GIF8[79]a/;
+var GIF = {
+	validate: (input) => gifRegexp.test(toUTF8String(input, 0, 6)),
+	calculate: (input) => ({
+		height: readUInt16LE(input, 8),
+		width: readUInt16LE(input, 6)
+	})
+};
+var brandMap = {
+	avif: "avif",
+	mif1: "heif",
+	msf1: "heif",
+	heic: "heic",
+	heix: "heic",
+	hevc: "heic",
+	hevx: "heic"
+};
+var HEIF = {
+	validate(input) {
+		if (toUTF8String(input, 4, 8) !== "ftyp") return false;
+		const ftypBox = findBox(input, "ftyp", 0);
+		if (!ftypBox) return false;
+		return toUTF8String(input, ftypBox.offset + 8, ftypBox.offset + 12) in brandMap;
+	},
+	calculate(input) {
+		const metaBox = findBox(input, "meta", 0);
+		const iprpBox = metaBox && findBox(input, "iprp", metaBox.offset + 12);
+		const ipcoBox = iprpBox && findBox(input, "ipco", iprpBox.offset + 8);
+		if (!ipcoBox) throw new TypeError("Invalid HEIF, no ipco box found");
+		const type = toUTF8String(input, 8, 12);
+		const images = [];
+		let currentOffset = ipcoBox.offset + 8;
+		while (currentOffset < ipcoBox.offset + ipcoBox.size) {
+			const ispeBox = findBox(input, "ispe", currentOffset);
+			if (!ispeBox) break;
+			const rawWidth = readUInt32BE(input, ispeBox.offset + 12);
+			const rawHeight = readUInt32BE(input, ispeBox.offset + 16);
+			const clapBox = findBox(input, "clap", currentOffset);
+			let width = rawWidth;
+			let height = rawHeight;
+			if (clapBox && clapBox.offset < ipcoBox.offset + ipcoBox.size) width = rawWidth - readUInt32BE(input, clapBox.offset + 12);
+			images.push({
+				height,
+				width
+			});
+			currentOffset = ispeBox.offset + (ispeBox.size > 0 ? ispeBox.size : 8);
+		}
+		if (images.length === 0) throw new TypeError("Invalid HEIF, no sizes found");
+		return {
+			width: images[0].width,
+			height: images[0].height,
+			type,
+			...images.length > 1 ? { images } : {}
+		};
+	}
+};
+var SIZE_HEADER2 = 8;
+var FILE_LENGTH_OFFSET = 4;
+var ENTRY_LENGTH_OFFSET = 4;
+var ICON_TYPE_SIZE = {
+	ICON: 32,
+	"ICN#": 32,
+	"icm#": 16,
+	icm4: 16,
+	icm8: 16,
+	"ics#": 16,
+	ics4: 16,
+	ics8: 16,
+	is32: 16,
+	s8mk: 16,
+	icp4: 16,
+	icl4: 32,
+	icl8: 32,
+	il32: 32,
+	l8mk: 32,
+	icp5: 32,
+	ic11: 32,
+	ich4: 48,
+	ich8: 48,
+	ih32: 48,
+	h8mk: 48,
+	icp6: 64,
+	ic12: 32,
+	it32: 128,
+	t8mk: 128,
+	ic07: 128,
+	ic08: 256,
+	ic13: 256,
+	ic09: 512,
+	ic14: 512,
+	ic10: 1024
+};
+function readImageHeader(input, imageOffset) {
+	const imageLengthOffset = imageOffset + ENTRY_LENGTH_OFFSET;
+	return [toUTF8String(input, imageOffset, imageLengthOffset), readUInt32BE(input, imageLengthOffset)];
+}
+function getImageSize2(type) {
+	const size = ICON_TYPE_SIZE[type];
+	return {
+		width: size,
+		height: size,
+		type
+	};
+}
+var ICNS = {
+	validate: (input) => toUTF8String(input, 0, 4) === "icns",
+	calculate(input) {
+		const inputLength = input.length;
+		const fileLength = readUInt32BE(input, FILE_LENGTH_OFFSET);
+		let imageOffset = SIZE_HEADER2;
+		const images = [];
+		while (imageOffset < fileLength && imageOffset < inputLength) {
+			const imageHeader = readImageHeader(input, imageOffset);
+			const imageSize2 = getImageSize2(imageHeader[0]);
+			images.push(imageSize2);
+			imageOffset += imageHeader[1] > 0 ? imageHeader[1] : 8;
+		}
+		if (images.length === 0) throw new TypeError("Invalid ICNS, no sizes found");
+		return {
+			width: images[0].width,
+			height: images[0].height,
+			...images.length > 1 ? { images } : {}
+		};
+	}
+};
+var J2C = {
+	validate: (input) => readUInt32BE(input, 0) === 4283432785,
+	calculate: (input) => ({
+		height: readUInt32BE(input, 12),
+		width: readUInt32BE(input, 8)
+	})
+};
+var JP2 = {
+	validate(input) {
+		if (toUTF8String(input, 4, 8) !== "jP  ") return false;
+		const ftypBox = findBox(input, "ftyp", 0);
+		if (!ftypBox) return false;
+		return toUTF8String(input, ftypBox.offset + 8, ftypBox.offset + 12) === "jp2 ";
+	},
+	calculate(input) {
+		const jp2hBox = findBox(input, "jp2h", 0);
+		const ihdrBox = jp2hBox && findBox(input, "ihdr", jp2hBox.offset + 8);
+		if (ihdrBox) return {
+			height: readUInt32BE(input, ihdrBox.offset + 8),
+			width: readUInt32BE(input, ihdrBox.offset + 12)
+		};
+		throw new TypeError("Unsupported JPEG 2000 format");
+	}
+};
+var EXIF_MARKER = "45786966";
+var APP1_DATA_SIZE_BYTES = 2;
+var EXIF_HEADER_BYTES = 6;
+var TIFF_BYTE_ALIGN_BYTES = 2;
+var BIG_ENDIAN_BYTE_ALIGN = "4d4d";
+var LITTLE_ENDIAN_BYTE_ALIGN = "4949";
+var IDF_ENTRY_BYTES = 12;
+var NUM_DIRECTORY_ENTRIES_BYTES = 2;
+function isEXIF(input) {
+	return toHexString(input, 2, 6) === EXIF_MARKER;
+}
+function extractSize(input, index) {
+	return {
+		height: readUInt16BE(input, index),
+		width: readUInt16BE(input, index + 2)
+	};
+}
+function extractOrientation(exifBlock, isBigEndian) {
+	const offset = EXIF_HEADER_BYTES + 8;
+	const idfDirectoryEntries = readUInt(exifBlock, 16, offset, isBigEndian);
+	for (let directoryEntryNumber = 0; directoryEntryNumber < idfDirectoryEntries; directoryEntryNumber++) {
+		const start = offset + NUM_DIRECTORY_ENTRIES_BYTES + directoryEntryNumber * IDF_ENTRY_BYTES;
+		const end = start + IDF_ENTRY_BYTES;
+		if (start > exifBlock.length) return;
+		const block = exifBlock.slice(start, end);
+		if (readUInt(block, 16, 0, isBigEndian) === 274) {
+			if (readUInt(block, 16, 2, isBigEndian) !== 3) return;
+			if (readUInt(block, 32, 4, isBigEndian) !== 1) return;
+			return readUInt(block, 16, 8, isBigEndian);
+		}
+	}
+}
+function validateExifBlock(input, index) {
+	const exifBlock = input.slice(APP1_DATA_SIZE_BYTES, index);
+	const byteAlign = toHexString(exifBlock, EXIF_HEADER_BYTES, EXIF_HEADER_BYTES + TIFF_BYTE_ALIGN_BYTES);
+	const isBigEndian = byteAlign === BIG_ENDIAN_BYTE_ALIGN;
+	if (isBigEndian || byteAlign === LITTLE_ENDIAN_BYTE_ALIGN) return extractOrientation(exifBlock, isBigEndian);
+}
+function validateInput(input, index) {
+	if (index > input.length) throw new TypeError("Corrupt JPG, exceeded buffer limits");
+}
+var JPG = {
+	validate: (input) => toHexString(input, 0, 2) === "ffd8",
+	calculate(_input) {
+		let input = _input.slice(4);
+		let orientation;
+		let next;
+		while (input.length) {
+			const i = readUInt16BE(input, 0);
+			validateInput(input, i);
+			if (input[i] !== 255) {
+				input = input.slice(1);
+				continue;
+			}
+			if (isEXIF(input)) orientation = validateExifBlock(input, i);
+			next = input[i + 1];
+			if (next === 192 || next === 193 || next === 194) {
+				const size = extractSize(input, i + 5);
+				if (!orientation) return size;
+				return {
+					height: size.height,
+					orientation,
+					width: size.width
+				};
+			}
+			input = input.slice(i + 2);
+		}
+		throw new TypeError("Invalid JPG, no size found");
+	}
+};
+var BitReader = class {
+	constructor(input, endianness) {
+		this.input = input;
+		this.endianness = endianness;
+		this.byteOffset = 2;
+		this.bitOffset = 0;
+	}
+	/** Reads a specified number of bits, and move the offset */
+	getBits(length = 1) {
+		let result = 0;
+		let bitsRead = 0;
+		while (bitsRead < length) {
+			if (this.byteOffset >= this.input.length) throw new Error("Reached end of input");
+			const currentByte = this.input[this.byteOffset];
+			const bitsLeft = 8 - this.bitOffset;
+			const bitsToRead = Math.min(length - bitsRead, bitsLeft);
+			if (this.endianness === "little-endian") {
+				const mask = (1 << bitsToRead) - 1;
+				const bits = currentByte >> this.bitOffset & mask;
+				result |= bits << bitsRead;
+			} else {
+				const bits = (currentByte & (1 << bitsToRead) - 1 << 8 - this.bitOffset - bitsToRead) >> 8 - this.bitOffset - bitsToRead;
+				result = result << bitsToRead | bits;
+			}
+			bitsRead += bitsToRead;
+			this.bitOffset += bitsToRead;
+			if (this.bitOffset === 8) {
+				this.byteOffset++;
+				this.bitOffset = 0;
+			}
+		}
+		return result;
+	}
+};
+function calculateImageDimension(reader, isSmallImage) {
+	if (isSmallImage) return 8 * (1 + reader.getBits(5));
+	const extraBits = [
+		9,
+		13,
+		18,
+		30
+	][reader.getBits(2)];
+	return 1 + reader.getBits(extraBits);
+}
+function calculateImageWidth(reader, isSmallImage, widthMode, height) {
+	if (isSmallImage && widthMode === 0) return 8 * (1 + reader.getBits(5));
+	if (widthMode === 0) return calculateImageDimension(reader, false);
+	return Math.floor(height * [
+		1,
+		1.2,
+		4 / 3,
+		1.5,
+		16 / 9,
+		5 / 4,
+		2
+	][widthMode - 1]);
+}
+var JXLStream = {
+	validate: (input) => {
+		return toHexString(input, 0, 2) === "ff0a";
+	},
+	calculate(input) {
+		const reader = new BitReader(input, "little-endian");
+		const isSmallImage = reader.getBits(1) === 1;
+		const height = calculateImageDimension(reader, isSmallImage);
+		return {
+			width: calculateImageWidth(reader, isSmallImage, reader.getBits(3), height),
+			height
+		};
+	}
+};
+function extractCodestream(input) {
+	const jxlcBox = findBox(input, "jxlc", 0);
+	if (jxlcBox) return input.slice(jxlcBox.offset + 8, jxlcBox.offset + jxlcBox.size);
+	const partialStreams = extractPartialStreams(input);
+	if (partialStreams.length > 0) return concatenateCodestreams(partialStreams);
+}
+function extractPartialStreams(input) {
+	const partialStreams = [];
+	let offset = 0;
+	while (offset < input.length) {
+		const jxlpBox = findBox(input, "jxlp", offset);
+		if (!jxlpBox) break;
+		partialStreams.push(input.slice(jxlpBox.offset + 12, jxlpBox.offset + jxlpBox.size));
+		offset = jxlpBox.offset + (jxlpBox.size > 0 ? jxlpBox.size : 8);
+	}
+	return partialStreams;
+}
+function concatenateCodestreams(partialCodestreams) {
+	const totalLength = partialCodestreams.reduce((acc, curr) => acc + curr.length, 0);
+	const codestream = new Uint8Array(totalLength);
+	let position = 0;
+	for (const partial of partialCodestreams) {
+		codestream.set(partial, position);
+		position += partial.length;
+	}
+	return codestream;
+}
+var JXL = {
+	validate: (input) => {
+		if (toUTF8String(input, 4, 8) !== "JXL ") return false;
+		const ftypBox = findBox(input, "ftyp", 0);
+		if (!ftypBox) return false;
+		return toUTF8String(input, ftypBox.offset + 8, ftypBox.offset + 12) === "jxl ";
+	},
+	calculate(input) {
+		const codestream = extractCodestream(input);
+		if (codestream) return JXLStream.calculate(codestream);
+		throw new Error("No codestream found in JXL container");
+	}
+};
+var KTX = {
+	validate: (input) => {
+		const signature = toUTF8String(input, 1, 7);
+		return ["KTX 11", "KTX 20"].includes(signature);
+	},
+	calculate: (input) => {
+		const type = input[5] === 49 ? "ktx" : "ktx2";
+		const offset = type === "ktx" ? 36 : 20;
+		return {
+			height: readUInt32LE(input, offset + 4),
+			width: readUInt32LE(input, offset),
+			type
+		};
+	}
+};
+var pngSignature = "PNG\r\n\n";
+var pngImageHeaderChunkName = "IHDR";
+var pngFriedChunkName = "CgBI";
+var PNG = {
+	validate(input) {
+		if (pngSignature === toUTF8String(input, 1, 8)) {
+			let chunkName = toUTF8String(input, 12, 16);
+			if (chunkName === pngFriedChunkName) chunkName = toUTF8String(input, 28, 32);
+			if (chunkName !== pngImageHeaderChunkName) throw new TypeError("Invalid PNG");
+			return true;
+		}
+		return false;
+	},
+	calculate(input) {
+		if (toUTF8String(input, 12, 16) === pngFriedChunkName) return {
+			height: readUInt32BE(input, 36),
+			width: readUInt32BE(input, 32)
+		};
+		return {
+			height: readUInt32BE(input, 20),
+			width: readUInt32BE(input, 16)
+		};
+	}
+};
+var PNMTypes = {
+	P1: "pbm/ascii",
+	P2: "pgm/ascii",
+	P3: "ppm/ascii",
+	P4: "pbm",
+	P5: "pgm",
+	P6: "ppm",
+	P7: "pam",
+	PF: "pfm"
+};
+var handlers = {
+	default: (lines) => {
+		let dimensions = [];
+		while (lines.length > 0) {
+			const line = lines.shift();
+			if (line[0] === "#") continue;
+			dimensions = line.split(" ");
+			break;
+		}
+		if (dimensions.length === 2) return {
+			height: Number.parseInt(dimensions[1], 10),
+			width: Number.parseInt(dimensions[0], 10)
+		};
+		throw new TypeError("Invalid PNM");
+	},
+	pam: (lines) => {
+		const size = {};
+		while (lines.length > 0) {
+			const line = lines.shift();
+			if (line.length > 16 || line.charCodeAt(0) > 128) continue;
+			const [key, value] = line.split(" ");
+			if (key && value) size[key.toLowerCase()] = Number.parseInt(value, 10);
+			if (size.height && size.width) break;
+		}
+		if (size.height && size.width) return {
+			height: size.height,
+			width: size.width
+		};
+		throw new TypeError("Invalid PAM");
+	}
+};
+var PNM = {
+	validate: (input) => toUTF8String(input, 0, 2) in PNMTypes,
+	calculate(input) {
+		const type = PNMTypes[toUTF8String(input, 0, 2)];
+		const lines = toUTF8String(input, 3).split(/[\r\n]+/);
+		return (handlers[type] || handlers.default)(lines);
+	}
+};
+var PSD = {
+	validate: (input) => toUTF8String(input, 0, 4) === "8BPS",
+	calculate: (input) => ({
+		height: readUInt32BE(input, 14),
+		width: readUInt32BE(input, 18)
+	})
+};
+var svgReg = /<svg\s([^>"']|"[^"]*"|'[^']*')*>/;
+var extractorRegExps = {
+	height: /\sheight=(['"])([^%]+?)\1/,
+	root: svgReg,
+	viewbox: /\sviewBox=(['"])(.+?)\1/i,
+	width: /\swidth=(['"])([^%]+?)\1/
+};
+var INCH_CM = 2.54;
+var units = {
+	in: 96,
+	cm: 96 / INCH_CM,
+	em: 16,
+	ex: 8,
+	m: 96 / INCH_CM * 100,
+	mm: 96 / INCH_CM / 10,
+	pc: 96 / 72 / 12,
+	pt: 96 / 72,
+	px: 1
+};
+var unitsReg = new RegExp(`^([0-9.]+(?:e\\d+)?)(${Object.keys(units).join("|")})?$`);
+function parseLength(len) {
+	const m = unitsReg.exec(len);
+	if (!m) return;
+	return Math.round(Number(m[1]) * (units[m[2]] || 1));
+}
+function parseViewbox(viewbox) {
+	const bounds = viewbox.split(" ");
+	return {
+		height: parseLength(bounds[3]),
+		width: parseLength(bounds[2])
+	};
+}
+function parseAttributes(root) {
+	const width = root.match(extractorRegExps.width);
+	const height = root.match(extractorRegExps.height);
+	const viewbox = root.match(extractorRegExps.viewbox);
+	return {
+		height: height && parseLength(height[2]),
+		viewbox: viewbox && parseViewbox(viewbox[2]),
+		width: width && parseLength(width[2])
+	};
+}
+function calculateByDimensions(attrs) {
+	return {
+		height: attrs.height,
+		width: attrs.width
+	};
+}
+function calculateByViewbox(attrs, viewbox) {
+	const ratio = viewbox.width / viewbox.height;
+	if (attrs.width) return {
+		height: Math.floor(attrs.width / ratio),
+		width: attrs.width
+	};
+	if (attrs.height) return {
+		height: attrs.height,
+		width: Math.floor(attrs.height * ratio)
+	};
+	return {
+		height: viewbox.height,
+		width: viewbox.width
+	};
+}
+var SVG = {
+	validate: (input) => svgReg.test(toUTF8String(input, 0, 1e3)),
+	calculate(input) {
+		const root = toUTF8String(input).match(extractorRegExps.root);
+		if (root) {
+			const attrs = parseAttributes(root[0]);
+			if (attrs.width && attrs.height) return calculateByDimensions(attrs);
+			if (attrs.viewbox) return calculateByViewbox(attrs, attrs.viewbox);
+		}
+		throw new TypeError("Invalid SVG");
+	}
+};
+var TGA = {
+	validate(input) {
+		return readUInt16LE(input, 0) === 0 && readUInt16LE(input, 4) === 0;
+	},
+	calculate(input) {
+		return {
+			height: readUInt16LE(input, 14),
+			width: readUInt16LE(input, 12)
+		};
+	}
+};
+var CONSTANTS = {
+	TAG: {
+		WIDTH: 256,
+		HEIGHT: 257,
+		COMPRESSION: 259
+	},
+	TYPE: {
+		SHORT: 3,
+		LONG: 4,
+		LONG8: 16
+	},
+	ENTRY_SIZE: {
+		STANDARD: 12,
+		BIG: 20
+	},
+	COUNT_SIZE: {
+		STANDARD: 2,
+		BIG: 8
+	}
+};
+function readIFD(input, { isBigEndian, isBigTiff }) {
+	const ifdOffset = isBigTiff ? Number(readUInt64(input, 8, isBigEndian)) : readUInt(input, 32, 4, isBigEndian);
+	const entryCountSize = isBigTiff ? CONSTANTS.COUNT_SIZE.BIG : CONSTANTS.COUNT_SIZE.STANDARD;
+	return input.slice(ifdOffset + entryCountSize);
+}
+function readTagValue(input, type, offset, isBigEndian) {
+	switch (type) {
+		case CONSTANTS.TYPE.SHORT: return readUInt(input, 16, offset, isBigEndian);
+		case CONSTANTS.TYPE.LONG: return readUInt(input, 32, offset, isBigEndian);
+		case CONSTANTS.TYPE.LONG8: {
+			const value = Number(readUInt64(input, offset, isBigEndian));
+			if (value > Number.MAX_SAFE_INTEGER) throw new TypeError("Value too large");
+			return value;
+		}
+		default: return 0;
+	}
+}
+function nextTag(input, isBigTiff) {
+	const entrySize = isBigTiff ? CONSTANTS.ENTRY_SIZE.BIG : CONSTANTS.ENTRY_SIZE.STANDARD;
+	if (input.length > entrySize) return input.slice(entrySize);
+}
+function extractTags(input, { isBigEndian, isBigTiff }) {
+	const tags = {};
+	let temp = input;
+	while (temp?.length) {
+		const code = readUInt(temp, 16, 0, isBigEndian);
+		const type = readUInt(temp, 16, 2, isBigEndian);
+		const length = isBigTiff ? Number(readUInt64(temp, 4, isBigEndian)) : readUInt(temp, 32, 4, isBigEndian);
+		if (code === 0) break;
+		if (length === 1 && (type === CONSTANTS.TYPE.SHORT || type === CONSTANTS.TYPE.LONG || isBigTiff && type === CONSTANTS.TYPE.LONG8)) tags[code] = readTagValue(temp, type, isBigTiff ? 12 : 8, isBigEndian);
+		temp = nextTag(temp, isBigTiff);
+	}
+	return tags;
+}
+function determineFormat(input) {
+	const signature = toUTF8String(input, 0, 2);
+	const version = readUInt(input, 16, 2, signature === "MM");
+	return {
+		isBigEndian: signature === "MM",
+		isBigTiff: version === 43
+	};
+}
+function validateBigTIFFHeader(input, isBigEndian) {
+	const byteSize = readUInt(input, 16, 4, isBigEndian);
+	const reserved = readUInt(input, 16, 6, isBigEndian);
+	if (byteSize !== 8 || reserved !== 0) throw new TypeError("Invalid BigTIFF header");
+}
+var signatures = /* @__PURE__ */ new Set([
+	"49492a00",
+	"4d4d002a",
+	"49492b00",
+	"4d4d002b"
+]);
+var TIFF = {
+	validate: (input) => {
+		const signature = toHexString(input, 0, 4);
+		return signatures.has(signature);
+	},
+	calculate(input) {
+		const format = determineFormat(input);
+		if (format.isBigTiff) validateBigTIFFHeader(input, format.isBigEndian);
+		const tags = extractTags(readIFD(input, format), format);
+		const info = {
+			height: tags[CONSTANTS.TAG.HEIGHT],
+			width: tags[CONSTANTS.TAG.WIDTH],
+			type: format.isBigTiff ? "bigtiff" : "tiff"
+		};
+		if (tags[CONSTANTS.TAG.COMPRESSION]) info.compression = tags[CONSTANTS.TAG.COMPRESSION];
+		if (!info.width || !info.height) throw new TypeError("Invalid Tiff. Missing tags");
+		return info;
+	}
+};
+function calculateExtended(input) {
+	return {
+		height: 1 + readUInt24LE(input, 7),
+		width: 1 + readUInt24LE(input, 4)
+	};
+}
+function calculateLossless(input) {
+	return {
+		height: 1 + ((input[4] & 15) << 10 | input[3] << 2 | (input[2] & 192) >> 6),
+		width: 1 + ((input[2] & 63) << 8 | input[1])
+	};
+}
+function calculateLossy(input) {
+	return {
+		height: readInt16LE(input, 8) & 16383,
+		width: readInt16LE(input, 6) & 16383
+	};
+}
+var typeHandlers = /* @__PURE__ */ new Map([
+	["bmp", BMP],
+	["cur", CUR],
+	["dds", DDS],
+	["gif", GIF],
+	["heif", HEIF],
+	["icns", ICNS],
+	["ico", ICO],
+	["j2c", J2C],
+	["jp2", JP2],
+	["jpg", JPG],
+	["jxl", JXL],
+	["jxl-stream", JXLStream],
+	["ktx", KTX],
+	["png", PNG],
+	["pnm", PNM],
+	["psd", PSD],
+	["svg", SVG],
+	["tga", TGA],
+	["tiff", TIFF],
+	["webp", {
+		validate(input) {
+			const riffHeader = "RIFF" === toUTF8String(input, 0, 4);
+			const webpHeader = "WEBP" === toUTF8String(input, 8, 12);
+			const vp8Header = "VP8" === toUTF8String(input, 12, 15);
+			return riffHeader && webpHeader && vp8Header;
+		},
+		calculate(_input) {
+			const chunkHeader = toUTF8String(_input, 12, 16);
+			const input = _input.slice(20, 30);
+			if (chunkHeader === "VP8X") {
+				const extendedHeader = input[0];
+				const validStart = (extendedHeader & 192) === 0;
+				const validEnd = (extendedHeader & 1) === 0;
+				if (validStart && validEnd) return calculateExtended(input);
+				throw new TypeError("Invalid WebP");
+			}
+			if (chunkHeader === "VP8 " && input[0] !== 47) return calculateLossy(input);
+			const signature = toHexString(input, 3, 6);
+			if (chunkHeader === "VP8L" && signature !== "9d012a") return calculateLossless(input);
+			throw new TypeError("Invalid WebP");
+		}
+	}]
+]);
+var types = Array.from(typeHandlers.keys());
+var firstBytes = /* @__PURE__ */ new Map([
+	[0, "heif"],
+	[56, "psd"],
+	[66, "bmp"],
+	[68, "dds"],
+	[71, "gif"],
+	[73, "tiff"],
+	[77, "tiff"],
+	[82, "webp"],
+	[105, "icns"],
+	[137, "png"],
+	[255, "jpg"]
+]);
+function detector(input) {
+	const byte = input[0];
+	const type = firstBytes.get(byte);
+	if (type && typeHandlers.get(type).validate(input)) return type;
+	return types.find((type2) => typeHandlers.get(type2).validate(input));
+}
+var globalOptions = { disabledTypes: [] };
+function imageSize(input) {
+	const type = detector(input);
+	if (typeof type !== "undefined") {
+		if (globalOptions.disabledTypes.indexOf(type) > -1) throw new TypeError(`disabled file type: ${type}`);
+		const size = typeHandlers.get(type).calculate(input);
+		if (size !== void 0) {
+			size.type = size.type ?? type;
+			if (size.images && size.images.length > 1) {
+				const largestImage = size.images.reduce((largest, current) => {
+					return current.width * current.height > largest.width * largest.height ? current : largest;
+				}, size.images[0]);
+				size.width = largestImage.width;
+				size.height = largestImage.height;
+			}
+			return size;
+		}
+	}
+	throw new TypeError(`unsupported file type: ${type}`);
+}
+
+//#endregion
+export { imageSize as t };
+//# sourceMappingURL=dist-FPR93_xf.mjs.map