vinext 1.2.1 → 1.3.1

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/bmp.js

@@ -0,0 +1,11 @@
+import { readInt32LE, readUInt32LE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/bmp.js
+const BMP = {
+	validate: (input) => toUTF8String(input, 0, 2) === "BM",
+	calculate: (input) => ({
+		height: Math.abs(readInt32LE(input, 22)),
+		width: readUInt32LE(input, 18)
+	})
+};
+//#endregion
+export { BMP };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/cur.js

@@ -0,0 +1,15 @@
+import { readUInt16LE } from "./utils.js";
+import { ICO } from "./ico.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/cur.js
+const TYPE_CURSOR = 2;
+const 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)
+};
+//#endregion
+export { CUR };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/dds.js

@@ -0,0 +1,11 @@
+import { readUInt32LE } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/dds.js
+const DDS = {
+	validate: (input) => readUInt32LE(input, 0) === 542327876,
+	calculate: (input) => ({
+		height: readUInt32LE(input, 12),
+		width: readUInt32LE(input, 16)
+	})
+};
+//#endregion
+export { DDS };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/gif.js

@@ -0,0 +1,12 @@
+import { readUInt16LE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/gif.js
+const gifRegexp = /^GIF8[79]a/;
+const GIF = {
+	validate: (input) => gifRegexp.test(toUTF8String(input, 0, 6)),
+	calculate: (input) => ({
+		height: readUInt16LE(input, 8),
+		width: readUInt16LE(input, 6)
+	})
+};
+//#endregion
+export { GIF };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/heif.js

@@ -0,0 +1,55 @@
+import { findBox, readUInt32BE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/heif.js
+const brandMap = {
+	avif: "avif",
+	mif1: "heif",
+	msf1: "heif",
+	heic: "heic",
+	heix: "heic",
+	hevc: "heic",
+	hevx: "heic"
+};
+const 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;
+			if (ispeBox.size < 20) throw new TypeError("Invalid HEIF");
+			const rawWidth = readUInt32BE(input, ispeBox.offset + 12);
+			const rawHeight = readUInt32BE(input, ispeBox.offset + 16);
+			const clapBox = findBox(input, "clap", currentOffset);
+			let width = rawWidth;
+			const height = rawHeight;
+			if (clapBox && clapBox.size >= 16 && clapBox.offset < ipcoBox.offset + ipcoBox.size) width = rawWidth - readUInt32BE(input, clapBox.offset + 12);
+			images.push({
+				height,
+				width
+			});
+			const nextOffset = ispeBox.offset + ispeBox.size;
+			if (nextOffset <= currentOffset) throw new TypeError("Invalid HEIF");
+			currentOffset = nextOffset;
+		}
+		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 } : {}
+		};
+	}
+};
+//#endregion
+export { HEIF };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/icns.js

@@ -0,0 +1,76 @@
+import { readUInt32BE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/icns.js
+const SIZE_HEADER = 8;
+const FILE_LENGTH_OFFSET = 4;
+const ENTRY_LENGTH_OFFSET = 4;
+const 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;
+	if (imageLengthOffset + 4 > input.length) throw new TypeError("Invalid ICNS");
+	return [toUTF8String(input, imageOffset, imageLengthOffset), readUInt32BE(input, imageLengthOffset)];
+}
+function getImageSize(type) {
+	const size = ICON_TYPE_SIZE[type];
+	return {
+		width: size,
+		height: size,
+		type
+	};
+}
+const ICNS = {
+	validate: (input) => toUTF8String(input, 0, 4) === "icns",
+	calculate(input) {
+		const inputLength = input.length;
+		const fileLength = readUInt32BE(input, FILE_LENGTH_OFFSET);
+		let imageOffset = SIZE_HEADER;
+		const images = [];
+		while (imageOffset < fileLength && imageOffset < inputLength) {
+			const imageHeader = readImageHeader(input, imageOffset);
+			const entryLength = imageHeader[1];
+			if (entryLength < 8) throw new TypeError("Invalid ICNS");
+			const imageSize = getImageSize(imageHeader[0]);
+			images.push(imageSize);
+			imageOffset += entryLength;
+		}
+		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 } : {}
+		};
+	}
+};
+//#endregion
+export { ICNS };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/ico.js

@@ -0,0 +1,39 @@
+import { readUInt16LE } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/ico.js
+const TYPE_ICON = 1;
+const SIZE_HEADER = 6;
+const 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)
+	};
+}
+const 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);
+		if (SIZE_HEADER + nbImages * SIZE_IMAGE_ENTRY > input.length) throw new TypeError("Invalid ICO");
+		const imageSize = getImageSize(input, 0);
+		if (nbImages === 1) return imageSize;
+		const images = [];
+		for (let imageIndex = 0; imageIndex < nbImages; imageIndex += 1) images.push(getImageSize(input, imageIndex));
+		return {
+			width: imageSize.width,
+			height: imageSize.height,
+			images
+		};
+	}
+};
+//#endregion
+export { ICO };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/index.js

@@ -0,0 +1,46 @@
+import { BMP } from "./bmp.js";
+import { ICO } from "./ico.js";
+import { CUR } from "./cur.js";
+import { DDS } from "./dds.js";
+import { GIF } from "./gif.js";
+import { HEIF } from "./heif.js";
+import { ICNS } from "./icns.js";
+import { J2C } from "./j2c.js";
+import { JP2 } from "./jp2.js";
+import { JPG } from "./jpg.js";
+import { JXLStream } from "./jxl-stream.js";
+import { JXL } from "./jxl.js";
+import { KTX } from "./ktx.js";
+import { PNG } from "./png.js";
+import { PNM } from "./pnm.js";
+import { PSD } from "./psd.js";
+import { SVG } from "./svg.js";
+import { TGA } from "./tga.js";
+import { TIFF } from "./tiff.js";
+import { WEBP } from "./webp.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/index.js
+const 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", WEBP]
+]);
+const types = Array.from(typeHandlers.keys());
+//#endregion
+export { typeHandlers, types };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/j2c.js

@@ -0,0 +1,11 @@
+import { readUInt32BE } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/j2c.js
+const J2C = {
+	validate: (input) => readUInt32BE(input, 0) === 4283432785,
+	calculate: (input) => ({
+		height: readUInt32BE(input, 12),
+		width: readUInt32BE(input, 8)
+	})
+};
+//#endregion
+export { J2C };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/jp2.js

@@ -0,0 +1,21 @@
+import { findBox, readUInt32BE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/jp2.js
+const 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");
+	}
+};
+//#endregion
+export { JP2 };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/jpg.js

@@ -0,0 +1,71 @@
+import { readUInt, readUInt16BE, toHexString } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/jpg.js
+const EXIF_MARKER = "45786966";
+const APP1_DATA_SIZE_BYTES = 2;
+const EXIF_HEADER_BYTES = 6;
+const BIG_ENDIAN_BYTE_ALIGN = "4d4d";
+const LITTLE_ENDIAN_BYTE_ALIGN = "4949";
+const IDF_ENTRY_BYTES = 12;
+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 idfDirectoryEntries = readUInt(exifBlock, 16, 14, isBigEndian);
+	for (let directoryEntryNumber = 0; directoryEntryNumber < idfDirectoryEntries; directoryEntryNumber++) {
+		const start = 16 + 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, 8);
+	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");
+}
+const 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");
+	}
+};
+//#endregion
+export { JPG };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/jxl-stream.js

@@ -0,0 +1,42 @@
+import { toHexString } from "./utils.js";
+import { BitReader } from "../utils/bit-reader.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/jxl-stream.js
+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]);
+}
+const 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
+		};
+	}
+};
+//#endregion
+export { JXLStream };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/jxl.js

@@ -0,0 +1,46 @@
+import { findBox, toUTF8String } from "./utils.js";
+import { JXLStream } from "./jxl-stream.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/jxl.js
+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;
+		if (jxlpBox.size < 12) throw new TypeError("Invalid JXL");
+		partialStreams.push(input.slice(jxlpBox.offset + 12, jxlpBox.offset + jxlpBox.size));
+		offset = jxlpBox.offset + jxlpBox.size;
+	}
+	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;
+}
+const 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 TypeError("Invalid JXL");
+	}
+};
+//#endregion
+export { JXL };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/ktx.js

@@ -0,0 +1,19 @@
+import { readUInt32LE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/ktx.js
+const 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
+		};
+	}
+};
+//#endregion
+export { KTX };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/png.js

@@ -0,0 +1,28 @@
+import { readUInt32BE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/png.js
+const pngSignature = "PNG\r\n\n";
+const pngImageHeaderChunkName = "IHDR";
+const pngFriedChunkName = "CgBI";
+const 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)
+		};
+	}
+};
+//#endregion
+export { PNG };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/pnm.js

@@ -0,0 +1,54 @@
+import { toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/pnm.js
+const PNMTypes = {
+	P1: "pbm/ascii",
+	P2: "pgm/ascii",
+	P3: "ppm/ascii",
+	P4: "pbm",
+	P5: "pgm",
+	P6: "ppm",
+	P7: "pam",
+	PF: "pfm"
+};
+const 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");
+	}
+};
+const PNM = {
+	validate: (input) => toUTF8String(input, 0, 2) in PNMTypes,
+	calculate(input) {
+		const signature = toUTF8String(input, 0, 2);
+		const type = PNMTypes[signature];
+		const lines = toUTF8String(input, 3).split(/[\r\n]+/);
+		return (handlers[type] || handlers.default)(lines);
+	}
+};
+//#endregion
+export { PNM };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/psd.js

@@ -0,0 +1,11 @@
+import { readUInt32BE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/psd.js
+const PSD = {
+	validate: (input) => toUTF8String(input, 0, 4) === "8BPS",
+	calculate: (input) => ({
+		height: readUInt32BE(input, 14),
+		width: readUInt32BE(input, 18)
+	})
+};
+//#endregion
+export { PSD };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/svg.js

@@ -0,0 +1,79 @@
+import { toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/svg.js
+const svgReg = /<svg\s([^>"']|"[^"]*"|'[^']*')*>/;
+const extractorRegExps = {
+	height: /\sheight=(['"])([^%]+?)\1/,
+	root: svgReg,
+	viewbox: /\sviewBox=(['"])(.+?)\1/i,
+	width: /\swidth=(['"])([^%]+?)\1/
+};
+const INCH_CM = 2.54;
+const 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
+};
+const 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
+	};
+}
+const 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");
+	}
+};
+//#endregion
+export { SVG };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/tga.js

@@ -0,0 +1,15 @@
+import { readUInt16LE } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/tga.js
+const TGA = {
+	validate(input) {
+		return readUInt16LE(input, 0) === 0 && readUInt16LE(input, 4) === 0;
+	},
+	calculate(input) {
+		return {
+			height: readUInt16LE(input, 14),
+			width: readUInt16LE(input, 12)
+		};
+	}
+};
+//#endregion
+export { TGA };