vinext 1.3.0 → 1.4.0

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/lib/extend-node.js

@@ -0,0 +1,147 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/extend-node.js
+var require_extend_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Buffer = __require("buffer").Buffer;
+	module.exports = function(iconv) {
+		var original = void 0;
+		iconv.supportsNodeEncodingsExtension = !(Buffer.from || new Buffer(0) instanceof Uint8Array);
+		iconv.extendNodeEncodings = function extendNodeEncodings() {
+			if (original) return;
+			original = {};
+			if (!iconv.supportsNodeEncodingsExtension) {
+				console.error("ACTION NEEDED: require('iconv-lite').extendNodeEncodings() is not supported in your version of Node");
+				console.error("See more info at https://github.com/ashtuchkin/iconv-lite/wiki/Node-v4-compatibility");
+				return;
+			}
+			var nodeNativeEncodings = {
+				"hex": true,
+				"utf8": true,
+				"utf-8": true,
+				"ascii": true,
+				"binary": true,
+				"base64": true,
+				"ucs2": true,
+				"ucs-2": true,
+				"utf16le": true,
+				"utf-16le": true
+			};
+			Buffer.isNativeEncoding = function(enc) {
+				return enc && nodeNativeEncodings[enc.toLowerCase()];
+			};
+			var SlowBuffer = __require("buffer").SlowBuffer;
+			original.SlowBufferToString = SlowBuffer.prototype.toString;
+			SlowBuffer.prototype.toString = function(encoding, start, end) {
+				encoding = String(encoding || "utf8").toLowerCase();
+				if (Buffer.isNativeEncoding(encoding)) return original.SlowBufferToString.call(this, encoding, start, end);
+				if (typeof start == "undefined") start = 0;
+				if (typeof end == "undefined") end = this.length;
+				return iconv.decode(this.slice(start, end), encoding);
+			};
+			original.SlowBufferWrite = SlowBuffer.prototype.write;
+			SlowBuffer.prototype.write = function(string, offset, length, encoding) {
+				if (isFinite(offset)) {
+					if (!isFinite(length)) {
+						encoding = length;
+						length = void 0;
+					}
+				} else {
+					var swap = encoding;
+					encoding = offset;
+					offset = length;
+					length = swap;
+				}
+				offset = +offset || 0;
+				var remaining = this.length - offset;
+				if (!length) length = remaining;
+				else {
+					length = +length;
+					if (length > remaining) length = remaining;
+				}
+				encoding = String(encoding || "utf8").toLowerCase();
+				if (Buffer.isNativeEncoding(encoding)) return original.SlowBufferWrite.call(this, string, offset, length, encoding);
+				if (string.length > 0 && (length < 0 || offset < 0)) throw new RangeError("attempt to write beyond buffer bounds");
+				var buf = iconv.encode(string, encoding);
+				if (buf.length < length) length = buf.length;
+				buf.copy(this, offset, 0, length);
+				return length;
+			};
+			original.BufferIsEncoding = Buffer.isEncoding;
+			Buffer.isEncoding = function(encoding) {
+				return Buffer.isNativeEncoding(encoding) || iconv.encodingExists(encoding);
+			};
+			original.BufferByteLength = Buffer.byteLength;
+			Buffer.byteLength = SlowBuffer.byteLength = function(str, encoding) {
+				encoding = String(encoding || "utf8").toLowerCase();
+				if (Buffer.isNativeEncoding(encoding)) return original.BufferByteLength.call(this, str, encoding);
+				return iconv.encode(str, encoding).length;
+			};
+			original.BufferToString = Buffer.prototype.toString;
+			Buffer.prototype.toString = function(encoding, start, end) {
+				encoding = String(encoding || "utf8").toLowerCase();
+				if (Buffer.isNativeEncoding(encoding)) return original.BufferToString.call(this, encoding, start, end);
+				if (typeof start == "undefined") start = 0;
+				if (typeof end == "undefined") end = this.length;
+				return iconv.decode(this.slice(start, end), encoding);
+			};
+			original.BufferWrite = Buffer.prototype.write;
+			Buffer.prototype.write = function(string, offset, length, encoding) {
+				var _offset = offset, _length = length, _encoding = encoding;
+				if (isFinite(offset)) {
+					if (!isFinite(length)) {
+						encoding = length;
+						length = void 0;
+					}
+				} else {
+					var swap = encoding;
+					encoding = offset;
+					offset = length;
+					length = swap;
+				}
+				encoding = String(encoding || "utf8").toLowerCase();
+				if (Buffer.isNativeEncoding(encoding)) return original.BufferWrite.call(this, string, _offset, _length, _encoding);
+				offset = +offset || 0;
+				var remaining = this.length - offset;
+				if (!length) length = remaining;
+				else {
+					length = +length;
+					if (length > remaining) length = remaining;
+				}
+				if (string.length > 0 && (length < 0 || offset < 0)) throw new RangeError("attempt to write beyond buffer bounds");
+				var buf = iconv.encode(string, encoding);
+				if (buf.length < length) length = buf.length;
+				buf.copy(this, offset, 0, length);
+				return length;
+			};
+			if (iconv.supportsStreams) {
+				var Readable = __require("stream").Readable;
+				original.ReadableSetEncoding = Readable.prototype.setEncoding;
+				Readable.prototype.setEncoding = function setEncoding(enc, options) {
+					this._readableState.decoder = iconv.getDecoder(enc, options);
+					this._readableState.encoding = enc;
+				};
+				Readable.prototype.collect = iconv._collect;
+			}
+		};
+		iconv.undoExtendNodeEncodings = function undoExtendNodeEncodings() {
+			if (!iconv.supportsNodeEncodingsExtension) return;
+			if (!original) throw new Error("require('iconv-lite').undoExtendNodeEncodings(): Nothing to undo; extendNodeEncodings() is not called.");
+			delete Buffer.isNativeEncoding;
+			var SlowBuffer = __require("buffer").SlowBuffer;
+			SlowBuffer.prototype.toString = original.SlowBufferToString;
+			SlowBuffer.prototype.write = original.SlowBufferWrite;
+			Buffer.isEncoding = original.BufferIsEncoding;
+			Buffer.byteLength = original.BufferByteLength;
+			Buffer.prototype.toString = original.BufferToString;
+			Buffer.prototype.write = original.BufferWrite;
+			if (iconv.supportsStreams) {
+				var Readable = __require("stream").Readable;
+				Readable.prototype.setEncoding = original.ReadableSetEncoding;
+				delete Readable.prototype.collect;
+			}
+			original = void 0;
+		};
+	};
+}));
+//#endregion
+export default require_extend_node();
+export { require_extend_node };

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/lib/index.js

@@ -0,0 +1,94 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_safer } from "../../../../safer-buffer@2.1.2/deps/safer-buffer/safer.js";
+import { require_bom_handling } from "./bom-handling.js";
+import { require_encodings } from "../encodings/index.js";
+import { require_streams } from "./streams.js";
+import { require_extend_node } from "./extend-node.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Buffer = require_safer().Buffer;
+	var bomHandling = require_bom_handling();
+	var iconv = module.exports;
+	iconv.encodings = null;
+	iconv.defaultCharUnicode = "�";
+	iconv.defaultCharSingleByte = "?";
+	iconv.encode = function encode(str, encoding, options) {
+		str = "" + (str || "");
+		var encoder = iconv.getEncoder(encoding, options);
+		var res = encoder.write(str);
+		var trail = encoder.end();
+		return trail && trail.length > 0 ? Buffer.concat([res, trail]) : res;
+	};
+	iconv.decode = function decode(buf, encoding, options) {
+		if (typeof buf === "string") {
+			if (!iconv.skipDecodeWarning) {
+				console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
+				iconv.skipDecodeWarning = true;
+			}
+			buf = Buffer.from("" + (buf || ""), "binary");
+		}
+		var decoder = iconv.getDecoder(encoding, options);
+		var res = decoder.write(buf);
+		var trail = decoder.end();
+		return trail ? res + trail : res;
+	};
+	iconv.encodingExists = function encodingExists(enc) {
+		try {
+			iconv.getCodec(enc);
+			return true;
+		} catch (e) {
+			return false;
+		}
+	};
+	iconv.toEncoding = iconv.encode;
+	iconv.fromEncoding = iconv.decode;
+	iconv._codecDataCache = {};
+	iconv.getCodec = function getCodec(encoding) {
+		if (!iconv.encodings) iconv.encodings = require_encodings();
+		var enc = iconv._canonicalizeEncoding(encoding);
+		var codecOptions = {};
+		while (true) {
+			var codec = iconv._codecDataCache[enc];
+			if (codec) return codec;
+			var codecDef = iconv.encodings[enc];
+			switch (typeof codecDef) {
+				case "string":
+					enc = codecDef;
+					break;
+				case "object":
+					for (var key in codecDef) codecOptions[key] = codecDef[key];
+					if (!codecOptions.encodingName) codecOptions.encodingName = enc;
+					enc = codecDef.type;
+					break;
+				case "function":
+					if (!codecOptions.encodingName) codecOptions.encodingName = enc;
+					codec = new codecDef(codecOptions, iconv);
+					iconv._codecDataCache[codecOptions.encodingName] = codec;
+					return codec;
+				default: throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')");
+			}
+		}
+	};
+	iconv._canonicalizeEncoding = function(encoding) {
+		return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
+	};
+	iconv.getEncoder = function getEncoder(encoding, options) {
+		var codec = iconv.getCodec(encoding), encoder = new codec.encoder(options, codec);
+		if (codec.bomAware && options && options.addBOM) encoder = new bomHandling.PrependBOM(encoder, options);
+		return encoder;
+	};
+	iconv.getDecoder = function getDecoder(encoding, options) {
+		var codec = iconv.getCodec(encoding), decoder = new codec.decoder(options, codec);
+		if (codec.bomAware && !(options && options.stripBOM === false)) decoder = new bomHandling.StripBOM(decoder, options);
+		return decoder;
+	};
+	var nodeVer = typeof process !== "undefined" && process.versions && process.versions.node;
+	if (nodeVer) {
+		var nodeVerArr = nodeVer.split(".").map(Number);
+		if (nodeVerArr[0] > 0 || nodeVerArr[1] >= 10) require_streams()(iconv);
+		require_extend_node()(iconv);
+	}
+}));
+//#endregion
+export default require_lib();
+export {};

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/lib/streams.js

@@ -0,0 +1,95 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/streams.js
+var require_streams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Buffer = __require("buffer").Buffer;
+	var Transform = __require("stream").Transform;
+	module.exports = function(iconv) {
+		iconv.encodeStream = function encodeStream(encoding, options) {
+			return new IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options);
+		};
+		iconv.decodeStream = function decodeStream(encoding, options) {
+			return new IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options);
+		};
+		iconv.supportsStreams = true;
+		iconv.IconvLiteEncoderStream = IconvLiteEncoderStream;
+		iconv.IconvLiteDecoderStream = IconvLiteDecoderStream;
+		iconv._collect = IconvLiteDecoderStream.prototype.collect;
+	};
+	function IconvLiteEncoderStream(conv, options) {
+		this.conv = conv;
+		options = options || {};
+		options.decodeStrings = false;
+		Transform.call(this, options);
+	}
+	IconvLiteEncoderStream.prototype = Object.create(Transform.prototype, { constructor: { value: IconvLiteEncoderStream } });
+	IconvLiteEncoderStream.prototype._transform = function(chunk, encoding, done) {
+		if (typeof chunk != "string") return done(/* @__PURE__ */ new Error("Iconv encoding stream needs strings as its input."));
+		try {
+			var res = this.conv.write(chunk);
+			if (res && res.length) this.push(res);
+			done();
+		} catch (e) {
+			done(e);
+		}
+	};
+	IconvLiteEncoderStream.prototype._flush = function(done) {
+		try {
+			var res = this.conv.end();
+			if (res && res.length) this.push(res);
+			done();
+		} catch (e) {
+			done(e);
+		}
+	};
+	IconvLiteEncoderStream.prototype.collect = function(cb) {
+		var chunks = [];
+		this.on("error", cb);
+		this.on("data", function(chunk) {
+			chunks.push(chunk);
+		});
+		this.on("end", function() {
+			cb(null, Buffer.concat(chunks));
+		});
+		return this;
+	};
+	function IconvLiteDecoderStream(conv, options) {
+		this.conv = conv;
+		options = options || {};
+		options.encoding = this.encoding = "utf8";
+		Transform.call(this, options);
+	}
+	IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, { constructor: { value: IconvLiteDecoderStream } });
+	IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) {
+		if (!Buffer.isBuffer(chunk)) return done(/* @__PURE__ */ new Error("Iconv decoding stream needs buffers as its input."));
+		try {
+			var res = this.conv.write(chunk);
+			if (res && res.length) this.push(res, this.encoding);
+			done();
+		} catch (e) {
+			done(e);
+		}
+	};
+	IconvLiteDecoderStream.prototype._flush = function(done) {
+		try {
+			var res = this.conv.end();
+			if (res && res.length) this.push(res, this.encoding);
+			done();
+		} catch (e) {
+			done(e);
+		}
+	};
+	IconvLiteDecoderStream.prototype.collect = function(cb) {
+		var res = "";
+		this.on("error", cb);
+		this.on("data", function(chunk) {
+			res += chunk;
+		});
+		this.on("end", function() {
+			cb(null, res);
+		});
+		return this;
+	};
+}));
+//#endregion
+export default require_streams();
+export { require_streams };

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

@@ -0,0 +1,23 @@
+import { typeHandlers, types } from "./types/index.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/detector.js
+const 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((type) => typeHandlers.get(type)?.validate(input));
+}
+//#endregion
+export { detector };

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

@@ -0,0 +1,2 @@
+import "./types/index.js";
+export { imageSize } from "./lookup.js";

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

@@ -0,0 +1,25 @@
+import { typeHandlers } from "./types/index.js";
+import { detector } from "./detector.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/lookup.js
+const 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 };

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 };