@mistweaverco/kulala-cli 0.7.1 → 0.8.1

package/dist/cli.cjs

@@ -46,7 +46,7 @@ let node_readline = require("node:readline");
 node_readline = __toESM(node_readline, 1);
 var package_default = {
 	name: "@mistweaverco/kulala-cli",
-	version: "0.7.1",
+	version: "0.8.1",
 	repository: {
 		"type": "git",
 		"url": "https://github.com/mistweaverco/kulala-cli"
@@ -62,16 +62,19 @@ var package_default = {
 		"postinstall": "node dist/install-backend.cjs || true"
 	},
 	devDependencies: {
-		"@inquirer/core": "^11.2.1",
+		"@inquirer/core": "11.2.1",
 		"@inquirer/select": "4.3.4",
-		"@inquirer/type": "^4.0.7",
+		"@inquirer/type": "4.0.7",
 		"@types/node": "25.9.1",
+		"@types/pngjs": "6.0.5",
 		"chalk": "5.6.2",
 		"cli-highlight": "2.1.11",
 		"commander": "15.0.0",
 		"eslint-plugin-prettier": "5.5.6",
 		"globals": "17.6.0",
+		"jpeg-js": "0.4.4",
 		"picocolors": "1.1.1",
+		"pngjs": "7.0.0",
 		"prettier": "3.8.4",
 		"tsx": "4.22.4",
 		"typescript": "5.9.3",
@@ -3471,7 +3474,7 @@ function fileWalker(inputPath, extensions) {
 }
 //#endregion
 //#region src/versions/backend.ts
-var KULALA_CORE_VERSION = "0.24.1";
+var KULALA_CORE_VERSION = "0.24.2";
 //#endregion
 //#region src/lib/downloader/index.ts
 var BINARY_NAME = "kulala-core";
@@ -57805,7 +57808,7 @@ var require_foreign_content = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 //#endregion
 //#region node_modules/.pnpm/parse5@5.1.1/node_modules/parse5/lib/parser/index.js
-var require_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var require_parser$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var Tokenizer = require_tokenizer();
 	var OpenElementStack = require_open_element_stack();
 	var FormattingElementList = require_formatting_element_list();
@@ -59683,7 +59686,7 @@ var require_serializer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region node_modules/.pnpm/parse5@5.1.1/node_modules/parse5/lib/index.js
 var require_lib$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
-	var Parser = require_parser();
+	var Parser = require_parser$1();
 	var Serializer = require_serializer();
 	exports.parse = function parse(html, options) {
 		return new Parser(options).parse(html);
@@ -62842,18 +62845,3742 @@ function highlightCode(text, language) {
 	}
 }
 //#endregion
+//#region node_modules/.pnpm/jpeg-js@0.4.4/node_modules/jpeg-js/lib/encoder.js
+var require_encoder = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function JPEGEncoder(quality) {
+		var ffloor = Math.floor;
+		var YTable = new Array(64);
+		var UVTable = new Array(64);
+		var fdtbl_Y = new Array(64);
+		var fdtbl_UV = new Array(64);
+		var YDC_HT;
+		var UVDC_HT;
+		var YAC_HT;
+		var UVAC_HT;
+		var bitcode = new Array(65535);
+		var category = new Array(65535);
+		var outputfDCTQuant = new Array(64);
+		var DU = new Array(64);
+		var byteout = [];
+		var bytenew = 0;
+		var bytepos = 7;
+		var YDU = new Array(64);
+		var UDU = new Array(64);
+		var VDU = new Array(64);
+		var clt = new Array(256);
+		var RGB_YUV_TABLE = new Array(2048);
+		var currentQuality;
+		var ZigZag = [
+			0,
+			1,
+			5,
+			6,
+			14,
+			15,
+			27,
+			28,
+			2,
+			4,
+			7,
+			13,
+			16,
+			26,
+			29,
+			42,
+			3,
+			8,
+			12,
+			17,
+			25,
+			30,
+			41,
+			43,
+			9,
+			11,
+			18,
+			24,
+			31,
+			40,
+			44,
+			53,
+			10,
+			19,
+			23,
+			32,
+			39,
+			45,
+			52,
+			54,
+			20,
+			22,
+			33,
+			38,
+			46,
+			51,
+			55,
+			60,
+			21,
+			34,
+			37,
+			47,
+			50,
+			56,
+			59,
+			61,
+			35,
+			36,
+			48,
+			49,
+			57,
+			58,
+			62,
+			63
+		];
+		var std_dc_luminance_nrcodes = [
+			0,
+			0,
+			1,
+			5,
+			1,
+			1,
+			1,
+			1,
+			1,
+			1,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		];
+		var std_dc_luminance_values = [
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10,
+			11
+		];
+		var std_ac_luminance_nrcodes = [
+			0,
+			0,
+			2,
+			1,
+			3,
+			3,
+			2,
+			4,
+			3,
+			5,
+			5,
+			4,
+			4,
+			0,
+			0,
+			1,
+			125
+		];
+		var std_ac_luminance_values = [
+			1,
+			2,
+			3,
+			0,
+			4,
+			17,
+			5,
+			18,
+			33,
+			49,
+			65,
+			6,
+			19,
+			81,
+			97,
+			7,
+			34,
+			113,
+			20,
+			50,
+			129,
+			145,
+			161,
+			8,
+			35,
+			66,
+			177,
+			193,
+			21,
+			82,
+			209,
+			240,
+			36,
+			51,
+			98,
+			114,
+			130,
+			9,
+			10,
+			22,
+			23,
+			24,
+			25,
+			26,
+			37,
+			38,
+			39,
+			40,
+			41,
+			42,
+			52,
+			53,
+			54,
+			55,
+			56,
+			57,
+			58,
+			67,
+			68,
+			69,
+			70,
+			71,
+			72,
+			73,
+			74,
+			83,
+			84,
+			85,
+			86,
+			87,
+			88,
+			89,
+			90,
+			99,
+			100,
+			101,
+			102,
+			103,
+			104,
+			105,
+			106,
+			115,
+			116,
+			117,
+			118,
+			119,
+			120,
+			121,
+			122,
+			131,
+			132,
+			133,
+			134,
+			135,
+			136,
+			137,
+			138,
+			146,
+			147,
+			148,
+			149,
+			150,
+			151,
+			152,
+			153,
+			154,
+			162,
+			163,
+			164,
+			165,
+			166,
+			167,
+			168,
+			169,
+			170,
+			178,
+			179,
+			180,
+			181,
+			182,
+			183,
+			184,
+			185,
+			186,
+			194,
+			195,
+			196,
+			197,
+			198,
+			199,
+			200,
+			201,
+			202,
+			210,
+			211,
+			212,
+			213,
+			214,
+			215,
+			216,
+			217,
+			218,
+			225,
+			226,
+			227,
+			228,
+			229,
+			230,
+			231,
+			232,
+			233,
+			234,
+			241,
+			242,
+			243,
+			244,
+			245,
+			246,
+			247,
+			248,
+			249,
+			250
+		];
+		var std_dc_chrominance_nrcodes = [
+			0,
+			0,
+			3,
+			1,
+			1,
+			1,
+			1,
+			1,
+			1,
+			1,
+			1,
+			1,
+			0,
+			0,
+			0,
+			0,
+			0
+		];
+		var std_dc_chrominance_values = [
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10,
+			11
+		];
+		var std_ac_chrominance_nrcodes = [
+			0,
+			0,
+			2,
+			1,
+			2,
+			4,
+			4,
+			3,
+			4,
+			7,
+			5,
+			4,
+			4,
+			0,
+			1,
+			2,
+			119
+		];
+		var std_ac_chrominance_values = [
+			0,
+			1,
+			2,
+			3,
+			17,
+			4,
+			5,
+			33,
+			49,
+			6,
+			18,
+			65,
+			81,
+			7,
+			97,
+			113,
+			19,
+			34,
+			50,
+			129,
+			8,
+			20,
+			66,
+			145,
+			161,
+			177,
+			193,
+			9,
+			35,
+			51,
+			82,
+			240,
+			21,
+			98,
+			114,
+			209,
+			10,
+			22,
+			36,
+			52,
+			225,
+			37,
+			241,
+			23,
+			24,
+			25,
+			26,
+			38,
+			39,
+			40,
+			41,
+			42,
+			53,
+			54,
+			55,
+			56,
+			57,
+			58,
+			67,
+			68,
+			69,
+			70,
+			71,
+			72,
+			73,
+			74,
+			83,
+			84,
+			85,
+			86,
+			87,
+			88,
+			89,
+			90,
+			99,
+			100,
+			101,
+			102,
+			103,
+			104,
+			105,
+			106,
+			115,
+			116,
+			117,
+			118,
+			119,
+			120,
+			121,
+			122,
+			130,
+			131,
+			132,
+			133,
+			134,
+			135,
+			136,
+			137,
+			138,
+			146,
+			147,
+			148,
+			149,
+			150,
+			151,
+			152,
+			153,
+			154,
+			162,
+			163,
+			164,
+			165,
+			166,
+			167,
+			168,
+			169,
+			170,
+			178,
+			179,
+			180,
+			181,
+			182,
+			183,
+			184,
+			185,
+			186,
+			194,
+			195,
+			196,
+			197,
+			198,
+			199,
+			200,
+			201,
+			202,
+			210,
+			211,
+			212,
+			213,
+			214,
+			215,
+			216,
+			217,
+			218,
+			226,
+			227,
+			228,
+			229,
+			230,
+			231,
+			232,
+			233,
+			234,
+			242,
+			243,
+			244,
+			245,
+			246,
+			247,
+			248,
+			249,
+			250
+		];
+		function initQuantTables(sf) {
+			var YQT = [
+				16,
+				11,
+				10,
+				16,
+				24,
+				40,
+				51,
+				61,
+				12,
+				12,
+				14,
+				19,
+				26,
+				58,
+				60,
+				55,
+				14,
+				13,
+				16,
+				24,
+				40,
+				57,
+				69,
+				56,
+				14,
+				17,
+				22,
+				29,
+				51,
+				87,
+				80,
+				62,
+				18,
+				22,
+				37,
+				56,
+				68,
+				109,
+				103,
+				77,
+				24,
+				35,
+				55,
+				64,
+				81,
+				104,
+				113,
+				92,
+				49,
+				64,
+				78,
+				87,
+				103,
+				121,
+				120,
+				101,
+				72,
+				92,
+				95,
+				98,
+				112,
+				100,
+				103,
+				99
+			];
+			for (var i = 0; i < 64; i++) {
+				var t = ffloor((YQT[i] * sf + 50) / 100);
+				if (t < 1) t = 1;
+				else if (t > 255) t = 255;
+				YTable[ZigZag[i]] = t;
+			}
+			var UVQT = [
+				17,
+				18,
+				24,
+				47,
+				99,
+				99,
+				99,
+				99,
+				18,
+				21,
+				26,
+				66,
+				99,
+				99,
+				99,
+				99,
+				24,
+				26,
+				56,
+				99,
+				99,
+				99,
+				99,
+				99,
+				47,
+				66,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99,
+				99
+			];
+			for (var j = 0; j < 64; j++) {
+				var u = ffloor((UVQT[j] * sf + 50) / 100);
+				if (u < 1) u = 1;
+				else if (u > 255) u = 255;
+				UVTable[ZigZag[j]] = u;
+			}
+			var aasf = [
+				1,
+				1.387039845,
+				1.306562965,
+				1.175875602,
+				1,
+				.785694958,
+				.5411961,
+				.275899379
+			];
+			var k = 0;
+			for (var row = 0; row < 8; row++) for (var col = 0; col < 8; col++) {
+				fdtbl_Y[k] = 1 / (YTable[ZigZag[k]] * aasf[row] * aasf[col] * 8);
+				fdtbl_UV[k] = 1 / (UVTable[ZigZag[k]] * aasf[row] * aasf[col] * 8);
+				k++;
+			}
+		}
+		function computeHuffmanTbl(nrcodes, std_table) {
+			var codevalue = 0;
+			var pos_in_table = 0;
+			var HT = new Array();
+			for (var k = 1; k <= 16; k++) {
+				for (var j = 1; j <= nrcodes[k]; j++) {
+					HT[std_table[pos_in_table]] = [];
+					HT[std_table[pos_in_table]][0] = codevalue;
+					HT[std_table[pos_in_table]][1] = k;
+					pos_in_table++;
+					codevalue++;
+				}
+				codevalue *= 2;
+			}
+			return HT;
+		}
+		function initHuffmanTbl() {
+			YDC_HT = computeHuffmanTbl(std_dc_luminance_nrcodes, std_dc_luminance_values);
+			UVDC_HT = computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values);
+			YAC_HT = computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values);
+			UVAC_HT = computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values);
+		}
+		function initCategoryNumber() {
+			var nrlower = 1;
+			var nrupper = 2;
+			for (var cat = 1; cat <= 15; cat++) {
+				for (var nr = nrlower; nr < nrupper; nr++) {
+					category[32767 + nr] = cat;
+					bitcode[32767 + nr] = [];
+					bitcode[32767 + nr][1] = cat;
+					bitcode[32767 + nr][0] = nr;
+				}
+				for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) {
+					category[32767 + nrneg] = cat;
+					bitcode[32767 + nrneg] = [];
+					bitcode[32767 + nrneg][1] = cat;
+					bitcode[32767 + nrneg][0] = nrupper - 1 + nrneg;
+				}
+				nrlower <<= 1;
+				nrupper <<= 1;
+			}
+		}
+		function initRGBYUVTable() {
+			for (var i = 0; i < 256; i++) {
+				RGB_YUV_TABLE[i] = 19595 * i;
+				RGB_YUV_TABLE[i + 256 >> 0] = 38470 * i;
+				RGB_YUV_TABLE[i + 512 >> 0] = 7471 * i + 32768;
+				RGB_YUV_TABLE[i + 768 >> 0] = -11059 * i;
+				RGB_YUV_TABLE[i + 1024 >> 0] = -21709 * i;
+				RGB_YUV_TABLE[i + 1280 >> 0] = 32768 * i + 8421375;
+				RGB_YUV_TABLE[i + 1536 >> 0] = -27439 * i;
+				RGB_YUV_TABLE[i + 1792 >> 0] = -5329 * i;
+			}
+		}
+		function writeBits(bs) {
+			var value = bs[0];
+			var posval = bs[1] - 1;
+			while (posval >= 0) {
+				if (value & 1 << posval) bytenew |= 1 << bytepos;
+				posval--;
+				bytepos--;
+				if (bytepos < 0) {
+					if (bytenew == 255) {
+						writeByte(255);
+						writeByte(0);
+					} else writeByte(bytenew);
+					bytepos = 7;
+					bytenew = 0;
+				}
+			}
+		}
+		function writeByte(value) {
+			byteout.push(value);
+		}
+		function writeWord(value) {
+			writeByte(value >> 8 & 255);
+			writeByte(value & 255);
+		}
+		function fDCTQuant(data, fdtbl) {
+			var d0, d1, d2, d3, d4, d5, d6, d7;
+			var dataOff = 0;
+			var i;
+			var I8 = 8;
+			var I64 = 64;
+			for (i = 0; i < I8; ++i) {
+				d0 = data[dataOff];
+				d1 = data[dataOff + 1];
+				d2 = data[dataOff + 2];
+				d3 = data[dataOff + 3];
+				d4 = data[dataOff + 4];
+				d5 = data[dataOff + 5];
+				d6 = data[dataOff + 6];
+				d7 = data[dataOff + 7];
+				var tmp0 = d0 + d7;
+				var tmp7 = d0 - d7;
+				var tmp1 = d1 + d6;
+				var tmp6 = d1 - d6;
+				var tmp2 = d2 + d5;
+				var tmp5 = d2 - d5;
+				var tmp3 = d3 + d4;
+				var tmp4 = d3 - d4;
+				var tmp10 = tmp0 + tmp3;
+				var tmp13 = tmp0 - tmp3;
+				var tmp11 = tmp1 + tmp2;
+				var tmp12 = tmp1 - tmp2;
+				data[dataOff] = tmp10 + tmp11;
+				data[dataOff + 4] = tmp10 - tmp11;
+				var z1 = (tmp12 + tmp13) * .707106781;
+				data[dataOff + 2] = tmp13 + z1;
+				data[dataOff + 6] = tmp13 - z1;
+				tmp10 = tmp4 + tmp5;
+				tmp11 = tmp5 + tmp6;
+				tmp12 = tmp6 + tmp7;
+				var z5 = (tmp10 - tmp12) * .382683433;
+				var z2 = .5411961 * tmp10 + z5;
+				var z4 = 1.306562965 * tmp12 + z5;
+				var z3 = tmp11 * .707106781;
+				var z11 = tmp7 + z3;
+				var z13 = tmp7 - z3;
+				data[dataOff + 5] = z13 + z2;
+				data[dataOff + 3] = z13 - z2;
+				data[dataOff + 1] = z11 + z4;
+				data[dataOff + 7] = z11 - z4;
+				dataOff += 8;
+			}
+			dataOff = 0;
+			for (i = 0; i < I8; ++i) {
+				d0 = data[dataOff];
+				d1 = data[dataOff + 8];
+				d2 = data[dataOff + 16];
+				d3 = data[dataOff + 24];
+				d4 = data[dataOff + 32];
+				d5 = data[dataOff + 40];
+				d6 = data[dataOff + 48];
+				d7 = data[dataOff + 56];
+				var tmp0p2 = d0 + d7;
+				var tmp7p2 = d0 - d7;
+				var tmp1p2 = d1 + d6;
+				var tmp6p2 = d1 - d6;
+				var tmp2p2 = d2 + d5;
+				var tmp5p2 = d2 - d5;
+				var tmp3p2 = d3 + d4;
+				var tmp4p2 = d3 - d4;
+				var tmp10p2 = tmp0p2 + tmp3p2;
+				var tmp13p2 = tmp0p2 - tmp3p2;
+				var tmp11p2 = tmp1p2 + tmp2p2;
+				var tmp12p2 = tmp1p2 - tmp2p2;
+				data[dataOff] = tmp10p2 + tmp11p2;
+				data[dataOff + 32] = tmp10p2 - tmp11p2;
+				var z1p2 = (tmp12p2 + tmp13p2) * .707106781;
+				data[dataOff + 16] = tmp13p2 + z1p2;
+				data[dataOff + 48] = tmp13p2 - z1p2;
+				tmp10p2 = tmp4p2 + tmp5p2;
+				tmp11p2 = tmp5p2 + tmp6p2;
+				tmp12p2 = tmp6p2 + tmp7p2;
+				var z5p2 = (tmp10p2 - tmp12p2) * .382683433;
+				var z2p2 = .5411961 * tmp10p2 + z5p2;
+				var z4p2 = 1.306562965 * tmp12p2 + z5p2;
+				var z3p2 = tmp11p2 * .707106781;
+				var z11p2 = tmp7p2 + z3p2;
+				var z13p2 = tmp7p2 - z3p2;
+				data[dataOff + 40] = z13p2 + z2p2;
+				data[dataOff + 24] = z13p2 - z2p2;
+				data[dataOff + 8] = z11p2 + z4p2;
+				data[dataOff + 56] = z11p2 - z4p2;
+				dataOff++;
+			}
+			var fDCTQuant;
+			for (i = 0; i < I64; ++i) {
+				fDCTQuant = data[i] * fdtbl[i];
+				outputfDCTQuant[i] = fDCTQuant > 0 ? fDCTQuant + .5 | 0 : fDCTQuant - .5 | 0;
+			}
+			return outputfDCTQuant;
+		}
+		function writeAPP0() {
+			writeWord(65504);
+			writeWord(16);
+			writeByte(74);
+			writeByte(70);
+			writeByte(73);
+			writeByte(70);
+			writeByte(0);
+			writeByte(1);
+			writeByte(1);
+			writeByte(0);
+			writeWord(1);
+			writeWord(1);
+			writeByte(0);
+			writeByte(0);
+		}
+		function writeAPP1(exifBuffer) {
+			if (!exifBuffer) return;
+			writeWord(65505);
+			if (exifBuffer[0] === 69 && exifBuffer[1] === 120 && exifBuffer[2] === 105 && exifBuffer[3] === 102) writeWord(exifBuffer.length + 2);
+			else {
+				writeWord(exifBuffer.length + 5 + 2);
+				writeByte(69);
+				writeByte(120);
+				writeByte(105);
+				writeByte(102);
+				writeByte(0);
+			}
+			for (var i = 0; i < exifBuffer.length; i++) writeByte(exifBuffer[i]);
+		}
+		function writeSOF0(width, height) {
+			writeWord(65472);
+			writeWord(17);
+			writeByte(8);
+			writeWord(height);
+			writeWord(width);
+			writeByte(3);
+			writeByte(1);
+			writeByte(17);
+			writeByte(0);
+			writeByte(2);
+			writeByte(17);
+			writeByte(1);
+			writeByte(3);
+			writeByte(17);
+			writeByte(1);
+		}
+		function writeDQT() {
+			writeWord(65499);
+			writeWord(132);
+			writeByte(0);
+			for (var i = 0; i < 64; i++) writeByte(YTable[i]);
+			writeByte(1);
+			for (var j = 0; j < 64; j++) writeByte(UVTable[j]);
+		}
+		function writeDHT() {
+			writeWord(65476);
+			writeWord(418);
+			writeByte(0);
+			for (var i = 0; i < 16; i++) writeByte(std_dc_luminance_nrcodes[i + 1]);
+			for (var j = 0; j <= 11; j++) writeByte(std_dc_luminance_values[j]);
+			writeByte(16);
+			for (var k = 0; k < 16; k++) writeByte(std_ac_luminance_nrcodes[k + 1]);
+			for (var l = 0; l <= 161; l++) writeByte(std_ac_luminance_values[l]);
+			writeByte(1);
+			for (var m = 0; m < 16; m++) writeByte(std_dc_chrominance_nrcodes[m + 1]);
+			for (var n = 0; n <= 11; n++) writeByte(std_dc_chrominance_values[n]);
+			writeByte(17);
+			for (var o = 0; o < 16; o++) writeByte(std_ac_chrominance_nrcodes[o + 1]);
+			for (var p = 0; p <= 161; p++) writeByte(std_ac_chrominance_values[p]);
+		}
+		function writeCOM(comments) {
+			if (typeof comments === "undefined" || comments.constructor !== Array) return;
+			comments.forEach((e) => {
+				if (typeof e !== "string") return;
+				writeWord(65534);
+				var l = e.length;
+				writeWord(l + 2);
+				var i;
+				for (i = 0; i < l; i++) writeByte(e.charCodeAt(i));
+			});
+		}
+		function writeSOS() {
+			writeWord(65498);
+			writeWord(12);
+			writeByte(3);
+			writeByte(1);
+			writeByte(0);
+			writeByte(2);
+			writeByte(17);
+			writeByte(3);
+			writeByte(17);
+			writeByte(0);
+			writeByte(63);
+			writeByte(0);
+		}
+		function processDU(CDU, fdtbl, DC, HTDC, HTAC) {
+			var EOB = HTAC[0];
+			var M16zeroes = HTAC[240];
+			var pos;
+			var I16 = 16;
+			var I63 = 63;
+			var I64 = 64;
+			var DU_DCT = fDCTQuant(CDU, fdtbl);
+			for (var j = 0; j < I64; ++j) DU[ZigZag[j]] = DU_DCT[j];
+			var Diff = DU[0] - DC;
+			DC = DU[0];
+			if (Diff == 0) writeBits(HTDC[0]);
+			else {
+				pos = 32767 + Diff;
+				writeBits(HTDC[category[pos]]);
+				writeBits(bitcode[pos]);
+			}
+			var end0pos = 63;
+			for (; end0pos > 0 && DU[end0pos] == 0; end0pos--);
+			if (end0pos == 0) {
+				writeBits(EOB);
+				return DC;
+			}
+			var i = 1;
+			var lng;
+			while (i <= end0pos) {
+				var startpos = i;
+				for (; DU[i] == 0 && i <= end0pos; ++i);
+				var nrzeroes = i - startpos;
+				if (nrzeroes >= I16) {
+					lng = nrzeroes >> 4;
+					for (var nrmarker = 1; nrmarker <= lng; ++nrmarker) writeBits(M16zeroes);
+					nrzeroes = nrzeroes & 15;
+				}
+				pos = 32767 + DU[i];
+				writeBits(HTAC[(nrzeroes << 4) + category[pos]]);
+				writeBits(bitcode[pos]);
+				i++;
+			}
+			if (end0pos != I63) writeBits(EOB);
+			return DC;
+		}
+		function initCharLookupTable() {
+			var sfcc = String.fromCharCode;
+			for (var i = 0; i < 256; i++) clt[i] = sfcc(i);
+		}
+		this.encode = function(image, quality) {
+			(/* @__PURE__ */ new Date()).getTime();
+			if (quality) setQuality(quality);
+			byteout = new Array();
+			bytenew = 0;
+			bytepos = 7;
+			writeWord(65496);
+			writeAPP0();
+			writeCOM(image.comments);
+			writeAPP1(image.exifBuffer);
+			writeDQT();
+			writeSOF0(image.width, image.height);
+			writeDHT();
+			writeSOS();
+			var DCY = 0;
+			var DCU = 0;
+			var DCV = 0;
+			bytenew = 0;
+			bytepos = 7;
+			this.encode.displayName = "_encode_";
+			var imageData = image.data;
+			var width = image.width;
+			var height = image.height;
+			var quadWidth = width * 4;
+			width * 3;
+			var x, y = 0;
+			var r, g, b;
+			var start, p, col, row, pos;
+			while (y < height) {
+				x = 0;
+				while (x < quadWidth) {
+					start = quadWidth * y + x;
+					p = start;
+					col = -1;
+					row = 0;
+					for (pos = 0; pos < 64; pos++) {
+						row = pos >> 3;
+						col = (pos & 7) * 4;
+						p = start + row * quadWidth + col;
+						if (y + row >= height) p -= quadWidth * (y + 1 + row - height);
+						if (x + col >= quadWidth) p -= x + col - quadWidth + 4;
+						r = imageData[p++];
+						g = imageData[p++];
+						b = imageData[p++];
+						YDU[pos] = (RGB_YUV_TABLE[r] + RGB_YUV_TABLE[g + 256 >> 0] + RGB_YUV_TABLE[b + 512 >> 0] >> 16) - 128;
+						UDU[pos] = (RGB_YUV_TABLE[r + 768 >> 0] + RGB_YUV_TABLE[g + 1024 >> 0] + RGB_YUV_TABLE[b + 1280 >> 0] >> 16) - 128;
+						VDU[pos] = (RGB_YUV_TABLE[r + 1280 >> 0] + RGB_YUV_TABLE[g + 1536 >> 0] + RGB_YUV_TABLE[b + 1792 >> 0] >> 16) - 128;
+					}
+					DCY = processDU(YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+					DCU = processDU(UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
+					DCV = processDU(VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
+					x += 32;
+				}
+				y += 8;
+			}
+			if (bytepos >= 0) {
+				var fillbits = [];
+				fillbits[1] = bytepos + 1;
+				fillbits[0] = (1 << bytepos + 1) - 1;
+				writeBits(fillbits);
+			}
+			writeWord(65497);
+			if (typeof module === "undefined") return new Uint8Array(byteout);
+			return Buffer.from(byteout);
+		};
+		function setQuality(quality) {
+			if (quality <= 0) quality = 1;
+			if (quality > 100) quality = 100;
+			if (currentQuality == quality) return;
+			var sf = 0;
+			if (quality < 50) sf = Math.floor(5e3 / quality);
+			else sf = Math.floor(200 - quality * 2);
+			initQuantTables(sf);
+			currentQuality = quality;
+		}
+		function init() {
+			var time_start = (/* @__PURE__ */ new Date()).getTime();
+			if (!quality) quality = 50;
+			initCharLookupTable();
+			initHuffmanTbl();
+			initCategoryNumber();
+			initRGBYUVTable();
+			setQuality(quality);
+			(/* @__PURE__ */ new Date()).getTime() - time_start;
+		}
+		init();
+	}
+	if (typeof module !== "undefined") module.exports = encode;
+	else if (typeof window !== "undefined") {
+		window["jpeg-js"] = window["jpeg-js"] || {};
+		window["jpeg-js"].encode = encode;
+	}
+	function encode(imgData, qu) {
+		if (typeof qu === "undefined") qu = 50;
+		return {
+			data: new JPEGEncoder(qu).encode(imgData, qu),
+			width: imgData.width,
+			height: imgData.height
+		};
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/jpeg-js@0.4.4/node_modules/jpeg-js/lib/decoder.js
+var require_decoder = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var JpegImage = (function jpegImage() {
+		"use strict";
+		var dctZigZag = new Int32Array([
+			0,
+			1,
+			8,
+			16,
+			9,
+			2,
+			3,
+			10,
+			17,
+			24,
+			32,
+			25,
+			18,
+			11,
+			4,
+			5,
+			12,
+			19,
+			26,
+			33,
+			40,
+			48,
+			41,
+			34,
+			27,
+			20,
+			13,
+			6,
+			7,
+			14,
+			21,
+			28,
+			35,
+			42,
+			49,
+			56,
+			57,
+			50,
+			43,
+			36,
+			29,
+			22,
+			15,
+			23,
+			30,
+			37,
+			44,
+			51,
+			58,
+			59,
+			52,
+			45,
+			38,
+			31,
+			39,
+			46,
+			53,
+			60,
+			61,
+			54,
+			47,
+			55,
+			62,
+			63
+		]);
+		var dctCos1 = 4017;
+		var dctSin1 = 799;
+		var dctCos3 = 3406;
+		var dctSin3 = 2276;
+		var dctCos6 = 1567;
+		var dctSin6 = 3784;
+		var dctSqrt2 = 5793;
+		var dctSqrt1d2 = 2896;
+		function constructor() {}
+		function buildHuffmanTable(codeLengths, values) {
+			var k = 0, code = [], i, j, length = 16;
+			while (length > 0 && !codeLengths[length - 1]) length--;
+			code.push({
+				children: [],
+				index: 0
+			});
+			var p = code[0], q;
+			for (i = 0; i < length; i++) {
+				for (j = 0; j < codeLengths[i]; j++) {
+					p = code.pop();
+					p.children[p.index] = values[k];
+					while (p.index > 0) {
+						if (code.length === 0) throw new Error("Could not recreate Huffman Table");
+						p = code.pop();
+					}
+					p.index++;
+					code.push(p);
+					while (code.length <= i) {
+						code.push(q = {
+							children: [],
+							index: 0
+						});
+						p.children[p.index] = q.children;
+						p = q;
+					}
+					k++;
+				}
+				if (i + 1 < length) {
+					code.push(q = {
+						children: [],
+						index: 0
+					});
+					p.children[p.index] = q.children;
+					p = q;
+				}
+			}
+			return code[0].children;
+		}
+		function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive, opts) {
+			frame.precision;
+			frame.samplesPerLine;
+			frame.scanLines;
+			var mcusPerLine = frame.mcusPerLine;
+			var progressive = frame.progressive;
+			frame.maxH;
+			frame.maxV;
+			var startOffset = offset, bitsData = 0, bitsCount = 0;
+			function readBit() {
+				if (bitsCount > 0) {
+					bitsCount--;
+					return bitsData >> bitsCount & 1;
+				}
+				bitsData = data[offset++];
+				if (bitsData == 255) {
+					var nextByte = data[offset++];
+					if (nextByte) throw new Error("unexpected marker: " + (bitsData << 8 | nextByte).toString(16));
+				}
+				bitsCount = 7;
+				return bitsData >>> 7;
+			}
+			function decodeHuffman(tree) {
+				var node = tree, bit;
+				while ((bit = readBit()) !== null) {
+					node = node[bit];
+					if (typeof node === "number") return node;
+					if (typeof node !== "object") throw new Error("invalid huffman sequence");
+				}
+				return null;
+			}
+			function receive(length) {
+				var n = 0;
+				while (length > 0) {
+					var bit = readBit();
+					if (bit === null) return;
+					n = n << 1 | bit;
+					length--;
+				}
+				return n;
+			}
+			function receiveAndExtend(length) {
+				var n = receive(length);
+				if (n >= 1 << length - 1) return n;
+				return n + (-1 << length) + 1;
+			}
+			function decodeBaseline(component, zz) {
+				var t = decodeHuffman(component.huffmanTableDC);
+				var diff = t === 0 ? 0 : receiveAndExtend(t);
+				zz[0] = component.pred += diff;
+				var k = 1;
+				while (k < 64) {
+					var rs = decodeHuffman(component.huffmanTableAC);
+					var s = rs & 15, r = rs >> 4;
+					if (s === 0) {
+						if (r < 15) break;
+						k += 16;
+						continue;
+					}
+					k += r;
+					var z = dctZigZag[k];
+					zz[z] = receiveAndExtend(s);
+					k++;
+				}
+			}
+			function decodeDCFirst(component, zz) {
+				var t = decodeHuffman(component.huffmanTableDC);
+				var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;
+				zz[0] = component.pred += diff;
+			}
+			function decodeDCSuccessive(component, zz) {
+				zz[0] |= readBit() << successive;
+			}
+			var eobrun = 0;
+			function decodeACFirst(component, zz) {
+				if (eobrun > 0) {
+					eobrun--;
+					return;
+				}
+				var k = spectralStart, e = spectralEnd;
+				while (k <= e) {
+					var rs = decodeHuffman(component.huffmanTableAC);
+					var s = rs & 15, r = rs >> 4;
+					if (s === 0) {
+						if (r < 15) {
+							eobrun = receive(r) + (1 << r) - 1;
+							break;
+						}
+						k += 16;
+						continue;
+					}
+					k += r;
+					var z = dctZigZag[k];
+					zz[z] = receiveAndExtend(s) * (1 << successive);
+					k++;
+				}
+			}
+			var successiveACState = 0, successiveACNextValue;
+			function decodeACSuccessive(component, zz) {
+				var k = spectralStart, e = spectralEnd, r = 0;
+				while (k <= e) {
+					var z = dctZigZag[k];
+					var direction = zz[z] < 0 ? -1 : 1;
+					switch (successiveACState) {
+						case 0:
+							var rs = decodeHuffman(component.huffmanTableAC);
+							var s = rs & 15, r = rs >> 4;
+							if (s === 0) if (r < 15) {
+								eobrun = receive(r) + (1 << r);
+								successiveACState = 4;
+							} else {
+								r = 16;
+								successiveACState = 1;
+							}
+							else {
+								if (s !== 1) throw new Error("invalid ACn encoding");
+								successiveACNextValue = receiveAndExtend(s);
+								successiveACState = r ? 2 : 3;
+							}
+							continue;
+						case 1:
+						case 2:
+							if (zz[z]) zz[z] += (readBit() << successive) * direction;
+							else {
+								r--;
+								if (r === 0) successiveACState = successiveACState == 2 ? 3 : 0;
+							}
+							break;
+						case 3:
+							if (zz[z]) zz[z] += (readBit() << successive) * direction;
+							else {
+								zz[z] = successiveACNextValue << successive;
+								successiveACState = 0;
+							}
+							break;
+						case 4:
+							if (zz[z]) zz[z] += (readBit() << successive) * direction;
+							break;
+					}
+					k++;
+				}
+				if (successiveACState === 4) {
+					eobrun--;
+					if (eobrun === 0) successiveACState = 0;
+				}
+			}
+			function decodeMcu(component, decode, mcu, row, col) {
+				var mcuRow = mcu / mcusPerLine | 0;
+				var mcuCol = mcu % mcusPerLine;
+				var blockRow = mcuRow * component.v + row;
+				var blockCol = mcuCol * component.h + col;
+				if (component.blocks[blockRow] === void 0 && opts.tolerantDecoding) return;
+				decode(component, component.blocks[blockRow][blockCol]);
+			}
+			function decodeBlock(component, decode, mcu) {
+				var blockRow = mcu / component.blocksPerLine | 0;
+				var blockCol = mcu % component.blocksPerLine;
+				if (component.blocks[blockRow] === void 0 && opts.tolerantDecoding) return;
+				decode(component, component.blocks[blockRow][blockCol]);
+			}
+			var componentsLength = components.length;
+			var component, i, j, k, n;
+			var decodeFn;
+			if (progressive) if (spectralStart === 0) decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
+			else decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
+			else decodeFn = decodeBaseline;
+			var mcu = 0, marker;
+			var mcuExpected;
+			if (componentsLength == 1) mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
+			else mcuExpected = mcusPerLine * frame.mcusPerColumn;
+			if (!resetInterval) resetInterval = mcuExpected;
+			var h, v;
+			while (mcu < mcuExpected) {
+				for (i = 0; i < componentsLength; i++) components[i].pred = 0;
+				eobrun = 0;
+				if (componentsLength == 1) {
+					component = components[0];
+					for (n = 0; n < resetInterval; n++) {
+						decodeBlock(component, decodeFn, mcu);
+						mcu++;
+					}
+				} else for (n = 0; n < resetInterval; n++) {
+					for (i = 0; i < componentsLength; i++) {
+						component = components[i];
+						h = component.h;
+						v = component.v;
+						for (j = 0; j < v; j++) for (k = 0; k < h; k++) decodeMcu(component, decodeFn, mcu, j, k);
+					}
+					mcu++;
+					if (mcu === mcuExpected) break;
+				}
+				if (mcu === mcuExpected) do {
+					if (data[offset] === 255) {
+						if (data[offset + 1] !== 0) break;
+					}
+					offset += 1;
+				} while (offset < data.length - 2);
+				bitsCount = 0;
+				marker = data[offset] << 8 | data[offset + 1];
+				if (marker < 65280) throw new Error("marker was not found");
+				if (marker >= 65488 && marker <= 65495) offset += 2;
+				else break;
+			}
+			return offset - startOffset;
+		}
+		function buildComponentData(frame, component) {
+			var lines = [];
+			var blocksPerLine = component.blocksPerLine;
+			var blocksPerColumn = component.blocksPerColumn;
+			var samplesPerLine = blocksPerLine << 3;
+			var R = new Int32Array(64), r = new Uint8Array(64);
+			function quantizeAndInverse(zz, dataOut, dataIn) {
+				var qt = component.quantizationTable;
+				var v0, v1, v2, v3, v4, v5, v6, v7, t;
+				var p = dataIn;
+				var i;
+				for (i = 0; i < 64; i++) p[i] = zz[i] * qt[i];
+				for (i = 0; i < 8; ++i) {
+					var row = 8 * i;
+					if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 && p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 && p[7 + row] == 0) {
+						t = dctSqrt2 * p[0 + row] + 512 >> 10;
+						p[0 + row] = t;
+						p[1 + row] = t;
+						p[2 + row] = t;
+						p[3 + row] = t;
+						p[4 + row] = t;
+						p[5 + row] = t;
+						p[6 + row] = t;
+						p[7 + row] = t;
+						continue;
+					}
+					v0 = dctSqrt2 * p[0 + row] + 128 >> 8;
+					v1 = dctSqrt2 * p[4 + row] + 128 >> 8;
+					v2 = p[2 + row];
+					v3 = p[6 + row];
+					v4 = dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128 >> 8;
+					v7 = dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128 >> 8;
+					v5 = p[3 + row] << 4;
+					v6 = p[5 + row] << 4;
+					t = v0 - v1 + 1 >> 1;
+					v0 = v0 + v1 + 1 >> 1;
+					v1 = t;
+					t = v2 * dctSin6 + v3 * dctCos6 + 128 >> 8;
+					v2 = v2 * dctCos6 - v3 * dctSin6 + 128 >> 8;
+					v3 = t;
+					t = v4 - v6 + 1 >> 1;
+					v4 = v4 + v6 + 1 >> 1;
+					v6 = t;
+					t = v7 + v5 + 1 >> 1;
+					v5 = v7 - v5 + 1 >> 1;
+					v7 = t;
+					t = v0 - v3 + 1 >> 1;
+					v0 = v0 + v3 + 1 >> 1;
+					v3 = t;
+					t = v1 - v2 + 1 >> 1;
+					v1 = v1 + v2 + 1 >> 1;
+					v2 = t;
+					t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
+					v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
+					v7 = t;
+					t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
+					v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
+					v6 = t;
+					p[0 + row] = v0 + v7;
+					p[7 + row] = v0 - v7;
+					p[1 + row] = v1 + v6;
+					p[6 + row] = v1 - v6;
+					p[2 + row] = v2 + v5;
+					p[5 + row] = v2 - v5;
+					p[3 + row] = v3 + v4;
+					p[4 + row] = v3 - v4;
+				}
+				for (i = 0; i < 8; ++i) {
+					var col = i;
+					if (p[8 + col] == 0 && p[16 + col] == 0 && p[24 + col] == 0 && p[32 + col] == 0 && p[40 + col] == 0 && p[48 + col] == 0 && p[56 + col] == 0) {
+						t = dctSqrt2 * dataIn[i + 0] + 8192 >> 14;
+						p[0 + col] = t;
+						p[8 + col] = t;
+						p[16 + col] = t;
+						p[24 + col] = t;
+						p[32 + col] = t;
+						p[40 + col] = t;
+						p[48 + col] = t;
+						p[56 + col] = t;
+						continue;
+					}
+					v0 = dctSqrt2 * p[0 + col] + 2048 >> 12;
+					v1 = dctSqrt2 * p[32 + col] + 2048 >> 12;
+					v2 = p[16 + col];
+					v3 = p[48 + col];
+					v4 = dctSqrt1d2 * (p[8 + col] - p[56 + col]) + 2048 >> 12;
+					v7 = dctSqrt1d2 * (p[8 + col] + p[56 + col]) + 2048 >> 12;
+					v5 = p[24 + col];
+					v6 = p[40 + col];
+					t = v0 - v1 + 1 >> 1;
+					v0 = v0 + v1 + 1 >> 1;
+					v1 = t;
+					t = v2 * dctSin6 + v3 * dctCos6 + 2048 >> 12;
+					v2 = v2 * dctCos6 - v3 * dctSin6 + 2048 >> 12;
+					v3 = t;
+					t = v4 - v6 + 1 >> 1;
+					v4 = v4 + v6 + 1 >> 1;
+					v6 = t;
+					t = v7 + v5 + 1 >> 1;
+					v5 = v7 - v5 + 1 >> 1;
+					v7 = t;
+					t = v0 - v3 + 1 >> 1;
+					v0 = v0 + v3 + 1 >> 1;
+					v3 = t;
+					t = v1 - v2 + 1 >> 1;
+					v1 = v1 + v2 + 1 >> 1;
+					v2 = t;
+					t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
+					v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
+					v7 = t;
+					t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
+					v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
+					v6 = t;
+					p[0 + col] = v0 + v7;
+					p[56 + col] = v0 - v7;
+					p[8 + col] = v1 + v6;
+					p[48 + col] = v1 - v6;
+					p[16 + col] = v2 + v5;
+					p[40 + col] = v2 - v5;
+					p[24 + col] = v3 + v4;
+					p[32 + col] = v3 - v4;
+				}
+				for (i = 0; i < 64; ++i) {
+					var sample = 128 + (p[i] + 8 >> 4);
+					dataOut[i] = sample < 0 ? 0 : sample > 255 ? 255 : sample;
+				}
+			}
+			requestMemoryAllocation(samplesPerLine * blocksPerColumn * 8);
+			var i, j;
+			for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
+				var scanLine = blockRow << 3;
+				for (i = 0; i < 8; i++) lines.push(new Uint8Array(samplesPerLine));
+				for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
+					quantizeAndInverse(component.blocks[blockRow][blockCol], r, R);
+					var offset = 0, sample = blockCol << 3;
+					for (j = 0; j < 8; j++) {
+						var line = lines[scanLine + j];
+						for (i = 0; i < 8; i++) line[sample + i] = r[offset++];
+					}
+				}
+			}
+			return lines;
+		}
+		function clampTo8bit(a) {
+			return a < 0 ? 0 : a > 255 ? 255 : a;
+		}
+		constructor.prototype = {
+			load: function load(path) {
+				var xhr = new XMLHttpRequest();
+				xhr.open("GET", path, true);
+				xhr.responseType = "arraybuffer";
+				xhr.onload = (function() {
+					var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer);
+					this.parse(data);
+					if (this.onload) this.onload();
+				}).bind(this);
+				xhr.send(null);
+			},
+			parse: function parse(data) {
+				var maxResolutionInPixels = this.opts.maxResolutionInMP * 1e3 * 1e3, offset = 0;
+				data.length;
+				function readUint16() {
+					var value = data[offset] << 8 | data[offset + 1];
+					offset += 2;
+					return value;
+				}
+				function readDataBlock() {
+					var length = readUint16();
+					var array = data.subarray(offset, offset + length - 2);
+					offset += array.length;
+					return array;
+				}
+				function prepareComponents(frame) {
+					var maxH = 1, maxV = 1;
+					var component, componentId;
+					for (componentId in frame.components) if (frame.components.hasOwnProperty(componentId)) {
+						component = frame.components[componentId];
+						if (maxH < component.h) maxH = component.h;
+						if (maxV < component.v) maxV = component.v;
+					}
+					var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH);
+					var mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV);
+					for (componentId in frame.components) if (frame.components.hasOwnProperty(componentId)) {
+						component = frame.components[componentId];
+						var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH);
+						var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV);
+						var blocksPerLineForMcu = mcusPerLine * component.h;
+						var blocksPerColumnForMcu = mcusPerColumn * component.v;
+						var blocksToAllocate = blocksPerColumnForMcu * blocksPerLineForMcu;
+						var blocks = [];
+						requestMemoryAllocation(blocksToAllocate * 256);
+						for (var i = 0; i < blocksPerColumnForMcu; i++) {
+							var row = [];
+							for (var j = 0; j < blocksPerLineForMcu; j++) row.push(new Int32Array(64));
+							blocks.push(row);
+						}
+						component.blocksPerLine = blocksPerLine;
+						component.blocksPerColumn = blocksPerColumn;
+						component.blocks = blocks;
+					}
+					frame.maxH = maxH;
+					frame.maxV = maxV;
+					frame.mcusPerLine = mcusPerLine;
+					frame.mcusPerColumn = mcusPerColumn;
+				}
+				var jfif = null;
+				var adobe = null;
+				var frame, resetInterval;
+				var quantizationTables = [], frames = [];
+				var huffmanTablesAC = [], huffmanTablesDC = [];
+				var fileMarker = readUint16();
+				var malformedDataOffset = -1;
+				this.comments = [];
+				if (fileMarker != 65496) throw new Error("SOI not found");
+				fileMarker = readUint16();
+				while (fileMarker != 65497) {
+					var i, j;
+					switch (fileMarker) {
+						case 65280: break;
+						case 65504:
+						case 65505:
+						case 65506:
+						case 65507:
+						case 65508:
+						case 65509:
+						case 65510:
+						case 65511:
+						case 65512:
+						case 65513:
+						case 65514:
+						case 65515:
+						case 65516:
+						case 65517:
+						case 65518:
+						case 65519:
+						case 65534:
+							var appData = readDataBlock();
+							if (fileMarker === 65534) {
+								var comment = String.fromCharCode.apply(null, appData);
+								this.comments.push(comment);
+							}
+							if (fileMarker === 65504) {
+								if (appData[0] === 74 && appData[1] === 70 && appData[2] === 73 && appData[3] === 70 && appData[4] === 0) jfif = {
+									version: {
+										major: appData[5],
+										minor: appData[6]
+									},
+									densityUnits: appData[7],
+									xDensity: appData[8] << 8 | appData[9],
+									yDensity: appData[10] << 8 | appData[11],
+									thumbWidth: appData[12],
+									thumbHeight: appData[13],
+									thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])
+								};
+							}
+							if (fileMarker === 65505) {
+								if (appData[0] === 69 && appData[1] === 120 && appData[2] === 105 && appData[3] === 102 && appData[4] === 0) this.exifBuffer = appData.subarray(5, appData.length);
+							}
+							if (fileMarker === 65518) {
+								if (appData[0] === 65 && appData[1] === 100 && appData[2] === 111 && appData[3] === 98 && appData[4] === 101 && appData[5] === 0) adobe = {
+									version: appData[6],
+									flags0: appData[7] << 8 | appData[8],
+									flags1: appData[9] << 8 | appData[10],
+									transformCode: appData[11]
+								};
+							}
+							break;
+						case 65499:
+							var quantizationTablesEnd = readUint16() + offset - 2;
+							while (offset < quantizationTablesEnd) {
+								var quantizationTableSpec = data[offset++];
+								requestMemoryAllocation(256);
+								var tableData = new Int32Array(64);
+								if (quantizationTableSpec >> 4 === 0) for (j = 0; j < 64; j++) {
+									var z = dctZigZag[j];
+									tableData[z] = data[offset++];
+								}
+								else if (quantizationTableSpec >> 4 === 1) for (j = 0; j < 64; j++) {
+									var z = dctZigZag[j];
+									tableData[z] = readUint16();
+								}
+								else throw new Error("DQT: invalid table spec");
+								quantizationTables[quantizationTableSpec & 15] = tableData;
+							}
+							break;
+						case 65472:
+						case 65473:
+						case 65474:
+							readUint16();
+							frame = {};
+							frame.extended = fileMarker === 65473;
+							frame.progressive = fileMarker === 65474;
+							frame.precision = data[offset++];
+							frame.scanLines = readUint16();
+							frame.samplesPerLine = readUint16();
+							frame.components = {};
+							frame.componentsOrder = [];
+							var pixelsInFrame = frame.scanLines * frame.samplesPerLine;
+							if (pixelsInFrame > maxResolutionInPixels) {
+								var exceededAmount = Math.ceil((pixelsInFrame - maxResolutionInPixels) / 1e6);
+								throw new Error(`maxResolutionInMP limit exceeded by ${exceededAmount}MP`);
+							}
+							var componentsCount = data[offset++], componentId;
+							for (i = 0; i < componentsCount; i++) {
+								componentId = data[offset];
+								var h = data[offset + 1] >> 4;
+								var v = data[offset + 1] & 15;
+								var qId = data[offset + 2];
+								if (h <= 0 || v <= 0) throw new Error("Invalid sampling factor, expected values above 0");
+								frame.componentsOrder.push(componentId);
+								frame.components[componentId] = {
+									h,
+									v,
+									quantizationIdx: qId
+								};
+								offset += 3;
+							}
+							prepareComponents(frame);
+							frames.push(frame);
+							break;
+						case 65476:
+							var huffmanLength = readUint16();
+							for (i = 2; i < huffmanLength;) {
+								var huffmanTableSpec = data[offset++];
+								var codeLengths = new Uint8Array(16);
+								var codeLengthSum = 0;
+								for (j = 0; j < 16; j++, offset++) codeLengthSum += codeLengths[j] = data[offset];
+								requestMemoryAllocation(16 + codeLengthSum);
+								var huffmanValues = new Uint8Array(codeLengthSum);
+								for (j = 0; j < codeLengthSum; j++, offset++) huffmanValues[j] = data[offset];
+								i += 17 + codeLengthSum;
+								(huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = buildHuffmanTable(codeLengths, huffmanValues);
+							}
+							break;
+						case 65501:
+							readUint16();
+							resetInterval = readUint16();
+							break;
+						case 65500:
+							readUint16();
+							readUint16();
+							break;
+						case 65498:
+							readUint16();
+							var selectorsCount = data[offset++];
+							var components = [], component;
+							for (i = 0; i < selectorsCount; i++) {
+								component = frame.components[data[offset++]];
+								var tableSpec = data[offset++];
+								component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
+								component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
+								components.push(component);
+							}
+							var spectralStart = data[offset++];
+							var spectralEnd = data[offset++];
+							var successiveApproximation = data[offset++];
+							var processed = decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15, this.opts);
+							offset += processed;
+							break;
+						case 65535:
+							if (data[offset] !== 255) offset--;
+							break;
+						default:
+							if (data[offset - 3] == 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) {
+								offset -= 3;
+								break;
+							} else if (fileMarker === 224 || fileMarker == 225) {
+								if (malformedDataOffset !== -1) throw new Error(`first unknown JPEG marker at offset ${malformedDataOffset.toString(16)}, second unknown JPEG marker ${fileMarker.toString(16)} at offset ${(offset - 1).toString(16)}`);
+								malformedDataOffset = offset - 1;
+								const nextOffset = readUint16();
+								if (data[offset + nextOffset - 2] === 255) {
+									offset += nextOffset - 2;
+									break;
+								}
+							}
+							throw new Error("unknown JPEG marker " + fileMarker.toString(16));
+					}
+					fileMarker = readUint16();
+				}
+				if (frames.length != 1) throw new Error("only single frame JPEGs supported");
+				for (var i = 0; i < frames.length; i++) {
+					var cp = frames[i].components;
+					for (var j in cp) {
+						cp[j].quantizationTable = quantizationTables[cp[j].quantizationIdx];
+						delete cp[j].quantizationIdx;
+					}
+				}
+				this.width = frame.samplesPerLine;
+				this.height = frame.scanLines;
+				this.jfif = jfif;
+				this.adobe = adobe;
+				this.components = [];
+				for (var i = 0; i < frame.componentsOrder.length; i++) {
+					var component = frame.components[frame.componentsOrder[i]];
+					this.components.push({
+						lines: buildComponentData(frame, component),
+						scaleX: component.h / frame.maxH,
+						scaleY: component.v / frame.maxV
+					});
+				}
+			},
+			getData: function getData(width, height) {
+				var scaleX = this.width / width, scaleY = this.height / height;
+				var component1, component2, component3, component4;
+				var component1Line, component2Line, component3Line, component4Line;
+				var x, y;
+				var offset = 0;
+				var Y, Cb, Cr, K, C, M, Ye, R, G, B;
+				var colorTransform;
+				var dataLength = width * height * this.components.length;
+				requestMemoryAllocation(dataLength);
+				var data = new Uint8Array(dataLength);
+				switch (this.components.length) {
+					case 1:
+						component1 = this.components[0];
+						for (y = 0; y < height; y++) {
+							component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
+							for (x = 0; x < width; x++) {
+								Y = component1Line[0 | x * component1.scaleX * scaleX];
+								data[offset++] = Y;
+							}
+						}
+						break;
+					case 2:
+						component1 = this.components[0];
+						component2 = this.components[1];
+						for (y = 0; y < height; y++) {
+							component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
+							component2Line = component2.lines[0 | y * component2.scaleY * scaleY];
+							for (x = 0; x < width; x++) {
+								Y = component1Line[0 | x * component1.scaleX * scaleX];
+								data[offset++] = Y;
+								Y = component2Line[0 | x * component2.scaleX * scaleX];
+								data[offset++] = Y;
+							}
+						}
+						break;
+					case 3:
+						colorTransform = true;
+						if (this.adobe && this.adobe.transformCode) colorTransform = true;
+						else if (typeof this.opts.colorTransform !== "undefined") colorTransform = !!this.opts.colorTransform;
+						component1 = this.components[0];
+						component2 = this.components[1];
+						component3 = this.components[2];
+						for (y = 0; y < height; y++) {
+							component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
+							component2Line = component2.lines[0 | y * component2.scaleY * scaleY];
+							component3Line = component3.lines[0 | y * component3.scaleY * scaleY];
+							for (x = 0; x < width; x++) {
+								if (!colorTransform) {
+									R = component1Line[0 | x * component1.scaleX * scaleX];
+									G = component2Line[0 | x * component2.scaleX * scaleX];
+									B = component3Line[0 | x * component3.scaleX * scaleX];
+								} else {
+									Y = component1Line[0 | x * component1.scaleX * scaleX];
+									Cb = component2Line[0 | x * component2.scaleX * scaleX];
+									Cr = component3Line[0 | x * component3.scaleX * scaleX];
+									R = clampTo8bit(Y + 1.402 * (Cr - 128));
+									G = clampTo8bit(Y - .3441363 * (Cb - 128) - .71413636 * (Cr - 128));
+									B = clampTo8bit(Y + 1.772 * (Cb - 128));
+								}
+								data[offset++] = R;
+								data[offset++] = G;
+								data[offset++] = B;
+							}
+						}
+						break;
+					case 4:
+						if (!this.adobe) throw new Error("Unsupported color mode (4 components)");
+						colorTransform = false;
+						if (this.adobe && this.adobe.transformCode) colorTransform = true;
+						else if (typeof this.opts.colorTransform !== "undefined") colorTransform = !!this.opts.colorTransform;
+						component1 = this.components[0];
+						component2 = this.components[1];
+						component3 = this.components[2];
+						component4 = this.components[3];
+						for (y = 0; y < height; y++) {
+							component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
+							component2Line = component2.lines[0 | y * component2.scaleY * scaleY];
+							component3Line = component3.lines[0 | y * component3.scaleY * scaleY];
+							component4Line = component4.lines[0 | y * component4.scaleY * scaleY];
+							for (x = 0; x < width; x++) {
+								if (!colorTransform) {
+									C = component1Line[0 | x * component1.scaleX * scaleX];
+									M = component2Line[0 | x * component2.scaleX * scaleX];
+									Ye = component3Line[0 | x * component3.scaleX * scaleX];
+									K = component4Line[0 | x * component4.scaleX * scaleX];
+								} else {
+									Y = component1Line[0 | x * component1.scaleX * scaleX];
+									Cb = component2Line[0 | x * component2.scaleX * scaleX];
+									Cr = component3Line[0 | x * component3.scaleX * scaleX];
+									K = component4Line[0 | x * component4.scaleX * scaleX];
+									C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128));
+									M = 255 - clampTo8bit(Y - .3441363 * (Cb - 128) - .71413636 * (Cr - 128));
+									Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128));
+								}
+								data[offset++] = 255 - C;
+								data[offset++] = 255 - M;
+								data[offset++] = 255 - Ye;
+								data[offset++] = 255 - K;
+							}
+						}
+						break;
+					default: throw new Error("Unsupported color mode");
+				}
+				return data;
+			},
+			copyToImageData: function copyToImageData(imageData, formatAsRGBA) {
+				var width = imageData.width, height = imageData.height;
+				var imageDataArray = imageData.data;
+				var data = this.getData(width, height);
+				var i = 0, j = 0, x, y;
+				var Y, K, C, M, R, G, B;
+				switch (this.components.length) {
+					case 1:
+						for (y = 0; y < height; y++) for (x = 0; x < width; x++) {
+							Y = data[i++];
+							imageDataArray[j++] = Y;
+							imageDataArray[j++] = Y;
+							imageDataArray[j++] = Y;
+							if (formatAsRGBA) imageDataArray[j++] = 255;
+						}
+						break;
+					case 3:
+						for (y = 0; y < height; y++) for (x = 0; x < width; x++) {
+							R = data[i++];
+							G = data[i++];
+							B = data[i++];
+							imageDataArray[j++] = R;
+							imageDataArray[j++] = G;
+							imageDataArray[j++] = B;
+							if (formatAsRGBA) imageDataArray[j++] = 255;
+						}
+						break;
+					case 4:
+						for (y = 0; y < height; y++) for (x = 0; x < width; x++) {
+							C = data[i++];
+							M = data[i++];
+							Y = data[i++];
+							K = data[i++];
+							R = 255 - clampTo8bit(C * (1 - K / 255) + K);
+							G = 255 - clampTo8bit(M * (1 - K / 255) + K);
+							B = 255 - clampTo8bit(Y * (1 - K / 255) + K);
+							imageDataArray[j++] = R;
+							imageDataArray[j++] = G;
+							imageDataArray[j++] = B;
+							if (formatAsRGBA) imageDataArray[j++] = 255;
+						}
+						break;
+					default: throw new Error("Unsupported color mode");
+				}
+			}
+		};
+		var totalBytesAllocated = 0;
+		var maxMemoryUsageBytes = 0;
+		function requestMemoryAllocation(increaseAmount = 0) {
+			var totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;
+			if (totalMemoryImpactBytes > maxMemoryUsageBytes) {
+				var exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);
+				throw new Error(`maxMemoryUsageInMB limit exceeded by at least ${exceededAmount}MB`);
+			}
+			totalBytesAllocated = totalMemoryImpactBytes;
+		}
+		constructor.resetMaxMemoryUsage = function(maxMemoryUsageBytes_) {
+			totalBytesAllocated = 0;
+			maxMemoryUsageBytes = maxMemoryUsageBytes_;
+		};
+		constructor.getBytesAllocated = function() {
+			return totalBytesAllocated;
+		};
+		constructor.requestMemoryAllocation = requestMemoryAllocation;
+		return constructor;
+	})();
+	if (typeof module !== "undefined") module.exports = decode;
+	else if (typeof window !== "undefined") {
+		window["jpeg-js"] = window["jpeg-js"] || {};
+		window["jpeg-js"].decode = decode;
+	}
+	function decode(jpegData, userOpts = {}) {
+		var opts = {
+			colorTransform: void 0,
+			useTArray: false,
+			formatAsRGBA: true,
+			tolerantDecoding: true,
+			maxResolutionInMP: 100,
+			maxMemoryUsageInMB: 512,
+			...userOpts
+		};
+		var arr = new Uint8Array(jpegData);
+		var decoder = new JpegImage();
+		decoder.opts = opts;
+		JpegImage.resetMaxMemoryUsage(opts.maxMemoryUsageInMB * 1024 * 1024);
+		decoder.parse(arr);
+		var channels = opts.formatAsRGBA ? 4 : 3;
+		var bytesNeeded = decoder.width * decoder.height * channels;
+		try {
+			JpegImage.requestMemoryAllocation(bytesNeeded);
+			var image = {
+				width: decoder.width,
+				height: decoder.height,
+				exifBuffer: decoder.exifBuffer,
+				data: opts.useTArray ? new Uint8Array(bytesNeeded) : Buffer.alloc(bytesNeeded)
+			};
+			if (decoder.comments.length > 0) image["comments"] = decoder.comments;
+		} catch (err) {
+			if (err instanceof RangeError) throw new Error("Could not allocate enough memory for the image. Required: " + bytesNeeded);
+			if (err instanceof ReferenceError) {
+				if (err.message === "Buffer is not defined") throw new Error("Buffer is not globally defined in this environment. Consider setting useTArray to true");
+			}
+			throw err;
+		}
+		decoder.copyToImageData(image, opts.formatAsRGBA);
+		return image;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/jpeg-js@0.4.4/node_modules/jpeg-js/index.js
+var require_jpeg_js = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		encode: require_encoder(),
+		decode: require_decoder()
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/chunkstream.js
+var require_chunkstream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var util$5 = require("util");
+	var Stream$3 = require("stream");
+	var ChunkStream = module.exports = function() {
+		Stream$3.call(this);
+		this._buffers = [];
+		this._buffered = 0;
+		this._reads = [];
+		this._paused = false;
+		this._encoding = "utf8";
+		this.writable = true;
+	};
+	util$5.inherits(ChunkStream, Stream$3);
+	ChunkStream.prototype.read = function(length, callback) {
+		this._reads.push({
+			length: Math.abs(length),
+			allowLess: length < 0,
+			func: callback
+		});
+		process.nextTick(function() {
+			this._process();
+			if (this._paused && this._reads && this._reads.length > 0) {
+				this._paused = false;
+				this.emit("drain");
+			}
+		}.bind(this));
+	};
+	ChunkStream.prototype.write = function(data, encoding) {
+		if (!this.writable) {
+			this.emit("error", /* @__PURE__ */ new Error("Stream not writable"));
+			return false;
+		}
+		let dataBuffer;
+		if (Buffer.isBuffer(data)) dataBuffer = data;
+		else dataBuffer = Buffer.from(data, encoding || this._encoding);
+		this._buffers.push(dataBuffer);
+		this._buffered += dataBuffer.length;
+		this._process();
+		if (this._reads && this._reads.length === 0) this._paused = true;
+		return this.writable && !this._paused;
+	};
+	ChunkStream.prototype.end = function(data, encoding) {
+		if (data) this.write(data, encoding);
+		this.writable = false;
+		if (!this._buffers) return;
+		if (this._buffers.length === 0) this._end();
+		else {
+			this._buffers.push(null);
+			this._process();
+		}
+	};
+	ChunkStream.prototype.destroySoon = ChunkStream.prototype.end;
+	ChunkStream.prototype._end = function() {
+		if (this._reads.length > 0) this.emit("error", /* @__PURE__ */ new Error("Unexpected end of input"));
+		this.destroy();
+	};
+	ChunkStream.prototype.destroy = function() {
+		if (!this._buffers) return;
+		this.writable = false;
+		this._reads = null;
+		this._buffers = null;
+		this.emit("close");
+	};
+	ChunkStream.prototype._processReadAllowingLess = function(read) {
+		this._reads.shift();
+		let smallerBuf = this._buffers[0];
+		if (smallerBuf.length > read.length) {
+			this._buffered -= read.length;
+			this._buffers[0] = smallerBuf.slice(read.length);
+			read.func.call(this, smallerBuf.slice(0, read.length));
+		} else {
+			this._buffered -= smallerBuf.length;
+			this._buffers.shift();
+			read.func.call(this, smallerBuf);
+		}
+	};
+	ChunkStream.prototype._processRead = function(read) {
+		this._reads.shift();
+		let pos = 0;
+		let count = 0;
+		let data = Buffer.alloc(read.length);
+		while (pos < read.length) {
+			let buf = this._buffers[count++];
+			let len = Math.min(buf.length, read.length - pos);
+			buf.copy(data, pos, 0, len);
+			pos += len;
+			if (len !== buf.length) this._buffers[--count] = buf.slice(len);
+		}
+		if (count > 0) this._buffers.splice(0, count);
+		this._buffered -= read.length;
+		read.func.call(this, data);
+	};
+	ChunkStream.prototype._process = function() {
+		try {
+			while (this._buffered > 0 && this._reads && this._reads.length > 0) {
+				let read = this._reads[0];
+				if (read.allowLess) this._processReadAllowingLess(read);
+				else if (this._buffered >= read.length) this._processRead(read);
+				else break;
+			}
+			if (this._buffers && !this.writable) this._end();
+		} catch (ex) {
+			this.emit("error", ex);
+		}
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/interlace.js
+var require_interlace = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var imagePasses = [
+		{
+			x: [0],
+			y: [0]
+		},
+		{
+			x: [4],
+			y: [0]
+		},
+		{
+			x: [0, 4],
+			y: [4]
+		},
+		{
+			x: [2, 6],
+			y: [0, 4]
+		},
+		{
+			x: [
+				0,
+				2,
+				4,
+				6
+			],
+			y: [2, 6]
+		},
+		{
+			x: [
+				1,
+				3,
+				5,
+				7
+			],
+			y: [
+				0,
+				2,
+				4,
+				6
+			]
+		},
+		{
+			x: [
+				0,
+				1,
+				2,
+				3,
+				4,
+				5,
+				6,
+				7
+			],
+			y: [
+				1,
+				3,
+				5,
+				7
+			]
+		}
+	];
+	exports.getImagePasses = function(width, height) {
+		let images = [];
+		let xLeftOver = width % 8;
+		let yLeftOver = height % 8;
+		let xRepeats = (width - xLeftOver) / 8;
+		let yRepeats = (height - yLeftOver) / 8;
+		for (let i = 0; i < imagePasses.length; i++) {
+			let pass = imagePasses[i];
+			let passWidth = xRepeats * pass.x.length;
+			let passHeight = yRepeats * pass.y.length;
+			for (let j = 0; j < pass.x.length; j++) if (pass.x[j] < xLeftOver) passWidth++;
+			else break;
+			for (let j = 0; j < pass.y.length; j++) if (pass.y[j] < yLeftOver) passHeight++;
+			else break;
+			if (passWidth > 0 && passHeight > 0) images.push({
+				width: passWidth,
+				height: passHeight,
+				index: i
+			});
+		}
+		return images;
+	};
+	exports.getInterlaceIterator = function(width) {
+		return function(x, y, pass) {
+			let outerXLeftOver = x % imagePasses[pass].x.length;
+			let outerX = (x - outerXLeftOver) / imagePasses[pass].x.length * 8 + imagePasses[pass].x[outerXLeftOver];
+			let outerYLeftOver = y % imagePasses[pass].y.length;
+			let outerY = (y - outerYLeftOver) / imagePasses[pass].y.length * 8 + imagePasses[pass].y[outerYLeftOver];
+			return outerX * 4 + outerY * width * 4;
+		};
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/paeth-predictor.js
+var require_paeth_predictor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function paethPredictor(left, above, upLeft) {
+		let paeth = left + above - upLeft;
+		let pLeft = Math.abs(paeth - left);
+		let pAbove = Math.abs(paeth - above);
+		let pUpLeft = Math.abs(paeth - upLeft);
+		if (pLeft <= pAbove && pLeft <= pUpLeft) return left;
+		if (pAbove <= pUpLeft) return above;
+		return upLeft;
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-parse.js
+var require_filter_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var interlaceUtils = require_interlace();
+	var paethPredictor = require_paeth_predictor();
+	function getByteWidth(width, bpp, depth) {
+		let byteWidth = width * bpp;
+		if (depth !== 8) byteWidth = Math.ceil(byteWidth / (8 / depth));
+		return byteWidth;
+	}
+	var Filter = module.exports = function(bitmapInfo, dependencies) {
+		let width = bitmapInfo.width;
+		let height = bitmapInfo.height;
+		let interlace = bitmapInfo.interlace;
+		let bpp = bitmapInfo.bpp;
+		let depth = bitmapInfo.depth;
+		this.read = dependencies.read;
+		this.write = dependencies.write;
+		this.complete = dependencies.complete;
+		this._imageIndex = 0;
+		this._images = [];
+		if (interlace) {
+			let passes = interlaceUtils.getImagePasses(width, height);
+			for (let i = 0; i < passes.length; i++) this._images.push({
+				byteWidth: getByteWidth(passes[i].width, bpp, depth),
+				height: passes[i].height,
+				lineIndex: 0
+			});
+		} else this._images.push({
+			byteWidth: getByteWidth(width, bpp, depth),
+			height,
+			lineIndex: 0
+		});
+		if (depth === 8) this._xComparison = bpp;
+		else if (depth === 16) this._xComparison = bpp * 2;
+		else this._xComparison = 1;
+	};
+	Filter.prototype.start = function() {
+		this.read(this._images[this._imageIndex].byteWidth + 1, this._reverseFilterLine.bind(this));
+	};
+	Filter.prototype._unFilterType1 = function(rawData, unfilteredLine, byteWidth) {
+		let xComparison = this._xComparison;
+		let xBiggerThan = xComparison - 1;
+		for (let x = 0; x < byteWidth; x++) unfilteredLine[x] = rawData[1 + x] + (x > xBiggerThan ? unfilteredLine[x - xComparison] : 0);
+	};
+	Filter.prototype._unFilterType2 = function(rawData, unfilteredLine, byteWidth) {
+		let lastLine = this._lastLine;
+		for (let x = 0; x < byteWidth; x++) unfilteredLine[x] = rawData[1 + x] + (lastLine ? lastLine[x] : 0);
+	};
+	Filter.prototype._unFilterType3 = function(rawData, unfilteredLine, byteWidth) {
+		let xComparison = this._xComparison;
+		let xBiggerThan = xComparison - 1;
+		let lastLine = this._lastLine;
+		for (let x = 0; x < byteWidth; x++) {
+			let rawByte = rawData[1 + x];
+			let f3Up = lastLine ? lastLine[x] : 0;
+			let f3Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
+			unfilteredLine[x] = rawByte + Math.floor((f3Left + f3Up) / 2);
+		}
+	};
+	Filter.prototype._unFilterType4 = function(rawData, unfilteredLine, byteWidth) {
+		let xComparison = this._xComparison;
+		let xBiggerThan = xComparison - 1;
+		let lastLine = this._lastLine;
+		for (let x = 0; x < byteWidth; x++) {
+			let rawByte = rawData[1 + x];
+			let f4Up = lastLine ? lastLine[x] : 0;
+			unfilteredLine[x] = rawByte + paethPredictor(x > xBiggerThan ? unfilteredLine[x - xComparison] : 0, f4Up, x > xBiggerThan && lastLine ? lastLine[x - xComparison] : 0);
+		}
+	};
+	Filter.prototype._reverseFilterLine = function(rawData) {
+		let filter = rawData[0];
+		let unfilteredLine;
+		let currentImage = this._images[this._imageIndex];
+		let byteWidth = currentImage.byteWidth;
+		if (filter === 0) unfilteredLine = rawData.slice(1, byteWidth + 1);
+		else {
+			unfilteredLine = Buffer.alloc(byteWidth);
+			switch (filter) {
+				case 1:
+					this._unFilterType1(rawData, unfilteredLine, byteWidth);
+					break;
+				case 2:
+					this._unFilterType2(rawData, unfilteredLine, byteWidth);
+					break;
+				case 3:
+					this._unFilterType3(rawData, unfilteredLine, byteWidth);
+					break;
+				case 4:
+					this._unFilterType4(rawData, unfilteredLine, byteWidth);
+					break;
+				default: throw new Error("Unrecognised filter type - " + filter);
+			}
+		}
+		this.write(unfilteredLine);
+		currentImage.lineIndex++;
+		if (currentImage.lineIndex >= currentImage.height) {
+			this._lastLine = null;
+			this._imageIndex++;
+			currentImage = this._images[this._imageIndex];
+		} else this._lastLine = unfilteredLine;
+		if (currentImage) this.read(currentImage.byteWidth + 1, this._reverseFilterLine.bind(this));
+		else {
+			this._lastLine = null;
+			this.complete();
+		}
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-parse-async.js
+var require_filter_parse_async = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var util$4 = require("util");
+	var ChunkStream = require_chunkstream();
+	var Filter = require_filter_parse();
+	var FilterAsync = module.exports = function(bitmapInfo) {
+		ChunkStream.call(this);
+		let buffers = [];
+		let that = this;
+		this._filter = new Filter(bitmapInfo, {
+			read: this.read.bind(this),
+			write: function(buffer) {
+				buffers.push(buffer);
+			},
+			complete: function() {
+				that.emit("complete", Buffer.concat(buffers));
+			}
+		});
+		this._filter.start();
+	};
+	util$4.inherits(FilterAsync, ChunkStream);
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		PNG_SIGNATURE: [
+			137,
+			80,
+			78,
+			71,
+			13,
+			10,
+			26,
+			10
+		],
+		TYPE_IHDR: 1229472850,
+		TYPE_IEND: 1229278788,
+		TYPE_IDAT: 1229209940,
+		TYPE_PLTE: 1347179589,
+		TYPE_tRNS: 1951551059,
+		TYPE_gAMA: 1732332865,
+		COLORTYPE_GRAYSCALE: 0,
+		COLORTYPE_PALETTE: 1,
+		COLORTYPE_COLOR: 2,
+		COLORTYPE_ALPHA: 4,
+		COLORTYPE_PALETTE_COLOR: 3,
+		COLORTYPE_COLOR_ALPHA: 6,
+		COLORTYPE_TO_BPP_MAP: {
+			0: 1,
+			2: 3,
+			3: 1,
+			4: 2,
+			6: 4
+		},
+		GAMMA_DIVISION: 1e5
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/crc.js
+var require_crc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var crcTable = [];
+	(function() {
+		for (let i = 0; i < 256; i++) {
+			let currentCrc = i;
+			for (let j = 0; j < 8; j++) if (currentCrc & 1) currentCrc = 3988292384 ^ currentCrc >>> 1;
+			else currentCrc = currentCrc >>> 1;
+			crcTable[i] = currentCrc;
+		}
+	})();
+	var CrcCalculator = module.exports = function() {
+		this._crc = -1;
+	};
+	CrcCalculator.prototype.write = function(data) {
+		for (let i = 0; i < data.length; i++) this._crc = crcTable[(this._crc ^ data[i]) & 255] ^ this._crc >>> 8;
+		return true;
+	};
+	CrcCalculator.prototype.crc32 = function() {
+		return this._crc ^ -1;
+	};
+	CrcCalculator.crc32 = function(buf) {
+		let crc = -1;
+		for (let i = 0; i < buf.length; i++) crc = crcTable[(crc ^ buf[i]) & 255] ^ crc >>> 8;
+		return crc ^ -1;
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/parser.js
+var require_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var constants = require_constants();
+	var CrcCalculator = require_crc();
+	var Parser = module.exports = function(options, dependencies) {
+		this._options = options;
+		options.checkCRC = options.checkCRC !== false;
+		this._hasIHDR = false;
+		this._hasIEND = false;
+		this._emittedHeadersFinished = false;
+		this._palette = [];
+		this._colorType = 0;
+		this._chunks = {};
+		this._chunks[constants.TYPE_IHDR] = this._handleIHDR.bind(this);
+		this._chunks[constants.TYPE_IEND] = this._handleIEND.bind(this);
+		this._chunks[constants.TYPE_IDAT] = this._handleIDAT.bind(this);
+		this._chunks[constants.TYPE_PLTE] = this._handlePLTE.bind(this);
+		this._chunks[constants.TYPE_tRNS] = this._handleTRNS.bind(this);
+		this._chunks[constants.TYPE_gAMA] = this._handleGAMA.bind(this);
+		this.read = dependencies.read;
+		this.error = dependencies.error;
+		this.metadata = dependencies.metadata;
+		this.gamma = dependencies.gamma;
+		this.transColor = dependencies.transColor;
+		this.palette = dependencies.palette;
+		this.parsed = dependencies.parsed;
+		this.inflateData = dependencies.inflateData;
+		this.finished = dependencies.finished;
+		this.simpleTransparency = dependencies.simpleTransparency;
+		this.headersFinished = dependencies.headersFinished || function() {};
+	};
+	Parser.prototype.start = function() {
+		this.read(constants.PNG_SIGNATURE.length, this._parseSignature.bind(this));
+	};
+	Parser.prototype._parseSignature = function(data) {
+		let signature = constants.PNG_SIGNATURE;
+		for (let i = 0; i < signature.length; i++) if (data[i] !== signature[i]) {
+			this.error(/* @__PURE__ */ new Error("Invalid file signature"));
+			return;
+		}
+		this.read(8, this._parseChunkBegin.bind(this));
+	};
+	Parser.prototype._parseChunkBegin = function(data) {
+		let length = data.readUInt32BE(0);
+		let type = data.readUInt32BE(4);
+		let name = "";
+		for (let i = 4; i < 8; i++) name += String.fromCharCode(data[i]);
+		let ancillary = Boolean(data[4] & 32);
+		if (!this._hasIHDR && type !== constants.TYPE_IHDR) {
+			this.error(/* @__PURE__ */ new Error("Expected IHDR on beggining"));
+			return;
+		}
+		this._crc = new CrcCalculator();
+		this._crc.write(Buffer.from(name));
+		if (this._chunks[type]) return this._chunks[type](length);
+		if (!ancillary) {
+			this.error(/* @__PURE__ */ new Error("Unsupported critical chunk type " + name));
+			return;
+		}
+		this.read(length + 4, this._skipChunk.bind(this));
+	};
+	Parser.prototype._skipChunk = function() {
+		this.read(8, this._parseChunkBegin.bind(this));
+	};
+	Parser.prototype._handleChunkEnd = function() {
+		this.read(4, this._parseChunkEnd.bind(this));
+	};
+	Parser.prototype._parseChunkEnd = function(data) {
+		let fileCrc = data.readInt32BE(0);
+		let calcCrc = this._crc.crc32();
+		if (this._options.checkCRC && calcCrc !== fileCrc) {
+			this.error(/* @__PURE__ */ new Error("Crc error - " + fileCrc + " - " + calcCrc));
+			return;
+		}
+		if (!this._hasIEND) this.read(8, this._parseChunkBegin.bind(this));
+	};
+	Parser.prototype._handleIHDR = function(length) {
+		this.read(length, this._parseIHDR.bind(this));
+	};
+	Parser.prototype._parseIHDR = function(data) {
+		this._crc.write(data);
+		let width = data.readUInt32BE(0);
+		let height = data.readUInt32BE(4);
+		let depth = data[8];
+		let colorType = data[9];
+		let compr = data[10];
+		let filter = data[11];
+		let interlace = data[12];
+		if (depth !== 8 && depth !== 4 && depth !== 2 && depth !== 1 && depth !== 16) {
+			this.error(/* @__PURE__ */ new Error("Unsupported bit depth " + depth));
+			return;
+		}
+		if (!(colorType in constants.COLORTYPE_TO_BPP_MAP)) {
+			this.error(/* @__PURE__ */ new Error("Unsupported color type"));
+			return;
+		}
+		if (compr !== 0) {
+			this.error(/* @__PURE__ */ new Error("Unsupported compression method"));
+			return;
+		}
+		if (filter !== 0) {
+			this.error(/* @__PURE__ */ new Error("Unsupported filter method"));
+			return;
+		}
+		if (interlace !== 0 && interlace !== 1) {
+			this.error(/* @__PURE__ */ new Error("Unsupported interlace method"));
+			return;
+		}
+		this._colorType = colorType;
+		let bpp = constants.COLORTYPE_TO_BPP_MAP[this._colorType];
+		this._hasIHDR = true;
+		this.metadata({
+			width,
+			height,
+			depth,
+			interlace: Boolean(interlace),
+			palette: Boolean(colorType & constants.COLORTYPE_PALETTE),
+			color: Boolean(colorType & constants.COLORTYPE_COLOR),
+			alpha: Boolean(colorType & constants.COLORTYPE_ALPHA),
+			bpp,
+			colorType
+		});
+		this._handleChunkEnd();
+	};
+	Parser.prototype._handlePLTE = function(length) {
+		this.read(length, this._parsePLTE.bind(this));
+	};
+	Parser.prototype._parsePLTE = function(data) {
+		this._crc.write(data);
+		let entries = Math.floor(data.length / 3);
+		for (let i = 0; i < entries; i++) this._palette.push([
+			data[i * 3],
+			data[i * 3 + 1],
+			data[i * 3 + 2],
+			255
+		]);
+		this.palette(this._palette);
+		this._handleChunkEnd();
+	};
+	Parser.prototype._handleTRNS = function(length) {
+		this.simpleTransparency();
+		this.read(length, this._parseTRNS.bind(this));
+	};
+	Parser.prototype._parseTRNS = function(data) {
+		this._crc.write(data);
+		if (this._colorType === constants.COLORTYPE_PALETTE_COLOR) {
+			if (this._palette.length === 0) {
+				this.error(/* @__PURE__ */ new Error("Transparency chunk must be after palette"));
+				return;
+			}
+			if (data.length > this._palette.length) {
+				this.error(/* @__PURE__ */ new Error("More transparent colors than palette size"));
+				return;
+			}
+			for (let i = 0; i < data.length; i++) this._palette[i][3] = data[i];
+			this.palette(this._palette);
+		}
+		if (this._colorType === constants.COLORTYPE_GRAYSCALE) this.transColor([data.readUInt16BE(0)]);
+		if (this._colorType === constants.COLORTYPE_COLOR) this.transColor([
+			data.readUInt16BE(0),
+			data.readUInt16BE(2),
+			data.readUInt16BE(4)
+		]);
+		this._handleChunkEnd();
+	};
+	Parser.prototype._handleGAMA = function(length) {
+		this.read(length, this._parseGAMA.bind(this));
+	};
+	Parser.prototype._parseGAMA = function(data) {
+		this._crc.write(data);
+		this.gamma(data.readUInt32BE(0) / constants.GAMMA_DIVISION);
+		this._handleChunkEnd();
+	};
+	Parser.prototype._handleIDAT = function(length) {
+		if (!this._emittedHeadersFinished) {
+			this._emittedHeadersFinished = true;
+			this.headersFinished();
+		}
+		this.read(-length, this._parseIDAT.bind(this, length));
+	};
+	Parser.prototype._parseIDAT = function(length, data) {
+		this._crc.write(data);
+		if (this._colorType === constants.COLORTYPE_PALETTE_COLOR && this._palette.length === 0) throw new Error("Expected palette not found");
+		this.inflateData(data);
+		let leftOverLength = length - data.length;
+		if (leftOverLength > 0) this._handleIDAT(leftOverLength);
+		else this._handleChunkEnd();
+	};
+	Parser.prototype._handleIEND = function(length) {
+		this.read(length, this._parseIEND.bind(this));
+	};
+	Parser.prototype._parseIEND = function(data) {
+		this._crc.write(data);
+		this._hasIEND = true;
+		this._handleChunkEnd();
+		if (this.finished) this.finished();
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/bitmapper.js
+var require_bitmapper = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var interlaceUtils = require_interlace();
+	var pixelBppMapper = [
+		function() {},
+		function(pxData, data, pxPos, rawPos) {
+			if (rawPos === data.length) throw new Error("Ran out of data");
+			let pixel = data[rawPos];
+			pxData[pxPos] = pixel;
+			pxData[pxPos + 1] = pixel;
+			pxData[pxPos + 2] = pixel;
+			pxData[pxPos + 3] = 255;
+		},
+		function(pxData, data, pxPos, rawPos) {
+			if (rawPos + 1 >= data.length) throw new Error("Ran out of data");
+			let pixel = data[rawPos];
+			pxData[pxPos] = pixel;
+			pxData[pxPos + 1] = pixel;
+			pxData[pxPos + 2] = pixel;
+			pxData[pxPos + 3] = data[rawPos + 1];
+		},
+		function(pxData, data, pxPos, rawPos) {
+			if (rawPos + 2 >= data.length) throw new Error("Ran out of data");
+			pxData[pxPos] = data[rawPos];
+			pxData[pxPos + 1] = data[rawPos + 1];
+			pxData[pxPos + 2] = data[rawPos + 2];
+			pxData[pxPos + 3] = 255;
+		},
+		function(pxData, data, pxPos, rawPos) {
+			if (rawPos + 3 >= data.length) throw new Error("Ran out of data");
+			pxData[pxPos] = data[rawPos];
+			pxData[pxPos + 1] = data[rawPos + 1];
+			pxData[pxPos + 2] = data[rawPos + 2];
+			pxData[pxPos + 3] = data[rawPos + 3];
+		}
+	];
+	var pixelBppCustomMapper = [
+		function() {},
+		function(pxData, pixelData, pxPos, maxBit) {
+			let pixel = pixelData[0];
+			pxData[pxPos] = pixel;
+			pxData[pxPos + 1] = pixel;
+			pxData[pxPos + 2] = pixel;
+			pxData[pxPos + 3] = maxBit;
+		},
+		function(pxData, pixelData, pxPos) {
+			let pixel = pixelData[0];
+			pxData[pxPos] = pixel;
+			pxData[pxPos + 1] = pixel;
+			pxData[pxPos + 2] = pixel;
+			pxData[pxPos + 3] = pixelData[1];
+		},
+		function(pxData, pixelData, pxPos, maxBit) {
+			pxData[pxPos] = pixelData[0];
+			pxData[pxPos + 1] = pixelData[1];
+			pxData[pxPos + 2] = pixelData[2];
+			pxData[pxPos + 3] = maxBit;
+		},
+		function(pxData, pixelData, pxPos) {
+			pxData[pxPos] = pixelData[0];
+			pxData[pxPos + 1] = pixelData[1];
+			pxData[pxPos + 2] = pixelData[2];
+			pxData[pxPos + 3] = pixelData[3];
+		}
+	];
+	function bitRetriever(data, depth) {
+		let leftOver = [];
+		let i = 0;
+		function split() {
+			if (i === data.length) throw new Error("Ran out of data");
+			let byte = data[i];
+			i++;
+			let byte8, byte7, byte6, byte5, byte4, byte3, byte2, byte1;
+			switch (depth) {
+				default: throw new Error("unrecognised depth");
+				case 16:
+					byte2 = data[i];
+					i++;
+					leftOver.push((byte << 8) + byte2);
+					break;
+				case 4:
+					byte2 = byte & 15;
+					byte1 = byte >> 4;
+					leftOver.push(byte1, byte2);
+					break;
+				case 2:
+					byte4 = byte & 3;
+					byte3 = byte >> 2 & 3;
+					byte2 = byte >> 4 & 3;
+					byte1 = byte >> 6 & 3;
+					leftOver.push(byte1, byte2, byte3, byte4);
+					break;
+				case 1:
+					byte8 = byte & 1;
+					byte7 = byte >> 1 & 1;
+					byte6 = byte >> 2 & 1;
+					byte5 = byte >> 3 & 1;
+					byte4 = byte >> 4 & 1;
+					byte3 = byte >> 5 & 1;
+					byte2 = byte >> 6 & 1;
+					byte1 = byte >> 7 & 1;
+					leftOver.push(byte1, byte2, byte3, byte4, byte5, byte6, byte7, byte8);
+					break;
+			}
+		}
+		return {
+			get: function(count) {
+				while (leftOver.length < count) split();
+				let returner = leftOver.slice(0, count);
+				leftOver = leftOver.slice(count);
+				return returner;
+			},
+			resetAfterLine: function() {
+				leftOver.length = 0;
+			},
+			end: function() {
+				if (i !== data.length) throw new Error("extra data found");
+			}
+		};
+	}
+	function mapImage8Bit(image, pxData, getPxPos, bpp, data, rawPos) {
+		let imageWidth = image.width;
+		let imageHeight = image.height;
+		let imagePass = image.index;
+		for (let y = 0; y < imageHeight; y++) for (let x = 0; x < imageWidth; x++) {
+			let pxPos = getPxPos(x, y, imagePass);
+			pixelBppMapper[bpp](pxData, data, pxPos, rawPos);
+			rawPos += bpp;
+		}
+		return rawPos;
+	}
+	function mapImageCustomBit(image, pxData, getPxPos, bpp, bits, maxBit) {
+		let imageWidth = image.width;
+		let imageHeight = image.height;
+		let imagePass = image.index;
+		for (let y = 0; y < imageHeight; y++) {
+			for (let x = 0; x < imageWidth; x++) {
+				let pixelData = bits.get(bpp);
+				let pxPos = getPxPos(x, y, imagePass);
+				pixelBppCustomMapper[bpp](pxData, pixelData, pxPos, maxBit);
+			}
+			bits.resetAfterLine();
+		}
+	}
+	exports.dataToBitMap = function(data, bitmapInfo) {
+		let width = bitmapInfo.width;
+		let height = bitmapInfo.height;
+		let depth = bitmapInfo.depth;
+		let bpp = bitmapInfo.bpp;
+		let interlace = bitmapInfo.interlace;
+		let bits;
+		if (depth !== 8) bits = bitRetriever(data, depth);
+		let pxData;
+		if (depth <= 8) pxData = Buffer.alloc(width * height * 4);
+		else pxData = new Uint16Array(width * height * 4);
+		let maxBit = Math.pow(2, depth) - 1;
+		let rawPos = 0;
+		let images;
+		let getPxPos;
+		if (interlace) {
+			images = interlaceUtils.getImagePasses(width, height);
+			getPxPos = interlaceUtils.getInterlaceIterator(width, height);
+		} else {
+			let nonInterlacedPxPos = 0;
+			getPxPos = function() {
+				let returner = nonInterlacedPxPos;
+				nonInterlacedPxPos += 4;
+				return returner;
+			};
+			images = [{
+				width,
+				height
+			}];
+		}
+		for (let imageIndex = 0; imageIndex < images.length; imageIndex++) if (depth === 8) rawPos = mapImage8Bit(images[imageIndex], pxData, getPxPos, bpp, data, rawPos);
+		else mapImageCustomBit(images[imageIndex], pxData, getPxPos, bpp, bits, maxBit);
+		if (depth === 8) {
+			if (rawPos !== data.length) throw new Error("extra data found");
+		} else bits.end();
+		return pxData;
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/format-normaliser.js
+var require_format_normaliser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function dePalette(indata, outdata, width, height, palette) {
+		let pxPos = 0;
+		for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+			let color = palette[indata[pxPos]];
+			if (!color) throw new Error("index " + indata[pxPos] + " not in palette");
+			for (let i = 0; i < 4; i++) outdata[pxPos + i] = color[i];
+			pxPos += 4;
+		}
+	}
+	function replaceTransparentColor(indata, outdata, width, height, transColor) {
+		let pxPos = 0;
+		for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+			let makeTrans = false;
+			if (transColor.length === 1) {
+				if (transColor[0] === indata[pxPos]) makeTrans = true;
+			} else if (transColor[0] === indata[pxPos] && transColor[1] === indata[pxPos + 1] && transColor[2] === indata[pxPos + 2]) makeTrans = true;
+			if (makeTrans) for (let i = 0; i < 4; i++) outdata[pxPos + i] = 0;
+			pxPos += 4;
+		}
+	}
+	function scaleDepth(indata, outdata, width, height, depth) {
+		let maxOutSample = 255;
+		let maxInSample = Math.pow(2, depth) - 1;
+		let pxPos = 0;
+		for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+			for (let i = 0; i < 4; i++) outdata[pxPos + i] = Math.floor(indata[pxPos + i] * maxOutSample / maxInSample + .5);
+			pxPos += 4;
+		}
+	}
+	module.exports = function(indata, imageData, skipRescale = false) {
+		let depth = imageData.depth;
+		let width = imageData.width;
+		let height = imageData.height;
+		let colorType = imageData.colorType;
+		let transColor = imageData.transColor;
+		let palette = imageData.palette;
+		let outdata = indata;
+		if (colorType === 3) dePalette(indata, outdata, width, height, palette);
+		else {
+			if (transColor) replaceTransparentColor(indata, outdata, width, height, transColor);
+			if (depth !== 8 && !skipRescale) {
+				if (depth === 16) outdata = Buffer.alloc(width * height * 4);
+				scaleDepth(indata, outdata, width, height, depth);
+			}
+		}
+		return outdata;
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/parser-async.js
+var require_parser_async = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var util$3 = require("util");
+	var zlib$4 = require("zlib");
+	var ChunkStream = require_chunkstream();
+	var FilterAsync = require_filter_parse_async();
+	var Parser = require_parser();
+	var bitmapper = require_bitmapper();
+	var formatNormaliser = require_format_normaliser();
+	var ParserAsync = module.exports = function(options) {
+		ChunkStream.call(this);
+		this._parser = new Parser(options, {
+			read: this.read.bind(this),
+			error: this._handleError.bind(this),
+			metadata: this._handleMetaData.bind(this),
+			gamma: this.emit.bind(this, "gamma"),
+			palette: this._handlePalette.bind(this),
+			transColor: this._handleTransColor.bind(this),
+			finished: this._finished.bind(this),
+			inflateData: this._inflateData.bind(this),
+			simpleTransparency: this._simpleTransparency.bind(this),
+			headersFinished: this._headersFinished.bind(this)
+		});
+		this._options = options;
+		this.writable = true;
+		this._parser.start();
+	};
+	util$3.inherits(ParserAsync, ChunkStream);
+	ParserAsync.prototype._handleError = function(err) {
+		this.emit("error", err);
+		this.writable = false;
+		this.destroy();
+		if (this._inflate && this._inflate.destroy) this._inflate.destroy();
+		if (this._filter) {
+			this._filter.destroy();
+			this._filter.on("error", function() {});
+		}
+		this.errord = true;
+	};
+	ParserAsync.prototype._inflateData = function(data) {
+		if (!this._inflate) if (this._bitmapInfo.interlace) {
+			this._inflate = zlib$4.createInflate();
+			this._inflate.on("error", this.emit.bind(this, "error"));
+			this._filter.on("complete", this._complete.bind(this));
+			this._inflate.pipe(this._filter);
+		} else {
+			let imageSize = ((this._bitmapInfo.width * this._bitmapInfo.bpp * this._bitmapInfo.depth + 7 >> 3) + 1) * this._bitmapInfo.height;
+			let chunkSize = Math.max(imageSize, zlib$4.Z_MIN_CHUNK);
+			this._inflate = zlib$4.createInflate({ chunkSize });
+			let leftToInflate = imageSize;
+			let emitError = this.emit.bind(this, "error");
+			this._inflate.on("error", function(err) {
+				if (!leftToInflate) return;
+				emitError(err);
+			});
+			this._filter.on("complete", this._complete.bind(this));
+			let filterWrite = this._filter.write.bind(this._filter);
+			this._inflate.on("data", function(chunk) {
+				if (!leftToInflate) return;
+				if (chunk.length > leftToInflate) chunk = chunk.slice(0, leftToInflate);
+				leftToInflate -= chunk.length;
+				filterWrite(chunk);
+			});
+			this._inflate.on("end", this._filter.end.bind(this._filter));
+		}
+		this._inflate.write(data);
+	};
+	ParserAsync.prototype._handleMetaData = function(metaData) {
+		this._metaData = metaData;
+		this._bitmapInfo = Object.create(metaData);
+		this._filter = new FilterAsync(this._bitmapInfo);
+	};
+	ParserAsync.prototype._handleTransColor = function(transColor) {
+		this._bitmapInfo.transColor = transColor;
+	};
+	ParserAsync.prototype._handlePalette = function(palette) {
+		this._bitmapInfo.palette = palette;
+	};
+	ParserAsync.prototype._simpleTransparency = function() {
+		this._metaData.alpha = true;
+	};
+	ParserAsync.prototype._headersFinished = function() {
+		this.emit("metadata", this._metaData);
+	};
+	ParserAsync.prototype._finished = function() {
+		if (this.errord) return;
+		if (!this._inflate) this.emit("error", "No Inflate block");
+		else this._inflate.end();
+	};
+	ParserAsync.prototype._complete = function(filteredData) {
+		if (this.errord) return;
+		let normalisedBitmapData;
+		try {
+			let bitmapData = bitmapper.dataToBitMap(filteredData, this._bitmapInfo);
+			normalisedBitmapData = formatNormaliser(bitmapData, this._bitmapInfo, this._options.skipRescale);
+			bitmapData = null;
+		} catch (ex) {
+			this._handleError(ex);
+			return;
+		}
+		this.emit("parsed", normalisedBitmapData);
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/bitpacker.js
+var require_bitpacker = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var constants = require_constants();
+	module.exports = function(dataIn, width, height, options) {
+		let outHasAlpha = [constants.COLORTYPE_COLOR_ALPHA, constants.COLORTYPE_ALPHA].indexOf(options.colorType) !== -1;
+		if (options.colorType === options.inputColorType) {
+			let bigEndian = (function() {
+				let buffer = /* @__PURE__ */ new ArrayBuffer(2);
+				new DataView(buffer).setInt16(0, 256, true);
+				return new Int16Array(buffer)[0] !== 256;
+			})();
+			if (options.bitDepth === 8 || options.bitDepth === 16 && bigEndian) return dataIn;
+		}
+		let data = options.bitDepth !== 16 ? dataIn : new Uint16Array(dataIn.buffer);
+		let maxValue = 255;
+		let inBpp = constants.COLORTYPE_TO_BPP_MAP[options.inputColorType];
+		if (inBpp === 4 && !options.inputHasAlpha) inBpp = 3;
+		let outBpp = constants.COLORTYPE_TO_BPP_MAP[options.colorType];
+		if (options.bitDepth === 16) {
+			maxValue = 65535;
+			outBpp *= 2;
+		}
+		let outData = Buffer.alloc(width * height * outBpp);
+		let inIndex = 0;
+		let outIndex = 0;
+		let bgColor = options.bgColor || {};
+		if (bgColor.red === void 0) bgColor.red = maxValue;
+		if (bgColor.green === void 0) bgColor.green = maxValue;
+		if (bgColor.blue === void 0) bgColor.blue = maxValue;
+		function getRGBA() {
+			let red;
+			let green;
+			let blue;
+			let alpha = maxValue;
+			switch (options.inputColorType) {
+				case constants.COLORTYPE_COLOR_ALPHA:
+					alpha = data[inIndex + 3];
+					red = data[inIndex];
+					green = data[inIndex + 1];
+					blue = data[inIndex + 2];
+					break;
+				case constants.COLORTYPE_COLOR:
+					red = data[inIndex];
+					green = data[inIndex + 1];
+					blue = data[inIndex + 2];
+					break;
+				case constants.COLORTYPE_ALPHA:
+					alpha = data[inIndex + 1];
+					red = data[inIndex];
+					green = red;
+					blue = red;
+					break;
+				case constants.COLORTYPE_GRAYSCALE:
+					red = data[inIndex];
+					green = red;
+					blue = red;
+					break;
+				default: throw new Error("input color type:" + options.inputColorType + " is not supported at present");
+			}
+			if (options.inputHasAlpha) {
+				if (!outHasAlpha) {
+					alpha /= maxValue;
+					red = Math.min(Math.max(Math.round((1 - alpha) * bgColor.red + alpha * red), 0), maxValue);
+					green = Math.min(Math.max(Math.round((1 - alpha) * bgColor.green + alpha * green), 0), maxValue);
+					blue = Math.min(Math.max(Math.round((1 - alpha) * bgColor.blue + alpha * blue), 0), maxValue);
+				}
+			}
+			return {
+				red,
+				green,
+				blue,
+				alpha
+			};
+		}
+		for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+			let rgba = getRGBA(data, inIndex);
+			switch (options.colorType) {
+				case constants.COLORTYPE_COLOR_ALPHA:
+				case constants.COLORTYPE_COLOR:
+					if (options.bitDepth === 8) {
+						outData[outIndex] = rgba.red;
+						outData[outIndex + 1] = rgba.green;
+						outData[outIndex + 2] = rgba.blue;
+						if (outHasAlpha) outData[outIndex + 3] = rgba.alpha;
+					} else {
+						outData.writeUInt16BE(rgba.red, outIndex);
+						outData.writeUInt16BE(rgba.green, outIndex + 2);
+						outData.writeUInt16BE(rgba.blue, outIndex + 4);
+						if (outHasAlpha) outData.writeUInt16BE(rgba.alpha, outIndex + 6);
+					}
+					break;
+				case constants.COLORTYPE_ALPHA:
+				case constants.COLORTYPE_GRAYSCALE: {
+					let grayscale = (rgba.red + rgba.green + rgba.blue) / 3;
+					if (options.bitDepth === 8) {
+						outData[outIndex] = grayscale;
+						if (outHasAlpha) outData[outIndex + 1] = rgba.alpha;
+					} else {
+						outData.writeUInt16BE(grayscale, outIndex);
+						if (outHasAlpha) outData.writeUInt16BE(rgba.alpha, outIndex + 2);
+					}
+					break;
+				}
+				default: throw new Error("unrecognised color Type " + options.colorType);
+			}
+			inIndex += inBpp;
+			outIndex += outBpp;
+		}
+		return outData;
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-pack.js
+var require_filter_pack = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var paethPredictor = require_paeth_predictor();
+	function filterNone(pxData, pxPos, byteWidth, rawData, rawPos) {
+		for (let x = 0; x < byteWidth; x++) rawData[rawPos + x] = pxData[pxPos + x];
+	}
+	function filterSumNone(pxData, pxPos, byteWidth) {
+		let sum = 0;
+		let length = pxPos + byteWidth;
+		for (let i = pxPos; i < length; i++) sum += Math.abs(pxData[i]);
+		return sum;
+	}
+	function filterSub(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+		for (let x = 0; x < byteWidth; x++) {
+			let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+			let val = pxData[pxPos + x] - left;
+			rawData[rawPos + x] = val;
+		}
+	}
+	function filterSumSub(pxData, pxPos, byteWidth, bpp) {
+		let sum = 0;
+		for (let x = 0; x < byteWidth; x++) {
+			let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+			let val = pxData[pxPos + x] - left;
+			sum += Math.abs(val);
+		}
+		return sum;
+	}
+	function filterUp(pxData, pxPos, byteWidth, rawData, rawPos) {
+		for (let x = 0; x < byteWidth; x++) {
+			let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+			let val = pxData[pxPos + x] - up;
+			rawData[rawPos + x] = val;
+		}
+	}
+	function filterSumUp(pxData, pxPos, byteWidth) {
+		let sum = 0;
+		let length = pxPos + byteWidth;
+		for (let x = pxPos; x < length; x++) {
+			let up = pxPos > 0 ? pxData[x - byteWidth] : 0;
+			let val = pxData[x] - up;
+			sum += Math.abs(val);
+		}
+		return sum;
+	}
+	function filterAvg(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+		for (let x = 0; x < byteWidth; x++) {
+			let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+			let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+			let val = pxData[pxPos + x] - (left + up >> 1);
+			rawData[rawPos + x] = val;
+		}
+	}
+	function filterSumAvg(pxData, pxPos, byteWidth, bpp) {
+		let sum = 0;
+		for (let x = 0; x < byteWidth; x++) {
+			let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+			let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+			let val = pxData[pxPos + x] - (left + up >> 1);
+			sum += Math.abs(val);
+		}
+		return sum;
+	}
+	function filterPaeth(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+		for (let x = 0; x < byteWidth; x++) {
+			let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+			let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+			let upleft = pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
+			let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
+			rawData[rawPos + x] = val;
+		}
+	}
+	function filterSumPaeth(pxData, pxPos, byteWidth, bpp) {
+		let sum = 0;
+		for (let x = 0; x < byteWidth; x++) {
+			let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+			let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+			let upleft = pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
+			let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
+			sum += Math.abs(val);
+		}
+		return sum;
+	}
+	var filters = {
+		0: filterNone,
+		1: filterSub,
+		2: filterUp,
+		3: filterAvg,
+		4: filterPaeth
+	};
+	var filterSums = {
+		0: filterSumNone,
+		1: filterSumSub,
+		2: filterSumUp,
+		3: filterSumAvg,
+		4: filterSumPaeth
+	};
+	module.exports = function(pxData, width, height, options, bpp) {
+		let filterTypes;
+		if (!("filterType" in options) || options.filterType === -1) filterTypes = [
+			0,
+			1,
+			2,
+			3,
+			4
+		];
+		else if (typeof options.filterType === "number") filterTypes = [options.filterType];
+		else throw new Error("unrecognised filter types");
+		if (options.bitDepth === 16) bpp *= 2;
+		let byteWidth = width * bpp;
+		let rawPos = 0;
+		let pxPos = 0;
+		let rawData = Buffer.alloc((byteWidth + 1) * height);
+		let sel = filterTypes[0];
+		for (let y = 0; y < height; y++) {
+			if (filterTypes.length > 1) {
+				let min = Infinity;
+				for (let i = 0; i < filterTypes.length; i++) {
+					let sum = filterSums[filterTypes[i]](pxData, pxPos, byteWidth, bpp);
+					if (sum < min) {
+						sel = filterTypes[i];
+						min = sum;
+					}
+				}
+			}
+			rawData[rawPos] = sel;
+			rawPos++;
+			filters[sel](pxData, pxPos, byteWidth, rawData, rawPos, bpp);
+			rawPos += byteWidth;
+			pxPos += byteWidth;
+		}
+		return rawData;
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/packer.js
+var require_packer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var constants = require_constants();
+	var CrcStream = require_crc();
+	var bitPacker = require_bitpacker();
+	var filter = require_filter_pack();
+	var zlib$3 = require("zlib");
+	var Packer = module.exports = function(options) {
+		this._options = options;
+		options.deflateChunkSize = options.deflateChunkSize || 32 * 1024;
+		options.deflateLevel = options.deflateLevel != null ? options.deflateLevel : 9;
+		options.deflateStrategy = options.deflateStrategy != null ? options.deflateStrategy : 3;
+		options.inputHasAlpha = options.inputHasAlpha != null ? options.inputHasAlpha : true;
+		options.deflateFactory = options.deflateFactory || zlib$3.createDeflate;
+		options.bitDepth = options.bitDepth || 8;
+		options.colorType = typeof options.colorType === "number" ? options.colorType : constants.COLORTYPE_COLOR_ALPHA;
+		options.inputColorType = typeof options.inputColorType === "number" ? options.inputColorType : constants.COLORTYPE_COLOR_ALPHA;
+		if ([
+			constants.COLORTYPE_GRAYSCALE,
+			constants.COLORTYPE_COLOR,
+			constants.COLORTYPE_COLOR_ALPHA,
+			constants.COLORTYPE_ALPHA
+		].indexOf(options.colorType) === -1) throw new Error("option color type:" + options.colorType + " is not supported at present");
+		if ([
+			constants.COLORTYPE_GRAYSCALE,
+			constants.COLORTYPE_COLOR,
+			constants.COLORTYPE_COLOR_ALPHA,
+			constants.COLORTYPE_ALPHA
+		].indexOf(options.inputColorType) === -1) throw new Error("option input color type:" + options.inputColorType + " is not supported at present");
+		if (options.bitDepth !== 8 && options.bitDepth !== 16) throw new Error("option bit depth:" + options.bitDepth + " is not supported at present");
+	};
+	Packer.prototype.getDeflateOptions = function() {
+		return {
+			chunkSize: this._options.deflateChunkSize,
+			level: this._options.deflateLevel,
+			strategy: this._options.deflateStrategy
+		};
+	};
+	Packer.prototype.createDeflate = function() {
+		return this._options.deflateFactory(this.getDeflateOptions());
+	};
+	Packer.prototype.filterData = function(data, width, height) {
+		let packedData = bitPacker(data, width, height, this._options);
+		let bpp = constants.COLORTYPE_TO_BPP_MAP[this._options.colorType];
+		return filter(packedData, width, height, this._options, bpp);
+	};
+	Packer.prototype._packChunk = function(type, data) {
+		let len = data ? data.length : 0;
+		let buf = Buffer.alloc(len + 12);
+		buf.writeUInt32BE(len, 0);
+		buf.writeUInt32BE(type, 4);
+		if (data) data.copy(buf, 8);
+		buf.writeInt32BE(CrcStream.crc32(buf.slice(4, buf.length - 4)), buf.length - 4);
+		return buf;
+	};
+	Packer.prototype.packGAMA = function(gamma) {
+		let buf = Buffer.alloc(4);
+		buf.writeUInt32BE(Math.floor(gamma * constants.GAMMA_DIVISION), 0);
+		return this._packChunk(constants.TYPE_gAMA, buf);
+	};
+	Packer.prototype.packIHDR = function(width, height) {
+		let buf = Buffer.alloc(13);
+		buf.writeUInt32BE(width, 0);
+		buf.writeUInt32BE(height, 4);
+		buf[8] = this._options.bitDepth;
+		buf[9] = this._options.colorType;
+		buf[10] = 0;
+		buf[11] = 0;
+		buf[12] = 0;
+		return this._packChunk(constants.TYPE_IHDR, buf);
+	};
+	Packer.prototype.packIDAT = function(data) {
+		return this._packChunk(constants.TYPE_IDAT, data);
+	};
+	Packer.prototype.packIEND = function() {
+		return this._packChunk(constants.TYPE_IEND, null);
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/packer-async.js
+var require_packer_async = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var util$2 = require("util");
+	var Stream$2 = require("stream");
+	var constants = require_constants();
+	var Packer = require_packer();
+	var PackerAsync = module.exports = function(opt) {
+		Stream$2.call(this);
+		let options = opt || {};
+		this._packer = new Packer(options);
+		this._deflate = this._packer.createDeflate();
+		this.readable = true;
+	};
+	util$2.inherits(PackerAsync, Stream$2);
+	PackerAsync.prototype.pack = function(data, width, height, gamma) {
+		this.emit("data", Buffer.from(constants.PNG_SIGNATURE));
+		this.emit("data", this._packer.packIHDR(width, height));
+		if (gamma) this.emit("data", this._packer.packGAMA(gamma));
+		let filteredData = this._packer.filterData(data, width, height);
+		this._deflate.on("error", this.emit.bind(this, "error"));
+		this._deflate.on("data", function(compressedData) {
+			this.emit("data", this._packer.packIDAT(compressedData));
+		}.bind(this));
+		this._deflate.on("end", function() {
+			this.emit("data", this._packer.packIEND());
+			this.emit("end");
+		}.bind(this));
+		this._deflate.end(filteredData);
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/sync-inflate.js
+var require_sync_inflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assert = require("assert").ok;
+	var zlib$2 = require("zlib");
+	var util$1 = require("util");
+	var kMaxLength = require("buffer").kMaxLength;
+	function Inflate(opts) {
+		if (!(this instanceof Inflate)) return new Inflate(opts);
+		if (opts && opts.chunkSize < zlib$2.Z_MIN_CHUNK) opts.chunkSize = zlib$2.Z_MIN_CHUNK;
+		zlib$2.Inflate.call(this, opts);
+		this._offset = this._offset === void 0 ? this._outOffset : this._offset;
+		this._buffer = this._buffer || this._outBuffer;
+		if (opts && opts.maxLength != null) this._maxLength = opts.maxLength;
+	}
+	function createInflate(opts) {
+		return new Inflate(opts);
+	}
+	function _close(engine, callback) {
+		if (callback) process.nextTick(callback);
+		if (!engine._handle) return;
+		engine._handle.close();
+		engine._handle = null;
+	}
+	Inflate.prototype._processChunk = function(chunk, flushFlag, asyncCb) {
+		if (typeof asyncCb === "function") return zlib$2.Inflate._processChunk.call(this, chunk, flushFlag, asyncCb);
+		let self = this;
+		let availInBefore = chunk && chunk.length;
+		let availOutBefore = this._chunkSize - this._offset;
+		let leftToInflate = this._maxLength;
+		let inOff = 0;
+		let buffers = [];
+		let nread = 0;
+		let error;
+		this.on("error", function(err) {
+			error = err;
+		});
+		function handleChunk(availInAfter, availOutAfter) {
+			if (self._hadError) return;
+			let have = availOutBefore - availOutAfter;
+			assert(have >= 0, "have should not go down");
+			if (have > 0) {
+				let out = self._buffer.slice(self._offset, self._offset + have);
+				self._offset += have;
+				if (out.length > leftToInflate) out = out.slice(0, leftToInflate);
+				buffers.push(out);
+				nread += out.length;
+				leftToInflate -= out.length;
+				if (leftToInflate === 0) return false;
+			}
+			if (availOutAfter === 0 || self._offset >= self._chunkSize) {
+				availOutBefore = self._chunkSize;
+				self._offset = 0;
+				self._buffer = Buffer.allocUnsafe(self._chunkSize);
+			}
+			if (availOutAfter === 0) {
+				inOff += availInBefore - availInAfter;
+				availInBefore = availInAfter;
+				return true;
+			}
+			return false;
+		}
+		assert(this._handle, "zlib binding closed");
+		let res;
+		do {
+			res = this._handle.writeSync(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, availOutBefore);
+			res = res || this._writeState;
+		} while (!this._hadError && handleChunk(res[0], res[1]));
+		if (this._hadError) throw error;
+		if (nread >= kMaxLength) {
+			_close(this);
+			throw new RangeError("Cannot create final Buffer. It would be larger than 0x" + kMaxLength.toString(16) + " bytes");
+		}
+		let buf = Buffer.concat(buffers, nread);
+		_close(this);
+		return buf;
+	};
+	util$1.inherits(Inflate, zlib$2.Inflate);
+	function zlibBufferSync(engine, buffer) {
+		if (typeof buffer === "string") buffer = Buffer.from(buffer);
+		if (!(buffer instanceof Buffer)) throw new TypeError("Not a string or buffer");
+		let flushFlag = engine._finishFlushFlag;
+		if (flushFlag == null) flushFlag = zlib$2.Z_FINISH;
+		return engine._processChunk(buffer, flushFlag);
+	}
+	function inflateSync(buffer, opts) {
+		return zlibBufferSync(new Inflate(opts), buffer);
+	}
+	module.exports = exports = inflateSync;
+	exports.Inflate = Inflate;
+	exports.createInflate = createInflate;
+	exports.inflateSync = inflateSync;
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/sync-reader.js
+var require_sync_reader = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var SyncReader = module.exports = function(buffer) {
+		this._buffer = buffer;
+		this._reads = [];
+	};
+	SyncReader.prototype.read = function(length, callback) {
+		this._reads.push({
+			length: Math.abs(length),
+			allowLess: length < 0,
+			func: callback
+		});
+	};
+	SyncReader.prototype.process = function() {
+		while (this._reads.length > 0 && this._buffer.length) {
+			let read = this._reads[0];
+			if (this._buffer.length && (this._buffer.length >= read.length || read.allowLess)) {
+				this._reads.shift();
+				let buf = this._buffer;
+				this._buffer = buf.slice(read.length);
+				read.func.call(this, buf.slice(0, read.length));
+			} else break;
+		}
+		if (this._reads.length > 0) throw new Error("There are some read requests waitng on finished stream");
+		if (this._buffer.length > 0) throw new Error("unrecognised content at end of stream");
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-parse-sync.js
+var require_filter_parse_sync = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var SyncReader = require_sync_reader();
+	var Filter = require_filter_parse();
+	exports.process = function(inBuffer, bitmapInfo) {
+		let outBuffers = [];
+		let reader = new SyncReader(inBuffer);
+		new Filter(bitmapInfo, {
+			read: reader.read.bind(reader),
+			write: function(bufferPart) {
+				outBuffers.push(bufferPart);
+			},
+			complete: function() {}
+		}).start();
+		reader.process();
+		return Buffer.concat(outBuffers);
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/parser-sync.js
+var require_parser_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasSyncZlib = true;
+	var zlib$1 = require("zlib");
+	var inflateSync = require_sync_inflate();
+	if (!zlib$1.deflateSync) hasSyncZlib = false;
+	var SyncReader = require_sync_reader();
+	var FilterSync = require_filter_parse_sync();
+	var Parser = require_parser();
+	var bitmapper = require_bitmapper();
+	var formatNormaliser = require_format_normaliser();
+	module.exports = function(buffer, options) {
+		if (!hasSyncZlib) throw new Error("To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0");
+		let err;
+		function handleError(_err_) {
+			err = _err_;
+		}
+		let metaData;
+		function handleMetaData(_metaData_) {
+			metaData = _metaData_;
+		}
+		function handleTransColor(transColor) {
+			metaData.transColor = transColor;
+		}
+		function handlePalette(palette) {
+			metaData.palette = palette;
+		}
+		function handleSimpleTransparency() {
+			metaData.alpha = true;
+		}
+		let gamma;
+		function handleGamma(_gamma_) {
+			gamma = _gamma_;
+		}
+		let inflateDataList = [];
+		function handleInflateData(inflatedData) {
+			inflateDataList.push(inflatedData);
+		}
+		let reader = new SyncReader(buffer);
+		new Parser(options, {
+			read: reader.read.bind(reader),
+			error: handleError,
+			metadata: handleMetaData,
+			gamma: handleGamma,
+			palette: handlePalette,
+			transColor: handleTransColor,
+			inflateData: handleInflateData,
+			simpleTransparency: handleSimpleTransparency
+		}).start();
+		reader.process();
+		if (err) throw err;
+		let inflateData = Buffer.concat(inflateDataList);
+		inflateDataList.length = 0;
+		let inflatedData;
+		if (metaData.interlace) inflatedData = zlib$1.inflateSync(inflateData);
+		else {
+			let imageSize = ((metaData.width * metaData.bpp * metaData.depth + 7 >> 3) + 1) * metaData.height;
+			inflatedData = inflateSync(inflateData, {
+				chunkSize: imageSize,
+				maxLength: imageSize
+			});
+		}
+		inflateData = null;
+		if (!inflatedData || !inflatedData.length) throw new Error("bad png - invalid inflate data response");
+		let unfilteredData = FilterSync.process(inflatedData, metaData);
+		inflateData = null;
+		let bitmapData = bitmapper.dataToBitMap(unfilteredData, metaData);
+		unfilteredData = null;
+		let normalisedBitmapData = formatNormaliser(bitmapData, metaData, options.skipRescale);
+		metaData.data = normalisedBitmapData;
+		metaData.gamma = gamma || 0;
+		return metaData;
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/packer-sync.js
+var require_packer_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasSyncZlib = true;
+	var zlib = require("zlib");
+	if (!zlib.deflateSync) hasSyncZlib = false;
+	var constants = require_constants();
+	var Packer = require_packer();
+	module.exports = function(metaData, opt) {
+		if (!hasSyncZlib) throw new Error("To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0");
+		let packer = new Packer(opt || {});
+		let chunks = [];
+		chunks.push(Buffer.from(constants.PNG_SIGNATURE));
+		chunks.push(packer.packIHDR(metaData.width, metaData.height));
+		if (metaData.gamma) chunks.push(packer.packGAMA(metaData.gamma));
+		let filteredData = packer.filterData(metaData.data, metaData.width, metaData.height);
+		let compressedData = zlib.deflateSync(filteredData, packer.getDeflateOptions());
+		filteredData = null;
+		if (!compressedData || !compressedData.length) throw new Error("bad png - invalid compressed data response");
+		chunks.push(packer.packIDAT(compressedData));
+		chunks.push(packer.packIEND());
+		return Buffer.concat(chunks);
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/png-sync.js
+var require_png_sync = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var parse = require_parser_sync();
+	var pack = require_packer_sync();
+	exports.read = function(buffer, options) {
+		return parse(buffer, options || {});
+	};
+	exports.write = function(png, options) {
+		return pack(png, options);
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/png.js
+var require_png = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var util = require("util");
+	var Stream$1 = require("stream");
+	var Parser = require_parser_async();
+	var Packer = require_packer_async();
+	var PNGSync = require_png_sync();
+	var PNG = exports.PNG = function(options) {
+		Stream$1.call(this);
+		options = options || {};
+		this.width = options.width | 0;
+		this.height = options.height | 0;
+		this.data = this.width > 0 && this.height > 0 ? Buffer.alloc(4 * this.width * this.height) : null;
+		if (options.fill && this.data) this.data.fill(0);
+		this.gamma = 0;
+		this.readable = this.writable = true;
+		this._parser = new Parser(options);
+		this._parser.on("error", this.emit.bind(this, "error"));
+		this._parser.on("close", this._handleClose.bind(this));
+		this._parser.on("metadata", this._metadata.bind(this));
+		this._parser.on("gamma", this._gamma.bind(this));
+		this._parser.on("parsed", function(data) {
+			this.data = data;
+			this.emit("parsed", data);
+		}.bind(this));
+		this._packer = new Packer(options);
+		this._packer.on("data", this.emit.bind(this, "data"));
+		this._packer.on("end", this.emit.bind(this, "end"));
+		this._parser.on("close", this._handleClose.bind(this));
+		this._packer.on("error", this.emit.bind(this, "error"));
+	};
+	util.inherits(PNG, Stream$1);
+	PNG.sync = PNGSync;
+	PNG.prototype.pack = function() {
+		if (!this.data || !this.data.length) {
+			this.emit("error", "No data provided");
+			return this;
+		}
+		process.nextTick(function() {
+			this._packer.pack(this.data, this.width, this.height, this.gamma);
+		}.bind(this));
+		return this;
+	};
+	PNG.prototype.parse = function(data, callback) {
+		if (callback) {
+			let onParsed, onError;
+			onParsed = function(parsedData) {
+				this.removeListener("error", onError);
+				this.data = parsedData;
+				callback(null, this);
+			}.bind(this);
+			onError = function(err) {
+				this.removeListener("parsed", onParsed);
+				callback(err, null);
+			}.bind(this);
+			this.once("parsed", onParsed);
+			this.once("error", onError);
+		}
+		this.end(data);
+		return this;
+	};
+	PNG.prototype.write = function(data) {
+		this._parser.write(data);
+		return true;
+	};
+	PNG.prototype.end = function(data) {
+		this._parser.end(data);
+	};
+	PNG.prototype._metadata = function(metadata) {
+		this.width = metadata.width;
+		this.height = metadata.height;
+		this.emit("metadata", metadata);
+	};
+	PNG.prototype._gamma = function(gamma) {
+		this.gamma = gamma;
+	};
+	PNG.prototype._handleClose = function() {
+		if (!this._parser.writable && !this._packer.readable) this.emit("close");
+	};
+	PNG.bitblt = function(src, dst, srcX, srcY, width, height, deltaX, deltaY) {
+		srcX |= 0;
+		srcY |= 0;
+		width |= 0;
+		height |= 0;
+		deltaX |= 0;
+		deltaY |= 0;
+		if (srcX > src.width || srcY > src.height || srcX + width > src.width || srcY + height > src.height) throw new Error("bitblt reading outside image");
+		if (deltaX > dst.width || deltaY > dst.height || deltaX + width > dst.width || deltaY + height > dst.height) throw new Error("bitblt writing outside image");
+		for (let y = 0; y < height; y++) src.data.copy(dst.data, (deltaY + y) * dst.width + deltaX << 2, (srcY + y) * src.width + srcX << 2, (srcY + y) * src.width + srcX + width << 2);
+	};
+	PNG.prototype.bitblt = function(dst, srcX, srcY, width, height, deltaX, deltaY) {
+		PNG.bitblt(this, dst, srcX, srcY, width, height, deltaX, deltaY);
+		return this;
+	};
+	PNG.adjustGamma = function(src) {
+		if (src.gamma) {
+			for (let y = 0; y < src.height; y++) for (let x = 0; x < src.width; x++) {
+				let idx = src.width * y + x << 2;
+				for (let i = 0; i < 3; i++) {
+					let sample = src.data[idx + i] / 255;
+					sample = Math.pow(sample, 1 / 2.2 / src.gamma);
+					src.data[idx + i] = Math.round(sample * 255);
+				}
+			}
+			src.gamma = 0;
+		}
+	};
+	PNG.prototype.adjustGamma = function() {
+		PNG.adjustGamma(this);
+	};
+}));
+//#endregion
 //#region src/lib/output/binary.ts
+var import_jpeg_js = /* @__PURE__ */ __toESM(require_jpeg_js(), 1);
+var import_png = require_png();
 function isGhostty() {
-	if (process.env.GHOSTTY_RESOURCES_DIR) return true;
+	if (process.env.GHOSTTY_RESOURCES_DIR || process.env.GHOSTTY_BIN_DIR || process.env.GHOSTTY_SHELL_FEATURES) return true;
 	if ((process.env.TERM ?? "").includes("ghostty")) return true;
 	return (process.env.TERM_PROGRAM ?? "").toLowerCase().includes("ghostty");
 }
+function isKitty() {
+	if (process.env.KITTY_WINDOW_ID || process.env.KITTY_PID) return true;
+	if ((process.env.TERM ?? "").includes("xterm-kitty")) return true;
+	return (process.env.TERM_PROGRAM ?? "").toLowerCase() === "kitty";
+}
 function isWezTerm() {
 	if (process.env.WEZTERM_EXECUTABLE || process.env.WEZTERM_PANE) return true;
 	return (process.env.TERM_PROGRAM ?? "").toLowerCase().includes("wezterm");
 }
 function detectTerminalImageProtocol() {
-	if (process.env.KITTY_WINDOW_ID || (process.env.TERM ?? "").includes("xterm-kitty")) return "kitty";
+	if (isKitty()) return "kitty";
 	if (isGhostty()) return "ghostty";
 	if (isWezTerm()) return "wezterm";
 	if (process.env.TERM_PROGRAM === "iTerm.app" || process.env.ITERM_SESSION_ID) return "iterm2";
@@ -62866,6 +66593,31 @@ function isImageBody(body) {
 	if (!body || body.type !== "text" && body.type !== "binary") return false;
 	return (body.mediaType?.toLowerCase() ?? "").startsWith("image/");
 }
+function isPngImage(body) {
+	if ((body.mediaType?.toLowerCase() ?? "") === "image/png") return true;
+	return body.content.startsWith("iVBORw0KGgo");
+}
+function isJpegImage(body) {
+	const mediaType = body.mediaType?.toLowerCase() ?? "";
+	if (mediaType === "image/jpeg" || mediaType === "image/jpg") return true;
+	return body.content.startsWith("/9j/");
+}
+function usesKittyGraphicsProtocol(protocol) {
+	return protocol === "kitty" || protocol === "ghostty";
+}
+function convertJpegBase64ToPngBase64(base64) {
+	try {
+		const decoded = import_jpeg_js.default.decode(Buffer.from(base64, "base64"));
+		const png = new import_png.PNG({
+			width: decoded.width,
+			height: decoded.height
+		});
+		png.data = decoded.data;
+		return import_png.PNG.sync.write(png).toString("base64");
+	} catch {
+		return null;
+	}
+}
 function formatByteSize(bytes) {
 	if (!Number.isFinite(bytes) || bytes < 0) return `${bytes} B`;
 	if (bytes < 1024) return `${bytes} B`;
@@ -62876,10 +66628,16 @@ function formatByteSize(bytes) {
 function kittyImageEscape(base64) {
 	const CHUNK = 4096;
 	let out = "";
-	for (let i = 0; i < base64.length; i += CHUNK) {
-		const chunk = base64.slice(i, i + CHUNK);
-		const more = i + CHUNK < base64.length ? 1 : 0;
-		out += `\u001b_Ga=T,t=d,m=${more};${chunk}\u001b\\`;
+	let offset = 0;
+	let first = true;
+	while (offset < base64.length) {
+		const chunk = base64.slice(offset, offset + CHUNK);
+		offset += CHUNK;
+		const more = offset < base64.length ? 1 : 0;
+		if (first) {
+			out += `\u001b_Ga=T,f=100,m=${more};${chunk}\u001b\\`;
+			first = false;
+		} else out += `\u001b_Gm=${more};${chunk}\u001b\\`;
 	}
 	return out;
 }
@@ -62890,8 +66648,21 @@ function renderImageInline(body) {
 	const protocol = detectTerminalImageProtocol();
 	if (!protocol) return null;
 	if (body.encoding !== "base64") return null;
-	if (protocol === "kitty" || protocol === "ghostty") return kittyImageEscape(body.content);
-	if (protocol === "iterm2" || protocol === "wezterm") return iterm2ImageEscape(body.content, body.byteLength);
+	if (usesKittyGraphicsProtocol(protocol)) {
+		let base64 = body.content;
+		let convertedFrom;
+		if (!isPngImage(body) && isJpegImage(body)) {
+			const pngBase64 = convertJpegBase64ToPngBase64(body.content);
+			if (!pngBase64) return null;
+			base64 = pngBase64;
+			convertedFrom = "jpeg";
+		}
+		return {
+			content: kittyImageEscape(base64),
+			convertedFrom
+		};
+	}
+	if (protocol === "iterm2" || protocol === "wezterm") return { content: iterm2ImageEscape(body.content, body.byteLength) };
 	return null;
 }
 //#endregion
@@ -63121,7 +66892,12 @@ function formatBody(body) {
 		const mediaType = body.mediaType ?? "application/octet-stream";
 		if (isImageBody(body)) {
 			const rendered = renderImageInline(body);
-			if (rendered) return rendered;
+			if (rendered) {
+				const parts = [];
+				if (rendered.convertedFrom === "jpeg") parts.push(import_picocolors.default.yellow("! Converted JPEG to PNG for terminal compatibility"));
+				parts.push(rendered.content);
+				return parts.join("\n");
+			}
 		}
 		return import_picocolors.default.dim(`Binary response body omitted (${mediaType}, ${formatByteSize(body.byteLength)})`);
 	}