ghc-proxy 0.10.0 → 0.10.2

package/dist/{file-type-BwbWtW7C.mjs → source-BpNO27ea.mjs}

@@ -1,6 +1,320 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./main.mjs";
-import { open } from "node:fs/promises";
-import "node:stream";
+//#region node_modules/@borewit/text-codec/lib/index.js
+const WINDOWS_1252_EXTRA = {
+	128: "€",
+	130: "‚",
+	131: "ƒ",
+	132: "„",
+	133: "…",
+	134: "†",
+	135: "‡",
+	136: "ˆ",
+	137: "‰",
+	138: "Š",
+	139: "‹",
+	140: "Œ",
+	142: "Ž",
+	145: "‘",
+	146: "’",
+	147: "“",
+	148: "”",
+	149: "•",
+	150: "–",
+	151: "—",
+	152: "˜",
+	153: "™",
+	154: "š",
+	155: "›",
+	156: "œ",
+	158: "ž",
+	159: "Ÿ"
+};
+const WINDOWS_1252_REVERSE = {};
+for (const [code, char] of Object.entries(WINDOWS_1252_EXTRA)) WINDOWS_1252_REVERSE[char] = Number.parseInt(code, 10);
+let _utf8Decoder;
+function utf8Decoder() {
+	if (typeof globalThis.TextDecoder === "undefined") return void 0;
+	return _utf8Decoder !== null && _utf8Decoder !== void 0 ? _utf8Decoder : _utf8Decoder = new globalThis.TextDecoder("utf-8");
+}
+const CHUNK = 32768;
+const REPLACEMENT = 65533;
+/**
+* Decode text from binary data
+*/
+function textDecode(bytes, encoding = "utf-8") {
+	switch (encoding.toLowerCase()) {
+		case "utf-8":
+		case "utf8": {
+			const dec = utf8Decoder();
+			return dec ? dec.decode(bytes) : decodeUTF8(bytes);
+		}
+		case "utf-16le": return decodeUTF16LE(bytes);
+		case "us-ascii":
+		case "ascii": return decodeASCII(bytes);
+		case "latin1":
+		case "iso-8859-1": return decodeLatin1(bytes);
+		case "windows-1252": return decodeWindows1252(bytes);
+		default: throw new RangeError(`Encoding '${encoding}' not supported`);
+	}
+}
+function flushChunk(parts, chunk) {
+	if (chunk.length === 0) return;
+	parts.push(String.fromCharCode.apply(null, chunk));
+	chunk.length = 0;
+}
+function pushCodeUnit(parts, chunk, codeUnit) {
+	chunk.push(codeUnit);
+	if (chunk.length >= CHUNK) flushChunk(parts, chunk);
+}
+function pushCodePoint(parts, chunk, cp) {
+	if (cp <= 65535) {
+		pushCodeUnit(parts, chunk, cp);
+		return;
+	}
+	cp -= 65536;
+	pushCodeUnit(parts, chunk, 55296 + (cp >> 10));
+	pushCodeUnit(parts, chunk, 56320 + (cp & 1023));
+}
+function decodeUTF8(bytes) {
+	const parts = [];
+	const chunk = [];
+	let i = 0;
+	if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) i = 3;
+	while (i < bytes.length) {
+		const b1 = bytes[i];
+		if (b1 <= 127) {
+			pushCodeUnit(parts, chunk, b1);
+			i++;
+			continue;
+		}
+		if (b1 < 194 || b1 > 244) {
+			pushCodeUnit(parts, chunk, REPLACEMENT);
+			i++;
+			continue;
+		}
+		if (b1 <= 223) {
+			if (i + 1 >= bytes.length) {
+				pushCodeUnit(parts, chunk, REPLACEMENT);
+				i++;
+				continue;
+			}
+			const b2 = bytes[i + 1];
+			if ((b2 & 192) !== 128) {
+				pushCodeUnit(parts, chunk, REPLACEMENT);
+				i++;
+				continue;
+			}
+			pushCodeUnit(parts, chunk, (b1 & 31) << 6 | b2 & 63);
+			i += 2;
+			continue;
+		}
+		if (b1 <= 239) {
+			if (i + 2 >= bytes.length) {
+				pushCodeUnit(parts, chunk, REPLACEMENT);
+				i++;
+				continue;
+			}
+			const b2 = bytes[i + 1];
+			const b3 = bytes[i + 2];
+			if (!((b2 & 192) === 128 && (b3 & 192) === 128 && !(b1 === 224 && b2 < 160) && !(b1 === 237 && b2 >= 160))) {
+				pushCodeUnit(parts, chunk, REPLACEMENT);
+				i++;
+				continue;
+			}
+			pushCodeUnit(parts, chunk, (b1 & 15) << 12 | (b2 & 63) << 6 | b3 & 63);
+			i += 3;
+			continue;
+		}
+		if (i + 3 >= bytes.length) {
+			pushCodeUnit(parts, chunk, REPLACEMENT);
+			i++;
+			continue;
+		}
+		const b2 = bytes[i + 1];
+		const b3 = bytes[i + 2];
+		const b4 = bytes[i + 3];
+		if (!((b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128 && !(b1 === 240 && b2 < 144) && !(b1 === 244 && b2 > 143))) {
+			pushCodeUnit(parts, chunk, REPLACEMENT);
+			i++;
+			continue;
+		}
+		pushCodePoint(parts, chunk, (b1 & 7) << 18 | (b2 & 63) << 12 | (b3 & 63) << 6 | b4 & 63);
+		i += 4;
+	}
+	flushChunk(parts, chunk);
+	return parts.join("");
+}
+function decodeUTF16LE(bytes) {
+	const parts = [];
+	const chunk = [];
+	const len = bytes.length;
+	let i = 0;
+	while (i + 1 < len) {
+		const u1 = bytes[i] | bytes[i + 1] << 8;
+		i += 2;
+		if (u1 >= 55296 && u1 <= 56319) {
+			if (i + 1 < len) {
+				const u2 = bytes[i] | bytes[i + 1] << 8;
+				if (u2 >= 56320 && u2 <= 57343) {
+					pushCodeUnit(parts, chunk, u1);
+					pushCodeUnit(parts, chunk, u2);
+					i += 2;
+				} else pushCodeUnit(parts, chunk, REPLACEMENT);
+			} else pushCodeUnit(parts, chunk, REPLACEMENT);
+			continue;
+		}
+		if (u1 >= 56320 && u1 <= 57343) {
+			pushCodeUnit(parts, chunk, REPLACEMENT);
+			continue;
+		}
+		pushCodeUnit(parts, chunk, u1);
+	}
+	if (i < len) pushCodeUnit(parts, chunk, REPLACEMENT);
+	flushChunk(parts, chunk);
+	return parts.join("");
+}
+function decodeASCII(bytes) {
+	const parts = [];
+	for (let i = 0; i < bytes.length; i += CHUNK) {
+		const end = Math.min(bytes.length, i + CHUNK);
+		const codes = new Array(end - i);
+		for (let j = i, k = 0; j < end; j++, k++) codes[k] = bytes[j] & 127;
+		parts.push(String.fromCharCode.apply(null, codes));
+	}
+	return parts.join("");
+}
+function decodeLatin1(bytes) {
+	const parts = [];
+	for (let i = 0; i < bytes.length; i += CHUNK) {
+		const end = Math.min(bytes.length, i + CHUNK);
+		const codes = new Array(end - i);
+		for (let j = i, k = 0; j < end; j++, k++) codes[k] = bytes[j];
+		parts.push(String.fromCharCode.apply(null, codes));
+	}
+	return parts.join("");
+}
+function decodeWindows1252(bytes) {
+	const parts = [];
+	let out = "";
+	for (let i = 0; i < bytes.length; i++) {
+		const b = bytes[i];
+		const extra = b >= 128 && b <= 159 ? WINDOWS_1252_EXTRA[b] : void 0;
+		out += extra !== null && extra !== void 0 ? extra : String.fromCharCode(b);
+		if (out.length >= CHUNK) {
+			parts.push(out);
+			out = "";
+		}
+	}
+	if (out) parts.push(out);
+	return parts.join("");
+}
+//#endregion
+//#region node_modules/token-types/lib/index.js
+function dv(array) {
+	return new DataView(array.buffer, array.byteOffset);
+}
+const UINT8 = {
+	len: 1,
+	get(array, offset) {
+		return dv(array).getUint8(offset);
+	},
+	put(array, offset, value) {
+		dv(array).setUint8(offset, value);
+		return offset + 1;
+	}
+};
+/**
+* 16-bit unsigned integer, Little Endian byte order
+*/
+const UINT16_LE = {
+	len: 2,
+	get(array, offset) {
+		return dv(array).getUint16(offset, true);
+	},
+	put(array, offset, value) {
+		dv(array).setUint16(offset, value, true);
+		return offset + 2;
+	}
+};
+/**
+* 16-bit unsigned integer, Big Endian byte order
+*/
+const UINT16_BE = {
+	len: 2,
+	get(array, offset) {
+		return dv(array).getUint16(offset);
+	},
+	put(array, offset, value) {
+		dv(array).setUint16(offset, value);
+		return offset + 2;
+	}
+};
+/**
+* 32-bit unsigned integer, Little Endian byte order
+*/
+const UINT32_LE = {
+	len: 4,
+	get(array, offset) {
+		return dv(array).getUint32(offset, true);
+	},
+	put(array, offset, value) {
+		dv(array).setUint32(offset, value, true);
+		return offset + 4;
+	}
+};
+/**
+* 32-bit unsigned integer, Big Endian byte order
+*/
+const UINT32_BE = {
+	len: 4,
+	get(array, offset) {
+		return dv(array).getUint32(offset);
+	},
+	put(array, offset, value) {
+		dv(array).setUint32(offset, value);
+		return offset + 4;
+	}
+};
+/**
+* 32-bit signed integer, Big Endian byte order
+*/
+const INT32_BE = {
+	len: 4,
+	get(array, offset) {
+		return dv(array).getInt32(offset);
+	},
+	put(array, offset, value) {
+		dv(array).setInt32(offset, value);
+		return offset + 4;
+	}
+};
+/**
+* 64-bit unsigned integer, Little Endian byte order
+*/
+const UINT64_LE = {
+	len: 8,
+	get(array, offset) {
+		return dv(array).getBigUint64(offset, true);
+	},
+	put(array, offset, value) {
+		dv(array).setBigUint64(offset, value, true);
+		return offset + 8;
+	}
+};
+/**
+* Consume a fixed number of bytes from the stream and return a string with a specified encoding.
+* Supports all encodings supported by TextDecoder, plus 'windows-1252'.
+*/
+var StringType = class {
+	constructor(len, encoding) {
+		this.len = len;
+		this.encoding = encoding;
+	}
+	get(data, offset = 0) {
+		return textDecode(data.subarray(offset, offset + this.len), this.encoding);
+	}
+};
+//#endregion
 //#region node_modules/strtok3/lib/stream/Errors.js
 const defaultMessages = "End-Of-Stream";
 /**
@@ -183,7 +497,7 @@ var AbstractTokenizer = class {
 	* @protected
 	*/
 	constructor(options) {
-		this.numBuffer = new Uint8Array(8);
+		this.numBuffer = /* @__PURE__ */ new Uint8Array(8);
 		/**
 		* Tokenizer-stream position
 		*/
@@ -234,637 +548,271 @@ var AbstractTokenizer = class {
 		return token.get(this.numBuffer, 0);
 	}
 	/**
-	* Ignore number of bytes, advances the pointer in under tokenizer-stream.
-	* @param length - Number of bytes to ignore
-	* @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
-	*/
-	async ignore(length) {
-		if (this.fileInfo.size !== void 0) {
-			const bytesLeft = this.fileInfo.size - this.position;
-			if (length > bytesLeft) {
-				this.position += bytesLeft;
-				return bytesLeft;
-			}
-		}
-		this.position += length;
-		return length;
-	}
-	async close() {
-		await this.abort();
-		await this.onClose?.();
-	}
-	normalizeOptions(uint8Array, options) {
-		if (!this.supportsRandomAccess() && options && options.position !== void 0 && options.position < this.position) throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
-		return {
-			mayBeLess: false,
-			offset: 0,
-			length: uint8Array.length,
-			position: this.position,
-			...options
-		};
-	}
-	abort() {
-		return Promise.resolve();
-	}
-};
-//#endregion
-//#region node_modules/strtok3/lib/ReadStreamTokenizer.js
-const maxBufferSize = 256e3;
-var ReadStreamTokenizer = class extends AbstractTokenizer {
-	/**
-	* Constructor
-	* @param streamReader stream-reader to read from
-	* @param options Tokenizer options
-	*/
-	constructor(streamReader, options) {
-		super(options);
-		this.streamReader = streamReader;
-		this.fileInfo = options?.fileInfo ?? {};
-	}
-	/**
-	* Read buffer from tokenizer
-	* @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream
-	* @param options - Read behaviour options
-	* @returns Promise with number of bytes read
-	*/
-	async readBuffer(uint8Array, options) {
-		const normOptions = this.normalizeOptions(uint8Array, options);
-		const skipBytes = normOptions.position - this.position;
-		if (skipBytes > 0) {
-			await this.ignore(skipBytes);
-			return this.readBuffer(uint8Array, options);
-		}
-		if (skipBytes < 0) throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
-		if (normOptions.length === 0) return 0;
-		const bytesRead = await this.streamReader.read(uint8Array.subarray(0, normOptions.length), normOptions.mayBeLess);
-		this.position += bytesRead;
-		if ((!options || !options.mayBeLess) && bytesRead < normOptions.length) throw new EndOfStreamError();
-		return bytesRead;
-	}
-	/**
-	* Peek (read ahead) buffer from tokenizer
-	* @param uint8Array - Uint8Array (or Buffer) to write data to
-	* @param options - Read behaviour options
-	* @returns Promise with number of bytes peeked
-	*/
-	async peekBuffer(uint8Array, options) {
-		const normOptions = this.normalizeOptions(uint8Array, options);
-		let bytesRead = 0;
-		if (normOptions.position) {
-			const skipBytes = normOptions.position - this.position;
-			if (skipBytes > 0) {
-				const skipBuffer = new Uint8Array(normOptions.length + skipBytes);
-				bytesRead = await this.peekBuffer(skipBuffer, { mayBeLess: normOptions.mayBeLess });
-				uint8Array.set(skipBuffer.subarray(skipBytes));
-				return bytesRead - skipBytes;
-			}
-			if (skipBytes < 0) throw new Error("Cannot peek from a negative offset in a stream");
-		}
-		if (normOptions.length > 0) {
-			try {
-				bytesRead = await this.streamReader.peek(uint8Array.subarray(0, normOptions.length), normOptions.mayBeLess);
-			} catch (err) {
-				if (options?.mayBeLess && err instanceof EndOfStreamError) return 0;
-				throw err;
-			}
-			if (!normOptions.mayBeLess && bytesRead < normOptions.length) throw new EndOfStreamError();
-		}
-		return bytesRead;
-	}
-	async ignore(length) {
-		const bufSize = Math.min(maxBufferSize, length);
-		const buf = new Uint8Array(bufSize);
-		let totBytesRead = 0;
-		while (totBytesRead < length) {
-			const remaining = length - totBytesRead;
-			const bytesRead = await this.readBuffer(buf, { length: Math.min(bufSize, remaining) });
-			if (bytesRead < 0) return bytesRead;
-			totBytesRead += bytesRead;
-		}
-		return totBytesRead;
-	}
-	abort() {
-		return this.streamReader.abort();
-	}
-	async close() {
-		return this.streamReader.close();
-	}
-	supportsRandomAccess() {
-		return false;
-	}
-};
-//#endregion
-//#region node_modules/strtok3/lib/BufferTokenizer.js
-var BufferTokenizer = class extends AbstractTokenizer {
-	/**
-	* Construct BufferTokenizer
-	* @param uint8Array - Uint8Array to tokenize
-	* @param options Tokenizer options
-	*/
-	constructor(uint8Array, options) {
-		super(options);
-		this.uint8Array = uint8Array;
-		this.fileInfo = {
-			...options?.fileInfo ?? {},
-			size: uint8Array.length
-		};
-	}
-	/**
-	* Read buffer from tokenizer
-	* @param uint8Array - Uint8Array to tokenize
-	* @param options - Read behaviour options
-	* @returns {Promise<number>}
-	*/
-	async readBuffer(uint8Array, options) {
-		if (options?.position) this.position = options.position;
-		const bytesRead = await this.peekBuffer(uint8Array, options);
-		this.position += bytesRead;
-		return bytesRead;
-	}
-	/**
-	* Peek (read ahead) buffer from tokenizer
-	* @param uint8Array
-	* @param options - Read behaviour options
-	* @returns {Promise<number>}
-	*/
-	async peekBuffer(uint8Array, options) {
-		const normOptions = this.normalizeOptions(uint8Array, options);
-		const bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);
-		if (!normOptions.mayBeLess && bytes2read < normOptions.length) throw new EndOfStreamError();
-		uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read));
-		return bytes2read;
-	}
-	close() {
-		return super.close();
-	}
-	supportsRandomAccess() {
-		return true;
-	}
-	setPosition(position) {
-		this.position = position;
-	}
-};
-//#endregion
-//#region node_modules/strtok3/lib/BlobTokenizer.js
-var BlobTokenizer = class extends AbstractTokenizer {
-	/**
-	* Construct BufferTokenizer
-	* @param blob - Uint8Array to tokenize
-	* @param options Tokenizer options
-	*/
-	constructor(blob, options) {
-		super(options);
-		this.blob = blob;
-		this.fileInfo = {
-			...options?.fileInfo ?? {},
-			size: blob.size,
-			mimeType: blob.type
-		};
-	}
-	/**
-	* Read buffer from tokenizer
-	* @param uint8Array - Uint8Array to tokenize
-	* @param options - Read behaviour options
-	* @returns {Promise<number>}
-	*/
-	async readBuffer(uint8Array, options) {
-		if (options?.position) this.position = options.position;
-		const bytesRead = await this.peekBuffer(uint8Array, options);
-		this.position += bytesRead;
-		return bytesRead;
-	}
-	/**
-	* Peek (read ahead) buffer from tokenizer
-	* @param buffer
-	* @param options - Read behaviour options
-	* @returns {Promise<number>}
+	* Ignore number of bytes, advances the pointer in under tokenizer-stream.
+	* @param length - Number of bytes to ignore.  Must be ≥ 0.
+	* @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
 	*/
-	async peekBuffer(buffer, options) {
-		const normOptions = this.normalizeOptions(buffer, options);
-		const bytes2read = Math.min(this.blob.size - normOptions.position, normOptions.length);
-		if (!normOptions.mayBeLess && bytes2read < normOptions.length) throw new EndOfStreamError();
-		const arrayBuffer = await this.blob.slice(normOptions.position, normOptions.position + bytes2read).arrayBuffer();
-		buffer.set(new Uint8Array(arrayBuffer));
-		return bytes2read;
+	async ignore(length) {
+		if (length < 0) throw new RangeError("ignore length must be ≥ 0 bytes");
+		if (this.fileInfo.size !== void 0) {
+			const bytesLeft = this.fileInfo.size - this.position;
+			if (length > bytesLeft) {
+				this.position += bytesLeft;
+				return bytesLeft;
+			}
+		}
+		this.position += length;
+		return length;
 	}
-	close() {
-		return super.close();
+	async close() {
+		await this.abort();
+		await this.onClose?.();
 	}
-	supportsRandomAccess() {
-		return true;
+	normalizeOptions(uint8Array, options) {
+		if (!this.supportsRandomAccess() && options && options.position !== void 0 && options.position < this.position) throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
+		return {
+			mayBeLess: false,
+			offset: 0,
+			length: uint8Array.length,
+			position: this.position,
+			...options
+		};
 	}
-	setPosition(position) {
-		this.position = position;
+	abort() {
+		return Promise.resolve();
 	}
 };
 //#endregion
-//#region node_modules/strtok3/lib/core.js
-/**
-* Construct ReadStreamTokenizer from given ReadableStream (WebStream API).
-* Will set fileSize, if provided given Stream has set the .path property/
-* @param webStream - Read from Node.js Stream.Readable (must be a byte stream)
-* @param options - Tokenizer options
-* @returns ReadStreamTokenizer
-*/
-function fromWebStream(webStream, options) {
-	const webStreamReader = makeWebStreamReader(webStream);
-	const _options = options ?? {};
-	const chainedClose = _options.onClose;
-	_options.onClose = async () => {
-		await webStreamReader.close();
-		if (chainedClose) return chainedClose();
-	};
-	return new ReadStreamTokenizer(webStreamReader, _options);
-}
-/**
-* Construct ReadStreamTokenizer from given Buffer.
-* @param uint8Array - Uint8Array to tokenize
-* @param options - Tokenizer options
-* @returns BufferTokenizer
-*/
-function fromBuffer(uint8Array, options) {
-	return new BufferTokenizer(uint8Array, options);
-}
-/**
-* Construct ReadStreamTokenizer from given Blob.
-* @param blob - Uint8Array to tokenize
-* @param options - Tokenizer options
-* @returns BufferTokenizer
-*/
-function fromBlob(blob, options) {
-	return new BlobTokenizer(blob, options);
-}
-(class FileTokenizer extends AbstractTokenizer {
+//#region node_modules/strtok3/lib/ReadStreamTokenizer.js
+const maxBufferSize = 256e3;
+var ReadStreamTokenizer = class extends AbstractTokenizer {
 	/**
-	* Create tokenizer from provided file path
-	* @param sourceFilePath File path
+	* Constructor
+	* @param streamReader stream-reader to read from
+	* @param options Tokenizer options
 	*/
-	static async fromFile(sourceFilePath) {
-		const fileHandle = await open(sourceFilePath, "r");
-		return new FileTokenizer(fileHandle, { fileInfo: {
-			path: sourceFilePath,
-			size: (await fileHandle.stat()).size
-		} });
-	}
-	constructor(fileHandle, options) {
+	constructor(streamReader, options) {
 		super(options);
-		this.fileHandle = fileHandle;
-		this.fileInfo = options.fileInfo;
+		this.streamReader = streamReader;
+		this.fileInfo = options?.fileInfo ?? {};
 	}
 	/**
-	* Read buffer from file
-	* @param uint8Array - Uint8Array to write result to
+	* Read buffer from tokenizer
+	* @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream
 	* @param options - Read behaviour options
-	* @returns Promise number of bytes read
+	* @returns Promise with number of bytes read
 	*/
 	async readBuffer(uint8Array, options) {
 		const normOptions = this.normalizeOptions(uint8Array, options);
-		this.position = normOptions.position;
+		const skipBytes = normOptions.position - this.position;
+		if (skipBytes > 0) {
+			await this.ignore(skipBytes);
+			return this.readBuffer(uint8Array, options);
+		}
+		if (skipBytes < 0) throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
 		if (normOptions.length === 0) return 0;
-		const res = await this.fileHandle.read(uint8Array, 0, normOptions.length, normOptions.position);
-		this.position += res.bytesRead;
-		if (res.bytesRead < normOptions.length && (!options || !options.mayBeLess)) throw new EndOfStreamError();
-		return res.bytesRead;
+		const bytesRead = await this.streamReader.read(uint8Array.subarray(0, normOptions.length), normOptions.mayBeLess);
+		this.position += bytesRead;
+		if ((!options || !options.mayBeLess) && bytesRead < normOptions.length) throw new EndOfStreamError();
+		return bytesRead;
 	}
 	/**
-	* Peek buffer from file
+	* Peek (read ahead) buffer from tokenizer
 	* @param uint8Array - Uint8Array (or Buffer) to write data to
 	* @param options - Read behaviour options
-	* @returns Promise number of bytes read
+	* @returns Promise with number of bytes peeked
 	*/
 	async peekBuffer(uint8Array, options) {
 		const normOptions = this.normalizeOptions(uint8Array, options);
-		const res = await this.fileHandle.read(uint8Array, 0, normOptions.length, normOptions.position);
-		if (!normOptions.mayBeLess && res.bytesRead < normOptions.length) throw new EndOfStreamError();
-		return res.bytesRead;
-	}
-	async close() {
-		await this.fileHandle.close();
-		return super.close();
-	}
-	setPosition(position) {
-		this.position = position;
-	}
-	supportsRandomAccess() {
-		return true;
-	}
-}).fromFile;
-//#endregion
-//#region node_modules/@borewit/text-codec/lib/index.js
-const WINDOWS_1252_EXTRA = {
-	128: "€",
-	130: "‚",
-	131: "ƒ",
-	132: "„",
-	133: "…",
-	134: "†",
-	135: "‡",
-	136: "ˆ",
-	137: "‰",
-	138: "Š",
-	139: "‹",
-	140: "Œ",
-	142: "Ž",
-	145: "‘",
-	146: "’",
-	147: "“",
-	148: "”",
-	149: "•",
-	150: "–",
-	151: "—",
-	152: "˜",
-	153: "™",
-	154: "š",
-	155: "›",
-	156: "œ",
-	158: "ž",
-	159: "Ÿ"
-};
-const WINDOWS_1252_REVERSE = {};
-for (const [code, char] of Object.entries(WINDOWS_1252_EXTRA)) WINDOWS_1252_REVERSE[char] = Number.parseInt(code, 10);
-let _utf8Decoder;
-function utf8Decoder() {
-	if (typeof globalThis.TextDecoder === "undefined") return void 0;
-	return _utf8Decoder !== null && _utf8Decoder !== void 0 ? _utf8Decoder : _utf8Decoder = new globalThis.TextDecoder("utf-8");
-}
-const CHUNK = 32 * 1024;
-const REPLACEMENT = 65533;
-/**
-* Decode text from binary data
-*/
-function textDecode(bytes, encoding = "utf-8") {
-	switch (encoding.toLowerCase()) {
-		case "utf-8":
-		case "utf8": {
-			const dec = utf8Decoder();
-			return dec ? dec.decode(bytes) : decodeUTF8(bytes);
-		}
-		case "utf-16le": return decodeUTF16LE(bytes);
-		case "us-ascii":
-		case "ascii": return decodeASCII(bytes);
-		case "latin1":
-		case "iso-8859-1": return decodeLatin1(bytes);
-		case "windows-1252": return decodeWindows1252(bytes);
-		default: throw new RangeError(`Encoding '${encoding}' not supported`);
-	}
-}
-function flushChunk(parts, chunk) {
-	if (chunk.length === 0) return;
-	parts.push(String.fromCharCode.apply(null, chunk));
-	chunk.length = 0;
-}
-function pushCodeUnit(parts, chunk, codeUnit) {
-	chunk.push(codeUnit);
-	if (chunk.length >= CHUNK) flushChunk(parts, chunk);
-}
-function pushCodePoint(parts, chunk, cp) {
-	if (cp <= 65535) {
-		pushCodeUnit(parts, chunk, cp);
-		return;
-	}
-	cp -= 65536;
-	pushCodeUnit(parts, chunk, 55296 + (cp >> 10));
-	pushCodeUnit(parts, chunk, 56320 + (cp & 1023));
-}
-function decodeUTF8(bytes) {
-	const parts = [];
-	const chunk = [];
-	let i = 0;
-	if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) i = 3;
-	while (i < bytes.length) {
-		const b1 = bytes[i];
-		if (b1 <= 127) {
-			pushCodeUnit(parts, chunk, b1);
-			i++;
-			continue;
-		}
-		if (b1 < 194 || b1 > 244) {
-			pushCodeUnit(parts, chunk, REPLACEMENT);
-			i++;
-			continue;
-		}
-		if (b1 <= 223) {
-			if (i + 1 >= bytes.length) {
-				pushCodeUnit(parts, chunk, REPLACEMENT);
-				i++;
-				continue;
-			}
-			const b2 = bytes[i + 1];
-			if ((b2 & 192) !== 128) {
-				pushCodeUnit(parts, chunk, REPLACEMENT);
-				i++;
-				continue;
-			}
-			pushCodeUnit(parts, chunk, (b1 & 31) << 6 | b2 & 63);
-			i += 2;
-			continue;
-		}
-		if (b1 <= 239) {
-			if (i + 2 >= bytes.length) {
-				pushCodeUnit(parts, chunk, REPLACEMENT);
-				i++;
-				continue;
-			}
-			const b2 = bytes[i + 1];
-			const b3 = bytes[i + 2];
-			if (!((b2 & 192) === 128 && (b3 & 192) === 128 && !(b1 === 224 && b2 < 160) && !(b1 === 237 && b2 >= 160))) {
-				pushCodeUnit(parts, chunk, REPLACEMENT);
-				i++;
-				continue;
+		let bytesRead = 0;
+		if (normOptions.position) {
+			const skipBytes = normOptions.position - this.position;
+			if (skipBytes > 0) {
+				const skipBuffer = new Uint8Array(normOptions.length + skipBytes);
+				bytesRead = await this.peekBuffer(skipBuffer, { mayBeLess: normOptions.mayBeLess });
+				uint8Array.set(skipBuffer.subarray(skipBytes));
+				return bytesRead - skipBytes;
 			}
-			pushCodeUnit(parts, chunk, (b1 & 15) << 12 | (b2 & 63) << 6 | b3 & 63);
-			i += 3;
-			continue;
-		}
-		if (i + 3 >= bytes.length) {
-			pushCodeUnit(parts, chunk, REPLACEMENT);
-			i++;
-			continue;
+			if (skipBytes < 0) throw new Error("Cannot peek from a negative offset in a stream");
 		}
-		const b2 = bytes[i + 1];
-		const b3 = bytes[i + 2];
-		const b4 = bytes[i + 3];
-		if (!((b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128 && !(b1 === 240 && b2 < 144) && !(b1 === 244 && b2 > 143))) {
-			pushCodeUnit(parts, chunk, REPLACEMENT);
-			i++;
-			continue;
+		if (normOptions.length > 0) {
+			try {
+				bytesRead = await this.streamReader.peek(uint8Array.subarray(0, normOptions.length), normOptions.mayBeLess);
+			} catch (err) {
+				if (options?.mayBeLess && err instanceof EndOfStreamError) return 0;
+				throw err;
+			}
+			if (!normOptions.mayBeLess && bytesRead < normOptions.length) throw new EndOfStreamError();
 		}
-		pushCodePoint(parts, chunk, (b1 & 7) << 18 | (b2 & 63) << 12 | (b3 & 63) << 6 | b4 & 63);
-		i += 4;
+		return bytesRead;
 	}
-	flushChunk(parts, chunk);
-	return parts.join("");
-}
-function decodeUTF16LE(bytes) {
-	const parts = [];
-	const chunk = [];
-	const len = bytes.length;
-	let i = 0;
-	while (i + 1 < len) {
-		const u1 = bytes[i] | bytes[i + 1] << 8;
-		i += 2;
-		if (u1 >= 55296 && u1 <= 56319) {
-			if (i + 1 < len) {
-				const u2 = bytes[i] | bytes[i + 1] << 8;
-				if (u2 >= 56320 && u2 <= 57343) {
-					pushCodeUnit(parts, chunk, u1);
-					pushCodeUnit(parts, chunk, u2);
-					i += 2;
-				} else pushCodeUnit(parts, chunk, REPLACEMENT);
-			} else pushCodeUnit(parts, chunk, REPLACEMENT);
-			continue;
-		}
-		if (u1 >= 56320 && u1 <= 57343) {
-			pushCodeUnit(parts, chunk, REPLACEMENT);
-			continue;
+	/**
+	* @param length Number of bytes to ignore. Must be ≥ 0.
+	*/
+	async ignore(length) {
+		if (length < 0) throw new RangeError("ignore length must be ≥ 0 bytes");
+		const bufSize = Math.min(maxBufferSize, length);
+		const buf = new Uint8Array(bufSize);
+		let totBytesRead = 0;
+		while (totBytesRead < length) {
+			const remaining = length - totBytesRead;
+			const bytesRead = await this.readBuffer(buf, { length: Math.min(bufSize, remaining) });
+			if (bytesRead < 0) return bytesRead;
+			totBytesRead += bytesRead;
 		}
-		pushCodeUnit(parts, chunk, u1);
+		return totBytesRead;
 	}
-	if (i < len) pushCodeUnit(parts, chunk, REPLACEMENT);
-	flushChunk(parts, chunk);
-	return parts.join("");
-}
-function decodeASCII(bytes) {
-	const parts = [];
-	for (let i = 0; i < bytes.length; i += CHUNK) {
-		const end = Math.min(bytes.length, i + CHUNK);
-		const codes = new Array(end - i);
-		for (let j = i, k = 0; j < end; j++, k++) codes[k] = bytes[j] & 127;
-		parts.push(String.fromCharCode.apply(null, codes));
+	abort() {
+		return this.streamReader.abort();
 	}
-	return parts.join("");
-}
-function decodeLatin1(bytes) {
-	const parts = [];
-	for (let i = 0; i < bytes.length; i += CHUNK) {
-		const end = Math.min(bytes.length, i + CHUNK);
-		const codes = new Array(end - i);
-		for (let j = i, k = 0; j < end; j++, k++) codes[k] = bytes[j];
-		parts.push(String.fromCharCode.apply(null, codes));
+	async close() {
+		return this.streamReader.close();
 	}
-	return parts.join("");
-}
-function decodeWindows1252(bytes) {
-	const parts = [];
-	let out = "";
-	for (let i = 0; i < bytes.length; i++) {
-		const b = bytes[i];
-		const extra = b >= 128 && b <= 159 ? WINDOWS_1252_EXTRA[b] : void 0;
-		out += extra !== null && extra !== void 0 ? extra : String.fromCharCode(b);
-		if (out.length >= CHUNK) {
-			parts.push(out);
-			out = "";
-		}
+	supportsRandomAccess() {
+		return false;
 	}
-	if (out) parts.push(out);
-	return parts.join("");
-}
+};
 //#endregion
-//#region node_modules/token-types/lib/index.js
-function dv(array) {
-	return new DataView(array.buffer, array.byteOffset);
-}
-const UINT8 = {
-	len: 1,
-	get(array, offset) {
-		return dv(array).getUint8(offset);
-	},
-	put(array, offset, value) {
-		dv(array).setUint8(offset, value);
-		return offset + 1;
+//#region node_modules/strtok3/lib/BufferTokenizer.js
+var BufferTokenizer = class extends AbstractTokenizer {
+	/**
+	* Construct BufferTokenizer
+	* @param uint8Array - Uint8Array to tokenize
+	* @param options Tokenizer options
+	*/
+	constructor(uint8Array, options) {
+		super(options);
+		this.uint8Array = uint8Array;
+		this.fileInfo = {
+			...options?.fileInfo ?? {},
+			size: uint8Array.length
+		};
 	}
-};
-/**
-* 16-bit unsigned integer, Little Endian byte order
-*/
-const UINT16_LE = {
-	len: 2,
-	get(array, offset) {
-		return dv(array).getUint16(offset, true);
-	},
-	put(array, offset, value) {
-		dv(array).setUint16(offset, value, true);
-		return offset + 2;
+	/**
+	* Read buffer from tokenizer
+	* @param uint8Array - Uint8Array to tokenize
+	* @param options - Read behaviour options
+	* @returns {Promise<number>}
+	*/
+	async readBuffer(uint8Array, options) {
+		if (options?.position) this.position = options.position;
+		const bytesRead = await this.peekBuffer(uint8Array, options);
+		this.position += bytesRead;
+		return bytesRead;
 	}
-};
-/**
-* 16-bit unsigned integer, Big Endian byte order
-*/
-const UINT16_BE = {
-	len: 2,
-	get(array, offset) {
-		return dv(array).getUint16(offset);
-	},
-	put(array, offset, value) {
-		dv(array).setUint16(offset, value);
-		return offset + 2;
+	/**
+	* Peek (read ahead) buffer from tokenizer
+	* @param uint8Array
+	* @param options - Read behaviour options
+	* @returns {Promise<number>}
+	*/
+	async peekBuffer(uint8Array, options) {
+		const normOptions = this.normalizeOptions(uint8Array, options);
+		const bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);
+		if (!normOptions.mayBeLess && bytes2read < normOptions.length) throw new EndOfStreamError();
+		uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read));
+		return bytes2read;
 	}
-};
-/**
-* 32-bit unsigned integer, Little Endian byte order
-*/
-const UINT32_LE = {
-	len: 4,
-	get(array, offset) {
-		return dv(array).getUint32(offset, true);
-	},
-	put(array, offset, value) {
-		dv(array).setUint32(offset, value, true);
-		return offset + 4;
+	close() {
+		return super.close();
 	}
-};
-/**
-* 32-bit unsigned integer, Big Endian byte order
-*/
-const UINT32_BE = {
-	len: 4,
-	get(array, offset) {
-		return dv(array).getUint32(offset);
-	},
-	put(array, offset, value) {
-		dv(array).setUint32(offset, value);
-		return offset + 4;
+	supportsRandomAccess() {
+		return true;
+	}
+	setPosition(position) {
+		this.position = position;
 	}
 };
-/**
-* 32-bit signed integer, Big Endian byte order
-*/
-const INT32_BE = {
-	len: 4,
-	get(array, offset) {
-		return dv(array).getInt32(offset);
-	},
-	put(array, offset, value) {
-		dv(array).setInt32(offset, value);
-		return offset + 4;
+//#endregion
+//#region node_modules/strtok3/lib/BlobTokenizer.js
+var BlobTokenizer = class extends AbstractTokenizer {
+	/**
+	* Construct BufferTokenizer
+	* @param blob - Uint8Array to tokenize
+	* @param options Tokenizer options
+	*/
+	constructor(blob, options) {
+		super(options);
+		this.blob = blob;
+		this.fileInfo = {
+			...options?.fileInfo ?? {},
+			size: blob.size,
+			mimeType: blob.type
+		};
+	}
+	/**
+	* Read buffer from tokenizer
+	* @param uint8Array - Uint8Array to tokenize
+	* @param options - Read behaviour options
+	* @returns {Promise<number>}
+	*/
+	async readBuffer(uint8Array, options) {
+		if (options?.position) this.position = options.position;
+		const bytesRead = await this.peekBuffer(uint8Array, options);
+		this.position += bytesRead;
+		return bytesRead;
+	}
+	/**
+	* Peek (read ahead) buffer from tokenizer
+	* @param buffer
+	* @param options - Read behaviour options
+	* @returns {Promise<number>}
+	*/
+	async peekBuffer(buffer, options) {
+		const normOptions = this.normalizeOptions(buffer, options);
+		const bytes2read = Math.min(this.blob.size - normOptions.position, normOptions.length);
+		if (!normOptions.mayBeLess && bytes2read < normOptions.length) throw new EndOfStreamError();
+		const arrayBuffer = await this.blob.slice(normOptions.position, normOptions.position + bytes2read).arrayBuffer();
+		buffer.set(new Uint8Array(arrayBuffer));
+		return bytes2read;
+	}
+	close() {
+		return super.close();
+	}
+	supportsRandomAccess() {
+		return true;
+	}
+	setPosition(position) {
+		this.position = position;
 	}
 };
+//#endregion
+//#region node_modules/strtok3/lib/core.js
 /**
-* 64-bit unsigned integer, Little Endian byte order
+* Construct ReadStreamTokenizer from given ReadableStream (WebStream API).
+* Will set fileSize, if provided given Stream has set the .path property/
+* @param webStream - Read from Node.js Stream.Readable (must be a byte stream)
+* @param options - Tokenizer options
+* @returns ReadStreamTokenizer
 */
-const UINT64_LE = {
-	len: 8,
-	get(array, offset) {
-		return dv(array).getBigUint64(offset, true);
-	},
-	put(array, offset, value) {
-		dv(array).setBigUint64(offset, value, true);
-		return offset + 8;
-	}
-};
+function fromWebStream(webStream, options) {
+	const webStreamReader = makeWebStreamReader(webStream);
+	const _options = options ?? {};
+	const chainedClose = _options.onClose;
+	_options.onClose = async () => {
+		await webStreamReader.close();
+		if (chainedClose) return chainedClose();
+	};
+	return new ReadStreamTokenizer(webStreamReader, _options);
+}
 /**
-* Consume a fixed number of bytes from the stream and return a string with a specified encoding.
-* Supports all encodings supported by TextDecoder, plus 'windows-1252'.
+* Construct ReadStreamTokenizer from given Buffer.
+* @param uint8Array - Uint8Array to tokenize
+* @param options - Tokenizer options
+* @returns BufferTokenizer
 */
-var StringType = class {
-	constructor(len, encoding) {
-		this.len = len;
-		this.encoding = encoding;
-	}
-	get(data, offset = 0) {
-		return textDecode(data.subarray(offset, offset + this.len), this.encoding);
-	}
-};
+function fromBuffer(uint8Array, options) {
+	return new BufferTokenizer(uint8Array, options);
+}
+/**
+* Construct ReadStreamTokenizer from given Blob.
+* @param blob - Uint8Array to tokenize
+* @param options - Tokenizer options
+* @returns BufferTokenizer
+*/
+function fromBlob(blob, options) {
+	return new BlobTokenizer(blob, options);
+}
 //#endregion
 //#region node_modules/ms/index.js
 var require_ms = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -1123,15 +1071,16 @@ var require_common = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			let templateIndex = 0;
 			let starIndex = -1;
 			let matchIndex = 0;
-			while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) if (template[templateIndex] === "*") {
-				starIndex = templateIndex;
-				matchIndex = searchIndex;
-				templateIndex++;
-			} else {
-				searchIndex++;
-				templateIndex++;
-			}
-			else if (starIndex !== -1) {
+			while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+				if (template[templateIndex] === "*") {
+					starIndex = templateIndex;
+					matchIndex = searchIndex;
+					templateIndex++;
+				} else {
+					searchIndex++;
+					templateIndex++;
+				}
+			} else if (starIndex !== -1) {
 				templateIndex = starIndex + 1;
 				matchIndex++;
 				searchIndex = matchIndex;
@@ -1726,7 +1675,7 @@ function signatureToArray(signature) {
 	return signatureBytes;
 }
 const debug = (0, import_src.default)("tokenizer:inflate");
-const syncBufferSize = 256 * 1024;
+const syncBufferSize = 262144;
 const ddSignatureArray = signatureToArray(Signature.DataDescriptor);
 const eocdSignatureBytes = signatureToArray(Signature.EndOfCentralDirectory);
 var ZipHandler = class ZipHandler {
@@ -1742,7 +1691,7 @@ var ZipHandler = class ZipHandler {
 	}
 	async findEndOfCentralDirectoryLocator() {
 		const randomReadTokenizer = this.tokenizer;
-		const chunkLength = Math.min(16 * 1024, randomReadTokenizer.fileInfo.size);
+		const chunkLength = Math.min(16384, randomReadTokenizer.fileInfo.size);
 		const buffer = this.syncBuffer.subarray(0, chunkLength);
 		await this.tokenizer.readBuffer(buffer, { position: randomReadTokenizer.fileInfo.size - chunkLength });
 		for (let i = buffer.length - 4; i >= 0; i--) if (buffer[i] === eocdSignatureBytes[0] && buffer[i + 1] === eocdSignatureBytes[1] && buffer[i + 2] === eocdSignatureBytes[2] && buffer[i + 3] === eocdSignatureBytes[3]) return randomReadTokenizer.fileInfo.size - chunkLength + i;
@@ -1900,7 +1849,7 @@ var GzipHandler = class {
 	inflate() {
 		const tokenizer = this.tokenizer;
 		return new ReadableStream({ async pull(controller) {
-			const buffer = new Uint8Array(1024);
+			const buffer = /* @__PURE__ */ new Uint8Array(1024);
 			const size = await tokenizer.readBuffer(buffer, { mayBeLess: true });
 			if (size === 0) {
 				controller.close();
@@ -1910,6 +1859,33 @@ var GzipHandler = class {
 		} }).pipeThrough(new DecompressionStream("gzip"));
 	}
 };
+//#endregion
+//#region node_modules/uint8array-extras/index.js
+const objectToString = Object.prototype.toString;
+const uint8ArrayStringified = "[object Uint8Array]";
+function isType(value, typeConstructor, typeStringified) {
+	if (!value) return false;
+	if (value.constructor === typeConstructor) return true;
+	return objectToString.call(value) === typeStringified;
+}
+function isUint8Array(value) {
+	return isType(value, Uint8Array, uint8ArrayStringified);
+}
+function assertUint8Array(value) {
+	if (!isUint8Array(value)) throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``);
+}
+function concatUint8Arrays(arrays, totalLength) {
+	if (arrays.length === 0) return /* @__PURE__ */ new Uint8Array(0);
+	totalLength ??= arrays.reduce((accumulator, currentValue) => accumulator + currentValue.length, 0);
+	const returnValue = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const array of arrays) {
+		assertUint8Array(array);
+		returnValue.set(array, offset);
+		offset += array.length;
+	}
+	return returnValue;
+}
 new globalThis.TextDecoder("utf8");
 new globalThis.TextEncoder();
 Array.from({ length: 256 }, (_, index) => index.toString(16).padStart(2, "0"));
@@ -1927,7 +1903,7 @@ function getUintBE(view) {
 	if (byteLength === 1) return view.getUint8(0);
 }
 //#endregion
-//#region node_modules/file-type/util.js
+//#region node_modules/file-type/source/tokens.js
 function stringToBytes(string, encoding) {
 	if (encoding === "utf-16le") {
 		const bytes = [];
@@ -1955,7 +1931,7 @@ Checks whether the TAR checksum is valid.
 @returns {boolean} `true` if the TAR checksum is valid, otherwise `false`.
 */
 function tarHeaderChecksumMatches(arrayBuffer, offset = 0) {
-	const readSum = Number.parseInt(new StringType(6).get(arrayBuffer, 148).replace(/\0.*$/, "").trim(), 8);
+	const readSum = Number.parseInt(new StringType(6).get(arrayBuffer, 148).replace(new RegExp("\\0.*$", "v"), "").trim(), 8);
 	if (Number.isNaN(readSum)) return false;
 	let sum = 256;
 	for (let index = offset; index < offset + 148; index++) sum += arrayBuffer[index];
@@ -1967,11 +1943,11 @@ ID3 UINT32 sync-safe tokenizer token.
 28 bits (representing up to 256MB) integer, the msb is 0 to avoid "false syncsignals".
 */
 const uint32SyncSafeToken = {
-	get: (buffer, offset) => buffer[offset + 3] & 127 | buffer[offset + 2] << 7 | buffer[offset + 1] << 14 | buffer[offset] << 21,
+	get: (buffer, offset) => buffer[offset + 3] & 127 | (buffer[offset + 2] & 127) << 7 | (buffer[offset + 1] & 127) << 14 | (buffer[offset] & 127) << 21,
 	len: 4
 };
 //#endregion
-//#region node_modules/file-type/supported.js
+//#region node_modules/file-type/source/supported.js
 const extensions = [
 	"jpg",
 	"png",
@@ -2152,7 +2128,10 @@ const extensions = [
 	"ppsx",
 	"tar.gz",
 	"reg",
-	"dat"
+	"dat",
+	"key",
+	"numbers",
+	"pages"
 ];
 const mimeTypes = [
 	"image/jpeg",
@@ -2235,7 +2214,7 @@ const mimeTypes = [
 	"application/x-unix-archive",
 	"application/x-rpm",
 	"application/x-compress",
-	"application/x-lzip",
+	"application/lzip",
 	"application/x-cfb",
 	"application/x-mie",
 	"application/mxf",
@@ -2264,8 +2243,8 @@ const mimeTypes = [
 	"model/gltf-binary",
 	"application/vnd.tcpdump.pcap",
 	"audio/x-dsf",
-	"application/x.ms.shortcut",
-	"application/x.apple.alias",
+	"application/x-ms-shortcut",
+	"application/x-ft-apple.alias",
 	"audio/x-voc",
 	"audio/vnd.dolby.dd-raw",
 	"audio/x-m4a",
@@ -2305,10 +2284,10 @@ const mimeTypes = [
 	"application/x-ace-compressed",
 	"application/avro",
 	"application/vnd.iccprofile",
-	"application/x.autodesk.fbx",
+	"application/x-ft-fbx",
 	"application/vnd.visio",
 	"application/vnd.android.package-archive",
-	"application/vnd.google.draco",
+	"application/x-ft-draco",
 	"application/x-lz4",
 	"application/vnd.openxmlformats-officedocument.presentationml.template",
 	"application/vnd.openxmlformats-officedocument.spreadsheetml.template",
@@ -2329,48 +2308,14 @@ const mimeTypes = [
 	"application/x-spss-sav",
 	"application/x-ms-regedit",
 	"application/x-ft-windows-registry-hive",
-	"application/x-jmp-data"
+	"application/x-jmp-data",
+	"application/vnd.apple.keynote",
+	"application/vnd.apple.numbers",
+	"application/vnd.apple.pages"
 ];
 //#endregion
-//#region node_modules/file-type/core.js
-/**
-Primary entry point, Node.js specific entry point is index.js
-*/
-const reasonableDetectionSizeInBytes = 4100;
-const maximumMpegOffsetTolerance = reasonableDetectionSizeInBytes - 2;
-const maximumZipEntrySizeInBytes = 1024 * 1024;
-const maximumZipEntryCount = 1024;
-const maximumZipBufferedReadSizeInBytes = 2 ** 31 - 1;
-const maximumUntrustedSkipSizeInBytes = 16 * 1024 * 1024;
-const maximumZipTextEntrySizeInBytes = maximumZipEntrySizeInBytes;
-const maximumNestedGzipDetectionSizeInBytes = maximumUntrustedSkipSizeInBytes;
-const maximumNestedGzipProbeDepth = 1;
-const maximumId3HeaderSizeInBytes = maximumUntrustedSkipSizeInBytes;
-const maximumEbmlDocumentTypeSizeInBytes = 64;
-const maximumEbmlElementPayloadSizeInBytes = maximumUntrustedSkipSizeInBytes;
-const maximumEbmlElementCount = 256;
-const maximumPngChunkCount = 512;
-const maximumAsfHeaderObjectCount = 512;
-const maximumTiffTagCount = 512;
-const maximumDetectionReentryCount = 256;
-const maximumPngChunkSizeInBytes = maximumUntrustedSkipSizeInBytes;
-const maximumTiffIfdOffsetInBytes = maximumUntrustedSkipSizeInBytes;
-const recoverableZipErrorMessages = new Set([
-	"Unexpected signature",
-	"Encrypted ZIP",
-	"Expected Central-File-Header signature"
-]);
-const recoverableZipErrorMessagePrefixes = [
-	"ZIP entry count exceeds ",
-	"Unsupported ZIP compression method:",
-	"ZIP entry compressed data exceeds ",
-	"ZIP entry decompressed data exceeds "
-];
-const recoverableZipErrorCodes = new Set([
-	"Z_BUF_ERROR",
-	"Z_DATA_ERROR",
-	"ERR_INVALID_STATE"
-]);
+//#region node_modules/file-type/source/parser.js
+const maximumUntrustedSkipSizeInBytes = 16777216;
 var ParserHardLimitError = class extends Error {};
 function getSafeBound(value, maximum, reason) {
 	if (!Number.isFinite(value) || value < 0 || value > maximum) throw new ParserHardLimitError(`${reason} has invalid size ${value} (maximum ${maximum} bytes)`);
@@ -2387,154 +2332,133 @@ async function safeReadBuffer(tokenizer, buffer, options, { maximumLength = buff
 		length: safeLength
 	});
 }
-async function decompressDeflateRawWithLimit(data, { maximumLength = maximumZipEntrySizeInBytes } = {}) {
-	const reader = new ReadableStream({ start(controller) {
-		controller.enqueue(data);
-		controller.close();
-	} }).pipeThrough(new DecompressionStream("deflate-raw")).getReader();
-	const chunks = [];
-	let totalLength = 0;
-	try {
-		for (;;) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			totalLength += value.length;
-			if (totalLength > maximumLength) {
-				await reader.cancel();
-				throw new Error(`ZIP entry decompressed data exceeds ${maximumLength} bytes`);
-			}
-			chunks.push(value);
-		}
-	} finally {
-		reader.releaseLock();
-	}
-	const uncompressedData = new Uint8Array(totalLength);
-	let offset = 0;
-	for (const chunk of chunks) {
-		uncompressedData.set(chunk, offset);
-		offset += chunk.length;
-	}
-	return uncompressedData;
-}
-const zipDataDescriptorSignature = 134695760;
-const zipDataDescriptorLengthInBytes = 16;
-const zipDataDescriptorOverlapLengthInBytes = zipDataDescriptorLengthInBytes - 1;
-function findZipDataDescriptorOffset(buffer, bytesConsumed) {
-	if (buffer.length < zipDataDescriptorLengthInBytes) return -1;
-	const lastPossibleDescriptorOffset = buffer.length - zipDataDescriptorLengthInBytes;
-	for (let index = 0; index <= lastPossibleDescriptorOffset; index++) if (UINT32_LE.get(buffer, index) === zipDataDescriptorSignature && UINT32_LE.get(buffer, index + 8) === bytesConsumed + index) return index;
-	return -1;
-}
-function mergeByteChunks(chunks, totalLength) {
-	const merged = new Uint8Array(totalLength);
-	let offset = 0;
-	for (const chunk of chunks) {
-		merged.set(chunk, offset);
-		offset += chunk.length;
-	}
-	return merged;
+function checkBytes(buffer, headers, options) {
+	options = {
+		offset: 0,
+		...options
+	};
+	for (const [index, header] of headers.entries()) if (options.mask) {
+		if (header !== (options.mask[index] & buffer[index + options.offset])) return false;
+	} else if (header !== buffer[index + options.offset]) return false;
+	return true;
 }
-async function readZipDataDescriptorEntryWithLimit(zipHandler, { shouldBuffer, maximumLength = maximumZipEntrySizeInBytes } = {}) {
-	const { syncBuffer } = zipHandler;
-	const { length: syncBufferLength } = syncBuffer;
-	const chunks = [];
-	let bytesConsumed = 0;
-	for (;;) {
-		const length = await zipHandler.tokenizer.peekBuffer(syncBuffer, { mayBeLess: true });
-		const dataDescriptorOffset = findZipDataDescriptorOffset(syncBuffer.subarray(0, length), bytesConsumed);
-		const retainedLength = dataDescriptorOffset >= 0 ? 0 : length === syncBufferLength ? Math.min(zipDataDescriptorOverlapLengthInBytes, length - 1) : 0;
-		const chunkLength = dataDescriptorOffset >= 0 ? dataDescriptorOffset : length - retainedLength;
-		if (chunkLength === 0) break;
-		bytesConsumed += chunkLength;
-		if (bytesConsumed > maximumLength) throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
-		if (shouldBuffer) {
-			const data = new Uint8Array(chunkLength);
-			await zipHandler.tokenizer.readBuffer(data);
-			chunks.push(data);
-		} else await zipHandler.tokenizer.ignore(chunkLength);
-		if (dataDescriptorOffset >= 0) break;
-	}
-	if (!shouldBuffer) return;
-	return mergeByteChunks(chunks, bytesConsumed);
+function hasUnknownFileSize(tokenizer) {
+	const fileSize = tokenizer.fileInfo.size;
+	return !Number.isFinite(fileSize) || fileSize === Number.MAX_SAFE_INTEGER;
 }
-async function readZipEntryData(zipHandler, zipHeader, { shouldBuffer } = {}) {
-	if (zipHeader.dataDescriptor && zipHeader.compressedSize === 0) return readZipDataDescriptorEntryWithLimit(zipHandler, { shouldBuffer });
-	if (!shouldBuffer) {
-		await zipHandler.tokenizer.ignore(zipHeader.compressedSize);
-		return;
-	}
-	const maximumLength = getMaximumZipBufferedReadLength(zipHandler.tokenizer);
-	if (!Number.isFinite(zipHeader.compressedSize) || zipHeader.compressedSize < 0 || zipHeader.compressedSize > maximumLength) throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
-	const fileData = new Uint8Array(zipHeader.compressedSize);
-	await zipHandler.tokenizer.readBuffer(fileData);
-	return fileData;
+function hasExceededUnknownSizeScanBudget(tokenizer, startOffset, maximumBytes) {
+	return hasUnknownFileSize(tokenizer) && tokenizer.position - startOffset > maximumBytes;
 }
-ZipHandler.prototype.inflate = async function(zipHeader, fileData, callback) {
-	if (zipHeader.compressedMethod === 0) return callback(fileData);
-	if (zipHeader.compressedMethod !== 8) throw new Error(`Unsupported ZIP compression method: ${zipHeader.compressedMethod}`);
-	return callback(await decompressDeflateRawWithLimit(fileData, { maximumLength: maximumZipEntrySizeInBytes }));
-};
-ZipHandler.prototype.unzip = async function(fileCallback) {
-	let stop = false;
-	let zipEntryCount = 0;
-	do {
-		const zipHeader = await this.readLocalFileHeader();
-		if (!zipHeader) break;
-		zipEntryCount++;
-		if (zipEntryCount > maximumZipEntryCount) throw new Error(`ZIP entry count exceeds ${maximumZipEntryCount}`);
-		const next = fileCallback(zipHeader);
-		stop = Boolean(next.stop);
-		await this.tokenizer.ignore(zipHeader.extraFieldLength);
-		const fileData = await readZipEntryData(this, zipHeader, { shouldBuffer: Boolean(next.handler) });
-		if (next.handler) await this.inflate(zipHeader, fileData, next.handler);
-		if (zipHeader.dataDescriptor) {
-			const dataDescriptor = new Uint8Array(zipDataDescriptorLengthInBytes);
-			await this.tokenizer.readBuffer(dataDescriptor);
-			if (UINT32_LE.get(dataDescriptor, 0) !== zipDataDescriptorSignature) throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - dataDescriptor.length}`);
-		}
-	} while (!stop);
-};
-function createByteLimitedReadableStream(stream, maximumBytes) {
-	const reader = stream.getReader();
-	let emittedBytes = 0;
-	let sourceDone = false;
-	let sourceCanceled = false;
-	const cancelSource = async (reason) => {
-		if (sourceDone || sourceCanceled) return;
-		sourceCanceled = true;
-		await reader.cancel(reason);
-	};
-	return new ReadableStream({
-		async pull(controller) {
-			if (emittedBytes >= maximumBytes) {
-				controller.close();
-				await cancelSource();
-				return;
-			}
-			const { done, value } = await reader.read();
-			if (done || !value) {
-				sourceDone = true;
-				controller.close();
-				return;
-			}
-			const remainingBytes = maximumBytes - emittedBytes;
-			if (value.length > remainingBytes) {
-				controller.enqueue(value.subarray(0, remainingBytes));
-				emittedBytes += remainingBytes;
-				controller.close();
-				await cancelSource();
-				return;
+//#endregion
+//#region node_modules/file-type/source/detectors/zip.js
+const maximumZipEntrySizeInBytes = 1048576;
+const maximumZipEntryCount = 1024;
+const maximumZipBufferedReadSizeInBytes = 2 ** 31 - 1;
+const maximumZipTextEntrySizeInBytes = maximumZipEntrySizeInBytes;
+const recoverableZipErrorMessages = /* @__PURE__ */ new Set([
+	"Unexpected signature",
+	"Encrypted ZIP",
+	"Expected Central-File-Header signature"
+]);
+const recoverableZipErrorMessagePrefixes = [
+	"ZIP entry count exceeds ",
+	"Unsupported ZIP compression method:",
+	"ZIP entry compressed data exceeds ",
+	"ZIP entry decompressed data exceeds ",
+	"Expected data-descriptor-signature at position "
+];
+const recoverableZipErrorCodes = /* @__PURE__ */ new Set([
+	"Z_BUF_ERROR",
+	"Z_DATA_ERROR",
+	"ERR_INVALID_STATE"
+]);
+async function decompressDeflateRawWithLimit(data, { maximumLength = maximumZipEntrySizeInBytes } = {}) {
+	const reader = new ReadableStream({ start(controller) {
+		controller.enqueue(data);
+		controller.close();
+	} }).pipeThrough(new DecompressionStream("deflate-raw")).getReader();
+	const chunks = [];
+	let totalLength = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			totalLength += value.length;
+			if (totalLength > maximumLength) {
+				await reader.cancel().catch(() => {});
+				throw new Error(`ZIP entry decompressed data exceeds ${maximumLength} bytes`);
 			}
-			controller.enqueue(value);
-			emittedBytes += value.length;
-		},
-		async cancel(reason) {
-			await cancelSource(reason);
+			chunks.push(value);
 		}
-	});
+	} catch (error) {
+		if (error.code !== "ERR_TRAILING_JUNK_AFTER_STREAM_END") throw error;
+	} finally {
+		reader.releaseLock();
+	}
+	const uncompressedData = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		uncompressedData.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return uncompressedData;
 }
-async function fileTypeFromBlob(blob, options) {
-	return new FileTypeParser(options).fromBlob(blob);
+function mergeByteChunks(chunks, totalLength) {
+	const merged = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return merged;
+}
+function getMaximumZipBufferedReadLength(tokenizer) {
+	const fileSize = tokenizer.fileInfo.size;
+	const remainingBytes = Number.isFinite(fileSize) ? Math.max(0, fileSize - tokenizer.position) : Number.MAX_SAFE_INTEGER;
+	return Math.min(remainingBytes, maximumZipBufferedReadSizeInBytes);
+}
+function isRecoverableZipError(error) {
+	if (error instanceof EndOfStreamError) return true;
+	if (error instanceof ParserHardLimitError) return true;
+	if (!(error instanceof Error)) return false;
+	if (recoverableZipErrorMessages.has(error.message)) return true;
+	if (recoverableZipErrorCodes.has(error.code)) return true;
+	for (const prefix of recoverableZipErrorMessagePrefixes) if (error.message.startsWith(prefix)) return true;
+	return false;
+}
+function canReadZipEntryForDetection(zipHeader, maximumSize = maximumZipEntrySizeInBytes) {
+	const sizes = [zipHeader.compressedSize, zipHeader.uncompressedSize];
+	for (const size of sizes) if (!Number.isFinite(size) || size < 0 || size > maximumSize) return false;
+	return true;
+}
+function createIWorkZipDetectionState() {
+	return {
+		hasDocumentEntry: false,
+		hasMasterSlideEntry: false,
+		hasTablesEntry: false,
+		hasCalculationEngineEntry: false
+	};
+}
+function updateIWorkZipDetectionStateFromFilename(iWorkState, filename) {
+	if (filename === "Index/Document.iwa") iWorkState.hasDocumentEntry = true;
+	if (filename.startsWith("Index/MasterSlide")) iWorkState.hasMasterSlideEntry = true;
+	if (filename.startsWith("Index/Tables/")) iWorkState.hasTablesEntry = true;
+	if (filename === "Index/CalculationEngine.iwa") iWorkState.hasCalculationEngineEntry = true;
+}
+function getIWorkFileTypeFromZipEntries(iWorkState) {
+	if (!iWorkState.hasDocumentEntry) return;
+	if (iWorkState.hasMasterSlideEntry) return {
+		ext: "key",
+		mime: "application/vnd.apple.keynote"
+	};
+	if (iWorkState.hasTablesEntry) return {
+		ext: "numbers",
+		mime: "application/vnd.apple.numbers"
+	};
+	return {
+		ext: "pages",
+		mime: "application/vnd.apple.pages"
+	};
 }
 function getFileTypeFromMimeType(mimeType) {
 	mimeType = mimeType.toLowerCase();
@@ -2639,19 +2563,495 @@ function getFileTypeFromMimeType(mimeType) {
 			ext: "3mf",
 			mime: "model/3mf"
 		};
-		default:
 	}
-}
-function _check(buffer, headers, options) {
-	options = {
-		offset: 0,
-		...options
+}
+function createOpenXmlZipDetectionState() {
+	return {
+		hasContentTypesEntry: false,
+		hasParsedContentTypesEntry: false,
+		isParsingContentTypes: false,
+		hasUnparseableContentTypes: false,
+		hasWordDirectory: false,
+		hasPresentationDirectory: false,
+		hasSpreadsheetDirectory: false,
+		hasThreeDimensionalModelEntry: false
+	};
+}
+function updateOpenXmlZipDetectionStateFromFilename(openXmlState, filename) {
+	if (filename.startsWith("word/")) openXmlState.hasWordDirectory = true;
+	if (filename.startsWith("ppt/")) openXmlState.hasPresentationDirectory = true;
+	if (filename.startsWith("xl/")) openXmlState.hasSpreadsheetDirectory = true;
+	if (filename.startsWith("3D/") && filename.endsWith(".model")) openXmlState.hasThreeDimensionalModelEntry = true;
+}
+function getOpenXmlFileTypeFromDirectoryNames(openXmlState) {
+	if (openXmlState.hasWordDirectory) return {
+		ext: "docx",
+		mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+	};
+	if (openXmlState.hasPresentationDirectory) return {
+		ext: "pptx",
+		mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+	};
+	if (openXmlState.hasSpreadsheetDirectory) return {
+		ext: "xlsx",
+		mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+	};
+	if (openXmlState.hasThreeDimensionalModelEntry) return {
+		ext: "3mf",
+		mime: "model/3mf"
+	};
+}
+function getOpenXmlFileTypeFromZipEntries(openXmlState) {
+	if (!openXmlState.hasContentTypesEntry || openXmlState.hasUnparseableContentTypes || openXmlState.isParsingContentTypes || openXmlState.hasParsedContentTypesEntry) return;
+	return getOpenXmlFileTypeFromDirectoryNames(openXmlState);
+}
+function getOpenXmlMimeTypeFromContentTypesXml(xmlContent) {
+	const endPosition = xmlContent.indexOf(".main+xml\"");
+	if (endPosition === -1) {
+		const mimeType = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml";
+		if (xmlContent.includes(`ContentType="${mimeType}"`)) return mimeType;
+		return;
+	}
+	const truncatedContent = xmlContent.slice(0, endPosition);
+	const firstQuotePosition = truncatedContent.lastIndexOf("\"");
+	return truncatedContent.slice(firstQuotePosition + 1);
+}
+const zipDataDescriptorSignature = 134695760;
+const zipDataDescriptorLengthInBytes = 16;
+const zipDataDescriptorOverlapLengthInBytes = 15;
+function findZipDataDescriptorOffset(buffer, bytesConsumed) {
+	if (buffer.length < zipDataDescriptorLengthInBytes) return -1;
+	const lastPossibleDescriptorOffset = buffer.length - zipDataDescriptorLengthInBytes;
+	for (let index = 0; index <= lastPossibleDescriptorOffset; index++) if (UINT32_LE.get(buffer, index) === zipDataDescriptorSignature && UINT32_LE.get(buffer, index + 8) === bytesConsumed + index) return index;
+	return -1;
+}
+async function readZipDataDescriptorEntryWithLimit(zipHandler, { shouldBuffer, maximumLength = maximumZipEntrySizeInBytes } = {}) {
+	const { syncBuffer } = zipHandler;
+	const { length: syncBufferLength } = syncBuffer;
+	const chunks = [];
+	let bytesConsumed = 0;
+	for (;;) {
+		const length = await zipHandler.tokenizer.peekBuffer(syncBuffer, { mayBeLess: true });
+		const dataDescriptorOffset = findZipDataDescriptorOffset(syncBuffer.subarray(0, length), bytesConsumed);
+		const retainedLength = dataDescriptorOffset >= 0 ? 0 : length === syncBufferLength ? Math.min(zipDataDescriptorOverlapLengthInBytes, length - 1) : 0;
+		const chunkLength = dataDescriptorOffset >= 0 ? dataDescriptorOffset : length - retainedLength;
+		if (chunkLength === 0) break;
+		bytesConsumed += chunkLength;
+		if (bytesConsumed > maximumLength) throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+		if (shouldBuffer) {
+			const data = new Uint8Array(chunkLength);
+			await zipHandler.tokenizer.readBuffer(data);
+			chunks.push(data);
+		} else await zipHandler.tokenizer.ignore(chunkLength);
+		if (dataDescriptorOffset >= 0) break;
+	}
+	if (!hasUnknownFileSize(zipHandler.tokenizer)) zipHandler.knownSizeDescriptorScannedBytes += bytesConsumed;
+	if (!shouldBuffer) return;
+	return mergeByteChunks(chunks, bytesConsumed);
+}
+function getRemainingZipScanBudget(zipHandler, startOffset) {
+	if (hasUnknownFileSize(zipHandler.tokenizer)) return Math.max(0, maximumUntrustedSkipSizeInBytes - (zipHandler.tokenizer.position - startOffset));
+	return Math.max(0, maximumZipEntrySizeInBytes - zipHandler.knownSizeDescriptorScannedBytes);
+}
+async function readZipEntryData(zipHandler, zipHeader, { shouldBuffer, maximumDescriptorLength = maximumZipEntrySizeInBytes } = {}) {
+	if (zipHeader.dataDescriptor && zipHeader.compressedSize === 0) return readZipDataDescriptorEntryWithLimit(zipHandler, {
+		shouldBuffer,
+		maximumLength: maximumDescriptorLength
+	});
+	if (!shouldBuffer) {
+		await safeIgnore(zipHandler.tokenizer, zipHeader.compressedSize, {
+			maximumLength: hasUnknownFileSize(zipHandler.tokenizer) ? maximumZipEntrySizeInBytes : zipHandler.tokenizer.fileInfo.size,
+			reason: "ZIP entry compressed data"
+		});
+		return;
+	}
+	const maximumLength = getMaximumZipBufferedReadLength(zipHandler.tokenizer);
+	if (!Number.isFinite(zipHeader.compressedSize) || zipHeader.compressedSize < 0 || zipHeader.compressedSize > maximumLength) throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+	const fileData = new Uint8Array(zipHeader.compressedSize);
+	await zipHandler.tokenizer.readBuffer(fileData);
+	return fileData;
+}
+ZipHandler.prototype.inflate = async function(zipHeader, fileData, callback) {
+	if (zipHeader.compressedMethod === 0) return callback(fileData);
+	if (zipHeader.compressedMethod !== 8) throw new Error(`Unsupported ZIP compression method: ${zipHeader.compressedMethod}`);
+	return callback(await decompressDeflateRawWithLimit(fileData, { maximumLength: maximumZipEntrySizeInBytes }));
+};
+ZipHandler.prototype.unzip = async function(fileCallback) {
+	let stop = false;
+	let zipEntryCount = 0;
+	const zipScanStart = this.tokenizer.position;
+	this.knownSizeDescriptorScannedBytes = 0;
+	do {
+		if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, 16777216)) throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
+		const zipHeader = await this.readLocalFileHeader();
+		if (!zipHeader) break;
+		zipEntryCount++;
+		if (zipEntryCount > maximumZipEntryCount) throw new Error(`ZIP entry count exceeds ${maximumZipEntryCount}`);
+		const next = fileCallback(zipHeader);
+		stop = Boolean(next.stop);
+		await this.tokenizer.ignore(zipHeader.extraFieldLength);
+		const fileData = await readZipEntryData(this, zipHeader, {
+			shouldBuffer: Boolean(next.handler),
+			maximumDescriptorLength: Math.min(maximumZipEntrySizeInBytes, getRemainingZipScanBudget(this, zipScanStart))
+		});
+		if (next.handler) await this.inflate(zipHeader, fileData, next.handler);
+		if (zipHeader.dataDescriptor) {
+			const dataDescriptor = new Uint8Array(zipDataDescriptorLengthInBytes);
+			await this.tokenizer.readBuffer(dataDescriptor);
+			if (UINT32_LE.get(dataDescriptor, 0) !== zipDataDescriptorSignature) throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - dataDescriptor.length}`);
+		}
+		if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, 16777216)) throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
+	} while (!stop);
+};
+async function detectZip(tokenizer) {
+	let fileType;
+	const openXmlState = createOpenXmlZipDetectionState();
+	const iWorkState = createIWorkZipDetectionState();
+	try {
+		await new ZipHandler(tokenizer).unzip((zipHeader) => {
+			updateOpenXmlZipDetectionStateFromFilename(openXmlState, zipHeader.filename);
+			updateIWorkZipDetectionStateFromFilename(iWorkState, zipHeader.filename);
+			if (iWorkState.hasDocumentEntry && (iWorkState.hasMasterSlideEntry || iWorkState.hasTablesEntry)) {
+				fileType = getIWorkFileTypeFromZipEntries(iWorkState);
+				return { stop: true };
+			}
+			const isOpenXmlContentTypesEntry = zipHeader.filename === "[Content_Types].xml";
+			const openXmlFileTypeFromEntries = getOpenXmlFileTypeFromZipEntries(openXmlState);
+			if (!isOpenXmlContentTypesEntry && openXmlFileTypeFromEntries) {
+				fileType = openXmlFileTypeFromEntries;
+				return { stop: true };
+			}
+			switch (zipHeader.filename) {
+				case "META-INF/mozilla.rsa":
+					fileType = {
+						ext: "xpi",
+						mime: "application/x-xpinstall"
+					};
+					return { stop: true };
+				case "META-INF/MANIFEST.MF":
+					fileType = {
+						ext: "jar",
+						mime: "application/java-archive"
+					};
+					return { stop: true };
+				case "mimetype":
+					if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) return {};
+					return {
+						async handler(fileData) {
+							fileType = getFileTypeFromMimeType(new TextDecoder("utf-8").decode(fileData).trim());
+						},
+						stop: true
+					};
+				case "[Content_Types].xml":
+					openXmlState.hasContentTypesEntry = true;
+					if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) {
+						openXmlState.hasUnparseableContentTypes = true;
+						return {};
+					}
+					openXmlState.isParsingContentTypes = true;
+					return {
+						async handler(fileData) {
+							const mimeType = getOpenXmlMimeTypeFromContentTypesXml(new TextDecoder("utf-8").decode(fileData));
+							if (mimeType) fileType = getFileTypeFromMimeType(mimeType);
+							openXmlState.hasParsedContentTypesEntry = true;
+							openXmlState.isParsingContentTypes = false;
+						},
+						stop: true
+					};
+				default:
+					if (new RegExp("classes\\d*\\.dex", "v").test(zipHeader.filename)) {
+						fileType = {
+							ext: "apk",
+							mime: "application/vnd.android.package-archive"
+						};
+						return { stop: true };
+					}
+					return {};
+			}
+		});
+	} catch (error) {
+		if (!isRecoverableZipError(error)) throw error;
+		if (openXmlState.isParsingContentTypes) {
+			openXmlState.isParsingContentTypes = false;
+			openXmlState.hasUnparseableContentTypes = true;
+		}
+		if (!fileType && error instanceof EndOfStreamError && !openXmlState.hasContentTypesEntry) fileType = getOpenXmlFileTypeFromDirectoryNames(openXmlState);
+	}
+	const iWorkFileType = hasUnknownFileSize(tokenizer) && iWorkState.hasDocumentEntry && !iWorkState.hasMasterSlideEntry && !iWorkState.hasTablesEntry && !iWorkState.hasCalculationEngineEntry ? void 0 : getIWorkFileTypeFromZipEntries(iWorkState);
+	return fileType ?? getOpenXmlFileTypeFromZipEntries(openXmlState) ?? iWorkFileType ?? {
+		ext: "zip",
+		mime: "application/zip"
+	};
+}
+//#endregion
+//#region node_modules/file-type/source/detectors/ebml.js
+const maximumEbmlDocumentTypeSizeInBytes = 64;
+const maximumEbmlElementPayloadSizeInBytes = 1048576;
+const maximumEbmlElementCount = 256;
+async function detectEbml(tokenizer) {
+	async function readField() {
+		const msb = await tokenizer.peekNumber(UINT8);
+		let mask = 128;
+		let ic = 0;
+		while ((msb & mask) === 0 && mask !== 0) {
+			++ic;
+			mask >>= 1;
+		}
+		const id = new Uint8Array(ic + 1);
+		await safeReadBuffer(tokenizer, id, void 0, {
+			maximumLength: id.length,
+			reason: "EBML field"
+		});
+		return id;
+	}
+	async function readElement() {
+		const idField = await readField();
+		const lengthField = await readField();
+		lengthField[0] ^= 128 >> lengthField.length - 1;
+		const nrLength = Math.min(6, lengthField.length);
+		const idView = new DataView(idField.buffer);
+		const lengthView = new DataView(lengthField.buffer, lengthField.length - nrLength, nrLength);
+		return {
+			id: getUintBE(idView),
+			len: getUintBE(lengthView)
+		};
+	}
+	async function readChildren(children) {
+		let ebmlElementCount = 0;
+		while (children > 0) {
+			ebmlElementCount++;
+			if (ebmlElementCount > maximumEbmlElementCount) return;
+			if (hasExceededUnknownSizeScanBudget(tokenizer, ebmlScanStart, 16777216)) return;
+			const previousPosition = tokenizer.position;
+			const element = await readElement();
+			if (element.id === 17026) {
+				if (element.len > maximumEbmlDocumentTypeSizeInBytes) return;
+				const documentTypeLength = getSafeBound(element.len, maximumEbmlDocumentTypeSizeInBytes, "EBML DocType");
+				return (await tokenizer.readToken(new StringType(documentTypeLength))).replaceAll(new RegExp("\\0.*$", "gv"), "");
+			}
+			if (hasUnknownFileSize(tokenizer) && (!Number.isFinite(element.len) || element.len < 0 || element.len > maximumEbmlElementPayloadSizeInBytes)) return;
+			await safeIgnore(tokenizer, element.len, {
+				maximumLength: hasUnknownFileSize(tokenizer) ? maximumEbmlElementPayloadSizeInBytes : tokenizer.fileInfo.size,
+				reason: "EBML payload"
+			});
+			--children;
+			if (tokenizer.position <= previousPosition) return;
+		}
+	}
+	const rootElement = await readElement();
+	const ebmlScanStart = tokenizer.position;
+	switch (await readChildren(rootElement.len)) {
+		case "webm": return {
+			ext: "webm",
+			mime: "video/webm"
+		};
+		case "matroska": return {
+			ext: "mkv",
+			mime: "video/matroska"
+		};
+	}
+}
+//#endregion
+//#region node_modules/file-type/source/detectors/png.js
+const maximumPngChunkCount = 512;
+const maximumPngStreamScanBudgetInBytes = 16777216;
+const maximumPngChunkSizeInBytes = 1048576;
+function isPngAncillaryChunk(type) {
+	return (type.codePointAt(0) & 32) !== 0;
+}
+async function detectPng(tokenizer) {
+	const pngFileType = {
+		ext: "png",
+		mime: "image/png"
+	};
+	const apngFileType = {
+		ext: "apng",
+		mime: "image/apng"
+	};
+	await tokenizer.ignore(8);
+	async function readChunkHeader() {
+		return {
+			length: await tokenizer.readToken(INT32_BE),
+			type: await tokenizer.readToken(new StringType(4, "latin1"))
+		};
+	}
+	const isUnknownPngStream = hasUnknownFileSize(tokenizer);
+	const pngScanStart = tokenizer.position;
+	let pngChunkCount = 0;
+	let hasSeenImageHeader = false;
+	do {
+		pngChunkCount++;
+		if (pngChunkCount > maximumPngChunkCount) break;
+		if (hasExceededUnknownSizeScanBudget(tokenizer, pngScanStart, maximumPngStreamScanBudgetInBytes)) break;
+		const previousPosition = tokenizer.position;
+		const chunk = await readChunkHeader();
+		if (chunk.length < 0) return;
+		if (chunk.type === "IHDR") {
+			if (chunk.length !== 13) return;
+			hasSeenImageHeader = true;
+		}
+		switch (chunk.type) {
+			case "IDAT": return pngFileType;
+			case "acTL": return apngFileType;
+			default:
+				if (!hasSeenImageHeader && chunk.type !== "CgBI") return;
+				if (isUnknownPngStream && chunk.length > maximumPngChunkSizeInBytes) return hasSeenImageHeader && isPngAncillaryChunk(chunk.type) ? pngFileType : void 0;
+				try {
+					await safeIgnore(tokenizer, chunk.length + 4, {
+						maximumLength: isUnknownPngStream ? 1048580 : tokenizer.fileInfo.size,
+						reason: "PNG chunk payload"
+					});
+				} catch (error) {
+					if (!isUnknownPngStream && (error instanceof ParserHardLimitError || error instanceof EndOfStreamError)) return pngFileType;
+					throw error;
+				}
+		}
+		if (tokenizer.position <= previousPosition) break;
+	} while (tokenizer.position + 8 < tokenizer.fileInfo.size);
+	return pngFileType;
+}
+//#endregion
+//#region node_modules/file-type/source/detectors/asf.js
+const maximumAsfHeaderObjectCount = 512;
+const maximumAsfHeaderPayloadSizeInBytes = 1048576;
+async function detectAsf(tokenizer) {
+	let isMalformedAsf = false;
+	try {
+		async function readHeader() {
+			const guid = /* @__PURE__ */ new Uint8Array(16);
+			await safeReadBuffer(tokenizer, guid, void 0, {
+				maximumLength: guid.length,
+				reason: "ASF header GUID"
+			});
+			return {
+				id: guid,
+				size: Number(await tokenizer.readToken(UINT64_LE))
+			};
+		}
+		await safeIgnore(tokenizer, 30, {
+			maximumLength: 30,
+			reason: "ASF header prelude"
+		});
+		const isUnknownFileSize = hasUnknownFileSize(tokenizer);
+		const asfHeaderScanStart = tokenizer.position;
+		let asfHeaderObjectCount = 0;
+		while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
+			asfHeaderObjectCount++;
+			if (asfHeaderObjectCount > maximumAsfHeaderObjectCount) break;
+			if (hasExceededUnknownSizeScanBudget(tokenizer, asfHeaderScanStart, 16777216)) break;
+			const previousPosition = tokenizer.position;
+			const header = await readHeader();
+			let payload = header.size - 24;
+			if (!Number.isFinite(payload) || payload < 0) {
+				isMalformedAsf = true;
+				break;
+			}
+			if (checkBytes(header.id, [
+				145,
+				7,
+				220,
+				183,
+				183,
+				169,
+				207,
+				17,
+				142,
+				230,
+				0,
+				192,
+				12,
+				32,
+				83,
+				101
+			])) {
+				const typeId = /* @__PURE__ */ new Uint8Array(16);
+				payload -= await safeReadBuffer(tokenizer, typeId, void 0, {
+					maximumLength: typeId.length,
+					reason: "ASF stream type GUID"
+				});
+				if (checkBytes(typeId, [
+					64,
+					158,
+					105,
+					248,
+					77,
+					91,
+					207,
+					17,
+					168,
+					253,
+					0,
+					128,
+					95,
+					92,
+					68,
+					43
+				])) return {
+					ext: "asf",
+					mime: "audio/x-ms-asf"
+				};
+				if (checkBytes(typeId, [
+					192,
+					239,
+					25,
+					188,
+					77,
+					91,
+					207,
+					17,
+					168,
+					253,
+					0,
+					128,
+					95,
+					92,
+					68,
+					43
+				])) return {
+					ext: "asf",
+					mime: "video/x-ms-asf"
+				};
+				break;
+			}
+			if (isUnknownFileSize && payload > maximumAsfHeaderPayloadSizeInBytes) {
+				isMalformedAsf = true;
+				break;
+			}
+			await safeIgnore(tokenizer, payload, {
+				maximumLength: isUnknownFileSize ? maximumAsfHeaderPayloadSizeInBytes : tokenizer.fileInfo.size,
+				reason: "ASF header payload"
+			});
+			if (tokenizer.position <= previousPosition) {
+				isMalformedAsf = true;
+				break;
+			}
+		}
+	} catch (error) {
+		if (error instanceof EndOfStreamError || error instanceof ParserHardLimitError) {
+			if (hasUnknownFileSize(tokenizer)) isMalformedAsf = true;
+		} else throw error;
+	}
+	if (isMalformedAsf) return;
+	return {
+		ext: "asf",
+		mime: "application/vnd.ms-asf"
 	};
-	for (const [index, header] of headers.entries()) if (options.mask) {
-		if (header !== (options.mask[index] & buffer[index + options.offset])) return false;
-	} else if (header !== buffer[index + options.offset]) return false;
-	return true;
 }
+//#endregion
+//#region node_modules/file-type/source/index.js
+/**
+Primary entry point, Node.js specific entry point is index.js
+*/
+const reasonableDetectionSizeInBytes = 4100;
+const maximumMpegOffsetTolerance = 4096;
+const maximumNestedGzipDetectionSizeInBytes = maximumUntrustedSkipSizeInBytes;
+const maximumNestedGzipProbeDepth = 1;
+const unknownSizeGzipProbeTimeoutInMilliseconds = 100;
+const maximumId3HeaderSizeInBytes = maximumUntrustedSkipSizeInBytes;
+const maximumTiffTagCount = 512;
+const maximumDetectionReentryCount = 256;
+const maximumTiffStreamIfdOffsetInBytes = 1048576;
+const maximumTiffIfdOffsetInBytes = maximumUntrustedSkipSizeInBytes;
 function normalizeSampleSize(sampleSize) {
 	if (!Number.isFinite(sampleSize)) return reasonableDetectionSizeInBytes;
 	return Math.max(1, Math.trunc(sampleSize));
@@ -2664,81 +3064,65 @@ function getKnownFileSizeOrMaximum(fileSize) {
 	if (!Number.isFinite(fileSize)) return Number.MAX_SAFE_INTEGER;
 	return Math.max(0, fileSize);
 }
-function hasUnknownFileSize(tokenizer) {
-	const fileSize = tokenizer.fileInfo.size;
-	return !Number.isFinite(fileSize) || fileSize === Number.MAX_SAFE_INTEGER;
-}
-function hasExceededUnknownSizeScanBudget(tokenizer, startOffset, maximumBytes) {
-	return hasUnknownFileSize(tokenizer) && tokenizer.position - startOffset > maximumBytes;
-}
-function getMaximumZipBufferedReadLength(tokenizer) {
-	const fileSize = tokenizer.fileInfo.size;
-	const remainingBytes = Number.isFinite(fileSize) ? Math.max(0, fileSize - tokenizer.position) : Number.MAX_SAFE_INTEGER;
-	return Math.min(remainingBytes, maximumZipBufferedReadSizeInBytes);
-}
-function isRecoverableZipError(error) {
-	if (error instanceof EndOfStreamError) return true;
-	if (error instanceof ParserHardLimitError) return true;
-	if (!(error instanceof Error)) return false;
-	if (recoverableZipErrorMessages.has(error.message)) return true;
-	if (recoverableZipErrorCodes.has(error.code)) return true;
-	for (const prefix of recoverableZipErrorMessagePrefixes) if (error.message.startsWith(prefix)) return true;
-	return false;
-}
-function canReadZipEntryForDetection(zipHeader, maximumSize = maximumZipEntrySizeInBytes) {
-	const sizes = [zipHeader.compressedSize, zipHeader.uncompressedSize];
-	for (const size of sizes) if (!Number.isFinite(size) || size < 0 || size > maximumSize) return false;
-	return true;
+function importAtRuntime(specifier) {
+	return import(specifier);
 }
-function createOpenXmlZipDetectionState() {
-	return {
-		hasContentTypesEntry: false,
-		hasParsedContentTypesEntry: false,
-		isParsingContentTypes: false,
-		hasUnparseableContentTypes: false,
-		hasWordDirectory: false,
-		hasPresentationDirectory: false,
-		hasSpreadsheetDirectory: false,
-		hasThreeDimensionalModelEntry: false
-	};
+function toDefaultStream(stream) {
+	return stream.pipeThrough(new TransformStream());
 }
-function updateOpenXmlZipDetectionStateFromFilename(openXmlState, filename) {
-	if (filename.startsWith("word/")) openXmlState.hasWordDirectory = true;
-	if (filename.startsWith("ppt/")) openXmlState.hasPresentationDirectory = true;
-	if (filename.startsWith("xl/")) openXmlState.hasSpreadsheetDirectory = true;
-	if (filename.startsWith("3D/") && filename.endsWith(".model")) openXmlState.hasThreeDimensionalModelEntry = true;
+function readWithSignal(reader, signal) {
+	if (signal === void 0) return reader.read();
+	signal.throwIfAborted();
+	return Promise.race([reader.read(), new Promise((_resolve, reject) => {
+		signal.addEventListener("abort", () => {
+			reject(signal.reason);
+			reader.cancel(signal.reason).catch(() => {});
+		}, { once: true });
+	})]);
 }
-function getOpenXmlFileTypeFromZipEntries(openXmlState) {
-	if (!openXmlState.hasContentTypesEntry || openXmlState.hasUnparseableContentTypes || openXmlState.isParsingContentTypes || openXmlState.hasParsedContentTypesEntry) return;
-	if (openXmlState.hasWordDirectory) return {
-		ext: "docx",
-		mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-	};
-	if (openXmlState.hasPresentationDirectory) return {
-		ext: "pptx",
-		mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-	};
-	if (openXmlState.hasSpreadsheetDirectory) return {
-		ext: "xlsx",
-		mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-	};
-	if (openXmlState.hasThreeDimensionalModelEntry) return {
-		ext: "3mf",
-		mime: "model/3mf"
+function createByteLimitedReadableStream(stream, maximumBytes) {
+	const reader = stream.getReader();
+	let emittedBytes = 0;
+	let sourceDone = false;
+	let sourceCanceled = false;
+	const cancelSource = async (reason) => {
+		if (sourceDone || sourceCanceled) return;
+		sourceCanceled = true;
+		await reader.cancel(reason);
 	};
+	return new ReadableStream({
+		async pull(controller) {
+			if (emittedBytes >= maximumBytes) {
+				controller.close();
+				await cancelSource();
+				return;
+			}
+			const { done, value } = await reader.read();
+			if (done || !value) {
+				sourceDone = true;
+				controller.close();
+				return;
+			}
+			const remainingBytes = maximumBytes - emittedBytes;
+			if (value.length > remainingBytes) {
+				controller.enqueue(value.subarray(0, remainingBytes));
+				emittedBytes += remainingBytes;
+				controller.close();
+				await cancelSource();
+				return;
+			}
+			controller.enqueue(value);
+			emittedBytes += value.length;
+		},
+		async cancel(reason) {
+			await cancelSource(reason);
+		}
+	});
 }
-function getOpenXmlMimeTypeFromContentTypesXml(xmlContent) {
-	const endPosition = xmlContent.indexOf(".main+xml\"");
-	if (endPosition === -1) {
-		const mimeType = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml";
-		if (xmlContent.includes(`ContentType="${mimeType}"`)) return mimeType;
-		return;
-	}
-	const truncatedContent = xmlContent.slice(0, endPosition);
-	const firstQuotePosition = truncatedContent.lastIndexOf("\"");
-	return truncatedContent.slice(firstQuotePosition + 1);
+async function fileTypeFromBlob(blob, options) {
+	return new FileTypeParser(options).fromBlob(blob);
 }
-var FileTypeParser = class {
+var FileTypeParser = class FileTypeParser {
 	constructor(options) {
 		const normalizedMpegOffsetTolerance = normalizeMpegOffsetTolerance(options?.mpegOffsetTolerance);
 		this.options = {
@@ -2762,7 +3146,10 @@ var FileTypeParser = class {
 	getTokenizerOptions() {
 		return { ...this.tokenizerOptions };
 	}
-	async fromTokenizer(tokenizer, detectionReentryCount = 0) {
+	createTokenizerFromWebStream(stream) {
+		return fromWebStream(toDefaultStream(stream), this.getTokenizerOptions());
+	}
+	async parseTokenizer(tokenizer, detectionReentryCount = 0) {
 		this.detectionReentryCount = detectionReentryCount;
 		const initialPosition = tokenizer.position;
 		for (const detector of this.detectors) {
@@ -2778,6 +3165,13 @@ var FileTypeParser = class {
 			if (initialPosition !== tokenizer.position) return;
 		}
 	}
+	async fromTokenizer(tokenizer) {
+		try {
+			return await this.parseTokenizer(tokenizer);
+		} finally {
+			await tokenizer.close();
+		}
+	}
 	async fromBuffer(input) {
 		if (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof input}\``);
 		const buffer = input instanceof Uint8Array ? input : new Uint8Array(input);
@@ -2785,42 +3179,78 @@ var FileTypeParser = class {
 		return this.fromTokenizer(fromBuffer(buffer, this.getTokenizerOptions()));
 	}
 	async fromBlob(blob) {
+		this.options.signal?.throwIfAborted();
 		const tokenizer = fromBlob(blob, this.getTokenizerOptions());
-		try {
-			return await this.fromTokenizer(tokenizer);
-		} finally {
-			await tokenizer.close();
-		}
+		return this.fromTokenizer(tokenizer);
 	}
 	async fromStream(stream) {
-		const tokenizer = fromWebStream(stream, this.getTokenizerOptions());
-		try {
-			return await this.fromTokenizer(tokenizer);
-		} finally {
-			await tokenizer.close();
+		this.options.signal?.throwIfAborted();
+		const tokenizer = this.createTokenizerFromWebStream(stream);
+		return this.fromTokenizer(tokenizer);
+	}
+	async fromFile(path) {
+		this.options.signal?.throwIfAborted();
+		const [{ default: fsPromises }, { FileTokenizer }] = await Promise.all([importAtRuntime("node:fs/promises"), importAtRuntime("strtok3")]);
+		const fileHandle = await fsPromises.open(path, fsPromises.constants.O_RDONLY | fsPromises.constants.O_NONBLOCK);
+		const fileStat = await fileHandle.stat();
+		if (!fileStat.isFile()) {
+			await fileHandle.close();
+			return;
 		}
+		const tokenizer = new FileTokenizer(fileHandle, {
+			...this.getTokenizerOptions(),
+			fileInfo: {
+				path,
+				size: fileStat.size
+			}
+		});
+		return this.fromTokenizer(tokenizer);
 	}
 	async toDetectionStream(stream, options) {
+		this.options.signal?.throwIfAborted();
 		const sampleSize = normalizeSampleSize(options?.sampleSize ?? 4100);
 		let detectedFileType;
-		let firstChunk;
-		const reader = stream.getReader({ mode: "byob" });
+		let streamEnded = false;
+		const reader = stream.getReader();
+		const chunks = [];
+		let totalSize = 0;
 		try {
-			const { value: chunk, done } = await reader.read(new Uint8Array(sampleSize));
-			firstChunk = chunk;
-			if (!done && chunk) try {
-				detectedFileType = await this.fromBuffer(chunk.subarray(0, sampleSize));
+			while (totalSize < sampleSize) {
+				const { value, done } = await readWithSignal(reader, this.options.signal);
+				if (done || !value) {
+					streamEnded = true;
+					break;
+				}
+				chunks.push(value);
+				totalSize += value.length;
+			}
+			if (!streamEnded && totalSize === sampleSize) {
+				const { value, done } = await readWithSignal(reader, this.options.signal);
+				if (done || !value) streamEnded = true;
+				else {
+					chunks.push(value);
+					totalSize += value.length;
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		if (totalSize > 0) {
+			const sample = chunks.length === 1 ? chunks[0] : concatUint8Arrays(chunks);
+			try {
+				detectedFileType = await this.fromBuffer(sample.subarray(0, sampleSize));
 			} catch (error) {
 				if (!(error instanceof EndOfStreamError)) throw error;
 				detectedFileType = void 0;
 			}
-			firstChunk = chunk;
-		} finally {
-			reader.releaseLock();
+			if (!streamEnded && detectedFileType?.ext === "pages") detectedFileType = {
+				ext: "zip",
+				mime: "application/zip"
+			};
 		}
 		const transformStream = new TransformStream({
-			async start(controller) {
-				controller.enqueue(firstChunk);
+			start(controller) {
+				for (const chunk of chunks) controller.enqueue(chunk);
 			},
 			transform(chunk, controller) {
 				controller.enqueue(chunk);
@@ -2830,8 +3260,48 @@ var FileTypeParser = class {
 		newStream.fileType = detectedFileType;
 		return newStream;
 	}
+	async detectGzip(tokenizer) {
+		if (this.gzipProbeDepth >= maximumNestedGzipProbeDepth) return {
+			ext: "gz",
+			mime: "application/gzip"
+		};
+		const limitedInflatedStream = createByteLimitedReadableStream(new GzipHandler(tokenizer).inflate(), maximumNestedGzipDetectionSizeInBytes);
+		const hasUnknownSize = hasUnknownFileSize(tokenizer);
+		let timeout;
+		let probeSignal;
+		let probeParser;
+		let compressedFileType;
+		if (hasUnknownSize) {
+			const timeoutController = new AbortController();
+			timeout = setTimeout(() => {
+				timeoutController.abort(new DOMException(`Operation timed out after ${unknownSizeGzipProbeTimeoutInMilliseconds} ms`, "TimeoutError"));
+			}, unknownSizeGzipProbeTimeoutInMilliseconds);
+			probeSignal = this.options.signal === void 0 ? timeoutController.signal : AbortSignal.any([this.options.signal, timeoutController.signal]);
+			probeParser = new FileTypeParser({
+				...this.options,
+				signal: probeSignal
+			});
+			probeParser.gzipProbeDepth = this.gzipProbeDepth + 1;
+		} else this.gzipProbeDepth++;
+		try {
+			compressedFileType = await (probeParser ?? this).fromStream(limitedInflatedStream);
+		} catch (error) {
+			if (error?.name === "AbortError" && probeSignal?.reason?.name !== "TimeoutError") throw error;
+		} finally {
+			clearTimeout(timeout);
+			if (!hasUnknownSize) this.gzipProbeDepth--;
+		}
+		if (compressedFileType?.ext === "tar") return {
+			ext: "tar.gz",
+			mime: "application/gzip"
+		};
+		return {
+			ext: "gz",
+			mime: "application/gzip"
+		};
+	}
 	check(header, options) {
-		return _check(this.buffer, header, options);
+		return checkBytes(this.buffer, header, options);
 	}
 	checkString(header, options) {
 		return this.check(stringToBytes(header, options?.encoding), options);
@@ -2840,6 +3310,17 @@ var FileTypeParser = class {
 		this.buffer = new Uint8Array(reasonableDetectionSizeInBytes);
 		if (tokenizer.fileInfo.size === void 0) tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
 		this.tokenizer = tokenizer;
+		if (hasUnknownFileSize(tokenizer)) {
+			await tokenizer.peekBuffer(this.buffer, {
+				length: 3,
+				mayBeLess: true
+			});
+			if (this.check([
+				31,
+				139,
+				8
+			])) return this.detectGzip(tokenizer);
+		}
 		await tokenizer.peekBuffer(this.buffer, {
 			length: 32,
 			mayBeLess: true
@@ -2916,30 +3397,7 @@ var FileTypeParser = class {
 			31,
 			139,
 			8
-		])) {
-			if (this.gzipProbeDepth >= maximumNestedGzipProbeDepth) return {
-				ext: "gz",
-				mime: "application/gzip"
-			};
-			const limitedInflatedStream = createByteLimitedReadableStream(new GzipHandler(tokenizer).inflate(), maximumNestedGzipDetectionSizeInBytes);
-			let compressedFileType;
-			try {
-				this.gzipProbeDepth++;
-				compressedFileType = await this.fromStream(limitedInflatedStream);
-			} catch (error) {
-				if (error?.name === "AbortError") throw error;
-			} finally {
-				this.gzipProbeDepth--;
-			}
-			if (compressedFileType?.ext === "tar") return {
-				ext: "tar.gz",
-				mime: "application/gzip"
-			};
-			return {
-				ext: "gz",
-				mime: "application/gzip"
-			};
-		}
+		])) return this.detectGzip(tokenizer);
 		if (this.check([
 			66,
 			90,
@@ -2955,7 +3413,7 @@ var FileTypeParser = class {
 			});
 			const id3HeaderLength = await tokenizer.readToken(uint32SyncSafeToken);
 			const isUnknownFileSize = hasUnknownFileSize(tokenizer);
-			if (!Number.isFinite(id3HeaderLength) || id3HeaderLength < 0 || isUnknownFileSize && id3HeaderLength > maximumId3HeaderSizeInBytes) return;
+			if (!Number.isFinite(id3HeaderLength) || id3HeaderLength < 0 || isUnknownFileSize && (id3HeaderLength > maximumId3HeaderSizeInBytes || tokenizer.position + id3HeaderLength > maximumId3HeaderSizeInBytes)) return;
 			if (tokenizer.position + id3HeaderLength > tokenizer.fileInfo.size) {
 				if (isUnknownFileSize) return;
 				return {
@@ -2974,7 +3432,7 @@ var FileTypeParser = class {
 			}
 			if (this.detectionReentryCount >= maximumDetectionReentryCount) return;
 			this.detectionReentryCount++;
-			return this.fromTokenizer(tokenizer, this.detectionReentryCount);
+			return this.parseTokenizer(tokenizer, this.detectionReentryCount);
 		}
 		if (this.checkString("MP+")) return {
 			ext: "mpc",
@@ -3032,83 +3490,12 @@ var FileTypeParser = class {
 			75,
 			3,
 			4
-		])) {
-			let fileType;
-			const openXmlState = createOpenXmlZipDetectionState();
-			try {
-				await new ZipHandler(tokenizer).unzip((zipHeader) => {
-					updateOpenXmlZipDetectionStateFromFilename(openXmlState, zipHeader.filename);
-					const isOpenXmlContentTypesEntry = zipHeader.filename === "[Content_Types].xml";
-					const openXmlFileTypeFromEntries = getOpenXmlFileTypeFromZipEntries(openXmlState);
-					if (!isOpenXmlContentTypesEntry && openXmlFileTypeFromEntries) {
-						fileType = openXmlFileTypeFromEntries;
-						return { stop: true };
-					}
-					switch (zipHeader.filename) {
-						case "META-INF/mozilla.rsa":
-							fileType = {
-								ext: "xpi",
-								mime: "application/x-xpinstall"
-							};
-							return { stop: true };
-						case "META-INF/MANIFEST.MF":
-							fileType = {
-								ext: "jar",
-								mime: "application/java-archive"
-							};
-							return { stop: true };
-						case "mimetype":
-							if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) return {};
-							return {
-								async handler(fileData) {
-									fileType = getFileTypeFromMimeType(new TextDecoder("utf-8").decode(fileData).trim());
-								},
-								stop: true
-							};
-						case "[Content_Types].xml":
-							openXmlState.hasContentTypesEntry = true;
-							if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) {
-								openXmlState.hasUnparseableContentTypes = true;
-								return {};
-							}
-							openXmlState.isParsingContentTypes = true;
-							return {
-								async handler(fileData) {
-									const mimeType = getOpenXmlMimeTypeFromContentTypesXml(new TextDecoder("utf-8").decode(fileData));
-									if (mimeType) fileType = getFileTypeFromMimeType(mimeType);
-									openXmlState.hasParsedContentTypesEntry = true;
-									openXmlState.isParsingContentTypes = false;
-								},
-								stop: true
-							};
-						default:
-							if (/classes\d*\.dex/.test(zipHeader.filename)) {
-								fileType = {
-									ext: "apk",
-									mime: "application/vnd.android.package-archive"
-								};
-								return { stop: true };
-							}
-							return {};
-					}
-				});
-			} catch (error) {
-				if (!isRecoverableZipError(error)) throw error;
-				if (openXmlState.isParsingContentTypes) {
-					openXmlState.isParsingContentTypes = false;
-					openXmlState.hasUnparseableContentTypes = true;
-				}
-			}
-			return fileType ?? getOpenXmlFileTypeFromZipEntries(openXmlState) ?? {
-				ext: "zip",
-				mime: "application/zip"
-			};
-		}
+		])) return detectZip(tokenizer);
 		if (this.checkString("OggS")) {
 			await tokenizer.ignore(28);
-			const type = new Uint8Array(8);
+			const type = /* @__PURE__ */ new Uint8Array(8);
 			await tokenizer.readBuffer(type);
-			if (_check(type, [
+			if (checkBytes(type, [
 				79,
 				112,
 				117,
@@ -3121,7 +3508,7 @@ var FileTypeParser = class {
 				ext: "opus",
 				mime: "audio/ogg; codecs=opus"
 			};
-			if (_check(type, [
+			if (checkBytes(type, [
 				128,
 				116,
 				104,
@@ -3133,7 +3520,7 @@ var FileTypeParser = class {
 				ext: "ogv",
 				mime: "video/ogg"
 			};
-			if (_check(type, [
+			if (checkBytes(type, [
 				1,
 				118,
 				105,
@@ -3145,7 +3532,7 @@ var FileTypeParser = class {
 				ext: "ogm",
 				mime: "video/ogg"
 			};
-			if (_check(type, [
+			if (checkBytes(type, [
 				127,
 				70,
 				76,
@@ -3155,7 +3542,7 @@ var FileTypeParser = class {
 				ext: "oga",
 				mime: "audio/ogg"
 			};
-			if (_check(type, [
+			if (checkBytes(type, [
 				83,
 				112,
 				101,
@@ -3167,7 +3554,7 @@ var FileTypeParser = class {
 				ext: "spx",
 				mime: "audio/ogg"
 			};
-			if (_check(type, [
+			if (checkBytes(type, [
 				1,
 				118,
 				111,
@@ -3230,7 +3617,7 @@ var FileTypeParser = class {
 		};
 		if (this.checkString("LZIP")) return {
 			ext: "lz",
-			mime: "application/x-lzip"
+			mime: "application/lzip"
 		};
 		if (this.checkString("fLaC")) return {
 			ext: "flac",
@@ -3279,67 +3666,7 @@ var FileTypeParser = class {
 			69,
 			223,
 			163
-		])) {
-			async function readField() {
-				const msb = await tokenizer.peekNumber(UINT8);
-				let mask = 128;
-				let ic = 0;
-				while ((msb & mask) === 0 && mask !== 0) {
-					++ic;
-					mask >>= 1;
-				}
-				const id = new Uint8Array(ic + 1);
-				await safeReadBuffer(tokenizer, id, void 0, {
-					maximumLength: id.length,
-					reason: "EBML field"
-				});
-				return id;
-			}
-			async function readElement() {
-				const idField = await readField();
-				const lengthField = await readField();
-				lengthField[0] ^= 128 >> lengthField.length - 1;
-				const nrLength = Math.min(6, lengthField.length);
-				const idView = new DataView(idField.buffer);
-				const lengthView = new DataView(lengthField.buffer, lengthField.length - nrLength, nrLength);
-				return {
-					id: getUintBE(idView),
-					len: getUintBE(lengthView)
-				};
-			}
-			async function readChildren(children) {
-				let ebmlElementCount = 0;
-				while (children > 0) {
-					ebmlElementCount++;
-					if (ebmlElementCount > maximumEbmlElementCount) return;
-					const previousPosition = tokenizer.position;
-					const element = await readElement();
-					if (element.id === 17026) {
-						if (element.len > maximumEbmlDocumentTypeSizeInBytes) return;
-						const documentTypeLength = getSafeBound(element.len, maximumEbmlDocumentTypeSizeInBytes, "EBML DocType");
-						return (await tokenizer.readToken(new StringType(documentTypeLength))).replaceAll(/\00.*$/g, "");
-					}
-					if (hasUnknownFileSize(tokenizer) && (!Number.isFinite(element.len) || element.len < 0 || element.len > maximumEbmlElementPayloadSizeInBytes)) return;
-					await safeIgnore(tokenizer, element.len, {
-						maximumLength: hasUnknownFileSize(tokenizer) ? maximumEbmlElementPayloadSizeInBytes : tokenizer.fileInfo.size,
-						reason: "EBML payload"
-					});
-					--children;
-					if (tokenizer.position <= previousPosition) return;
-				}
-			}
-			switch (await readChildren((await readElement()).len)) {
-				case "webm": return {
-					ext: "webm",
-					mime: "video/webm"
-				};
-				case "matroska": return {
-					ext: "mkv",
-					mime: "video/matroska"
-				};
-				default: return;
-			}
-		}
+		])) return detectEbml(tokenizer);
 		if (this.checkString("SQLi")) return {
 			ext: "sqlite",
 			mime: "application/x-sqlite3"
@@ -3469,7 +3796,7 @@ var FileTypeParser = class {
 			ext: "amr",
 			mime: "audio/amr"
 		};
-		if (this.checkString("{\\rtf")) return {
+		if (this.checkString(String.raw`{\rtf`)) return {
 			ext: "rtf",
 			mime: "application/rtf"
 		};
@@ -3538,7 +3865,7 @@ var FileTypeParser = class {
 		};
 		if (this.checkString("DRACO")) return {
 			ext: "drc",
-			mime: "application/vnd.google.draco"
+			mime: "application/x-ft-draco"
 		};
 		if (this.check([
 			253,
@@ -3583,7 +3910,7 @@ var FileTypeParser = class {
 		};
 		if (this.checkString("AC")) {
 			const version = new StringType(4, "latin1").get(this.buffer, 2);
-			if (version.match("^d*") && version >= 1e3 && version <= 1050) return {
+			if (new RegExp("^\\d+$", "v").test(version) && version >= 1e3 && version <= 1050) return {
 				ext: "dwg",
 				mime: "image/vnd.dwg"
 			};
@@ -3626,51 +3953,7 @@ var FileTypeParser = class {
 			10,
 			26,
 			10
-		])) {
-			const pngFileType = {
-				ext: "png",
-				mime: "image/png"
-			};
-			const apngFileType = {
-				ext: "apng",
-				mime: "image/apng"
-			};
-			await tokenizer.ignore(8);
-			async function readChunkHeader() {
-				return {
-					length: await tokenizer.readToken(INT32_BE),
-					type: await tokenizer.readToken(new StringType(4, "latin1"))
-				};
-			}
-			const isUnknownPngStream = hasUnknownFileSize(tokenizer);
-			const pngScanStart = tokenizer.position;
-			let pngChunkCount = 0;
-			do {
-				pngChunkCount++;
-				if (pngChunkCount > maximumPngChunkCount) break;
-				if (hasExceededUnknownSizeScanBudget(tokenizer, pngScanStart, maximumPngChunkSizeInBytes)) break;
-				const previousPosition = tokenizer.position;
-				const chunk = await readChunkHeader();
-				if (chunk.length < 0) return;
-				switch (chunk.type) {
-					case "IDAT": return pngFileType;
-					case "acTL": return apngFileType;
-					default:
-						if (isUnknownPngStream && chunk.length > maximumPngChunkSizeInBytes) return;
-						try {
-							await safeIgnore(tokenizer, chunk.length + 4, {
-								maximumLength: isUnknownPngStream ? 16777220 : tokenizer.fileInfo.size,
-								reason: "PNG chunk payload"
-							});
-						} catch (error) {
-							if (!isUnknownPngStream && (error instanceof ParserHardLimitError || error instanceof EndOfStreamError)) return pngFileType;
-							throw error;
-						}
-				}
-				if (tokenizer.position <= previousPosition) break;
-			} while (tokenizer.position + 8 < tokenizer.fileInfo.size);
-			return pngFileType;
-		}
+		])) return detectPng(tokenizer);
 		if (this.check([
 			65,
 			82,
@@ -3893,125 +4176,7 @@ var FileTypeParser = class {
 			17,
 			166,
 			217
-		])) {
-			let isMalformedAsf = false;
-			try {
-				async function readHeader() {
-					const guid = new Uint8Array(16);
-					await safeReadBuffer(tokenizer, guid, void 0, {
-						maximumLength: guid.length,
-						reason: "ASF header GUID"
-					});
-					return {
-						id: guid,
-						size: Number(await tokenizer.readToken(UINT64_LE))
-					};
-				}
-				await safeIgnore(tokenizer, 30, {
-					maximumLength: 30,
-					reason: "ASF header prelude"
-				});
-				const isUnknownFileSize = hasUnknownFileSize(tokenizer);
-				const asfHeaderScanStart = tokenizer.position;
-				let asfHeaderObjectCount = 0;
-				while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
-					asfHeaderObjectCount++;
-					if (asfHeaderObjectCount > maximumAsfHeaderObjectCount) break;
-					if (hasExceededUnknownSizeScanBudget(tokenizer, asfHeaderScanStart, maximumUntrustedSkipSizeInBytes)) break;
-					const previousPosition = tokenizer.position;
-					const header = await readHeader();
-					let payload = header.size - 24;
-					if (!Number.isFinite(payload) || payload < 0) {
-						isMalformedAsf = true;
-						break;
-					}
-					if (_check(header.id, [
-						145,
-						7,
-						220,
-						183,
-						183,
-						169,
-						207,
-						17,
-						142,
-						230,
-						0,
-						192,
-						12,
-						32,
-						83,
-						101
-					])) {
-						const typeId = new Uint8Array(16);
-						payload -= await safeReadBuffer(tokenizer, typeId, void 0, {
-							maximumLength: typeId.length,
-							reason: "ASF stream type GUID"
-						});
-						if (_check(typeId, [
-							64,
-							158,
-							105,
-							248,
-							77,
-							91,
-							207,
-							17,
-							168,
-							253,
-							0,
-							128,
-							95,
-							92,
-							68,
-							43
-						])) return {
-							ext: "asf",
-							mime: "audio/x-ms-asf"
-						};
-						if (_check(typeId, [
-							192,
-							239,
-							25,
-							188,
-							77,
-							91,
-							207,
-							17,
-							168,
-							253,
-							0,
-							128,
-							95,
-							92,
-							68,
-							43
-						])) return {
-							ext: "asf",
-							mime: "video/x-ms-asf"
-						};
-						break;
-					}
-					await safeIgnore(tokenizer, payload, {
-						maximumLength: isUnknownFileSize ? maximumUntrustedSkipSizeInBytes : tokenizer.fileInfo.size,
-						reason: "ASF header payload"
-					});
-					if (tokenizer.position <= previousPosition) {
-						isMalformedAsf = true;
-						break;
-					}
-				}
-			} catch (error) {
-				if (error instanceof EndOfStreamError || error instanceof ParserHardLimitError) {
-					if (hasUnknownFileSize(tokenizer)) isMalformedAsf = true;
-				} else throw error;
-			}
-			if (isMalformedAsf) return;
-			return {
-				ext: "asf",
-				mime: "application/vnd.ms-asf"
-			};
-		}
+		])) return detectAsf(tokenizer);
 		if (this.check([
 			171,
 			75,
@@ -4277,7 +4442,7 @@ var FileTypeParser = class {
 			70
 		])) return {
 			ext: "lnk",
-			mime: "application/x.ms.shortcut"
+			mime: "application/x-ms-shortcut"
 		};
 		if (this.check([
 			98,
@@ -4298,11 +4463,11 @@ var FileTypeParser = class {
 			0
 		])) return {
 			ext: "alias",
-			mime: "application/x.apple.alias"
+			mime: "application/x-ft-apple.alias"
 		};
 		if (this.checkString("Kaydara FBX Binary  \0")) return {
 			ext: "fbx",
-			mime: "application/x.autodesk.fbx"
+			mime: "application/x-ft-fbx"
 		};
 		if (this.check([76, 80], { offset: 34 }) && (this.check([
 			0,
@@ -4474,10 +4639,10 @@ var FileTypeParser = class {
 			mime: "image/x-icon"
 		};
 		await tokenizer.peekBuffer(this.buffer, {
-			length: Math.min(2 + this.options.mpegOffsetTolerance, fileSize),
+			length: Math.min(4 + this.options.mpegOffsetTolerance, fileSize),
 			mayBeLess: true
 		});
-		if (this.buffer.length >= 2 + this.options.mpegOffsetTolerance) for (let depth = 0; depth <= this.options.mpegOffsetTolerance; ++depth) {
+		if (this.buffer.length >= 4 + this.options.mpegOffsetTolerance) for (let depth = 0; depth <= this.options.mpegOffsetTolerance; ++depth) {
 			const type = this.scanMpeg(depth);
 			if (type) return type;
 		}
@@ -4494,7 +4659,6 @@ var FileTypeParser = class {
 				ext: "dng",
 				mime: "image/x-adobe-dng"
 			};
-			default:
 		}
 	}
 	async readTiffIFD(bigEndian) {
@@ -4528,6 +4692,7 @@ var FileTypeParser = class {
 					};
 				}
 			}
+			if (hasUnknownFileSize(this.tokenizer) && ifdOffset > maximumTiffStreamIfdOffsetInBytes) return tiffFileType;
 			const maximumTiffOffset = hasUnknownFileSize(this.tokenizer) ? maximumTiffIfdOffsetInBytes : this.tokenizer.fileInfo.size;
 			try {
 				await safeIgnore(this.tokenizer, ifdOffset, {
@@ -4563,19 +4728,23 @@ var FileTypeParser = class {
 			if (this.check([16], {
 				offset: offset + 1,
 				mask: [22]
-			})) {
-				if (this.check([8], {
-					offset: offset + 1,
-					mask: [8]
-				})) return {
-					ext: "aac",
-					mime: "audio/aac"
-				};
-				return {
-					ext: "aac",
-					mime: "audio/aac"
-				};
-			}
+			})) return {
+				ext: "aac",
+				mime: "audio/aac"
+			};
+			if (this.check([255, 254], { offset })) return;
+			if (this.check([8], {
+				offset: offset + 1,
+				mask: [24]
+			})) return;
+			if (this.check([240], {
+				offset: offset + 2,
+				mask: [240]
+			})) return;
+			if (this.check([12], {
+				offset: offset + 2,
+				mask: [12]
+			})) return;
 			if (this.check([2], {
 				offset: offset + 1,
 				mask: [6]
@@ -4605,4 +4774,4 @@ new Set(mimeTypes);
 //#endregion
 export { fileTypeFromBlob };
 
-//# sourceMappingURL=file-type-BwbWtW7C.mjs.map
+//# sourceMappingURL=source-BpNO27ea.mjs.map