clear-excel 0.1.0 → 1.0.2

package/dist/index.js

@@ -0,0 +1,2777 @@
+import JSZip from "jszip";
+import { posix, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { readFile, rename, unlink, writeFile } from "node:fs/promises";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+//#region __vite-browser-external
+var require___vite_browser_external = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {};
+}));
+/*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com */
+//#endregion
+//#region src/errors.ts
+var import_cfb = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Base64_map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+	function Base64_encode(input) {
+		var o = "";
+		var c1 = 0, c2 = 0, c3 = 0, e1 = 0, e2 = 0, e3 = 0, e4 = 0;
+		for (var i = 0; i < input.length;) {
+			c1 = input.charCodeAt(i++);
+			e1 = c1 >> 2;
+			c2 = input.charCodeAt(i++);
+			e2 = (c1 & 3) << 4 | c2 >> 4;
+			c3 = input.charCodeAt(i++);
+			e3 = (c2 & 15) << 2 | c3 >> 6;
+			e4 = c3 & 63;
+			if (isNaN(c2)) e3 = e4 = 64;
+			else if (isNaN(c3)) e4 = 64;
+			o += Base64_map.charAt(e1) + Base64_map.charAt(e2) + Base64_map.charAt(e3) + Base64_map.charAt(e4);
+		}
+		return o;
+	}
+	function Base64_decode(input) {
+		var o = "";
+		var c1 = 0, c2 = 0, c3 = 0, e1 = 0, e2 = 0, e3 = 0, e4 = 0;
+		input = input.replace(/[^\w\+\/\=]/g, "");
+		for (var i = 0; i < input.length;) {
+			e1 = Base64_map.indexOf(input.charAt(i++));
+			e2 = Base64_map.indexOf(input.charAt(i++));
+			c1 = e1 << 2 | e2 >> 4;
+			o += String.fromCharCode(c1);
+			e3 = Base64_map.indexOf(input.charAt(i++));
+			c2 = (e2 & 15) << 4 | e3 >> 2;
+			if (e3 !== 64) o += String.fromCharCode(c2);
+			e4 = Base64_map.indexOf(input.charAt(i++));
+			c3 = (e3 & 3) << 6 | e4;
+			if (e4 !== 64) o += String.fromCharCode(c3);
+		}
+		return o;
+	}
+	var has_buf = (function() {
+		return typeof Buffer !== "undefined" && typeof process !== "undefined" && typeof process.versions !== "undefined" && !!process.versions.node;
+	})();
+	var Buffer_from = (function() {
+		if (typeof Buffer !== "undefined") {
+			var nbfs = !Buffer.from;
+			if (!nbfs) try {
+				Buffer.from("foo", "utf8");
+			} catch (e) {
+				nbfs = true;
+			}
+			return nbfs ? function(buf, enc) {
+				return enc ? new Buffer(buf, enc) : new Buffer(buf);
+			} : Buffer.from.bind(Buffer);
+		}
+		return function() {};
+	})();
+	function new_raw_buf(len) {
+		if (has_buf) {
+			if (Buffer.alloc) return Buffer.alloc(len);
+			var b = new Buffer(len);
+			b.fill(0);
+			return b;
+		}
+		return typeof Uint8Array != "undefined" ? new Uint8Array(len) : new Array(len);
+	}
+	function new_unsafe_buf(len) {
+		if (has_buf) return Buffer.allocUnsafe ? Buffer.allocUnsafe(len) : new Buffer(len);
+		return typeof Uint8Array != "undefined" ? new Uint8Array(len) : new Array(len);
+	}
+	var s2a = function s2a(s) {
+		if (has_buf) return Buffer_from(s, "binary");
+		return s.split("").map(function(x) {
+			return x.charCodeAt(0) & 255;
+		});
+	};
+	var chr0 = /\u0000/g;
+	var chr1 = /[\u0001-\u0006]/g;
+	var __toBuffer = function(bufs) {
+		var x = [];
+		for (var i = 0; i < bufs[0].length; ++i) x.push.apply(x, bufs[0][i]);
+		return x;
+	};
+	var ___toBuffer = __toBuffer;
+	var __utf16le = function(b, s, e) {
+		var ss = [];
+		for (var i = s; i < e; i += 2) ss.push(String.fromCharCode(__readUInt16LE(b, i)));
+		return ss.join("").replace(chr0, "");
+	};
+	var ___utf16le = __utf16le;
+	var __hexlify = function(b, s, l) {
+		var ss = [];
+		for (var i = s; i < s + l; ++i) ss.push(("0" + b[i].toString(16)).slice(-2));
+		return ss.join("");
+	};
+	var ___hexlify = __hexlify;
+	var __bconcat = function(bufs) {
+		if (Array.isArray(bufs[0])) return [].concat.apply([], bufs);
+		var maxlen = 0, i = 0;
+		for (i = 0; i < bufs.length; ++i) maxlen += bufs[i].length;
+		var o = new Uint8Array(maxlen);
+		for (i = 0, maxlen = 0; i < bufs.length; maxlen += bufs[i].length, ++i) o.set(bufs[i], maxlen);
+		return o;
+	};
+	var bconcat = __bconcat;
+	if (has_buf) {
+		__utf16le = function(b, s, e) {
+			if (!Buffer.isBuffer(b)) return ___utf16le(b, s, e);
+			return b.toString("utf16le", s, e).replace(chr0, "");
+		};
+		__hexlify = function(b, s, l) {
+			return Buffer.isBuffer(b) ? b.toString("hex", s, s + l) : ___hexlify(b, s, l);
+		};
+		__toBuffer = function(bufs) {
+			return bufs[0].length > 0 && Buffer.isBuffer(bufs[0][0]) ? Buffer.concat(bufs[0]) : ___toBuffer(bufs);
+		};
+		s2a = function(s) {
+			return Buffer_from(s, "binary");
+		};
+		bconcat = function(bufs) {
+			return Buffer.isBuffer(bufs[0]) ? Buffer.concat(bufs) : __bconcat(bufs);
+		};
+	}
+	var __readUInt8 = function(b, idx) {
+		return b[idx];
+	};
+	var __readUInt16LE = function(b, idx) {
+		return b[idx + 1] * 256 + b[idx];
+	};
+	var __readInt16LE = function(b, idx) {
+		var u = b[idx + 1] * 256 + b[idx];
+		return u < 32768 ? u : (65535 - u + 1) * -1;
+	};
+	var __readUInt32LE = function(b, idx) {
+		return b[idx + 3] * (1 << 24) + (b[idx + 2] << 16) + (b[idx + 1] << 8) + b[idx];
+	};
+	var __readInt32LE = function(b, idx) {
+		return (b[idx + 3] << 24) + (b[idx + 2] << 16) + (b[idx + 1] << 8) + b[idx];
+	};
+	function ReadShift(size, t) {
+		var oI, oS, type = 0;
+		switch (size) {
+			case 1:
+				oI = __readUInt8(this, this.l);
+				break;
+			case 2:
+				oI = (t !== "i" ? __readUInt16LE : __readInt16LE)(this, this.l);
+				break;
+			case 4:
+				oI = __readInt32LE(this, this.l);
+				break;
+			case 16:
+				type = 2;
+				oS = __hexlify(this, this.l, size);
+		}
+		this.l += size;
+		if (type === 0) return oI;
+		return oS;
+	}
+	var __writeUInt32LE = function(b, val, idx) {
+		b[idx] = val & 255;
+		b[idx + 1] = val >>> 8 & 255;
+		b[idx + 2] = val >>> 16 & 255;
+		b[idx + 3] = val >>> 24 & 255;
+	};
+	var __writeInt32LE = function(b, val, idx) {
+		b[idx] = val & 255;
+		b[idx + 1] = val >> 8 & 255;
+		b[idx + 2] = val >> 16 & 255;
+		b[idx + 3] = val >> 24 & 255;
+	};
+	function WriteShift(t, val, f) {
+		var size = 0, i = 0;
+		switch (f) {
+			case "hex":
+				for (; i < t; ++i) this[this.l++] = parseInt(val.slice(2 * i, 2 * i + 2), 16) || 0;
+				return this;
+			case "utf16le":
+				var end = this.l + t;
+				for (i = 0; i < Math.min(val.length, t); ++i) {
+					var cc = val.charCodeAt(i);
+					this[this.l++] = cc & 255;
+					this[this.l++] = cc >> 8;
+				}
+				while (this.l < end) this[this.l++] = 0;
+				return this;
+		}
+		switch (t) {
+			case 1:
+				size = 1;
+				this[this.l] = val & 255;
+				break;
+			case 2:
+				size = 2;
+				this[this.l] = val & 255;
+				val >>>= 8;
+				this[this.l + 1] = val & 255;
+				break;
+			case 4:
+				size = 4;
+				__writeUInt32LE(this, val, this.l);
+				break;
+			case -4:
+				size = 4;
+				__writeInt32LE(this, val, this.l);
+		}
+		this.l += size;
+		return this;
+	}
+	function CheckField(hexstr, fld) {
+		var m = __hexlify(this, this.l, hexstr.length >> 1);
+		if (m !== hexstr) throw new Error(fld + "Expected " + hexstr + " saw " + m);
+		this.l += hexstr.length >> 1;
+	}
+	function prep_blob(blob, pos) {
+		blob.l = pos;
+		blob.read_shift = ReadShift;
+		blob.chk = CheckField;
+		blob.write_shift = WriteShift;
+	}
+	function new_buf(sz) {
+		var o = new_raw_buf(sz);
+		prep_blob(o, 0);
+		return o;
+	}
+	var CRC32 = (function() {
+		var CRC32 = {};
+		CRC32.version = "1.2.1";
+		function signed_crc_table() {
+			var c = 0, table = new Array(256);
+			for (var n = 0; n != 256; ++n) {
+				c = n;
+				c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+				c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+				c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+				c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+				c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+				c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+				c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+				c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+				table[n] = c;
+			}
+			return typeof Int32Array !== "undefined" ? new Int32Array(table) : table;
+		}
+		var T0 = signed_crc_table();
+		function slice_by_16_tables(T) {
+			var c = 0, v = 0, n = 0, table = typeof Int32Array !== "undefined" ? /* @__PURE__ */ new Int32Array(4096) : new Array(4096);
+			for (n = 0; n != 256; ++n) table[n] = T[n];
+			for (n = 0; n != 256; ++n) {
+				v = T[n];
+				for (c = 256 + n; c < 4096; c += 256) v = table[c] = v >>> 8 ^ T[v & 255];
+			}
+			var out = [];
+			for (n = 1; n != 16; ++n) out[n - 1] = typeof Int32Array !== "undefined" ? table.subarray(n * 256, n * 256 + 256) : table.slice(n * 256, n * 256 + 256);
+			return out;
+		}
+		var TT = slice_by_16_tables(T0);
+		var T1 = TT[0], T2 = TT[1], T3 = TT[2], T4 = TT[3], T5 = TT[4];
+		var T6 = TT[5], T7 = TT[6], T8 = TT[7], T9 = TT[8], Ta = TT[9];
+		var Tb = TT[10], Tc = TT[11], Td = TT[12], Te = TT[13], Tf = TT[14];
+		function crc32_bstr(bstr, seed) {
+			var C = seed ^ -1;
+			for (var i = 0, L = bstr.length; i < L;) C = C >>> 8 ^ T0[(C ^ bstr.charCodeAt(i++)) & 255];
+			return ~C;
+		}
+		function crc32_buf(B, seed) {
+			var C = seed ^ -1, L = B.length - 15, i = 0;
+			for (; i < L;) C = Tf[B[i++] ^ C & 255] ^ Te[B[i++] ^ C >> 8 & 255] ^ Td[B[i++] ^ C >> 16 & 255] ^ Tc[B[i++] ^ C >>> 24] ^ Tb[B[i++]] ^ Ta[B[i++]] ^ T9[B[i++]] ^ T8[B[i++]] ^ T7[B[i++]] ^ T6[B[i++]] ^ T5[B[i++]] ^ T4[B[i++]] ^ T3[B[i++]] ^ T2[B[i++]] ^ T1[B[i++]] ^ T0[B[i++]];
+			L += 15;
+			while (i < L) C = C >>> 8 ^ T0[(C ^ B[i++]) & 255];
+			return ~C;
+		}
+		function crc32_str(str, seed) {
+			var C = seed ^ -1;
+			for (var i = 0, L = str.length, c = 0, d = 0; i < L;) {
+				c = str.charCodeAt(i++);
+				if (c < 128) C = C >>> 8 ^ T0[(C ^ c) & 255];
+				else if (c < 2048) {
+					C = C >>> 8 ^ T0[(C ^ (192 | c >> 6 & 31)) & 255];
+					C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
+				} else if (c >= 55296 && c < 57344) {
+					c = (c & 1023) + 64;
+					d = str.charCodeAt(i++) & 1023;
+					C = C >>> 8 ^ T0[(C ^ (240 | c >> 8 & 7)) & 255];
+					C = C >>> 8 ^ T0[(C ^ (128 | c >> 2 & 63)) & 255];
+					C = C >>> 8 ^ T0[(C ^ (128 | d >> 6 & 15 | (c & 3) << 4)) & 255];
+					C = C >>> 8 ^ T0[(C ^ (128 | d & 63)) & 255];
+				} else {
+					C = C >>> 8 ^ T0[(C ^ (224 | c >> 12 & 15)) & 255];
+					C = C >>> 8 ^ T0[(C ^ (128 | c >> 6 & 63)) & 255];
+					C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
+				}
+			}
+			return ~C;
+		}
+		CRC32.table = T0;
+		CRC32.bstr = crc32_bstr;
+		CRC32.buf = crc32_buf;
+		CRC32.str = crc32_str;
+		return CRC32;
+	})();
+	var CFB = (function _CFB() {
+		var exports$1 = {};
+		exports$1.version = "1.2.2";
+		function namecmp(l, r) {
+			var L = l.split("/"), R = r.split("/");
+			for (var i = 0, c = 0, Z = Math.min(L.length, R.length); i < Z; ++i) {
+				if (c = L[i].length - R[i].length) return c;
+				if (L[i] != R[i]) return L[i] < R[i] ? -1 : 1;
+			}
+			return L.length - R.length;
+		}
+		function dirname(p) {
+			if (p.charAt(p.length - 1) == "/") return p.slice(0, -1).indexOf("/") === -1 ? p : dirname(p.slice(0, -1));
+			var c = p.lastIndexOf("/");
+			return c === -1 ? p : p.slice(0, c + 1);
+		}
+		function filename(p) {
+			if (p.charAt(p.length - 1) == "/") return filename(p.slice(0, -1));
+			var c = p.lastIndexOf("/");
+			return c === -1 ? p : p.slice(c + 1);
+		}
+		function write_dos_date(buf, date) {
+			if (typeof date === "string") date = new Date(date);
+			var hms = date.getHours();
+			hms = hms << 6 | date.getMinutes();
+			hms = hms << 5 | date.getSeconds() >>> 1;
+			buf.write_shift(2, hms);
+			var ymd = date.getFullYear() - 1980;
+			ymd = ymd << 4 | date.getMonth() + 1;
+			ymd = ymd << 5 | date.getDate();
+			buf.write_shift(2, ymd);
+		}
+		function parse_dos_date(buf) {
+			var hms = buf.read_shift(2) & 65535;
+			var ymd = buf.read_shift(2) & 65535;
+			var val = /* @__PURE__ */ new Date();
+			var d = ymd & 31;
+			ymd >>>= 5;
+			var m = ymd & 15;
+			ymd >>>= 4;
+			val.setMilliseconds(0);
+			val.setFullYear(ymd + 1980);
+			val.setMonth(m - 1);
+			val.setDate(d);
+			var S = hms & 31;
+			hms >>>= 5;
+			var M = hms & 63;
+			hms >>>= 6;
+			val.setHours(hms);
+			val.setMinutes(M);
+			val.setSeconds(S << 1);
+			return val;
+		}
+		function parse_extra_field(blob) {
+			prep_blob(blob, 0);
+			var o = {};
+			var flags = 0;
+			while (blob.l <= blob.length - 4) {
+				var type = blob.read_shift(2);
+				var sz = blob.read_shift(2), tgt = blob.l + sz;
+				var p = {};
+				switch (type) {
+					case 21589:
+						flags = blob.read_shift(1);
+						if (flags & 1) p.mtime = blob.read_shift(4);
+						if (sz > 5) {
+							if (flags & 2) p.atime = blob.read_shift(4);
+							if (flags & 4) p.ctime = blob.read_shift(4);
+						}
+						if (p.mtime) p.mt = /* @__PURE__ */ new Date(p.mtime * 1e3);
+				}
+				blob.l = tgt;
+				o[type] = p;
+			}
+			return o;
+		}
+		var fs;
+		function get_fs() {
+			return fs || (fs = require___vite_browser_external());
+		}
+		function parse(file, options) {
+			if (file[0] == 80 && file[1] == 75) return parse_zip(file, options);
+			if ((file[0] | 32) == 109 && (file[1] | 32) == 105) return parse_mad(file, options);
+			if (file.length < 512) throw new Error("CFB file size " + file.length + " < 512");
+			var mver = 3;
+			var ssz = 512;
+			var nmfs = 0;
+			var difat_sec_cnt = 0;
+			var dir_start = 0;
+			var minifat_start = 0;
+			var difat_start = 0;
+			var fat_addrs = [];
+			var blob = file.slice(0, 512);
+			prep_blob(blob, 0);
+			var mv = check_get_mver(blob);
+			mver = mv[0];
+			switch (mver) {
+				case 3:
+					ssz = 512;
+					break;
+				case 4:
+					ssz = 4096;
+					break;
+				case 0: if (mv[1] == 0) return parse_zip(file, options);
+				default: throw new Error("Major Version: Expected 3 or 4 saw " + mver);
+			}
+			if (ssz !== 512) {
+				blob = file.slice(0, ssz);
+				prep_blob(blob, 28);
+			}
+			var header = file.slice(0, ssz);
+			check_shifts(blob, mver);
+			var dir_cnt = blob.read_shift(4, "i");
+			if (mver === 3 && dir_cnt !== 0) throw new Error("# Directory Sectors: Expected 0 saw " + dir_cnt);
+			blob.l += 4;
+			dir_start = blob.read_shift(4, "i");
+			blob.l += 4;
+			blob.chk("00100000", "Mini Stream Cutoff Size: ");
+			minifat_start = blob.read_shift(4, "i");
+			nmfs = blob.read_shift(4, "i");
+			difat_start = blob.read_shift(4, "i");
+			difat_sec_cnt = blob.read_shift(4, "i");
+			for (var q = -1, j = 0; j < 109; ++j) {
+				q = blob.read_shift(4, "i");
+				if (q < 0) break;
+				fat_addrs[j] = q;
+			}
+			/** Break the file up into sectors */
+			var sectors = sectorify(file, ssz);
+			sleuth_fat(difat_start, difat_sec_cnt, sectors, ssz, fat_addrs);
+			/** Chains */
+			var sector_list = make_sector_list(sectors, dir_start, fat_addrs, ssz);
+			sector_list[dir_start].name = "!Directory";
+			if (nmfs > 0 && minifat_start !== ENDOFCHAIN) sector_list[minifat_start].name = "!MiniFAT";
+			sector_list[fat_addrs[0]].name = "!FAT";
+			sector_list.fat_addrs = fat_addrs;
+			sector_list.ssz = ssz;
+			var files = {}, Paths = [], FileIndex = [], FullPaths = [];
+			read_directory(dir_start, sector_list, sectors, Paths, nmfs, files, FileIndex, minifat_start);
+			build_full_paths(FileIndex, FullPaths, Paths);
+			Paths.shift();
+			var o = {
+				FileIndex,
+				FullPaths
+			};
+			if (options && options.raw) o.raw = {
+				header,
+				sectors
+			};
+			return o;
+		}
+		function check_get_mver(blob) {
+			if (blob[blob.l] == 80 && blob[blob.l + 1] == 75) return [0, 0];
+			blob.chk(HEADER_SIGNATURE, "Header Signature: ");
+			blob.l += 16;
+			var mver = blob.read_shift(2, "u");
+			return [blob.read_shift(2, "u"), mver];
+		}
+		function check_shifts(blob, mver) {
+			var shift = 9;
+			blob.l += 2;
+			switch (shift = blob.read_shift(2)) {
+				case 9:
+					if (mver != 3) throw new Error("Sector Shift: Expected 9 saw " + shift);
+					break;
+				case 12:
+					if (mver != 4) throw new Error("Sector Shift: Expected 12 saw " + shift);
+					break;
+				default: throw new Error("Sector Shift: Expected 9 or 12 saw " + shift);
+			}
+			blob.chk("0600", "Mini Sector Shift: ");
+			blob.chk("000000000000", "Reserved: ");
+		}
+		/** Break the file up into sectors */
+		function sectorify(file, ssz) {
+			var nsectors = Math.ceil(file.length / ssz) - 1;
+			var sectors = [];
+			for (var i = 1; i < nsectors; ++i) sectors[i - 1] = file.slice(i * ssz, (i + 1) * ssz);
+			sectors[nsectors - 1] = file.slice(nsectors * ssz);
+			return sectors;
+		}
+		function build_full_paths(FI, FP, Paths) {
+			var i = 0, L = 0, R = 0, C = 0, j = 0, pl = Paths.length;
+			var dad = [], q = [];
+			for (; i < pl; ++i) {
+				dad[i] = q[i] = i;
+				FP[i] = Paths[i];
+			}
+			for (; j < q.length; ++j) {
+				i = q[j];
+				L = FI[i].L;
+				R = FI[i].R;
+				C = FI[i].C;
+				if (dad[i] === i) {
+					if (L !== -1 && dad[L] !== L) dad[i] = dad[L];
+					if (R !== -1 && dad[R] !== R) dad[i] = dad[R];
+				}
+				if (C !== -1) dad[C] = i;
+				if (L !== -1 && i != dad[i]) {
+					dad[L] = dad[i];
+					if (q.lastIndexOf(L) < j) q.push(L);
+				}
+				if (R !== -1 && i != dad[i]) {
+					dad[R] = dad[i];
+					if (q.lastIndexOf(R) < j) q.push(R);
+				}
+			}
+			for (i = 1; i < pl; ++i) if (dad[i] === i) {
+				if (R !== -1 && dad[R] !== R) dad[i] = dad[R];
+				else if (L !== -1 && dad[L] !== L) dad[i] = dad[L];
+			}
+			for (i = 1; i < pl; ++i) {
+				if (FI[i].type === 0) continue;
+				j = i;
+				if (j != dad[j]) do {
+					j = dad[j];
+					FP[i] = FP[j] + "/" + FP[i];
+				} while (j !== 0 && -1 !== dad[j] && j != dad[j]);
+				dad[i] = -1;
+			}
+			FP[0] += "/";
+			for (i = 1; i < pl; ++i) if (FI[i].type !== 2) FP[i] += "/";
+		}
+		function get_mfat_entry(entry, payload, mini) {
+			var start = entry.start, size = entry.size;
+			var o = [];
+			var idx = start;
+			while (mini && size > 0 && idx >= 0) {
+				o.push(payload.slice(idx * MSSZ, idx * MSSZ + MSSZ));
+				size -= MSSZ;
+				idx = __readInt32LE(mini, idx * 4);
+			}
+			if (o.length === 0) return new_buf(0);
+			return bconcat(o).slice(0, entry.size);
+		}
+		/** Chase down the rest of the DIFAT chain to build a comprehensive list
+		DIFAT chains by storing the next sector number as the last 32 bits */
+		function sleuth_fat(idx, cnt, sectors, ssz, fat_addrs) {
+			var q = ENDOFCHAIN;
+			if (idx === ENDOFCHAIN) {
+				if (cnt !== 0) throw new Error("DIFAT chain shorter than expected");
+			} else if (idx !== -1) {
+				var sector = sectors[idx], m = (ssz >>> 2) - 1;
+				if (!sector) return;
+				for (var i = 0; i < m; ++i) {
+					if ((q = __readInt32LE(sector, i * 4)) === ENDOFCHAIN) break;
+					fat_addrs.push(q);
+				}
+				if (cnt >= 1) sleuth_fat(__readInt32LE(sector, ssz - 4), cnt - 1, sectors, ssz, fat_addrs);
+			}
+		}
+		/** Follow the linked list of sectors for a given starting point */
+		function get_sector_list(sectors, start, fat_addrs, ssz, chkd) {
+			var buf = [], buf_chain = [];
+			if (!chkd) chkd = [];
+			var modulus = ssz - 1, j = 0, jj = 0;
+			for (j = start; j >= 0;) {
+				chkd[j] = true;
+				buf[buf.length] = j;
+				buf_chain.push(sectors[j]);
+				var addr = fat_addrs[Math.floor(j * 4 / ssz)];
+				jj = j * 4 & modulus;
+				if (ssz < 4 + jj) throw new Error("FAT boundary crossed: " + j + " 4 " + ssz);
+				if (!sectors[addr]) break;
+				j = __readInt32LE(sectors[addr], jj);
+			}
+			return {
+				nodes: buf,
+				data: __toBuffer([buf_chain])
+			};
+		}
+		/** Chase down the sector linked lists */
+		function make_sector_list(sectors, dir_start, fat_addrs, ssz) {
+			var sl = sectors.length, sector_list = [];
+			var chkd = [], buf = [], buf_chain = [];
+			var modulus = ssz - 1, i = 0, j = 0, k = 0, jj = 0;
+			for (i = 0; i < sl; ++i) {
+				buf = [];
+				k = i + dir_start;
+				if (k >= sl) k -= sl;
+				if (chkd[k]) continue;
+				buf_chain = [];
+				var seen = [];
+				for (j = k; j >= 0;) {
+					seen[j] = true;
+					chkd[j] = true;
+					buf[buf.length] = j;
+					buf_chain.push(sectors[j]);
+					var addr = fat_addrs[Math.floor(j * 4 / ssz)];
+					jj = j * 4 & modulus;
+					if (ssz < 4 + jj) throw new Error("FAT boundary crossed: " + j + " 4 " + ssz);
+					if (!sectors[addr]) break;
+					j = __readInt32LE(sectors[addr], jj);
+					if (seen[j]) break;
+				}
+				sector_list[k] = {
+					nodes: buf,
+					data: __toBuffer([buf_chain])
+				};
+			}
+			return sector_list;
+		}
+		function read_directory(dir_start, sector_list, sectors, Paths, nmfs, files, FileIndex, mini) {
+			var minifat_store = 0, pl = Paths.length ? 2 : 0;
+			var sector = sector_list[dir_start].data;
+			var i = 0, namelen = 0, name;
+			for (; i < sector.length; i += 128) {
+				var blob = sector.slice(i, i + 128);
+				prep_blob(blob, 64);
+				namelen = blob.read_shift(2);
+				name = __utf16le(blob, 0, namelen - pl);
+				Paths.push(name);
+				var o = {
+					name,
+					type: blob.read_shift(1),
+					color: blob.read_shift(1),
+					L: blob.read_shift(4, "i"),
+					R: blob.read_shift(4, "i"),
+					C: blob.read_shift(4, "i"),
+					clsid: blob.read_shift(16),
+					state: blob.read_shift(4, "i"),
+					start: 0,
+					size: 0
+				};
+				if (blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) !== 0) o.ct = read_date(blob, blob.l - 8);
+				if (blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) !== 0) o.mt = read_date(blob, blob.l - 8);
+				o.start = blob.read_shift(4, "i");
+				o.size = blob.read_shift(4, "i");
+				if (o.size < 0 && o.start < 0) {
+					o.size = o.type = 0;
+					o.start = ENDOFCHAIN;
+					o.name = "";
+				}
+				if (o.type === 5) {
+					minifat_store = o.start;
+					if (nmfs > 0 && minifat_store !== ENDOFCHAIN) sector_list[minifat_store].name = "!StreamData";
+				} else if (o.size >= 4096) {
+					o.storage = "fat";
+					if (sector_list[o.start] === void 0) sector_list[o.start] = get_sector_list(sectors, o.start, sector_list.fat_addrs, sector_list.ssz);
+					sector_list[o.start].name = o.name;
+					o.content = sector_list[o.start].data.slice(0, o.size);
+				} else {
+					o.storage = "minifat";
+					if (o.size < 0) o.size = 0;
+					else if (minifat_store !== ENDOFCHAIN && o.start !== ENDOFCHAIN && sector_list[minifat_store]) o.content = get_mfat_entry(o, sector_list[minifat_store].data, (sector_list[mini] || {}).data);
+				}
+				if (o.content) prep_blob(o.content, 0);
+				files[name] = o;
+				FileIndex.push(o);
+			}
+		}
+		function read_date(blob, offset) {
+			return /* @__PURE__ */ new Date((__readUInt32LE(blob, offset + 4) / 1e7 * Math.pow(2, 32) + __readUInt32LE(blob, offset) / 1e7 - 11644473600) * 1e3);
+		}
+		function read_file(filename, options) {
+			get_fs();
+			return parse(fs.readFileSync(filename), options);
+		}
+		function read(blob, options) {
+			var type = options && options.type;
+			if (!type) {
+				if (has_buf && Buffer.isBuffer(blob)) type = "buffer";
+			}
+			switch (type || "base64") {
+				case "file": return read_file(blob, options);
+				case "base64": return parse(s2a(Base64_decode(blob)), options);
+				case "binary": return parse(s2a(blob), options);
+			}
+			return parse(blob, options);
+		}
+		function init_cfb(cfb, opts) {
+			var o = opts || {}, root = o.root || "Root Entry";
+			if (!cfb.FullPaths) cfb.FullPaths = [];
+			if (!cfb.FileIndex) cfb.FileIndex = [];
+			if (cfb.FullPaths.length !== cfb.FileIndex.length) throw new Error("inconsistent CFB structure");
+			if (cfb.FullPaths.length === 0) {
+				cfb.FullPaths[0] = root + "/";
+				cfb.FileIndex[0] = {
+					name: root,
+					type: 5
+				};
+			}
+			if (o.CLSID) cfb.FileIndex[0].clsid = o.CLSID;
+			seed_cfb(cfb);
+		}
+		function seed_cfb(cfb) {
+			var nm = "
Sh33tJ5";
+			if (CFB.find(cfb, "/" + nm)) return;
+			var p = new_buf(4);
+			p[0] = 55;
+			p[1] = p[3] = 50;
+			p[2] = 54;
+			cfb.FileIndex.push({
+				name: nm,
+				type: 2,
+				content: p,
+				size: 4,
+				L: 69,
+				R: 69,
+				C: 69
+			});
+			cfb.FullPaths.push(cfb.FullPaths[0] + nm);
+			rebuild_cfb(cfb);
+		}
+		function rebuild_cfb(cfb, f) {
+			init_cfb(cfb);
+			var gc = false, s = false;
+			for (var i = cfb.FullPaths.length - 1; i >= 0; --i) {
+				var _file = cfb.FileIndex[i];
+				switch (_file.type) {
+					case 0:
+						if (s) gc = true;
+						else {
+							cfb.FileIndex.pop();
+							cfb.FullPaths.pop();
+						}
+						break;
+					case 1:
+					case 2:
+					case 5:
+						s = true;
+						if (isNaN(_file.R * _file.L * _file.C)) gc = true;
+						if (_file.R > -1 && _file.L > -1 && _file.R == _file.L) gc = true;
+						break;
+					default: gc = true;
+				}
+			}
+			if (!gc && !f) return;
+			var now = new Date(1987, 1, 19), j = 0;
+			var fullPaths = Object.create ? Object.create(null) : {};
+			var data = [];
+			for (i = 0; i < cfb.FullPaths.length; ++i) {
+				fullPaths[cfb.FullPaths[i]] = true;
+				if (cfb.FileIndex[i].type === 0) continue;
+				data.push([cfb.FullPaths[i], cfb.FileIndex[i]]);
+			}
+			for (i = 0; i < data.length; ++i) {
+				var dad = dirname(data[i][0]);
+				s = fullPaths[dad];
+				while (!s) {
+					while (dirname(dad) && !fullPaths[dirname(dad)]) dad = dirname(dad);
+					data.push([dad, {
+						name: filename(dad).replace("/", ""),
+						type: 1,
+						clsid: HEADER_CLSID,
+						ct: now,
+						mt: now,
+						content: null
+					}]);
+					fullPaths[dad] = true;
+					dad = dirname(data[i][0]);
+					s = fullPaths[dad];
+				}
+			}
+			data.sort(function(x, y) {
+				return namecmp(x[0], y[0]);
+			});
+			cfb.FullPaths = [];
+			cfb.FileIndex = [];
+			for (i = 0; i < data.length; ++i) {
+				cfb.FullPaths[i] = data[i][0];
+				cfb.FileIndex[i] = data[i][1];
+			}
+			for (i = 0; i < data.length; ++i) {
+				var elt = cfb.FileIndex[i];
+				var nm = cfb.FullPaths[i];
+				elt.name = filename(nm).replace("/", "");
+				elt.L = elt.R = elt.C = -(elt.color = 1);
+				elt.size = elt.content ? elt.content.length : 0;
+				elt.start = 0;
+				elt.clsid = elt.clsid || HEADER_CLSID;
+				if (i === 0) {
+					elt.C = data.length > 1 ? 1 : -1;
+					elt.size = 0;
+					elt.type = 5;
+				} else if (nm.slice(-1) == "/") {
+					for (j = i + 1; j < data.length; ++j) if (dirname(cfb.FullPaths[j]) == nm) break;
+					elt.C = j >= data.length ? -1 : j;
+					for (j = i + 1; j < data.length; ++j) if (dirname(cfb.FullPaths[j]) == dirname(nm)) break;
+					elt.R = j >= data.length ? -1 : j;
+					elt.type = 1;
+				} else {
+					if (dirname(cfb.FullPaths[i + 1] || "") == dirname(nm)) elt.R = i + 1;
+					elt.type = 2;
+				}
+			}
+		}
+		function _write(cfb, options) {
+			var _opts = options || {};
+			if (_opts.fileType == "mad") return write_mad(cfb, _opts);
+			rebuild_cfb(cfb);
+			switch (_opts.fileType) {
+				case "zip": return write_zip(cfb, _opts);
+			}
+			var L = (function(cfb) {
+				var mini_size = 0, fat_size = 0;
+				for (var i = 0; i < cfb.FileIndex.length; ++i) {
+					var file = cfb.FileIndex[i];
+					if (!file.content) continue;
+					var flen = file.content.length;
+					if (flen > 0) {
+						if (flen < 4096) mini_size += flen + 63 >> 6;
+						else fat_size += flen + 511 >> 9;
+					}
+				}
+				var dir_cnt = cfb.FullPaths.length + 3 >> 2;
+				var mini_cnt = mini_size + 7 >> 3;
+				var mfat_cnt = mini_size + 127 >> 7;
+				var fat_base = mini_cnt + fat_size + dir_cnt + mfat_cnt;
+				var fat_cnt = fat_base + 127 >> 7;
+				var difat_cnt = fat_cnt <= 109 ? 0 : Math.ceil((fat_cnt - 109) / 127);
+				while (fat_base + fat_cnt + difat_cnt + 127 >> 7 > fat_cnt) difat_cnt = ++fat_cnt <= 109 ? 0 : Math.ceil((fat_cnt - 109) / 127);
+				var L = [
+					1,
+					difat_cnt,
+					fat_cnt,
+					mfat_cnt,
+					dir_cnt,
+					fat_size,
+					mini_size,
+					0
+				];
+				cfb.FileIndex[0].size = mini_size << 6;
+				L[7] = (cfb.FileIndex[0].start = L[0] + L[1] + L[2] + L[3] + L[4] + L[5]) + (L[6] + 7 >> 3);
+				return L;
+			})(cfb);
+			var o = new_buf(L[7] << 9);
+			var i = 0, T = 0;
+			for (i = 0; i < 8; ++i) o.write_shift(1, HEADER_SIG[i]);
+			for (i = 0; i < 8; ++i) o.write_shift(2, 0);
+			o.write_shift(2, 62);
+			o.write_shift(2, 3);
+			o.write_shift(2, 65534);
+			o.write_shift(2, 9);
+			o.write_shift(2, 6);
+			for (i = 0; i < 3; ++i) o.write_shift(2, 0);
+			o.write_shift(4, 0);
+			o.write_shift(4, L[2]);
+			o.write_shift(4, L[0] + L[1] + L[2] + L[3] - 1);
+			o.write_shift(4, 0);
+			o.write_shift(4, 4096);
+			o.write_shift(4, L[3] ? L[0] + L[1] + L[2] - 1 : ENDOFCHAIN);
+			o.write_shift(4, L[3]);
+			o.write_shift(-4, L[1] ? L[0] - 1 : ENDOFCHAIN);
+			o.write_shift(4, L[1]);
+			for (i = 0; i < 109; ++i) o.write_shift(-4, i < L[2] ? L[1] + i : -1);
+			if (L[1]) for (T = 0; T < L[1]; ++T) {
+				for (; i < 236 + T * 127; ++i) o.write_shift(-4, i < L[2] ? L[1] + i : -1);
+				o.write_shift(-4, T === L[1] - 1 ? ENDOFCHAIN : T + 1);
+			}
+			var chainit = function(w) {
+				for (T += w; i < T - 1; ++i) o.write_shift(-4, i + 1);
+				if (w) {
+					++i;
+					o.write_shift(-4, ENDOFCHAIN);
+				}
+			};
+			T = i = 0;
+			for (T += L[1]; i < T; ++i) o.write_shift(-4, consts.DIFSECT);
+			for (T += L[2]; i < T; ++i) o.write_shift(-4, consts.FATSECT);
+			chainit(L[3]);
+			chainit(L[4]);
+			var j = 0, flen = 0;
+			var file = cfb.FileIndex[0];
+			for (; j < cfb.FileIndex.length; ++j) {
+				file = cfb.FileIndex[j];
+				if (!file.content) continue;
+				flen = file.content.length;
+				if (flen < 4096) continue;
+				file.start = T;
+				chainit(flen + 511 >> 9);
+			}
+			chainit(L[6] + 7 >> 3);
+			while (o.l & 511) o.write_shift(-4, consts.ENDOFCHAIN);
+			T = i = 0;
+			for (j = 0; j < cfb.FileIndex.length; ++j) {
+				file = cfb.FileIndex[j];
+				if (!file.content) continue;
+				flen = file.content.length;
+				if (!flen || flen >= 4096) continue;
+				file.start = T;
+				chainit(flen + 63 >> 6);
+			}
+			while (o.l & 511) o.write_shift(-4, consts.ENDOFCHAIN);
+			for (i = 0; i < L[4] << 2; ++i) {
+				var nm = cfb.FullPaths[i];
+				if (!nm || nm.length === 0) {
+					for (j = 0; j < 17; ++j) o.write_shift(4, 0);
+					for (j = 0; j < 3; ++j) o.write_shift(4, -1);
+					for (j = 0; j < 12; ++j) o.write_shift(4, 0);
+					continue;
+				}
+				file = cfb.FileIndex[i];
+				if (i === 0) file.start = file.size ? file.start - 1 : ENDOFCHAIN;
+				var _nm = i === 0 && _opts.root || file.name;
+				if (_nm.length > 32) {
+					console.error("Name " + _nm + " will be truncated to " + _nm.slice(0, 32));
+					_nm = _nm.slice(0, 32);
+				}
+				flen = 2 * (_nm.length + 1);
+				o.write_shift(64, _nm, "utf16le");
+				o.write_shift(2, flen);
+				o.write_shift(1, file.type);
+				o.write_shift(1, file.color);
+				o.write_shift(-4, file.L);
+				o.write_shift(-4, file.R);
+				o.write_shift(-4, file.C);
+				if (!file.clsid) for (j = 0; j < 4; ++j) o.write_shift(4, 0);
+				else o.write_shift(16, file.clsid, "hex");
+				o.write_shift(4, file.state || 0);
+				o.write_shift(4, 0);
+				o.write_shift(4, 0);
+				o.write_shift(4, 0);
+				o.write_shift(4, 0);
+				o.write_shift(4, file.start);
+				o.write_shift(4, file.size);
+				o.write_shift(4, 0);
+			}
+			for (i = 1; i < cfb.FileIndex.length; ++i) {
+				file = cfb.FileIndex[i];
+				if (file.size >= 4096) {
+					o.l = file.start + 1 << 9;
+					if (has_buf && Buffer.isBuffer(file.content)) {
+						file.content.copy(o, o.l, 0, file.size);
+						o.l += file.size + 511 & -512;
+					} else {
+						for (j = 0; j < file.size; ++j) o.write_shift(1, file.content[j]);
+						for (; j & 511; ++j) o.write_shift(1, 0);
+					}
+				}
+			}
+			for (i = 1; i < cfb.FileIndex.length; ++i) {
+				file = cfb.FileIndex[i];
+				if (file.size > 0 && file.size < 4096) {
+					if (has_buf && Buffer.isBuffer(file.content)) {
+						file.content.copy(o, o.l, 0, file.size);
+						o.l += file.size + 63 & -64;
+					} else {
+						for (j = 0; j < file.size; ++j) o.write_shift(1, file.content[j]);
+						for (; j & 63; ++j) o.write_shift(1, 0);
+					}
+				}
+			}
+			if (has_buf) o.l = o.length;
+			else while (o.l < o.length) o.write_shift(1, 0);
+			return o;
+		}
+		function find(cfb, path) {
+			var UCFullPaths = cfb.FullPaths.map(function(x) {
+				return x.toUpperCase();
+			});
+			var UCPaths = UCFullPaths.map(function(x) {
+				var y = x.split("/");
+				return y[y.length - (x.slice(-1) == "/" ? 2 : 1)];
+			});
+			var k = false;
+			if (path.charCodeAt(0) === 47) {
+				k = true;
+				path = UCFullPaths[0].slice(0, -1) + path;
+			} else k = path.indexOf("/") !== -1;
+			var UCPath = path.toUpperCase();
+			var w = k === true ? UCFullPaths.indexOf(UCPath) : UCPaths.indexOf(UCPath);
+			if (w !== -1) return cfb.FileIndex[w];
+			var m = !UCPath.match(chr1);
+			UCPath = UCPath.replace(chr0, "");
+			if (m) UCPath = UCPath.replace(chr1, "!");
+			for (w = 0; w < UCFullPaths.length; ++w) {
+				if ((m ? UCFullPaths[w].replace(chr1, "!") : UCFullPaths[w]).replace(chr0, "") == UCPath) return cfb.FileIndex[w];
+				if ((m ? UCPaths[w].replace(chr1, "!") : UCPaths[w]).replace(chr0, "") == UCPath) return cfb.FileIndex[w];
+			}
+			return null;
+		}
+		/** CFB Constants */
+		var MSSZ = 64;
+		var ENDOFCHAIN = -2;
+		var HEADER_SIGNATURE = "d0cf11e0a1b11ae1";
+		var HEADER_SIG = [
+			208,
+			207,
+			17,
+			224,
+			161,
+			177,
+			26,
+			225
+		];
+		var HEADER_CLSID = "00000000000000000000000000000000";
+		var consts = {
+			MAXREGSECT: -6,
+			DIFSECT: -4,
+			FATSECT: -3,
+			ENDOFCHAIN,
+			FREESECT: -1,
+			HEADER_SIGNATURE,
+			HEADER_MINOR_VERSION: "3e00",
+			MAXREGSID: -6,
+			NOSTREAM: -1,
+			HEADER_CLSID,
+			EntryTypes: [
+				"unknown",
+				"storage",
+				"stream",
+				"lockbytes",
+				"property",
+				"root"
+			]
+		};
+		function write_file(cfb, filename, options) {
+			get_fs();
+			var o = _write(cfb, options);
+			fs.writeFileSync(filename, o);
+		}
+		function a2s(o) {
+			var out = new Array(o.length);
+			for (var i = 0; i < o.length; ++i) out[i] = String.fromCharCode(o[i]);
+			return out.join("");
+		}
+		function write(cfb, options) {
+			var o = _write(cfb, options);
+			switch (options && options.type || "buffer") {
+				case "file":
+					get_fs();
+					fs.writeFileSync(options.filename, o);
+					return o;
+				case "binary": return typeof o == "string" ? o : a2s(o);
+				case "base64": return Base64_encode(typeof o == "string" ? o : a2s(o));
+				case "buffer": if (has_buf) return Buffer.isBuffer(o) ? o : Buffer_from(o);
+				case "array": return typeof o == "string" ? s2a(o) : o;
+			}
+			return o;
+		}
+		var _zlib;
+		function use_zlib(zlib) {
+			try {
+				var InflateRaw = zlib.InflateRaw;
+				var InflRaw = new InflateRaw();
+				InflRaw._processChunk(new Uint8Array([3, 0]), InflRaw._finishFlushFlag);
+				if (InflRaw.bytesRead) _zlib = zlib;
+				else throw new Error("zlib does not expose bytesRead");
+			} catch (e) {
+				console.error("cannot use native zlib: " + (e.message || e));
+			}
+		}
+		function _inflateRawSync(payload, usz) {
+			if (!_zlib) return _inflate(payload, usz);
+			var InflateRaw = _zlib.InflateRaw;
+			var InflRaw = new InflateRaw();
+			var out = InflRaw._processChunk(payload.slice(payload.l), InflRaw._finishFlushFlag);
+			payload.l += InflRaw.bytesRead;
+			return out;
+		}
+		function _deflateRawSync(payload) {
+			return _zlib ? _zlib.deflateRawSync(payload) : _deflate(payload);
+		}
+		var CLEN_ORDER = [
+			16,
+			17,
+			18,
+			0,
+			8,
+			7,
+			9,
+			6,
+			10,
+			5,
+			11,
+			4,
+			12,
+			3,
+			13,
+			2,
+			14,
+			1,
+			15
+		];
+		var LEN_LN = [
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10,
+			11,
+			13,
+			15,
+			17,
+			19,
+			23,
+			27,
+			31,
+			35,
+			43,
+			51,
+			59,
+			67,
+			83,
+			99,
+			115,
+			131,
+			163,
+			195,
+			227,
+			258
+		];
+		var DST_LN = [
+			1,
+			2,
+			3,
+			4,
+			5,
+			7,
+			9,
+			13,
+			17,
+			25,
+			33,
+			49,
+			65,
+			97,
+			129,
+			193,
+			257,
+			385,
+			513,
+			769,
+			1025,
+			1537,
+			2049,
+			3073,
+			4097,
+			6145,
+			8193,
+			12289,
+			16385,
+			24577
+		];
+		function bit_swap_8(n) {
+			var t = (n << 1 | n << 11) & 139536 | (n << 5 | n << 15) & 558144;
+			return (t >> 16 | t >> 8 | t) & 255;
+		}
+		var use_typed_arrays = typeof Uint8Array !== "undefined";
+		var bitswap8 = use_typed_arrays ? /* @__PURE__ */ new Uint8Array(256) : [];
+		for (var q = 0; q < 256; ++q) bitswap8[q] = bit_swap_8(q);
+		function bit_swap_n(n, b) {
+			var rev = bitswap8[n & 255];
+			if (b <= 8) return rev >>> 8 - b;
+			rev = rev << 8 | bitswap8[n >> 8 & 255];
+			if (b <= 16) return rev >>> 16 - b;
+			rev = rev << 8 | bitswap8[n >> 16 & 255];
+			return rev >>> 24 - b;
+		}
+		function read_bits_2(buf, bl) {
+			var w = bl & 7, h = bl >>> 3;
+			return (buf[h] | (w <= 6 ? 0 : buf[h + 1] << 8)) >>> w & 3;
+		}
+		function read_bits_3(buf, bl) {
+			var w = bl & 7, h = bl >>> 3;
+			return (buf[h] | (w <= 5 ? 0 : buf[h + 1] << 8)) >>> w & 7;
+		}
+		function read_bits_4(buf, bl) {
+			var w = bl & 7, h = bl >>> 3;
+			return (buf[h] | (w <= 4 ? 0 : buf[h + 1] << 8)) >>> w & 15;
+		}
+		function read_bits_5(buf, bl) {
+			var w = bl & 7, h = bl >>> 3;
+			return (buf[h] | (w <= 3 ? 0 : buf[h + 1] << 8)) >>> w & 31;
+		}
+		function read_bits_7(buf, bl) {
+			var w = bl & 7, h = bl >>> 3;
+			return (buf[h] | (w <= 1 ? 0 : buf[h + 1] << 8)) >>> w & 127;
+		}
+		function read_bits_n(buf, bl, n) {
+			var w = bl & 7, h = bl >>> 3, f = (1 << n) - 1;
+			var v = buf[h] >>> w;
+			if (n < 8 - w) return v & f;
+			v |= buf[h + 1] << 8 - w;
+			if (n < 16 - w) return v & f;
+			v |= buf[h + 2] << 16 - w;
+			if (n < 24 - w) return v & f;
+			v |= buf[h + 3] << 24 - w;
+			return v & f;
+		}
+		function write_bits_3(buf, bl, v) {
+			var w = bl & 7, h = bl >>> 3;
+			if (w <= 5) buf[h] |= (v & 7) << w;
+			else {
+				buf[h] |= v << w & 255;
+				buf[h + 1] = (v & 7) >> 8 - w;
+			}
+			return bl + 3;
+		}
+		function write_bits_1(buf, bl, v) {
+			var w = bl & 7, h = bl >>> 3;
+			v = (v & 1) << w;
+			buf[h] |= v;
+			return bl + 1;
+		}
+		function write_bits_8(buf, bl, v) {
+			var w = bl & 7, h = bl >>> 3;
+			v <<= w;
+			buf[h] |= v & 255;
+			v >>>= 8;
+			buf[h + 1] = v;
+			return bl + 8;
+		}
+		function write_bits_16(buf, bl, v) {
+			var w = bl & 7, h = bl >>> 3;
+			v <<= w;
+			buf[h] |= v & 255;
+			v >>>= 8;
+			buf[h + 1] = v & 255;
+			buf[h + 2] = v >>> 8;
+			return bl + 16;
+		}
+		function realloc(b, sz) {
+			var L = b.length, M = 2 * L > sz ? 2 * L : sz + 5, i = 0;
+			if (L >= sz) return b;
+			if (has_buf) {
+				var o = new_unsafe_buf(M);
+				if (b.copy) b.copy(o);
+				else for (; i < b.length; ++i) o[i] = b[i];
+				return o;
+			} else if (use_typed_arrays) {
+				var a = new Uint8Array(M);
+				if (a.set) a.set(b);
+				else for (; i < L; ++i) a[i] = b[i];
+				return a;
+			}
+			b.length = M;
+			return b;
+		}
+		function zero_fill_array(n) {
+			var o = new Array(n);
+			for (var i = 0; i < n; ++i) o[i] = 0;
+			return o;
+		}
+		function build_tree(clens, cmap, MAX) {
+			var maxlen = 1, w = 0, i = 0, j = 0, ccode = 0, L = clens.length;
+			var bl_count = use_typed_arrays ? /* @__PURE__ */ new Uint16Array(32) : zero_fill_array(32);
+			for (i = 0; i < 32; ++i) bl_count[i] = 0;
+			for (i = L; i < MAX; ++i) clens[i] = 0;
+			L = clens.length;
+			var ctree = use_typed_arrays ? new Uint16Array(L) : zero_fill_array(L);
+			for (i = 0; i < L; ++i) {
+				bl_count[w = clens[i]]++;
+				if (maxlen < w) maxlen = w;
+				ctree[i] = 0;
+			}
+			bl_count[0] = 0;
+			for (i = 1; i <= maxlen; ++i) bl_count[i + 16] = ccode = ccode + bl_count[i - 1] << 1;
+			for (i = 0; i < L; ++i) {
+				ccode = clens[i];
+				if (ccode != 0) ctree[i] = bl_count[ccode + 16]++;
+			}
+			var cleni = 0;
+			for (i = 0; i < L; ++i) {
+				cleni = clens[i];
+				if (cleni != 0) {
+					ccode = bit_swap_n(ctree[i], maxlen) >> maxlen - cleni;
+					for (j = (1 << maxlen + 4 - cleni) - 1; j >= 0; --j) cmap[ccode | j << cleni] = cleni & 15 | i << 4;
+				}
+			}
+			return maxlen;
+		}
+		var fix_lmap = use_typed_arrays ? /* @__PURE__ */ new Uint16Array(512) : zero_fill_array(512);
+		var fix_dmap = use_typed_arrays ? /* @__PURE__ */ new Uint16Array(32) : zero_fill_array(32);
+		if (!use_typed_arrays) {
+			for (var i = 0; i < 512; ++i) fix_lmap[i] = 0;
+			for (i = 0; i < 32; ++i) fix_dmap[i] = 0;
+		}
+		(function() {
+			var dlens = [];
+			var i = 0;
+			for (; i < 32; i++) dlens.push(5);
+			build_tree(dlens, fix_dmap, 32);
+			var clens = [];
+			i = 0;
+			for (; i <= 143; i++) clens.push(8);
+			for (; i <= 255; i++) clens.push(9);
+			for (; i <= 279; i++) clens.push(7);
+			for (; i <= 287; i++) clens.push(8);
+			build_tree(clens, fix_lmap, 288);
+		})();
+		var _deflateRaw = (function _deflateRawIIFE() {
+			var DST_LN_RE = use_typed_arrays ? /* @__PURE__ */ new Uint8Array(32768) : [];
+			var j = 0, k = 0;
+			for (; j < DST_LN.length - 1; ++j) for (; k < DST_LN[j + 1]; ++k) DST_LN_RE[k] = j;
+			for (; k < 32768; ++k) DST_LN_RE[k] = 29;
+			var LEN_LN_RE = use_typed_arrays ? /* @__PURE__ */ new Uint8Array(259) : [];
+			for (j = 0, k = 0; j < LEN_LN.length - 1; ++j) for (; k < LEN_LN[j + 1]; ++k) LEN_LN_RE[k] = j;
+			function write_stored(data, out) {
+				var boff = 0;
+				while (boff < data.length) {
+					var L = Math.min(65535, data.length - boff);
+					var h = boff + L == data.length;
+					out.write_shift(1, +h);
+					out.write_shift(2, L);
+					out.write_shift(2, ~L & 65535);
+					while (L-- > 0) out[out.l++] = data[boff++];
+				}
+				return out.l;
+			}
+			function write_huff_fixed(data, out) {
+				var bl = 0;
+				var boff = 0;
+				var addrs = use_typed_arrays ? /* @__PURE__ */ new Uint16Array(32768) : [];
+				while (boff < data.length) {
+					var L = Math.min(65535, data.length - boff);
+					if (L < 10) {
+						bl = write_bits_3(out, bl, +!!(boff + L == data.length));
+						if (bl & 7) bl += 8 - (bl & 7);
+						out.l = bl / 8 | 0;
+						out.write_shift(2, L);
+						out.write_shift(2, ~L & 65535);
+						while (L-- > 0) out[out.l++] = data[boff++];
+						bl = out.l * 8;
+						continue;
+					}
+					bl = write_bits_3(out, bl, +!!(boff + L == data.length) + 2);
+					var hash = 0;
+					while (L-- > 0) {
+						var d = data[boff];
+						hash = (hash << 5 ^ d) & 32767;
+						var match = -1, mlen = 0;
+						if (match = addrs[hash]) {
+							match |= boff & -32768;
+							if (match > boff) match -= 32768;
+							if (match < boff) while (data[match + mlen] == data[boff + mlen] && mlen < 250) ++mlen;
+						}
+						if (mlen > 2) {
+							d = LEN_LN_RE[mlen];
+							if (d <= 22) bl = write_bits_8(out, bl, bitswap8[d + 1] >> 1) - 1;
+							else {
+								write_bits_8(out, bl, 3);
+								bl += 5;
+								write_bits_8(out, bl, bitswap8[d - 23] >> 5);
+								bl += 3;
+							}
+							var len_eb = d < 8 ? 0 : d - 4 >> 2;
+							if (len_eb > 0) {
+								write_bits_16(out, bl, mlen - LEN_LN[d]);
+								bl += len_eb;
+							}
+							d = DST_LN_RE[boff - match];
+							bl = write_bits_8(out, bl, bitswap8[d] >> 3);
+							bl -= 3;
+							var dst_eb = d < 4 ? 0 : d - 2 >> 1;
+							if (dst_eb > 0) {
+								write_bits_16(out, bl, boff - match - DST_LN[d]);
+								bl += dst_eb;
+							}
+							for (var q = 0; q < mlen; ++q) {
+								addrs[hash] = boff & 32767;
+								hash = (hash << 5 ^ data[boff]) & 32767;
+								++boff;
+							}
+							L -= mlen - 1;
+						} else {
+							if (d <= 143) d = d + 48;
+							else bl = write_bits_1(out, bl, 1);
+							bl = write_bits_8(out, bl, bitswap8[d]);
+							addrs[hash] = boff & 32767;
+							++boff;
+						}
+					}
+					bl = write_bits_8(out, bl, 0) - 1;
+				}
+				out.l = (bl + 7) / 8 | 0;
+				return out.l;
+			}
+			return function _deflateRaw(data, out) {
+				if (data.length < 8) return write_stored(data, out);
+				return write_huff_fixed(data, out);
+			};
+		})();
+		function _deflate(data) {
+			var buf = new_buf(50 + Math.floor(data.length * 1.1));
+			var off = _deflateRaw(data, buf);
+			return buf.slice(0, off);
+		}
+		var dyn_lmap = use_typed_arrays ? /* @__PURE__ */ new Uint16Array(32768) : zero_fill_array(32768);
+		var dyn_dmap = use_typed_arrays ? /* @__PURE__ */ new Uint16Array(32768) : zero_fill_array(32768);
+		var dyn_cmap = use_typed_arrays ? /* @__PURE__ */ new Uint16Array(128) : zero_fill_array(128);
+		var dyn_len_1 = 1, dyn_len_2 = 1;
+		function dyn(data, boff) {
+			var _HLIT = read_bits_5(data, boff) + 257;
+			boff += 5;
+			var _HDIST = read_bits_5(data, boff) + 1;
+			boff += 5;
+			var _HCLEN = read_bits_4(data, boff) + 4;
+			boff += 4;
+			var w = 0;
+			var clens = use_typed_arrays ? /* @__PURE__ */ new Uint8Array(19) : zero_fill_array(19);
+			var ctree = [
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			];
+			var maxlen = 1;
+			var bl_count = use_typed_arrays ? /* @__PURE__ */ new Uint8Array(8) : zero_fill_array(8);
+			var next_code = use_typed_arrays ? /* @__PURE__ */ new Uint8Array(8) : zero_fill_array(8);
+			var L = clens.length;
+			for (var i = 0; i < _HCLEN; ++i) {
+				clens[CLEN_ORDER[i]] = w = read_bits_3(data, boff);
+				if (maxlen < w) maxlen = w;
+				bl_count[w]++;
+				boff += 3;
+			}
+			var ccode = 0;
+			bl_count[0] = 0;
+			for (i = 1; i <= maxlen; ++i) next_code[i] = ccode = ccode + bl_count[i - 1] << 1;
+			for (i = 0; i < L; ++i) if ((ccode = clens[i]) != 0) ctree[i] = next_code[ccode]++;
+			var cleni = 0;
+			for (i = 0; i < L; ++i) {
+				cleni = clens[i];
+				if (cleni != 0) {
+					ccode = bitswap8[ctree[i]] >> 8 - cleni;
+					for (var j = (1 << 7 - cleni) - 1; j >= 0; --j) dyn_cmap[ccode | j << cleni] = cleni & 7 | i << 3;
+				}
+			}
+			var hcodes = [];
+			maxlen = 1;
+			for (; hcodes.length < _HLIT + _HDIST;) {
+				ccode = dyn_cmap[read_bits_7(data, boff)];
+				boff += ccode & 7;
+				switch (ccode >>>= 3) {
+					case 16:
+						w = 3 + read_bits_2(data, boff);
+						boff += 2;
+						ccode = hcodes[hcodes.length - 1];
+						while (w-- > 0) hcodes.push(ccode);
+						break;
+					case 17:
+						w = 3 + read_bits_3(data, boff);
+						boff += 3;
+						while (w-- > 0) hcodes.push(0);
+						break;
+					case 18:
+						w = 11 + read_bits_7(data, boff);
+						boff += 7;
+						while (w-- > 0) hcodes.push(0);
+						break;
+					default:
+						hcodes.push(ccode);
+						if (maxlen < ccode) maxlen = ccode;
+				}
+			}
+			var h1 = hcodes.slice(0, _HLIT), h2 = hcodes.slice(_HLIT);
+			for (i = _HLIT; i < 286; ++i) h1[i] = 0;
+			for (i = _HDIST; i < 30; ++i) h2[i] = 0;
+			dyn_len_1 = build_tree(h1, dyn_lmap, 286);
+			dyn_len_2 = build_tree(h2, dyn_dmap, 30);
+			return boff;
+		}
+		function inflate(data, usz) {
+			if (data[0] == 3 && !(data[1] & 3)) return [new_raw_buf(usz), 2];
+			var boff = 0;
+			var header = 0;
+			var outbuf = new_unsafe_buf(usz ? usz : 1 << 18);
+			var woff = 0;
+			var OL = outbuf.length >>> 0;
+			var max_len_1 = 0, max_len_2 = 0;
+			while ((header & 1) == 0) {
+				header = read_bits_3(data, boff);
+				boff += 3;
+				if (header >>> 1 == 0) {
+					if (boff & 7) boff += 8 - (boff & 7);
+					var sz = data[boff >>> 3] | data[(boff >>> 3) + 1] << 8;
+					boff += 32;
+					if (sz > 0) {
+						if (!usz && OL < woff + sz) {
+							outbuf = realloc(outbuf, woff + sz);
+							OL = outbuf.length;
+						}
+						while (sz-- > 0) {
+							outbuf[woff++] = data[boff >>> 3];
+							boff += 8;
+						}
+					}
+					continue;
+				} else if (header >> 1 == 1) {
+					max_len_1 = 9;
+					max_len_2 = 5;
+				} else {
+					boff = dyn(data, boff);
+					max_len_1 = dyn_len_1;
+					max_len_2 = dyn_len_2;
+				}
+				for (;;) {
+					if (!usz && OL < woff + 32767) {
+						outbuf = realloc(outbuf, woff + 32767);
+						OL = outbuf.length;
+					}
+					var bits = read_bits_n(data, boff, max_len_1);
+					var code = header >>> 1 == 1 ? fix_lmap[bits] : dyn_lmap[bits];
+					boff += code & 15;
+					code >>>= 4;
+					if ((code >>> 8 & 255) === 0) outbuf[woff++] = code;
+					else if (code == 256) break;
+					else {
+						code -= 257;
+						var len_eb = code < 8 ? 0 : code - 4 >> 2;
+						if (len_eb > 5) len_eb = 0;
+						var tgt = woff + LEN_LN[code];
+						if (len_eb > 0) {
+							tgt += read_bits_n(data, boff, len_eb);
+							boff += len_eb;
+						}
+						bits = read_bits_n(data, boff, max_len_2);
+						code = header >>> 1 == 1 ? fix_dmap[bits] : dyn_dmap[bits];
+						boff += code & 15;
+						code >>>= 4;
+						var dst_eb = code < 4 ? 0 : code - 2 >> 1;
+						var dst = DST_LN[code];
+						if (dst_eb > 0) {
+							dst += read_bits_n(data, boff, dst_eb);
+							boff += dst_eb;
+						}
+						if (!usz && OL < tgt) {
+							outbuf = realloc(outbuf, tgt + 100);
+							OL = outbuf.length;
+						}
+						while (woff < tgt) {
+							outbuf[woff] = outbuf[woff - dst];
+							++woff;
+						}
+					}
+				}
+			}
+			if (usz) return [outbuf, boff + 7 >>> 3];
+			return [outbuf.slice(0, woff), boff + 7 >>> 3];
+		}
+		function _inflate(payload, usz) {
+			var out = inflate(payload.slice(payload.l || 0), usz);
+			payload.l += out[1];
+			return out[0];
+		}
+		function warn_or_throw(wrn, msg) {
+			if (wrn) {
+				if (typeof console !== "undefined") console.error(msg);
+			} else throw new Error(msg);
+		}
+		function parse_zip(file, options) {
+			var blob = file;
+			prep_blob(blob, 0);
+			var o = {
+				FileIndex: [],
+				FullPaths: []
+			};
+			init_cfb(o, { root: options.root });
+			var i = blob.length - 4;
+			while ((blob[i] != 80 || blob[i + 1] != 75 || blob[i + 2] != 5 || blob[i + 3] != 6) && i >= 0) --i;
+			blob.l = i + 4;
+			blob.l += 4;
+			var fcnt = blob.read_shift(2);
+			blob.l += 6;
+			blob.l = blob.read_shift(4);
+			for (i = 0; i < fcnt; ++i) {
+				blob.l += 20;
+				var csz = blob.read_shift(4);
+				var usz = blob.read_shift(4);
+				var namelen = blob.read_shift(2);
+				var efsz = blob.read_shift(2);
+				var fcsz = blob.read_shift(2);
+				blob.l += 8;
+				var offset = blob.read_shift(4);
+				var EF = parse_extra_field(blob.slice(blob.l + namelen, blob.l + namelen + efsz));
+				blob.l += namelen + efsz + fcsz;
+				var L = blob.l;
+				blob.l = offset + 4;
+				parse_local_file(blob, csz, usz, o, EF);
+				blob.l = L;
+			}
+			return o;
+		}
+		function parse_local_file(blob, csz, usz, o, EF) {
+			blob.l += 2;
+			var flags = blob.read_shift(2);
+			var meth = blob.read_shift(2);
+			var date = parse_dos_date(blob);
+			if (flags & 8257) throw new Error("Unsupported ZIP encryption");
+			var crc32 = blob.read_shift(4);
+			var _csz = blob.read_shift(4);
+			var _usz = blob.read_shift(4);
+			var namelen = blob.read_shift(2);
+			var efsz = blob.read_shift(2);
+			var name = "";
+			for (var i = 0; i < namelen; ++i) name += String.fromCharCode(blob[blob.l++]);
+			if (efsz) {
+				var ef = parse_extra_field(blob.slice(blob.l, blob.l + efsz));
+				if ((ef[21589] || {}).mt) date = ef[21589].mt;
+				if (((EF || {})[21589] || {}).mt) date = EF[21589].mt;
+			}
+			blob.l += efsz;
+			var data = blob.slice(blob.l, blob.l + _csz);
+			switch (meth) {
+				case 8:
+					data = _inflateRawSync(blob, _usz);
+					break;
+				case 0: break;
+				default: throw new Error("Unsupported ZIP Compression method " + meth);
+			}
+			var wrn = false;
+			if (flags & 8) {
+				crc32 = blob.read_shift(4);
+				if (crc32 == 134695760) {
+					crc32 = blob.read_shift(4);
+					wrn = true;
+				}
+				_csz = blob.read_shift(4);
+				_usz = blob.read_shift(4);
+			}
+			if (_csz != csz) warn_or_throw(wrn, "Bad compressed size: " + csz + " != " + _csz);
+			if (_usz != usz) warn_or_throw(wrn, "Bad uncompressed size: " + usz + " != " + _usz);
+			var _crc32 = CRC32.buf(data, 0);
+			if (crc32 >> 0 != _crc32 >> 0) warn_or_throw(wrn, "Bad CRC32 checksum: " + crc32 + " != " + _crc32);
+			cfb_add(o, name, data, {
+				unsafe: true,
+				mt: date
+			});
+		}
+		function write_zip(cfb, options) {
+			var _opts = options || {};
+			var out = [], cdirs = [];
+			var o = new_buf(1);
+			var method = _opts.compression ? 8 : 0, flags = 0;
+			var i = 0, j = 0;
+			var start_cd = 0, fcnt = 0;
+			var root = cfb.FullPaths[0], fp = root, fi = cfb.FileIndex[0];
+			var crcs = [];
+			var sz_cd = 0;
+			for (i = 1; i < cfb.FullPaths.length; ++i) {
+				fp = cfb.FullPaths[i].slice(root.length);
+				fi = cfb.FileIndex[i];
+				if (!fi.size || !fi.content || fp == "
Sh33tJ5") continue;
+				var start = start_cd;
+				var namebuf = new_buf(fp.length);
+				for (j = 0; j < fp.length; ++j) namebuf.write_shift(1, fp.charCodeAt(j) & 127);
+				namebuf = namebuf.slice(0, namebuf.l);
+				crcs[fcnt] = CRC32.buf(fi.content, 0);
+				var outbuf = fi.content;
+				if (method == 8) outbuf = _deflateRawSync(outbuf);
+				o = new_buf(30);
+				o.write_shift(4, 67324752);
+				o.write_shift(2, 20);
+				o.write_shift(2, flags);
+				o.write_shift(2, method);
+				if (fi.mt) write_dos_date(o, fi.mt);
+				else o.write_shift(4, 0);
+				o.write_shift(-4, flags & 8 ? 0 : crcs[fcnt]);
+				o.write_shift(4, flags & 8 ? 0 : outbuf.length);
+				o.write_shift(4, flags & 8 ? 0 : fi.content.length);
+				o.write_shift(2, namebuf.length);
+				o.write_shift(2, 0);
+				start_cd += o.length;
+				out.push(o);
+				start_cd += namebuf.length;
+				out.push(namebuf);
+				start_cd += outbuf.length;
+				out.push(outbuf);
+				if (flags & 8) {
+					o = new_buf(12);
+					o.write_shift(-4, crcs[fcnt]);
+					o.write_shift(4, outbuf.length);
+					o.write_shift(4, fi.content.length);
+					start_cd += o.l;
+					out.push(o);
+				}
+				o = new_buf(46);
+				o.write_shift(4, 33639248);
+				o.write_shift(2, 0);
+				o.write_shift(2, 20);
+				o.write_shift(2, flags);
+				o.write_shift(2, method);
+				o.write_shift(4, 0);
+				o.write_shift(-4, crcs[fcnt]);
+				o.write_shift(4, outbuf.length);
+				o.write_shift(4, fi.content.length);
+				o.write_shift(2, namebuf.length);
+				o.write_shift(2, 0);
+				o.write_shift(2, 0);
+				o.write_shift(2, 0);
+				o.write_shift(2, 0);
+				o.write_shift(4, 0);
+				o.write_shift(4, start);
+				sz_cd += o.l;
+				cdirs.push(o);
+				sz_cd += namebuf.length;
+				cdirs.push(namebuf);
+				++fcnt;
+			}
+			o = new_buf(22);
+			o.write_shift(4, 101010256);
+			o.write_shift(2, 0);
+			o.write_shift(2, 0);
+			o.write_shift(2, fcnt);
+			o.write_shift(2, fcnt);
+			o.write_shift(4, sz_cd);
+			o.write_shift(4, start_cd);
+			o.write_shift(2, 0);
+			return bconcat([
+				bconcat(out),
+				bconcat(cdirs),
+				o
+			]);
+		}
+		var ContentTypeMap = {
+			"htm": "text/html",
+			"xml": "text/xml",
+			"gif": "image/gif",
+			"jpg": "image/jpeg",
+			"png": "image/png",
+			"mso": "application/x-mso",
+			"thmx": "application/vnd.ms-officetheme",
+			"sh33tj5": "application/octet-stream"
+		};
+		function get_content_type(fi, fp) {
+			if (fi.ctype) return fi.ctype;
+			var ext = fi.name || "", m = ext.match(/\.([^\.]+)$/);
+			if (m && ContentTypeMap[m[1]]) return ContentTypeMap[m[1]];
+			if (fp) {
+				m = (ext = fp).match(/[\.\\]([^\.\\])+$/);
+				if (m && ContentTypeMap[m[1]]) return ContentTypeMap[m[1]];
+			}
+			return "application/octet-stream";
+		}
+		function write_base64_76(bstr) {
+			var data = Base64_encode(bstr);
+			var o = [];
+			for (var i = 0; i < data.length; i += 76) o.push(data.slice(i, i + 76));
+			return o.join("\r\n") + "\r\n";
+		}
+		function write_quoted_printable(text) {
+			var encoded = text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7E-\xFF=]/g, function(c) {
+				var w = c.charCodeAt(0).toString(16).toUpperCase();
+				return "=" + (w.length == 1 ? "0" + w : w);
+			});
+			encoded = encoded.replace(/ $/gm, "=20").replace(/\t$/gm, "=09");
+			if (encoded.charAt(0) == "\n") encoded = "=0D" + encoded.slice(1);
+			encoded = encoded.replace(/\r(?!\n)/gm, "=0D").replace(/\n\n/gm, "\n=0A").replace(/([^\r\n])\n/gm, "$1=0A");
+			var o = [], split = encoded.split("\r\n");
+			for (var si = 0; si < split.length; ++si) {
+				var str = split[si];
+				if (str.length == 0) {
+					o.push("");
+					continue;
+				}
+				for (var i = 0; i < str.length;) {
+					var end = 76;
+					var tmp = str.slice(i, i + end);
+					if (tmp.charAt(end - 1) == "=") end--;
+					else if (tmp.charAt(end - 2) == "=") end -= 2;
+					else if (tmp.charAt(end - 3) == "=") end -= 3;
+					tmp = str.slice(i, i + end);
+					i += end;
+					if (i < str.length) tmp += "=";
+					o.push(tmp);
+				}
+			}
+			return o.join("\r\n");
+		}
+		function parse_quoted_printable(data) {
+			var o = [];
+			for (var di = 0; di < data.length; ++di) {
+				var line = data[di];
+				while (di <= data.length && line.charAt(line.length - 1) == "=") line = line.slice(0, line.length - 1) + data[++di];
+				o.push(line);
+			}
+			for (var oi = 0; oi < o.length; ++oi) o[oi] = o[oi].replace(/[=][0-9A-Fa-f]{2}/g, function($$) {
+				return String.fromCharCode(parseInt($$.slice(1), 16));
+			});
+			return s2a(o.join("\r\n"));
+		}
+		function parse_mime(cfb, data, root) {
+			var fname = "", cte = "", ctype = "", fdata;
+			var di = 0;
+			for (; di < 10; ++di) {
+				var line = data[di];
+				if (!line || line.match(/^\s*$/)) break;
+				var m = line.match(/^(.*?):\s*([^\s].*)$/);
+				if (m) switch (m[1].toLowerCase()) {
+					case "content-location":
+						fname = m[2].trim();
+						break;
+					case "content-type":
+						ctype = m[2].trim();
+						break;
+					case "content-transfer-encoding":
+						cte = m[2].trim();
+						break;
+				}
+			}
+			++di;
+			switch (cte.toLowerCase()) {
+				case "base64":
+					fdata = s2a(Base64_decode(data.slice(di).join("")));
+					break;
+				case "quoted-printable":
+					fdata = parse_quoted_printable(data.slice(di));
+					break;
+				default: throw new Error("Unsupported Content-Transfer-Encoding " + cte);
+			}
+			var file = cfb_add(cfb, fname.slice(root.length), fdata, { unsafe: true });
+			if (ctype) file.ctype = ctype;
+		}
+		function parse_mad(file, options) {
+			if (a2s(file.slice(0, 13)).toLowerCase() != "mime-version:") throw new Error("Unsupported MAD header");
+			var root = options && options.root || "";
+			var data = (has_buf && Buffer.isBuffer(file) ? file.toString("binary") : a2s(file)).split("\r\n");
+			var di = 0, row = "";
+			for (di = 0; di < data.length; ++di) {
+				row = data[di];
+				if (!/^Content-Location:/i.test(row)) continue;
+				row = row.slice(row.indexOf("file"));
+				if (!root) root = row.slice(0, row.lastIndexOf("/") + 1);
+				if (row.slice(0, root.length) == root) continue;
+				while (root.length > 0) {
+					root = root.slice(0, root.length - 1);
+					root = root.slice(0, root.lastIndexOf("/") + 1);
+					if (row.slice(0, root.length) == root) break;
+				}
+			}
+			var mboundary = (data[1] || "").match(/boundary="(.*?)"/);
+			if (!mboundary) throw new Error("MAD cannot find boundary");
+			var boundary = "--" + (mboundary[1] || "");
+			var o = {
+				FileIndex: [],
+				FullPaths: []
+			};
+			init_cfb(o);
+			var start_di, fcnt = 0;
+			for (di = 0; di < data.length; ++di) {
+				var line = data[di];
+				if (line !== boundary && line !== boundary + "--") continue;
+				if (fcnt++) parse_mime(o, data.slice(start_di, di), root);
+				start_di = di;
+			}
+			return o;
+		}
+		function write_mad(cfb, options) {
+			var opts = options || {};
+			var boundary = opts.boundary || "SheetJS";
+			boundary = "------=" + boundary;
+			var out = [
+				"MIME-Version: 1.0",
+				"Content-Type: multipart/related; boundary=\"" + boundary.slice(2) + "\"",
+				"",
+				"",
+				""
+			];
+			var root = cfb.FullPaths[0], fp = root, fi = cfb.FileIndex[0];
+			for (var i = 1; i < cfb.FullPaths.length; ++i) {
+				fp = cfb.FullPaths[i].slice(root.length);
+				fi = cfb.FileIndex[i];
+				if (!fi.size || !fi.content || fp == "
Sh33tJ5") continue;
+				fp = fp.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7E-\xFF]/g, function(c) {
+					return "_x" + c.charCodeAt(0).toString(16) + "_";
+				}).replace(/[\u0080-\uFFFF]/g, function(u) {
+					return "_u" + u.charCodeAt(0).toString(16) + "_";
+				});
+				var ca = fi.content;
+				var cstr = has_buf && Buffer.isBuffer(ca) ? ca.toString("binary") : a2s(ca);
+				var dispcnt = 0, L = Math.min(1024, cstr.length), cc = 0;
+				for (var csl = 0; csl <= L; ++csl) if ((cc = cstr.charCodeAt(csl)) >= 32 && cc < 128) ++dispcnt;
+				var qp = dispcnt >= L * 4 / 5;
+				out.push(boundary);
+				out.push("Content-Location: " + (opts.root || "file:///C:/SheetJS/") + fp);
+				out.push("Content-Transfer-Encoding: " + (qp ? "quoted-printable" : "base64"));
+				out.push("Content-Type: " + get_content_type(fi, fp));
+				out.push("");
+				out.push(qp ? write_quoted_printable(cstr) : write_base64_76(cstr));
+			}
+			out.push(boundary + "--\r\n");
+			return out.join("\r\n");
+		}
+		function cfb_new(opts) {
+			var o = {};
+			init_cfb(o, opts);
+			return o;
+		}
+		function cfb_add(cfb, name, content, opts) {
+			var unsafe = opts && opts.unsafe;
+			if (!unsafe) init_cfb(cfb);
+			var file = !unsafe && CFB.find(cfb, name);
+			if (!file) {
+				var fpath = cfb.FullPaths[0];
+				if (name.slice(0, fpath.length) == fpath) fpath = name;
+				else {
+					if (fpath.slice(-1) != "/") fpath += "/";
+					fpath = (fpath + name).replace("//", "/");
+				}
+				file = {
+					name: filename(name),
+					type: 2
+				};
+				cfb.FileIndex.push(file);
+				cfb.FullPaths.push(fpath);
+				if (!unsafe) CFB.utils.cfb_gc(cfb);
+			}
+			file.content = content;
+			file.size = content ? content.length : 0;
+			if (opts) {
+				if (opts.CLSID) file.clsid = opts.CLSID;
+				if (opts.mt) file.mt = opts.mt;
+				if (opts.ct) file.ct = opts.ct;
+			}
+			return file;
+		}
+		function cfb_del(cfb, name) {
+			init_cfb(cfb);
+			var file = CFB.find(cfb, name);
+			if (file) {
+				for (var j = 0; j < cfb.FileIndex.length; ++j) if (cfb.FileIndex[j] == file) {
+					cfb.FileIndex.splice(j, 1);
+					cfb.FullPaths.splice(j, 1);
+					return true;
+				}
+			}
+			return false;
+		}
+		function cfb_mov(cfb, old_name, new_name) {
+			init_cfb(cfb);
+			var file = CFB.find(cfb, old_name);
+			if (file) {
+				for (var j = 0; j < cfb.FileIndex.length; ++j) if (cfb.FileIndex[j] == file) {
+					cfb.FileIndex[j].name = filename(new_name);
+					cfb.FullPaths[j] = new_name;
+					return true;
+				}
+			}
+			return false;
+		}
+		function cfb_gc(cfb) {
+			rebuild_cfb(cfb, true);
+		}
+		exports$1.find = find;
+		exports$1.read = read;
+		exports$1.parse = parse;
+		exports$1.write = write;
+		exports$1.writeFile = write_file;
+		exports$1.utils = {
+			cfb_new,
+			cfb_add,
+			cfb_del,
+			cfb_mov,
+			cfb_gc,
+			ReadShift,
+			CheckField,
+			prep_blob,
+			bconcat,
+			use_zlib,
+			_deflateRaw: _deflate,
+			_inflateRaw: _inflate,
+			consts
+		};
+		return exports$1;
+	})();
+	if (typeof __require !== "undefined" && typeof module !== "undefined" && typeof DO_NOT_EXPORT_CFB === "undefined") module.exports = CFB;
+})))(), 1);
+var ERROR_MESSAGES = Object.freeze({
+	ERR_INVALID_ARGUMENT: "Invalid argument",
+	ERR_UNSUPPORTED_EXTENSION: "Supported extensions are .xls, .xlsx, and .xlsm; input and output formats must match",
+	ERR_INVALID_XLS: "Invalid or unsupported XLS workbook",
+	ERR_INVALID_XLSX: "Invalid or unsupported OOXML workbook",
+	ERR_LIMIT_EXCEEDED: "Excel workbook exceeds a configured safety limit",
+	ERR_WORKSHEET_COUNT: "The workbook must contain exactly one worksheet",
+	ERR_SAME_PATH: "Input and output paths must be different",
+	ERR_OUTPUT_EXISTS: "The output file already exists",
+	ERR_FILE_READ: "Unable to read the input Excel file",
+	ERR_FILE_WRITE: "Unable to write the sanitized Excel file"
+});
+var ExcelSanitizationError = class extends Error {
+	name = "ExcelSanitizationError";
+	code;
+	details;
+	constructor(code, message, options = {}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.code = code;
+		if (options.details !== void 0) this.details = Object.freeze({ ...options.details });
+	}
+};
+function createError(code, options = {}) {
+	return new ExcelSanitizationError(code, options.message ?? ERROR_MESSAGES[code], options);
+}
+function limitExceeded(limit, configured, actual, partName) {
+	return createError("ERR_LIMIT_EXCEEDED", { details: {
+		limit,
+		configured,
+		actual,
+		...partName === void 0 ? {} : { partName }
+	} });
+}
+//#endregion
+//#region src/biff/workbook.ts
+var COMPOUND_FILE_SIGNATURE = Buffer.from([
+	208,
+	207,
+	17,
+	224,
+	161,
+	177,
+	26,
+	225
+]);
+var RECORD_HEADER_BYTES = 4;
+var CFB_STORAGE_ENTRY = 1;
+var CFB_STREAM_ENTRY = 2;
+var RECORD_CONTINUE = 60;
+var RECORD_BOUNDSHEET = 133;
+var RECORD_BOF_IDS = /* @__PURE__ */ new Set([
+	9,
+	521,
+	1033,
+	2057
+]);
+var OFFSET_CACHE_RECORD_IDS = /* @__PURE__ */ new Set([
+	215,
+	255,
+	523
+]);
+var DRAWING_RECORD_IDS = /* @__PURE__ */ new Set([
+	28,
+	93,
+	127,
+	233,
+	235,
+	236,
+	237,
+	438,
+	2150
+]);
+function hasCompoundFileSignature(buffer) {
+	return buffer.length >= COMPOUND_FILE_SIGNATURE.length && buffer.subarray(0, COMPOUND_FILE_SIGNATURE.length).equals(COMPOUND_FILE_SIGNATURE);
+}
+async function sanitizeBiffWorkbook(buffer, options) {
+	enforceInputSize(buffer, options);
+	const cfb = import_cfb.read(buffer, { type: "buffer" });
+	enforceContainerLimits(cfb, options);
+	const workbookEntry = import_cfb.find(cfb, "Workbook") ?? import_cfb.find(cfb, "Book");
+	if (!workbookEntry || workbookEntry.type !== CFB_STREAM_ENTRY) throw new Error("Compound file has no BIFF Workbook stream");
+	const records = parseBiffRecords(Buffer.from(workbookEntry.content));
+	rejectEncryptedWorkbook(records);
+	enforceWorksheetCount$1(records, options.requireSingleWorksheet);
+	const sanitizedStream = rebuildWorkbookStream(records);
+	workbookEntry.content = sanitizedStream;
+	workbookEntry.size = sanitizedStream.length;
+	removeEmbeddedObjectEntries(cfb);
+	return Buffer.from(import_cfb.write(cfb, {
+		type: "buffer",
+		fileType: "cfb"
+	}));
+}
+function enforceInputSize(buffer, options) {
+	const configured = options.limits.maxUncompressedBytes;
+	if (buffer.length > configured) throw limitExceeded("maxUncompressedBytes", configured, buffer.length);
+}
+function enforceContainerLimits(cfb, options) {
+	const entries = cfb.FileIndex.filter((entry) => entry.type === CFB_STORAGE_ENTRY || entry.type === CFB_STREAM_ENTRY);
+	if (entries.length > options.limits.maxEntryCount) throw limitExceeded("maxEntryCount", options.limits.maxEntryCount, entries.length);
+	const totalBytes = entries.reduce((total, entry) => entry.type === CFB_STREAM_ENTRY ? total + entry.content.length : total, 0);
+	if (totalBytes > options.limits.maxUncompressedBytes) throw limitExceeded("maxUncompressedBytes", options.limits.maxUncompressedBytes, totalBytes);
+}
+function parseBiffRecords(stream) {
+	const records = [];
+	let offset = 0;
+	let removeContinuation = false;
+	while (offset < stream.length) {
+		if (offset + RECORD_HEADER_BYTES > stream.length) throw new Error("Truncated BIFF record header");
+		const id = stream.readUInt16LE(offset);
+		const length = stream.readUInt16LE(offset + 2);
+		const nextOffset = offset + RECORD_HEADER_BYTES + length;
+		if (nextOffset > stream.length) throw new Error("Truncated BIFF record payload");
+		const remove = id === RECORD_CONTINUE ? removeContinuation : DRAWING_RECORD_IDS.has(id) || OFFSET_CACHE_RECORD_IDS.has(id);
+		records.push({
+			id,
+			originalOffset: offset,
+			payload: stream.subarray(offset + RECORD_HEADER_BYTES, nextOffset),
+			remove
+		});
+		if (id !== RECORD_CONTINUE) removeContinuation = remove;
+		offset = nextOffset;
+	}
+	if (records.length === 0 || !RECORD_BOF_IDS.has(records[0]?.id ?? -1)) throw new Error("Workbook stream does not start with a BIFF BOF record");
+	return records;
+}
+function rejectEncryptedWorkbook(records) {
+	if (records.some((record) => record.id === 47)) throw createError("ERR_INVALID_XLS", { message: "Encrypted XLS workbooks are not supported" });
+}
+function enforceWorksheetCount$1(records, required) {
+	const count = records.filter((record) => record.id === RECORD_BOUNDSHEET).length;
+	if (count === 0) throw new Error("Workbook contains no sheets");
+	if (required && count !== 1) throw createError("ERR_WORKSHEET_COUNT", { details: {
+		expected: 1,
+		actual: count
+	} });
+}
+function rebuildWorkbookStream(records) {
+	const newOffsets = /* @__PURE__ */ new Map();
+	let outputLength = 0;
+	for (const record of records) {
+		if (record.remove) continue;
+		newOffsets.set(record.originalOffset, outputLength);
+		outputLength += RECORD_HEADER_BYTES + record.payload.length;
+	}
+	const output = Buffer.allocUnsafe(outputLength);
+	let outputOffset = 0;
+	for (const record of records) {
+		if (record.remove) continue;
+		const payload = patchBoundSheetOffset(record, newOffsets);
+		output.writeUInt16LE(record.id, outputOffset);
+		output.writeUInt16LE(payload.length, outputOffset + 2);
+		payload.copy(output, outputOffset + RECORD_HEADER_BYTES);
+		outputOffset += RECORD_HEADER_BYTES + payload.length;
+	}
+	return output;
+}
+function patchBoundSheetOffset(record, newOffsets) {
+	if (record.id !== RECORD_BOUNDSHEET) return record.payload;
+	if (record.payload.length < 4) throw new Error("Invalid BoundSheet record");
+	const originalSheetOffset = record.payload.readUInt32LE(0);
+	const newSheetOffset = newOffsets.get(originalSheetOffset);
+	if (newSheetOffset === void 0) throw new Error("BoundSheet record points outside the Workbook stream");
+	const payload = Buffer.from(record.payload);
+	payload.writeUInt32LE(newSheetOffset, 0);
+	return payload;
+}
+function removeEmbeddedObjectEntries(cfb) {
+	const paths = cfb.FullPaths.filter((path) => path.split("/").filter(Boolean).some((segment) => segment.toLowerCase() === "objectpool" || segment.toLowerCase() === "ctls" || /^mbd[0-9a-f]{8}$/i.test(segment)));
+	for (let index = paths.length - 1; index >= 0; index -= 1) import_cfb.utils.cfb_del(cfb, paths[index] ?? "");
+	if (paths.length > 0) import_cfb.utils.cfb_gc(cfb);
+}
+//#endregion
+//#region src/zip/central-directory.ts
+var END_RECORD_MINIMUM_SIZE = 22;
+var CENTRAL_DIRECTORY_ENTRY_MINIMUM_SIZE = 46;
+var MAX_ZIP_COMMENT_SIZE = 65535;
+var END_RECORD_SIGNATURE = 101010256;
+var CENTRAL_DIRECTORY_ENTRY_SIGNATURE = 33639248;
+var ZIP64_END_LOCATOR_SIGNATURE = 117853008;
+function hasZipSignature(buffer) {
+	return buffer.length >= 2 && buffer[0] === 80 && buffer[1] === 75;
+}
+function validateZipCentralDirectory(buffer, limits) {
+	const endRecord = readEndRecord(buffer, limits);
+	const centralDirectoryEnd = endRecord.centralDirectoryOffset + endRecord.centralDirectorySize;
+	if (endRecord.centralDirectoryOffset > endRecord.offset || centralDirectoryEnd > endRecord.offset || centralDirectoryEnd > buffer.length) throw new Error("Invalid ZIP central-directory bounds");
+	let entryOffset = endRecord.centralDirectoryOffset;
+	let totalUncompressedSize = 0;
+	for (let index = 0; index < endRecord.totalEntries; index += 1) {
+		const entry = readCentralDirectoryEntry(buffer, entryOffset, centralDirectoryEnd, endRecord.centralDirectoryOffset);
+		totalUncompressedSize += entry.uncompressedSize;
+		if (totalUncompressedSize > limits.maxUncompressedBytes) throw limitExceeded("maxUncompressedBytes", limits.maxUncompressedBytes, totalUncompressedSize);
+		entryOffset = entry.nextOffset;
+	}
+	if (entryOffset !== centralDirectoryEnd) throw new Error("ZIP central-directory entry count is inconsistent");
+}
+function readEndRecord(buffer, limits) {
+	const offset = findEndOfCentralDirectory(buffer);
+	if (offset === void 0 || offset + END_RECORD_MINIMUM_SIZE > buffer.length) throw new Error("ZIP end-of-central-directory record is missing");
+	const diskNumber = buffer.readUInt16LE(offset + 4);
+	const centralDirectoryDisk = buffer.readUInt16LE(offset + 6);
+	const entriesOnDisk = buffer.readUInt16LE(offset + 8);
+	const totalEntries = buffer.readUInt16LE(offset + 10);
+	const centralDirectorySize = buffer.readUInt32LE(offset + 12);
+	const centralDirectoryOffset = buffer.readUInt32LE(offset + 16);
+	const commentLength = buffer.readUInt16LE(offset + 20);
+	if (offset + END_RECORD_MINIMUM_SIZE + commentLength > buffer.length) throw new Error("Truncated ZIP comment");
+	if (diskNumber !== 0 || centralDirectoryDisk !== 0 || entriesOnDisk !== totalEntries) throw new Error("Multi-disk ZIP files are not supported");
+	if (totalEntries === 65535 || centralDirectorySize === 4294967295 || centralDirectoryOffset === 4294967295 || offset >= 20 && buffer.readUInt32LE(offset - 20) === ZIP64_END_LOCATOR_SIGNATURE) throw new Error("ZIP64 files are not supported");
+	if (totalEntries > limits.maxEntryCount) throw limitExceeded("maxEntryCount", limits.maxEntryCount, totalEntries);
+	return {
+		offset,
+		totalEntries,
+		centralDirectoryOffset,
+		centralDirectorySize
+	};
+}
+function readCentralDirectoryEntry(buffer, entryOffset, centralDirectoryEnd, centralDirectoryOffset) {
+	if (entryOffset + CENTRAL_DIRECTORY_ENTRY_MINIMUM_SIZE > centralDirectoryEnd || buffer.readUInt32LE(entryOffset) !== CENTRAL_DIRECTORY_ENTRY_SIGNATURE) throw new Error("Malformed ZIP central-directory entry");
+	const compressedSize = buffer.readUInt32LE(entryOffset + 20);
+	const uncompressedSize = buffer.readUInt32LE(entryOffset + 24);
+	const fileNameLength = buffer.readUInt16LE(entryOffset + 28);
+	const extraLength = buffer.readUInt16LE(entryOffset + 30);
+	const fileCommentLength = buffer.readUInt16LE(entryOffset + 32);
+	const entryDisk = buffer.readUInt16LE(entryOffset + 34);
+	const localHeaderOffset = buffer.readUInt32LE(entryOffset + 42);
+	if (compressedSize === 4294967295 || uncompressedSize === 4294967295 || localHeaderOffset === 4294967295 || entryDisk !== 0) throw new Error("ZIP64 or multi-disk entries are not supported");
+	const fileNameOffset = entryOffset + CENTRAL_DIRECTORY_ENTRY_MINIMUM_SIZE;
+	const extraOffset = fileNameOffset + fileNameLength;
+	const nextOffset = extraOffset + extraLength + fileCommentLength;
+	if (nextOffset > centralDirectoryEnd) throw new Error("Truncated ZIP central-directory entry");
+	validatePackageEntryName(buffer.subarray(fileNameOffset, extraOffset).toString("utf8"));
+	rejectZip64ExtraFields(buffer, extraOffset, extraLength);
+	if (localHeaderOffset >= centralDirectoryOffset) throw new Error("Invalid ZIP local-header offset");
+	return {
+		nextOffset,
+		uncompressedSize
+	};
+}
+function validatePackageEntryName(name) {
+	const normalized = name.replaceAll("\\", "/");
+	if (normalized.includes("\0") || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized) || normalized.split("/").includes("..")) throw new Error(`Unsafe ZIP entry name: ${name}`);
+}
+function findEndOfCentralDirectory(buffer) {
+	const minimumOffset = Math.max(0, buffer.length - MAX_ZIP_COMMENT_SIZE - END_RECORD_MINIMUM_SIZE);
+	for (let offset = buffer.length - END_RECORD_MINIMUM_SIZE; offset >= minimumOffset; offset -= 1) if (buffer.readUInt32LE(offset) === END_RECORD_SIGNATURE && offset + END_RECORD_MINIMUM_SIZE + buffer.readUInt16LE(offset + 20) === buffer.length) return offset;
+}
+function rejectZip64ExtraFields(buffer, extraOffset, extraLength) {
+	const extraEnd = extraOffset + extraLength;
+	let offset = extraOffset;
+	while (offset < extraEnd) {
+		if (offset + 4 > extraEnd) throw new Error("Malformed ZIP extra field");
+		const headerId = buffer.readUInt16LE(offset);
+		const fieldLength = buffer.readUInt16LE(offset + 2);
+		offset += 4;
+		if (offset + fieldLength > extraEnd) throw new Error("Truncated ZIP extra field");
+		if (headerId === 1) throw new Error("ZIP64 files are not supported");
+		offset += fieldLength;
+	}
+}
+//#endregion
+//#region src/ooxml/constants.ts
+var DRAWING_RELATIONSHIP_SUFFIXES = [
+	"/comments",
+	"/control",
+	"/drawing",
+	"/image",
+	"/oleObject",
+	"/threadedComment",
+	"/vmlDrawing"
+];
+var PERSON_RELATIONSHIP_SUFFIXES = ["/person"];
+var DRAWING_ELEMENTS = [
+	"controls",
+	"drawing",
+	"legacyDrawing",
+	"legacyDrawingHF",
+	"oleObjects",
+	"picture"
+];
+//#endregion
+//#region src/ooxml/cleanup.ts
+function removeWorksheetDrawingMarkup(xml) {
+	return DRAWING_ELEMENTS.reduce((result, name) => {
+		const element = new RegExp(`<(?:\\w+:)?${name}\\b[^>]*(?:\\/\\s*>|>[\\s\\S]*?<\\/(?:\\w+:)?${name}\\s*>)`, "gi");
+		return result.replace(element, "");
+	}, xml);
+}
+function removeThreadedCommentExtensions(xml) {
+	return xml.replace(/<(?:\w+:)?ext\b[^>]*>[\s\S]*?<\/(?:\w+:)?ext\s*>/gi, (extension) => /<(?:\w+:)?threadedComments?\b/i.test(extension) ? "" : extension);
+}
+//#endregion
+//#region src/ooxml/parts.ts
+function getNodeBufferStream(file) {
+	return file.internalStream("nodebuffer");
+}
+async function requireXml(zip, partName, budget, partLimitBytes) {
+	const file = zip.file(partName);
+	if (!file) throw new Error(`Required workbook part is missing: ${partName}`);
+	return readXmlPart(file, partName, budget, partLimitBytes);
+}
+function readXmlPart(file, partName, budget, partLimitBytes) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		const stream = getNodeBufferStream(file);
+		let partBytes = 0;
+		let settled = false;
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			stream.pause();
+			reject(error);
+		};
+		stream.on("data", (chunk) => {
+			if (settled) return;
+			partBytes += chunk.length;
+			budget.consumedBytes += chunk.length;
+			if (partBytes > partLimitBytes) {
+				fail(limitExceeded("partBytes", partLimitBytes, partBytes, partName));
+				return;
+			}
+			if (budget.consumedBytes > budget.limitBytes) {
+				fail(limitExceeded("maxXmlBytes", budget.limitBytes, budget.consumedBytes, partName));
+				return;
+			}
+			chunks.push(Buffer.from(chunk));
+		}).on("error", (error) => fail(error)).on("end", () => {
+			if (settled) return;
+			settled = true;
+			resolve(Buffer.concat(chunks, partBytes).toString("utf8"));
+		}).resume();
+	});
+}
+//#endregion
+//#region src/ooxml/xml.ts
+function getAttribute(xml, name) {
+	const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const value = xml.match(new RegExp(`(?:^|\\s)${escaped}\\s*=\\s*(["'])(.*?)\\1`, "i"))?.[2];
+	return value === void 0 ? void 0 : decodeXml(value);
+}
+function decodeXml(value) {
+	return value.replaceAll("&amp;", "&").replaceAll("&quot;", "\"").replaceAll("&apos;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">");
+}
+function findCollection(xml, name) {
+	const match = xml.match(new RegExp(`<(?:\\w+:)?${name}\\b[^>]*>([\\s\\S]*?)<\\/(?:\\w+:)?${name}\\s*>`, "i"));
+	if (!match) return;
+	const full = match[0];
+	if (full === void 0) return;
+	return {
+		body: match[1] ?? "",
+		full,
+		opening: full.slice(0, full.indexOf(">") + 1)
+	};
+}
+function replaceCollection(xml, name, body, count) {
+	const collection = findCollection(xml, name);
+	if (!collection) return xml;
+	const opening = /\bcount\s*=/.test(collection.opening) ? collection.opening.replace(/(\bcount\s*=\s*)(["'])\d+\2/i, `$1"${count}"`) : collection.opening.replace(/>$/, ` count="${count}">`);
+	const prefix = collection.opening.match(/^<(\w+:)/)?.[1] ?? "";
+	return xml.replace(collection.full, `${opening}${body}</${prefix}${name}>`);
+}
+function matchElements(xml, name) {
+	return xml.match(new RegExp(`<(?:\\w+:)?${name}\\b[^>]*\\/\\s*>|<(?:\\w+:)?${name}\\b[^>]*>[\\s\\S]*?<\\/(?:\\w+:)?${name}\\s*>`, "gi")) ?? [];
+}
+//#endregion
+//#region src/ooxml/relationships.ts
+function removeRelationships(xml, source, relationshipSuffixes) {
+	const targets = /* @__PURE__ */ new Set();
+	return {
+		xml: xml.replace(/<(?:\w+:)?Relationship\b[^>]*?(?:\/\s*>|>\s*<\/(?:\w+:)?Relationship\s*>)/gi, (tag) => {
+			const type = getAttribute(tag, "Type") ?? "";
+			const target = getAttribute(tag, "Target");
+			const targetMode = getAttribute(tag, "TargetMode");
+			if (!target || targetMode?.toLowerCase() === "external" || !relationshipSuffixes.some((suffix) => type.endsWith(suffix))) return tag;
+			targets.add(resolveTarget(source, target));
+			return "";
+		}),
+		targets
+	};
+}
+function parseRelationships(xml, source) {
+	return Array.from(xml.matchAll(/<(?:\w+:)?Relationship\b([^>]*?)(?:\/\s*>|>\s*<\/(?:\w+:)?Relationship\s*>)/gi)).flatMap((match) => {
+		const attributes = match[1] ?? "";
+		const id = getAttribute(attributes, "Id");
+		const target = getAttribute(attributes, "Target");
+		const type = getAttribute(attributes, "Type");
+		if (!id || !target || !type) return [];
+		const targetMode = getAttribute(attributes, "TargetMode");
+		return [{
+			id,
+			target: targetMode?.toLowerCase() === "external" ? target : resolveTarget(source, target),
+			targetMode,
+			type
+		}];
+	});
+}
+function resolveTarget(source, target) {
+	const resolved = target.startsWith("/") ? posix.normalize(target.slice(1)) : posix.normalize(posix.join(posix.dirname(source), target));
+	if (resolved === ".." || resolved.startsWith("../")) throw new Error(`Relationship target escapes package: ${target}`);
+	return resolved;
+}
+function relationshipFileForPart(partName) {
+	return posix.join(posix.dirname(partName), "_rels", `${posix.basename(partName)}.rels`);
+}
+function sourcePartForRelationshipFile(fileName) {
+	if (fileName === "_rels/.rels") return "";
+	const match = fileName.match(/^(.*\/)_rels\/([^/]+)\.rels$/);
+	return match ? `${match[1]}${match[2]}` : void 0;
+}
+async function removeUnreachableParts(zip, detachedRoots, readBudget, limits) {
+	if (detachedRoots.size === 0) return;
+	const graph = await buildRelationshipGraph(zip, readBudget, limits);
+	const candidates = collectReachableParts(detachedRoots, graph);
+	const packageReachable = collectReachableParts(/* @__PURE__ */ new Set([""]), graph);
+	packageReachable.delete("");
+	const deletedParts = new Set([...candidates].filter((partName) => !packageReachable.has(partName)));
+	for (const partName of deletedParts) {
+		zip.remove(partName);
+		zip.remove(relationshipFileForPart(partName));
+	}
+	const contentTypes = await requireXml(zip, "[Content_Types].xml", readBudget, limits.maxMetadataXmlBytes);
+	zip.file("[Content_Types].xml", contentTypes.replace(/<(?:\w+:)?Override\b[^>]*\/>/gi, (tag) => {
+		const partName = getAttribute(tag, "PartName")?.replace(/^\//, "");
+		return partName && deletedParts.has(partName) ? "" : tag;
+	}));
+}
+async function buildRelationshipGraph(zip, readBudget, limits) {
+	const graph = /* @__PURE__ */ new Map();
+	for (const fileName of Object.keys(zip.files)) {
+		if (!fileName.endsWith(".rels")) continue;
+		const source = sourcePartForRelationshipFile(fileName);
+		const file = zip.file(fileName);
+		if (source !== void 0 && file) graph.set(source, parseRelationships(await readXmlPart(file, fileName, readBudget, limits.maxRelationshipsXmlBytes), source));
+	}
+	return graph;
+}
+function collectReachableParts(initial, graph) {
+	const reachable = new Set(initial);
+	const pending = [...initial];
+	while (pending.length > 0) {
+		const source = pending.pop();
+		if (source === void 0) continue;
+		for (const relationship of graph.get(source) ?? []) if (relationship.targetMode?.toLowerCase() !== "external" && !reachable.has(relationship.target)) {
+			reachable.add(relationship.target);
+			pending.push(relationship.target);
+		}
+	}
+	return reachable;
+}
+//#endregion
+//#region src/ooxml/styles.ts
+async function removeUnusedCellStyles(zip, worksheets, readBudget, limits) {
+	const stylesFile = zip.file("xl/styles.xml");
+	if (!stylesFile) return;
+	const usedStyles = /* @__PURE__ */ new Set([0]);
+	for (const xml of worksheets.values()) collectStyleReferences(xml, usedStyles);
+	const stylesXml = await readXmlPart(stylesFile, "xl/styles.xml", readBudget, limits.maxStylesXmlBytes);
+	const cellXfs = findCollection(stylesXml, "cellXfs");
+	if (!cellXfs) return;
+	const xfs = matchElements(cellXfs.body, "xf");
+	const retainedIndexes = [...usedStyles].sort((left, right) => left - right);
+	validateStyleIndexes(retainedIndexes, xfs.length);
+	const indexMap = new Map(retainedIndexes.map((oldIndex, newIndex) => [oldIndex, newIndex]));
+	const retainedStyles = retainedIndexes.map((index) => {
+		const style = xfs[index];
+		if (style === void 0) throw new Error(`Worksheet references an invalid style index: ${index}`);
+		return style;
+	});
+	zip.file("xl/styles.xml", replaceCollection(stylesXml, "cellXfs", retainedStyles.join(""), retainedIndexes.length));
+	for (const [worksheetPath, xml] of worksheets) zip.file(worksheetPath, remapWorksheetStyles(xml, indexMap));
+}
+function validateStyleIndexes(indexes, styleCount) {
+	if (indexes.some((index) => !Number.isInteger(index) || index < 0 || index >= styleCount)) throw new Error(`Worksheet references an invalid style index (${indexes.join(",")} of ${styleCount})`);
+}
+function collectStyleReferences(xml, references) {
+	for (const tag of xml.match(/<(?:\w+:)?(?:c|row)\b[^>]*>/gi) ?? []) {
+		const value = getAttribute(tag, "s");
+		if (value !== void 0) references.add(Number(value));
+	}
+	for (const tag of xml.match(/<(?:\w+:)?col\b[^>]*>/gi) ?? []) {
+		const value = getAttribute(tag, "style");
+		if (value !== void 0) references.add(Number(value));
+	}
+}
+function remapWorksheetStyles(xml, indexMap) {
+	return xml.replace(/<(?:\w+:)?(?:c|row)\b[^>]*>/gi, (tag) => remapNumericAttribute(tag, "s", indexMap)).replace(/<(?:\w+:)?col\b[^>]*>/gi, (tag) => remapNumericAttribute(tag, "style", indexMap));
+}
+function remapNumericAttribute(tag, attributeName, indexMap) {
+	const expression = new RegExp(`(\\s${attributeName}\\s*=\\s*)(["'])(\\d+)\\2`, "i");
+	return tag.replace(expression, (match, prefix, quote, value) => {
+		const remapped = indexMap.get(Number(value));
+		return remapped === void 0 ? match : `${prefix}${quote}${remapped}${quote}`;
+	});
+}
+//#endregion
+//#region src/ooxml/workbook.ts
+var WORKBOOK_PATH = "xl/workbook.xml";
+var WORKBOOK_RELATIONSHIPS_PATH = "xl/_rels/workbook.xml.rels";
+var CONTENT_TYPES_PATH = "[Content_Types].xml";
+async function sanitizeOoxmlWorkbook(buffer, options) {
+	if (!hasZipSignature(buffer)) throw new Error("Invalid OOXML ZIP container");
+	validateZipCentralDirectory(buffer, options.limits);
+	const context = await loadWorkbookContext(buffer, options);
+	const worksheetPaths = findWorksheetPaths(context.workbookXml, context.workbookRelationships, options.requireSingleWorksheet);
+	const detachedRoots = cleanWorkbookRelationships(context);
+	const worksheetXmlByPath = await cleanWorksheets(context, worksheetPaths, detachedRoots, options);
+	await removeUnreachableParts(context.zip, detachedRoots, context.readBudget, options.limits);
+	await removeUnusedCellStyles(context.zip, worksheetXmlByPath, context.readBudget, options.limits);
+	return context.zip.generateAsync({
+		type: "nodebuffer",
+		compression: "DEFLATE",
+		compressionOptions: { level: 6 }
+	});
+}
+async function loadWorkbookContext(buffer, options) {
+	const readBudget = {
+		consumedBytes: 0,
+		limitBytes: options.limits.maxXmlBytes
+	};
+	const zip = await JSZip.loadAsync(buffer);
+	const workbookXml = await requireXml(zip, WORKBOOK_PATH, readBudget, options.limits.maxMetadataXmlBytes);
+	const workbookRelationshipsXml = await requireXml(zip, WORKBOOK_RELATIONSHIPS_PATH, readBudget, options.limits.maxRelationshipsXmlBytes);
+	await requireXml(zip, CONTENT_TYPES_PATH, readBudget, options.limits.maxMetadataXmlBytes);
+	return {
+		zip,
+		readBudget,
+		workbookXml,
+		workbookRelationshipsXml,
+		workbookRelationships: parseRelationships(workbookRelationshipsXml, WORKBOOK_PATH)
+	};
+}
+function findWorksheetPaths(workbookXml, workbookRelationships, requireSingleWorksheet) {
+	const sheetTags = workbookXml.match(/<(?:\w+:)?sheet\b[^>]*\/?>/gi) ?? [];
+	enforceWorksheetCount(sheetTags.length, requireSingleWorksheet);
+	if (sheetTags.length === 0) throw new Error("Workbook contains no sheets");
+	const relationshipsById = new Map(workbookRelationships.map((relationship) => [relationship.id, relationship]));
+	return sheetTags.flatMap((sheetTag) => {
+		const id = getAttribute(sheetTag, "r:id");
+		const relationship = id ? relationshipsById.get(id) : void 0;
+		return relationship?.type.endsWith("/worksheet") ? [relationship.target] : [];
+	});
+}
+function cleanWorkbookRelationships(context) {
+	const cleaned = removeRelationships(context.workbookRelationshipsXml, WORKBOOK_PATH, PERSON_RELATIONSHIP_SUFFIXES);
+	context.zip.file(WORKBOOK_RELATIONSHIPS_PATH, cleaned.xml);
+	return cleaned.targets;
+}
+async function cleanWorksheets(context, worksheetPaths, detachedRoots, options) {
+	const worksheetXmlByPath = /* @__PURE__ */ new Map();
+	for (const worksheetPath of worksheetPaths) {
+		const cleanedWorksheetXml = removeThreadedCommentExtensions(removeWorksheetDrawingMarkup(await requireXml(context.zip, worksheetPath, context.readBudget, options.limits.maxWorksheetXmlBytes)));
+		worksheetXmlByPath.set(worksheetPath, cleanedWorksheetXml);
+		context.zip.file(worksheetPath, cleanedWorksheetXml);
+		await cleanWorksheetRelationships(context, worksheetPath, detachedRoots, options);
+	}
+	return worksheetXmlByPath;
+}
+async function cleanWorksheetRelationships(context, worksheetPath, detachedRoots, options) {
+	const relationshipsPath = relationshipFileForPart(worksheetPath);
+	const relationshipsFile = context.zip.file(relationshipsPath);
+	if (!relationshipsFile) return;
+	const cleaned = removeRelationships(await readXmlPart(relationshipsFile, relationshipsPath, context.readBudget, options.limits.maxRelationshipsXmlBytes), worksheetPath, DRAWING_RELATIONSHIP_SUFFIXES);
+	context.zip.file(relationshipsPath, cleaned.xml);
+	for (const target of cleaned.targets) detachedRoots.add(target);
+}
+function enforceWorksheetCount(count, required) {
+	if (required && count !== 1) throw createError("ERR_WORKSHEET_COUNT", { details: {
+		expected: 1,
+		actual: count
+	} });
+}
+//#endregion
+//#region src/constants.ts
+var DEFAULT_LIMITS = Object.freeze({
+	maxEntryCount: 1e4,
+	maxUncompressedBytes: 536870912,
+	maxXmlBytes: 536870912,
+	maxWorksheetXmlBytes: 268435456,
+	maxStylesXmlBytes: 67108864,
+	maxMetadataXmlBytes: 16777216,
+	maxRelationshipsXmlBytes: 8388608
+});
+var SANITIZE_OPTION_NAMES = /* @__PURE__ */ new Set(["requireSingleWorksheet", "limits"]);
+var FILE_OPTION_NAMES = /* @__PURE__ */ new Set([
+	"requireSingleWorksheet",
+	"limits",
+	"overwrite"
+]);
+var LIMIT_NAMES = /* @__PURE__ */ new Set([
+	"maxEntryCount",
+	"maxUncompressedBytes",
+	"maxXmlBytes",
+	"maxWorksheetXmlBytes",
+	"maxStylesXmlBytes",
+	"maxMetadataXmlBytes",
+	"maxRelationshipsXmlBytes"
+]);
+//#endregion
+//#region src/options.ts
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validateKnownKeys(value, knownKeys, label) {
+	for (const key of Object.keys(value)) if (!knownKeys.has(key)) throw createError("ERR_INVALID_ARGUMENT", {
+		message: `Unknown ${label}: ${key}`,
+		details: { key }
+	});
+}
+function isLimitName(name) {
+	return LIMIT_NAMES.has(name);
+}
+function normalizeLimits(overrides) {
+	if (overrides === void 0) return DEFAULT_LIMITS;
+	if (!isRecord(overrides)) throw createError("ERR_INVALID_ARGUMENT", { message: "options.limits must be an object" });
+	validateKnownKeys(overrides, LIMIT_NAMES, "limit");
+	const limits = { ...DEFAULT_LIMITS };
+	for (const [name, value] of Object.entries(overrides)) {
+		if (!isLimitName(name)) throw createError("ERR_INVALID_ARGUMENT", {
+			message: `Unknown limit: ${name}`,
+			details: { key: name }
+		});
+		if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw createError("ERR_INVALID_ARGUMENT", {
+			message: `options.limits.${name} must be a positive safe integer`,
+			details: {
+				limit: name,
+				value
+			}
+		});
+		limits[name] = value;
+	}
+	return Object.freeze(limits);
+}
+function normalizeOptions(options, fileOptions = false) {
+	if (options !== void 0 && !isRecord(options)) throw createError("ERR_INVALID_ARGUMENT", { message: "options must be an object" });
+	const rawOptions = options ?? {};
+	validateKnownKeys(rawOptions, fileOptions ? FILE_OPTION_NAMES : SANITIZE_OPTION_NAMES, "option");
+	if (rawOptions.requireSingleWorksheet !== void 0 && typeof rawOptions.requireSingleWorksheet !== "boolean") throw createError("ERR_INVALID_ARGUMENT", { message: "options.requireSingleWorksheet must be a boolean" });
+	let normalizedOverwrite = false;
+	if (fileOptions) {
+		const overwrite = rawOptions.overwrite;
+		if (overwrite !== void 0 && typeof overwrite !== "boolean") throw createError("ERR_INVALID_ARGUMENT", { message: "options.overwrite must be a boolean" });
+		normalizedOverwrite = overwrite ?? false;
+	}
+	const normalized = {
+		requireSingleWorksheet: rawOptions.requireSingleWorksheet ?? false,
+		limits: normalizeLimits(rawOptions.limits)
+	};
+	if (!fileOptions) return normalized;
+	return {
+		...normalized,
+		overwrite: normalizedOverwrite
+	};
+}
+//#endregion
+//#region src/api/sanitize-excel.ts
+async function sanitizeExcel(buffer, options) {
+	if (!Buffer.isBuffer(buffer)) throw createError("ERR_INVALID_ARGUMENT", { message: "buffer must be a Node.js Buffer" });
+	const normalized = normalizeOptions(options);
+	const isBiff = hasCompoundFileSignature(buffer);
+	try {
+		return isBiff ? await sanitizeBiffWorkbook(buffer, normalized) : await sanitizeOoxmlWorkbook(buffer, normalized);
+	} catch (error) {
+		if (error instanceof ExcelSanitizationError) throw error;
+		throw createError(isBiff ? "ERR_INVALID_XLS" : "ERR_INVALID_XLSX", { cause: error });
+	}
+}
+//#endregion
+//#region src/formats.ts
+function excelFileFormat(name) {
+	if (typeof name !== "string") return;
+	const extension = /\.(xls|xlsx|xlsm)$/i.exec(name)?.[1]?.toLowerCase();
+	return extension === "xls" || extension === "xlsx" || extension === "xlsm" ? extension : void 0;
+}
+function isExcelFilename(name) {
+	return excelFileFormat(name) !== void 0;
+}
+function isXlsxFilename(name) {
+	return excelFileFormat(name) === "xlsx";
+}
+//#endregion
+//#region src/api/sanitize-excel-file.ts
+async function sanitizeExcelFile(inputPath, outputPath, options) {
+	const format = validateFilePaths(inputPath, outputPath);
+	const normalized = normalizeOptions(options, true);
+	const absoluteInputPath = resolve(inputPath);
+	const absoluteOutputPath = resolve(outputPath);
+	if (absoluteInputPath === absoluteOutputPath) throw createError("ERR_SAME_PATH", { details: {
+		inputPath: absoluteInputPath,
+		outputPath: absoluteOutputPath
+	} });
+	const input = await readInputFile(absoluteInputPath);
+	validateInputFormat(input, format);
+	const sanitized = await sanitizeExcel(input, {
+		requireSingleWorksheet: normalized.requireSingleWorksheet,
+		limits: normalized.limits
+	});
+	if (normalized.overwrite) await replaceFileAtomically(absoluteOutputPath, sanitized);
+	else await writeNewFile(absoluteOutputPath, sanitized);
+}
+function validateFilePaths(inputPath, outputPath) {
+	if (typeof inputPath !== "string" || inputPath.length === 0 || typeof outputPath !== "string" || outputPath.length === 0) throw createError("ERR_INVALID_ARGUMENT", { message: "inputPath and outputPath must be non-empty strings" });
+	const inputFormat = excelFileFormat(inputPath);
+	const outputFormat = excelFileFormat(outputPath);
+	if (!inputFormat || !outputFormat || inputFormat !== outputFormat) throw createError("ERR_UNSUPPORTED_EXTENSION", { details: {
+		inputPath,
+		outputPath,
+		inputFormat,
+		outputFormat
+	} });
+	return inputFormat;
+}
+function validateInputFormat(input, format) {
+	const isXls = hasCompoundFileSignature(input);
+	if (format === "xls" !== isXls) throw createError(format === "xls" ? "ERR_INVALID_XLS" : "ERR_INVALID_XLSX", { details: { format } });
+}
+async function readInputFile(inputPath) {
+	try {
+		return await readFile(inputPath);
+	} catch (error) {
+		throw createError("ERR_FILE_READ", {
+			cause: error,
+			details: { inputPath }
+		});
+	}
+}
+async function writeNewFile(outputPath, contents) {
+	try {
+		await writeFile(outputPath, contents, { flag: "wx" });
+	} catch (error) {
+		if (hasErrorCode(error, "EEXIST")) throw createError("ERR_OUTPUT_EXISTS", {
+			cause: error,
+			details: { outputPath }
+		});
+		await removeIfPresent(outputPath);
+		throw createError("ERR_FILE_WRITE", {
+			cause: error,
+			details: { outputPath }
+		});
+	}
+}
+async function replaceFileAtomically(outputPath, contents) {
+	const temporaryPath = `${outputPath}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		await writeFile(temporaryPath, contents, { flag: "wx" });
+		await rename(temporaryPath, outputPath);
+	} catch (error) {
+		await removeIfPresent(temporaryPath);
+		throw createError("ERR_FILE_WRITE", {
+			cause: error,
+			details: { outputPath }
+		});
+	}
+}
+function hasErrorCode(error, expectedCode) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === expectedCode;
+}
+async function removeIfPresent(path) {
+	await unlink(path).catch(() => void 0);
+}
+//#endregion
+export { DEFAULT_LIMITS, ExcelSanitizationError, isExcelFilename, isXlsxFilename, sanitizeExcel, sanitizeExcelFile };
+
+//# sourceMappingURL=index.js.map