ghc-proxy 0.3.0 → 0.3.2

package/dist/file-type-BNd4XJK1.mjs

@@ -0,0 +1,4527 @@
+import { i as __toESM, r as __require, t as __commonJSMin } from "./main.mjs";
+import { open } from "node:fs/promises";
+import { PassThrough, Readable } from "node:stream";
+
+//#region node_modules/strtok3/lib/stream/Errors.js
+const defaultMessages = "End-Of-Stream";
+/**
+* Thrown on read operation of the end of file or stream has been reached
+*/
+var EndOfStreamError = class extends Error {
+	constructor() {
+		super(defaultMessages);
+		this.name = "EndOfStreamError";
+	}
+};
+var AbortError = class extends Error {
+	constructor(message = "The operation was aborted") {
+		super(message);
+		this.name = "AbortError";
+	}
+};
+
+//#endregion
+//#region node_modules/strtok3/lib/stream/AbstractStreamReader.js
+var AbstractStreamReader = class {
+	constructor() {
+		this.endOfStream = false;
+		this.interrupted = false;
+		/**
+		* Store peeked data
+		* @type {Array}
+		*/
+		this.peekQueue = [];
+	}
+	async peek(uint8Array, mayBeLess = false) {
+		const bytesRead = await this.read(uint8Array, mayBeLess);
+		this.peekQueue.push(uint8Array.subarray(0, bytesRead));
+		return bytesRead;
+	}
+	async read(buffer, mayBeLess = false) {
+		if (buffer.length === 0) return 0;
+		let bytesRead = this.readFromPeekBuffer(buffer);
+		if (!this.endOfStream) bytesRead += await this.readRemainderFromStream(buffer.subarray(bytesRead), mayBeLess);
+		if (bytesRead === 0 && !mayBeLess) throw new EndOfStreamError();
+		return bytesRead;
+	}
+	/**
+	* Read chunk from stream
+	* @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+	* @returns Number of bytes read
+	*/
+	readFromPeekBuffer(buffer) {
+		let remaining = buffer.length;
+		let bytesRead = 0;
+		while (this.peekQueue.length > 0 && remaining > 0) {
+			const peekData = this.peekQueue.pop();
+			if (!peekData) throw new Error("peekData should be defined");
+			const lenCopy = Math.min(peekData.length, remaining);
+			buffer.set(peekData.subarray(0, lenCopy), bytesRead);
+			bytesRead += lenCopy;
+			remaining -= lenCopy;
+			if (lenCopy < peekData.length) this.peekQueue.push(peekData.subarray(lenCopy));
+		}
+		return bytesRead;
+	}
+	async readRemainderFromStream(buffer, mayBeLess) {
+		let bytesRead = 0;
+		while (bytesRead < buffer.length && !this.endOfStream) {
+			if (this.interrupted) throw new AbortError();
+			const chunkLen = await this.readFromStream(buffer.subarray(bytesRead), mayBeLess);
+			if (chunkLen === 0) break;
+			bytesRead += chunkLen;
+		}
+		if (!mayBeLess && bytesRead < buffer.length) throw new EndOfStreamError();
+		return bytesRead;
+	}
+};
+
+//#endregion
+//#region node_modules/strtok3/lib/stream/WebStreamReader.js
+var WebStreamReader = class extends AbstractStreamReader {
+	constructor(reader) {
+		super();
+		this.reader = reader;
+	}
+	async abort() {
+		return this.close();
+	}
+	async close() {
+		this.reader.releaseLock();
+	}
+};
+
+//#endregion
+//#region node_modules/strtok3/lib/stream/WebStreamByobReader.js
+/**
+* Read from a WebStream using a BYOB reader
+* Reference: https://nodejs.org/api/webstreams.html#class-readablestreambyobreader
+*/
+var WebStreamByobReader = class extends WebStreamReader {
+	/**
+	* Read from stream
+	* @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+	* @param mayBeLess - If true, may fill the buffer partially
+	* @protected Bytes read
+	*/
+	async readFromStream(buffer, mayBeLess) {
+		if (buffer.length === 0) return 0;
+		const result = await this.reader.read(new Uint8Array(buffer.length), { min: mayBeLess ? void 0 : buffer.length });
+		if (result.done) this.endOfStream = result.done;
+		if (result.value) {
+			buffer.set(result.value);
+			return result.value.length;
+		}
+		return 0;
+	}
+};
+
+//#endregion
+//#region node_modules/strtok3/lib/stream/WebStreamDefaultReader.js
+var WebStreamDefaultReader = class extends AbstractStreamReader {
+	constructor(reader) {
+		super();
+		this.reader = reader;
+		this.buffer = null;
+	}
+	/**
+	* Copy chunk to target, and store the remainder in this.buffer
+	*/
+	writeChunk(target, chunk) {
+		const written = Math.min(chunk.length, target.length);
+		target.set(chunk.subarray(0, written));
+		if (written < chunk.length) this.buffer = chunk.subarray(written);
+		else this.buffer = null;
+		return written;
+	}
+	/**
+	* Read from stream
+	* @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+	* @param mayBeLess - If true, may fill the buffer partially
+	* @protected Bytes read
+	*/
+	async readFromStream(buffer, mayBeLess) {
+		if (buffer.length === 0) return 0;
+		let totalBytesRead = 0;
+		if (this.buffer) totalBytesRead += this.writeChunk(buffer, this.buffer);
+		while (totalBytesRead < buffer.length && !this.endOfStream) {
+			const result = await this.reader.read();
+			if (result.done) {
+				this.endOfStream = true;
+				break;
+			}
+			if (result.value) totalBytesRead += this.writeChunk(buffer.subarray(totalBytesRead), result.value);
+		}
+		if (!mayBeLess && totalBytesRead === 0 && this.endOfStream) throw new EndOfStreamError();
+		return totalBytesRead;
+	}
+	abort() {
+		this.interrupted = true;
+		return this.reader.cancel();
+	}
+	async close() {
+		await this.abort();
+		this.reader.releaseLock();
+	}
+};
+
+//#endregion
+//#region node_modules/strtok3/lib/stream/WebStreamReaderFactory.js
+function makeWebStreamReader(stream) {
+	try {
+		const reader = stream.getReader({ mode: "byob" });
+		if (reader instanceof ReadableStreamDefaultReader) return new WebStreamDefaultReader(reader);
+		return new WebStreamByobReader(reader);
+	} catch (error) {
+		if (error instanceof TypeError) return new WebStreamDefaultReader(stream.getReader());
+		throw error;
+	}
+}
+
+//#endregion
+//#region node_modules/strtok3/lib/AbstractTokenizer.js
+/**
+* Core tokenizer
+*/
+var AbstractTokenizer = class {
+	/**
+	* Constructor
+	* @param options Tokenizer options
+	* @protected
+	*/
+	constructor(options) {
+		this.numBuffer = new Uint8Array(8);
+		/**
+		* Tokenizer-stream position
+		*/
+		this.position = 0;
+		this.onClose = options?.onClose;
+		if (options?.abortSignal) options.abortSignal.addEventListener("abort", () => {
+			this.abort();
+		});
+	}
+	/**
+	* Read a token from the tokenizer-stream
+	* @param token - The token to read
+	* @param position - If provided, the desired position in the tokenizer-stream
+	* @returns Promise with token data
+	*/
+	async readToken(token, position = this.position) {
+		const uint8Array = new Uint8Array(token.len);
+		if (await this.readBuffer(uint8Array, { position }) < token.len) throw new EndOfStreamError();
+		return token.get(uint8Array, 0);
+	}
+	/**
+	* Peek a token from the tokenizer-stream.
+	* @param token - Token to peek from the tokenizer-stream.
+	* @param position - Offset where to begin reading within the file. If position is null, data will be read from the current file position.
+	* @returns Promise with token data
+	*/
+	async peekToken(token, position = this.position) {
+		const uint8Array = new Uint8Array(token.len);
+		if (await this.peekBuffer(uint8Array, { position }) < token.len) throw new EndOfStreamError();
+		return token.get(uint8Array, 0);
+	}
+	/**
+	* Read a numeric token from the stream
+	* @param token - Numeric token
+	* @returns Promise with number
+	*/
+	async readNumber(token) {
+		if (await this.readBuffer(this.numBuffer, { length: token.len }) < token.len) throw new EndOfStreamError();
+		return token.get(this.numBuffer, 0);
+	}
+	/**
+	* Read a numeric token from the stream
+	* @param token - Numeric token
+	* @returns Promise with number
+	*/
+	async peekNumber(token) {
+		if (await this.peekBuffer(this.numBuffer, { length: token.len }) < token.len) throw new EndOfStreamError();
+		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>}
+	*/
+	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
+/**
+* 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);
+}
+
+//#endregion
+//#region node_modules/strtok3/lib/FileTokenizer.js
+var FileTokenizer = class FileTokenizer extends AbstractTokenizer {
+	/**
+	* Create tokenizer from provided file path
+	* @param sourceFilePath File path
+	*/
+	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) {
+		super(options);
+		this.fileHandle = fileHandle;
+		this.fileInfo = options.fileInfo;
+	}
+	/**
+	* Read buffer from file
+	* @param uint8Array - Uint8Array to write result to
+	* @param options - Read behaviour options
+	* @returns Promise number of bytes read
+	*/
+	async readBuffer(uint8Array, options) {
+		const normOptions = this.normalizeOptions(uint8Array, options);
+		this.position = normOptions.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;
+	}
+	/**
+	* Peek buffer from file
+	* @param uint8Array - Uint8Array (or Buffer) to write data to
+	* @param options - Read behaviour options
+	* @returns Promise number of bytes read
+	*/
+	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;
+	}
+};
+
+//#endregion
+//#region node_modules/strtok3/lib/index.js
+const fromFile = FileTokenizer.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;
+			}
+			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/ms/index.js
+var require_ms = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Helpers.
+	*/
+	var s = 1e3;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+	/**
+	* Parse or format the given `val`.
+	*
+	* Options:
+	*
+	*  - `long` verbose formatting [false]
+	*
+	* @param {String|Number} val
+	* @param {Object} [options]
+	* @throws {Error} throw an error if val is not a non-empty string or a number
+	* @return {String|Number}
+	* @api public
+	*/
+	module.exports = function(val, options) {
+		options = options || {};
+		var type = typeof val;
+		if (type === "string" && val.length > 0) return parse(val);
+		else if (type === "number" && isFinite(val)) return options.long ? fmtLong(val) : fmtShort(val);
+		throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
+	};
+	/**
+	* Parse the given `str` and return milliseconds.
+	*
+	* @param {String} str
+	* @return {Number}
+	* @api private
+	*/
+	function parse(str) {
+		str = String(str);
+		if (str.length > 100) return;
+		var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+		if (!match) return;
+		var n = parseFloat(match[1]);
+		switch ((match[2] || "ms").toLowerCase()) {
+			case "years":
+			case "year":
+			case "yrs":
+			case "yr":
+			case "y": return n * y;
+			case "weeks":
+			case "week":
+			case "w": return n * w;
+			case "days":
+			case "day":
+			case "d": return n * d;
+			case "hours":
+			case "hour":
+			case "hrs":
+			case "hr":
+			case "h": return n * h;
+			case "minutes":
+			case "minute":
+			case "mins":
+			case "min":
+			case "m": return n * m;
+			case "seconds":
+			case "second":
+			case "secs":
+			case "sec":
+			case "s": return n * s;
+			case "milliseconds":
+			case "millisecond":
+			case "msecs":
+			case "msec":
+			case "ms": return n;
+			default: return;
+		}
+	}
+	/**
+	* Short format for `ms`.
+	*
+	* @param {Number} ms
+	* @return {String}
+	* @api private
+	*/
+	function fmtShort(ms) {
+		var msAbs = Math.abs(ms);
+		if (msAbs >= d) return Math.round(ms / d) + "d";
+		if (msAbs >= h) return Math.round(ms / h) + "h";
+		if (msAbs >= m) return Math.round(ms / m) + "m";
+		if (msAbs >= s) return Math.round(ms / s) + "s";
+		return ms + "ms";
+	}
+	/**
+	* Long format for `ms`.
+	*
+	* @param {Number} ms
+	* @return {String}
+	* @api private
+	*/
+	function fmtLong(ms) {
+		var msAbs = Math.abs(ms);
+		if (msAbs >= d) return plural(ms, msAbs, d, "day");
+		if (msAbs >= h) return plural(ms, msAbs, h, "hour");
+		if (msAbs >= m) return plural(ms, msAbs, m, "minute");
+		if (msAbs >= s) return plural(ms, msAbs, s, "second");
+		return ms + " ms";
+	}
+	/**
+	* Pluralization helper.
+	*/
+	function plural(ms, msAbs, n, name) {
+		var isPlural = msAbs >= n * 1.5;
+		return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+	}
+}));
+
+//#endregion
+//#region node_modules/debug/src/common.js
+var require_common = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* This is the common logic for both the Node.js and web browser
+	* implementations of `debug()`.
+	*/
+	function setup(env) {
+		createDebug.debug = createDebug;
+		createDebug.default = createDebug;
+		createDebug.coerce = coerce;
+		createDebug.disable = disable;
+		createDebug.enable = enable;
+		createDebug.enabled = enabled;
+		createDebug.humanize = require_ms();
+		createDebug.destroy = destroy;
+		Object.keys(env).forEach((key) => {
+			createDebug[key] = env[key];
+		});
+		/**
+		* The currently active debug mode names, and names to skip.
+		*/
+		createDebug.names = [];
+		createDebug.skips = [];
+		/**
+		* Map of special "%n" handling functions, for the debug "format" argument.
+		*
+		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+		*/
+		createDebug.formatters = {};
+		/**
+		* Selects a color for a debug namespace
+		* @param {String} namespace The namespace string for the debug instance to be colored
+		* @return {Number|String} An ANSI color code for the given namespace
+		* @api private
+		*/
+		function selectColor(namespace) {
+			let hash = 0;
+			for (let i = 0; i < namespace.length; i++) {
+				hash = (hash << 5) - hash + namespace.charCodeAt(i);
+				hash |= 0;
+			}
+			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+		}
+		createDebug.selectColor = selectColor;
+		/**
+		* Create a debugger with the given `namespace`.
+		*
+		* @param {String} namespace
+		* @return {Function}
+		* @api public
+		*/
+		function createDebug(namespace) {
+			let prevTime;
+			let enableOverride = null;
+			let namespacesCache;
+			let enabledCache;
+			function debug(...args) {
+				if (!debug.enabled) return;
+				const self = debug;
+				const curr = Number(/* @__PURE__ */ new Date());
+				self.diff = curr - (prevTime || curr);
+				self.prev = prevTime;
+				self.curr = curr;
+				prevTime = curr;
+				args[0] = createDebug.coerce(args[0]);
+				if (typeof args[0] !== "string") args.unshift("%O");
+				let index = 0;
+				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+					if (match === "%%") return "%";
+					index++;
+					const formatter = createDebug.formatters[format];
+					if (typeof formatter === "function") {
+						const val = args[index];
+						match = formatter.call(self, val);
+						args.splice(index, 1);
+						index--;
+					}
+					return match;
+				});
+				createDebug.formatArgs.call(self, args);
+				(self.log || createDebug.log).apply(self, args);
+			}
+			debug.namespace = namespace;
+			debug.useColors = createDebug.useColors();
+			debug.color = createDebug.selectColor(namespace);
+			debug.extend = extend;
+			debug.destroy = createDebug.destroy;
+			Object.defineProperty(debug, "enabled", {
+				enumerable: true,
+				configurable: false,
+				get: () => {
+					if (enableOverride !== null) return enableOverride;
+					if (namespacesCache !== createDebug.namespaces) {
+						namespacesCache = createDebug.namespaces;
+						enabledCache = createDebug.enabled(namespace);
+					}
+					return enabledCache;
+				},
+				set: (v) => {
+					enableOverride = v;
+				}
+			});
+			if (typeof createDebug.init === "function") createDebug.init(debug);
+			return debug;
+		}
+		function extend(namespace, delimiter) {
+			const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+			newDebug.log = this.log;
+			return newDebug;
+		}
+		/**
+		* Enables a debug mode by namespaces. This can include modes
+		* separated by a colon and wildcards.
+		*
+		* @param {String} namespaces
+		* @api public
+		*/
+		function enable(namespaces) {
+			createDebug.save(namespaces);
+			createDebug.namespaces = namespaces;
+			createDebug.names = [];
+			createDebug.skips = [];
+			const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+			for (const ns of split) if (ns[0] === "-") createDebug.skips.push(ns.slice(1));
+			else createDebug.names.push(ns);
+		}
+		/**
+		* Checks if the given string matches a namespace template, honoring
+		* asterisks as wildcards.
+		*
+		* @param {String} search
+		* @param {String} template
+		* @return {Boolean}
+		*/
+		function matchesTemplate(search, template) {
+			let searchIndex = 0;
+			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) {
+				templateIndex = starIndex + 1;
+				matchIndex++;
+				searchIndex = matchIndex;
+			} else return false;
+			while (templateIndex < template.length && template[templateIndex] === "*") templateIndex++;
+			return templateIndex === template.length;
+		}
+		/**
+		* Disable debug output.
+		*
+		* @return {String} namespaces
+		* @api public
+		*/
+		function disable() {
+			const namespaces = [...createDebug.names, ...createDebug.skips.map((namespace) => "-" + namespace)].join(",");
+			createDebug.enable("");
+			return namespaces;
+		}
+		/**
+		* Returns true if the given mode name is enabled, false otherwise.
+		*
+		* @param {String} name
+		* @return {Boolean}
+		* @api public
+		*/
+		function enabled(name) {
+			for (const skip of createDebug.skips) if (matchesTemplate(name, skip)) return false;
+			for (const ns of createDebug.names) if (matchesTemplate(name, ns)) return true;
+			return false;
+		}
+		/**
+		* Coerce `val`.
+		*
+		* @param {Mixed} val
+		* @return {Mixed}
+		* @api private
+		*/
+		function coerce(val) {
+			if (val instanceof Error) return val.stack || val.message;
+			return val;
+		}
+		/**
+		* XXX DO NOT USE. This is a temporary stub function.
+		* XXX It WILL be removed in the next major release.
+		*/
+		function destroy() {
+			console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+		}
+		createDebug.enable(createDebug.load());
+		return createDebug;
+	}
+	module.exports = setup;
+}));
+
+//#endregion
+//#region node_modules/debug/src/browser.js
+var require_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* This is the web browser implementation of `debug()`.
+	*/
+	exports.formatArgs = formatArgs;
+	exports.save = save;
+	exports.load = load;
+	exports.useColors = useColors;
+	exports.storage = localstorage();
+	exports.destroy = (() => {
+		let warned = false;
+		return () => {
+			if (!warned) {
+				warned = true;
+				console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+			}
+		};
+	})();
+	/**
+	* Colors.
+	*/
+	exports.colors = [
+		"#0000CC",
+		"#0000FF",
+		"#0033CC",
+		"#0033FF",
+		"#0066CC",
+		"#0066FF",
+		"#0099CC",
+		"#0099FF",
+		"#00CC00",
+		"#00CC33",
+		"#00CC66",
+		"#00CC99",
+		"#00CCCC",
+		"#00CCFF",
+		"#3300CC",
+		"#3300FF",
+		"#3333CC",
+		"#3333FF",
+		"#3366CC",
+		"#3366FF",
+		"#3399CC",
+		"#3399FF",
+		"#33CC00",
+		"#33CC33",
+		"#33CC66",
+		"#33CC99",
+		"#33CCCC",
+		"#33CCFF",
+		"#6600CC",
+		"#6600FF",
+		"#6633CC",
+		"#6633FF",
+		"#66CC00",
+		"#66CC33",
+		"#9900CC",
+		"#9900FF",
+		"#9933CC",
+		"#9933FF",
+		"#99CC00",
+		"#99CC33",
+		"#CC0000",
+		"#CC0033",
+		"#CC0066",
+		"#CC0099",
+		"#CC00CC",
+		"#CC00FF",
+		"#CC3300",
+		"#CC3333",
+		"#CC3366",
+		"#CC3399",
+		"#CC33CC",
+		"#CC33FF",
+		"#CC6600",
+		"#CC6633",
+		"#CC9900",
+		"#CC9933",
+		"#CCCC00",
+		"#CCCC33",
+		"#FF0000",
+		"#FF0033",
+		"#FF0066",
+		"#FF0099",
+		"#FF00CC",
+		"#FF00FF",
+		"#FF3300",
+		"#FF3333",
+		"#FF3366",
+		"#FF3399",
+		"#FF33CC",
+		"#FF33FF",
+		"#FF6600",
+		"#FF6633",
+		"#FF9900",
+		"#FF9933",
+		"#FFCC00",
+		"#FFCC33"
+	];
+	/**
+	* Currently only WebKit-based Web Inspectors, Firefox >= v31,
+	* and the Firebug extension (any Firefox version) are known
+	* to support "%c" CSS customizations.
+	*
+	* TODO: add a `localStorage` variable to explicitly enable/disable colors
+	*/
+	function useColors() {
+		if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) return true;
+		if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) return false;
+		let m;
+		return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+	}
+	/**
+	* Colorize log arguments if enabled.
+	*
+	* @api public
+	*/
+	function formatArgs(args) {
+		args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+		if (!this.useColors) return;
+		const c = "color: " + this.color;
+		args.splice(1, 0, c, "color: inherit");
+		let index = 0;
+		let lastC = 0;
+		args[0].replace(/%[a-zA-Z%]/g, (match) => {
+			if (match === "%%") return;
+			index++;
+			if (match === "%c") lastC = index;
+		});
+		args.splice(lastC, 0, c);
+	}
+	/**
+	* Invokes `console.debug()` when available.
+	* No-op when `console.debug` is not a "function".
+	* If `console.debug` is not available, falls back
+	* to `console.log`.
+	*
+	* @api public
+	*/
+	exports.log = console.debug || console.log || (() => {});
+	/**
+	* Save `namespaces`.
+	*
+	* @param {String} namespaces
+	* @api private
+	*/
+	function save(namespaces) {
+		try {
+			if (namespaces) exports.storage.setItem("debug", namespaces);
+			else exports.storage.removeItem("debug");
+		} catch (error) {}
+	}
+	/**
+	* Load `namespaces`.
+	*
+	* @return {String} returns the previously persisted debug modes
+	* @api private
+	*/
+	function load() {
+		let r;
+		try {
+			r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+		} catch (error) {}
+		if (!r && typeof process !== "undefined" && "env" in process) r = process.env.DEBUG;
+		return r;
+	}
+	/**
+	* Localstorage attempts to return the localstorage.
+	*
+	* This is necessary because safari throws
+	* when a user disables cookies/localstorage
+	* and you attempt to access it.
+	*
+	* @return {LocalStorage}
+	* @api private
+	*/
+	function localstorage() {
+		try {
+			return localStorage;
+		} catch (error) {}
+	}
+	module.exports = require_common()(exports);
+	const { formatters } = module.exports;
+	/**
+	* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+	*/
+	formatters.j = function(v) {
+		try {
+			return JSON.stringify(v);
+		} catch (error) {
+			return "[UnexpectedJSONParseError]: " + error.message;
+		}
+	};
+}));
+
+//#endregion
+//#region node_modules/debug/src/node.js
+var require_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	*/
+	const tty = __require("tty");
+	const util = __require("util");
+	/**
+	* This is the Node.js implementation of `debug()`.
+	*/
+	exports.init = init;
+	exports.log = log;
+	exports.formatArgs = formatArgs;
+	exports.save = save;
+	exports.load = load;
+	exports.useColors = useColors;
+	exports.destroy = util.deprecate(() => {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+	/**
+	* Colors.
+	*/
+	exports.colors = [
+		6,
+		2,
+		3,
+		4,
+		5,
+		1
+	];
+	try {
+		const supportsColor = __require("supports-color");
+		if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) exports.colors = [
+			20,
+			21,
+			26,
+			27,
+			32,
+			33,
+			38,
+			39,
+			40,
+			41,
+			42,
+			43,
+			44,
+			45,
+			56,
+			57,
+			62,
+			63,
+			68,
+			69,
+			74,
+			75,
+			76,
+			77,
+			78,
+			79,
+			80,
+			81,
+			92,
+			93,
+			98,
+			99,
+			112,
+			113,
+			128,
+			129,
+			134,
+			135,
+			148,
+			149,
+			160,
+			161,
+			162,
+			163,
+			164,
+			165,
+			166,
+			167,
+			168,
+			169,
+			170,
+			171,
+			172,
+			173,
+			178,
+			179,
+			184,
+			185,
+			196,
+			197,
+			198,
+			199,
+			200,
+			201,
+			202,
+			203,
+			204,
+			205,
+			206,
+			207,
+			208,
+			209,
+			214,
+			215,
+			220,
+			221
+		];
+	} catch (error) {}
+	/**
+	* Build up the default `inspectOpts` object from the environment variables.
+	*
+	*   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+	*/
+	exports.inspectOpts = Object.keys(process.env).filter((key) => {
+		return /^debug_/i.test(key);
+	}).reduce((obj, key) => {
+		const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+			return k.toUpperCase();
+		});
+		let val = process.env[key];
+		if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
+		else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
+		else if (val === "null") val = null;
+		else val = Number(val);
+		obj[prop] = val;
+		return obj;
+	}, {});
+	/**
+	* Is stdout a TTY? Colored output is enabled when `true`.
+	*/
+	function useColors() {
+		return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+	}
+	/**
+	* Adds ANSI color escape codes if enabled.
+	*
+	* @api public
+	*/
+	function formatArgs(args) {
+		const { namespace: name, useColors } = this;
+		if (useColors) {
+			const c = this.color;
+			const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+			const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+			args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+			args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+		} else args[0] = getDate() + name + " " + args[0];
+	}
+	function getDate() {
+		if (exports.inspectOpts.hideDate) return "";
+		return (/* @__PURE__ */ new Date()).toISOString() + " ";
+	}
+	/**
+	* Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
+	*/
+	function log(...args) {
+		return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
+	}
+	/**
+	* Save `namespaces`.
+	*
+	* @param {String} namespaces
+	* @api private
+	*/
+	function save(namespaces) {
+		if (namespaces) process.env.DEBUG = namespaces;
+		else delete process.env.DEBUG;
+	}
+	/**
+	* Load `namespaces`.
+	*
+	* @return {String} returns the previously persisted debug modes
+	* @api private
+	*/
+	function load() {
+		return process.env.DEBUG;
+	}
+	/**
+	* Init logic for `debug` instances.
+	*
+	* Create a new `inspectOpts` object in case `useColors` is set
+	* differently for a particular `debug` instance.
+	*/
+	function init(debug) {
+		debug.inspectOpts = {};
+		const keys = Object.keys(exports.inspectOpts);
+		for (let i = 0; i < keys.length; i++) debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+	}
+	module.exports = require_common()(exports);
+	const { formatters } = module.exports;
+	/**
+	* Map %o to `util.inspect()`, all on a single line.
+	*/
+	formatters.o = function(v) {
+		this.inspectOpts.colors = this.useColors;
+		return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+	};
+	/**
+	* Map %O to `util.inspect()`, allowing multiple lines if needed.
+	*/
+	formatters.O = function(v) {
+		this.inspectOpts.colors = this.useColors;
+		return util.inspect(v, this.inspectOpts);
+	};
+}));
+
+//#endregion
+//#region node_modules/debug/src/index.js
+var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Detect Electron renderer / nwjs process, which is node, but we should
+	* treat as a browser.
+	*/
+	if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) module.exports = require_browser();
+	else module.exports = require_node();
+}));
+
+//#endregion
+//#region node_modules/@tokenizer/inflate/lib/ZipToken.js
+var import_src = /* @__PURE__ */ __toESM(require_src(), 1);
+/**
+* Ref https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+*/
+const Signature = {
+	LocalFileHeader: 67324752,
+	DataDescriptor: 134695760,
+	CentralFileHeader: 33639248,
+	EndOfCentralDirectory: 101010256
+};
+const DataDescriptor = {
+	get(array) {
+		return {
+			signature: UINT32_LE.get(array, 0),
+			compressedSize: UINT32_LE.get(array, 8),
+			uncompressedSize: UINT32_LE.get(array, 12)
+		};
+	},
+	len: 16
+};
+/**
+* First part of the ZIP Local File Header
+* Offset | Bytes| Description
+* -------|------+-------------------------------------------------------------------
+*      0 |    4 | Signature (0x04034b50)
+*      4 |    2 | Minimum version needed to extract
+*      6 |    2 | Bit flag
+*      8 |    2 | Compression method
+*     10 |    2 | File last modification time (MS-DOS format)
+*     12 |    2 | File last modification date (MS-DOS format)
+*     14 |    4 | CRC-32 of uncompressed data
+*     18 |    4 | Compressed size
+*     22 |    4 | Uncompressed size
+*     26 |    2 | File name length (n)
+*     28 |    2 | Extra field length (m)
+*     30 |    n | File name
+* 30 + n |    m | Extra field
+*/
+const LocalFileHeaderToken = {
+	get(array) {
+		const flags = UINT16_LE.get(array, 6);
+		return {
+			signature: UINT32_LE.get(array, 0),
+			minVersion: UINT16_LE.get(array, 4),
+			dataDescriptor: !!(flags & 8),
+			compressedMethod: UINT16_LE.get(array, 8),
+			compressedSize: UINT32_LE.get(array, 18),
+			uncompressedSize: UINT32_LE.get(array, 22),
+			filenameLength: UINT16_LE.get(array, 26),
+			extraFieldLength: UINT16_LE.get(array, 28),
+			filename: null
+		};
+	},
+	len: 30
+};
+/**
+* 4.3.16  End of central directory record:
+*  end of central dir signature (0x06064b50)                                      4 bytes
+*  number of this disk                                                            2 bytes
+*  number of the disk with the start of the central directory                     2 bytes
+*  total number of entries in the central directory on this disk                  2 bytes
+*  total number of entries in the size of the central directory                   2 bytes
+*  sizeOfTheCentralDirectory                                                      4 bytes
+*  offset of start of central directory with respect to the starting disk number  4 bytes
+*  .ZIP file comment length                                                       2 bytes
+*  .ZIP file comment       (variable size)
+*/
+const EndOfCentralDirectoryRecordToken = {
+	get(array) {
+		return {
+			signature: UINT32_LE.get(array, 0),
+			nrOfThisDisk: UINT16_LE.get(array, 4),
+			nrOfThisDiskWithTheStart: UINT16_LE.get(array, 6),
+			nrOfEntriesOnThisDisk: UINT16_LE.get(array, 8),
+			nrOfEntriesOfSize: UINT16_LE.get(array, 10),
+			sizeOfCd: UINT32_LE.get(array, 12),
+			offsetOfStartOfCd: UINT32_LE.get(array, 16),
+			zipFileCommentLength: UINT16_LE.get(array, 20)
+		};
+	},
+	len: 22
+};
+/**
+* File header:
+*    central file header signature   4 bytes   0 (0x02014b50)
+*    version made by                 2 bytes   4
+*    version needed to extract       2 bytes   6
+*    general purpose bit flag        2 bytes   8
+*    compression method              2 bytes  10
+*    last mod file time              2 bytes  12
+*    last mod file date              2 bytes  14
+*    crc-32                          4 bytes  16
+*    compressed size                 4 bytes  20
+*    uncompressed size               4 bytes  24
+*    file name length                2 bytes  28
+*    extra field length              2 bytes  30
+*    file comment length             2 bytes  32
+*    disk number start               2 bytes  34
+*    internal file attributes        2 bytes  36
+*    external file attributes        4 bytes  38
+*    relative offset of local header 4 bytes  42
+*/
+const FileHeader = {
+	get(array) {
+		const flags = UINT16_LE.get(array, 8);
+		return {
+			signature: UINT32_LE.get(array, 0),
+			minVersion: UINT16_LE.get(array, 6),
+			dataDescriptor: !!(flags & 8),
+			compressedMethod: UINT16_LE.get(array, 10),
+			compressedSize: UINT32_LE.get(array, 20),
+			uncompressedSize: UINT32_LE.get(array, 24),
+			filenameLength: UINT16_LE.get(array, 28),
+			extraFieldLength: UINT16_LE.get(array, 30),
+			fileCommentLength: UINT16_LE.get(array, 32),
+			relativeOffsetOfLocalHeader: UINT32_LE.get(array, 42),
+			filename: null
+		};
+	},
+	len: 46
+};
+
+//#endregion
+//#region node_modules/@tokenizer/inflate/lib/ZipHandler.js
+function signatureToArray(signature) {
+	const signatureBytes = new Uint8Array(UINT32_LE.len);
+	UINT32_LE.put(signatureBytes, 0, signature);
+	return signatureBytes;
+}
+const debug = (0, import_src.default)("tokenizer:inflate");
+const syncBufferSize = 256 * 1024;
+const ddSignatureArray = signatureToArray(Signature.DataDescriptor);
+const eocdSignatureBytes = signatureToArray(Signature.EndOfCentralDirectory);
+var ZipHandler = class ZipHandler {
+	constructor(tokenizer) {
+		this.tokenizer = tokenizer;
+		this.syncBuffer = new Uint8Array(syncBufferSize);
+	}
+	async isZip() {
+		return await this.peekSignature() === Signature.LocalFileHeader;
+	}
+	peekSignature() {
+		return this.tokenizer.peekToken(UINT32_LE);
+	}
+	async findEndOfCentralDirectoryLocator() {
+		const randomReadTokenizer = this.tokenizer;
+		const chunkLength = Math.min(16 * 1024, 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;
+		return -1;
+	}
+	async readCentralDirectory() {
+		if (!this.tokenizer.supportsRandomAccess()) {
+			debug("Cannot reading central-directory without random-read support");
+			return;
+		}
+		debug("Reading central-directory...");
+		const pos = this.tokenizer.position;
+		const offset = await this.findEndOfCentralDirectoryLocator();
+		if (offset > 0) {
+			debug("Central-directory 32-bit signature found");
+			const eocdHeader = await this.tokenizer.readToken(EndOfCentralDirectoryRecordToken, offset);
+			const files = [];
+			this.tokenizer.setPosition(eocdHeader.offsetOfStartOfCd);
+			for (let n = 0; n < eocdHeader.nrOfEntriesOfSize; ++n) {
+				const entry = await this.tokenizer.readToken(FileHeader);
+				if (entry.signature !== Signature.CentralFileHeader) throw new Error("Expected Central-File-Header signature");
+				entry.filename = await this.tokenizer.readToken(new StringType(entry.filenameLength, "utf-8"));
+				await this.tokenizer.ignore(entry.extraFieldLength);
+				await this.tokenizer.ignore(entry.fileCommentLength);
+				files.push(entry);
+				debug(`Add central-directory file-entry: n=${n + 1}/${files.length}: filename=${files[n].filename}`);
+			}
+			this.tokenizer.setPosition(pos);
+			return files;
+		}
+		this.tokenizer.setPosition(pos);
+	}
+	async unzip(fileCb) {
+		const entries = await this.readCentralDirectory();
+		if (entries) return this.iterateOverCentralDirectory(entries, fileCb);
+		let stop = false;
+		do {
+			const zipHeader = await this.readLocalFileHeader();
+			if (!zipHeader) break;
+			const next = fileCb(zipHeader);
+			stop = !!next.stop;
+			let fileData;
+			await this.tokenizer.ignore(zipHeader.extraFieldLength);
+			if (zipHeader.dataDescriptor && zipHeader.compressedSize === 0) {
+				const chunks = [];
+				let len = syncBufferSize;
+				debug("Compressed-file-size unknown, scanning for next data-descriptor-signature....");
+				let nextHeaderIndex = -1;
+				while (nextHeaderIndex < 0 && len === syncBufferSize) {
+					len = await this.tokenizer.peekBuffer(this.syncBuffer, { mayBeLess: true });
+					nextHeaderIndex = indexOf(this.syncBuffer.subarray(0, len), ddSignatureArray);
+					const size = nextHeaderIndex >= 0 ? nextHeaderIndex : len;
+					if (next.handler) {
+						const data = new Uint8Array(size);
+						await this.tokenizer.readBuffer(data);
+						chunks.push(data);
+					} else await this.tokenizer.ignore(size);
+				}
+				debug(`Found data-descriptor-signature at pos=${this.tokenizer.position}`);
+				if (next.handler) await this.inflate(zipHeader, mergeArrays(chunks), next.handler);
+			} else if (next.handler) {
+				debug(`Reading compressed-file-data: ${zipHeader.compressedSize} bytes`);
+				fileData = new Uint8Array(zipHeader.compressedSize);
+				await this.tokenizer.readBuffer(fileData);
+				await this.inflate(zipHeader, fileData, next.handler);
+			} else {
+				debug(`Ignoring compressed-file-data: ${zipHeader.compressedSize} bytes`);
+				await this.tokenizer.ignore(zipHeader.compressedSize);
+			}
+			debug(`Reading data-descriptor at pos=${this.tokenizer.position}`);
+			if (zipHeader.dataDescriptor) {
+				if ((await this.tokenizer.readToken(DataDescriptor)).signature !== 134695760) throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - DataDescriptor.len}`);
+			}
+		} while (!stop);
+	}
+	async iterateOverCentralDirectory(entries, fileCb) {
+		for (const fileHeader of entries) {
+			const next = fileCb(fileHeader);
+			if (next.handler) {
+				this.tokenizer.setPosition(fileHeader.relativeOffsetOfLocalHeader);
+				const zipHeader = await this.readLocalFileHeader();
+				if (zipHeader) {
+					await this.tokenizer.ignore(zipHeader.extraFieldLength);
+					const fileData = new Uint8Array(fileHeader.compressedSize);
+					await this.tokenizer.readBuffer(fileData);
+					await this.inflate(zipHeader, fileData, next.handler);
+				}
+			}
+			if (next.stop) break;
+		}
+	}
+	async inflate(zipHeader, fileData, cb) {
+		if (zipHeader.compressedMethod === 0) return cb(fileData);
+		if (zipHeader.compressedMethod !== 8) throw new Error(`Unsupported ZIP compression method: ${zipHeader.compressedMethod}`);
+		debug(`Decompress filename=${zipHeader.filename}, compressed-size=${fileData.length}`);
+		return cb(await ZipHandler.decompressDeflateRaw(fileData));
+	}
+	static async decompressDeflateRaw(data) {
+		const input = new ReadableStream({ start(controller) {
+			controller.enqueue(data);
+			controller.close();
+		} });
+		const ds = new DecompressionStream("deflate-raw");
+		const output = input.pipeThrough(ds);
+		try {
+			const buffer = await new Response(output).arrayBuffer();
+			return new Uint8Array(buffer);
+		} catch (err) {
+			const message = err instanceof Error ? `Failed to deflate ZIP entry: ${err.message}` : "Unknown decompression error in ZIP entry";
+			throw new TypeError(message);
+		}
+	}
+	async readLocalFileHeader() {
+		const signature = await this.tokenizer.peekToken(UINT32_LE);
+		if (signature === Signature.LocalFileHeader) {
+			const header = await this.tokenizer.readToken(LocalFileHeaderToken);
+			header.filename = await this.tokenizer.readToken(new StringType(header.filenameLength, "utf-8"));
+			return header;
+		}
+		if (signature === Signature.CentralFileHeader) return false;
+		if (signature === 3759263696) throw new Error("Encrypted ZIP");
+		throw new Error("Unexpected signature");
+	}
+};
+function indexOf(buffer, portion) {
+	const bufferLength = buffer.length;
+	const portionLength = portion.length;
+	if (portionLength > bufferLength) return -1;
+	for (let i = 0; i <= bufferLength - portionLength; i++) {
+		let found = true;
+		for (let j = 0; j < portionLength; j++) if (buffer[i + j] !== portion[j]) {
+			found = false;
+			break;
+		}
+		if (found) return i;
+	}
+	return -1;
+}
+function mergeArrays(chunks) {
+	const totalLength = chunks.reduce((acc, curr) => acc + curr.length, 0);
+	const mergedArray = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		mergedArray.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return mergedArray;
+}
+
+//#endregion
+//#region node_modules/@tokenizer/inflate/lib/GzipHandler.js
+var GzipHandler = class {
+	constructor(tokenizer) {
+		this.tokenizer = tokenizer;
+	}
+	inflate() {
+		const tokenizer = this.tokenizer;
+		return new ReadableStream({ async pull(controller) {
+			const buffer = new Uint8Array(1024);
+			const size = await tokenizer.readBuffer(buffer, { mayBeLess: true });
+			if (size === 0) {
+				controller.close();
+				return;
+			}
+			controller.enqueue(buffer.subarray(0, size));
+		} }).pipeThrough(new DecompressionStream("gzip"));
+	}
+};
+
+//#endregion
+//#region node_modules/uint8array-extras/index.js
+const cachedDecoders = { utf8: new globalThis.TextDecoder("utf8") };
+const cachedEncoder = new globalThis.TextEncoder();
+const byteToHexLookupTable = Array.from({ length: 256 }, (_, index) => index.toString(16).padStart(2, "0"));
+/**
+@param {DataView} view
+@returns {number}
+*/
+function getUintBE(view) {
+	const { byteLength } = view;
+	if (byteLength === 6) return view.getUint16(0) * 2 ** 32 + view.getUint32(2);
+	if (byteLength === 5) return view.getUint8(0) * 2 ** 32 + view.getUint32(1);
+	if (byteLength === 4) return view.getUint32(0);
+	if (byteLength === 3) return view.getUint8(0) * 2 ** 16 + view.getUint16(1);
+	if (byteLength === 2) return view.getUint16(0);
+	if (byteLength === 1) return view.getUint8(0);
+}
+
+//#endregion
+//#region node_modules/file-type/util.js
+function stringToBytes(string, encoding) {
+	if (encoding === "utf-16le") {
+		const bytes = [];
+		for (let index = 0; index < string.length; index++) {
+			const code = string.charCodeAt(index);
+			bytes.push(code & 255, code >> 8 & 255);
+		}
+		return bytes;
+	}
+	if (encoding === "utf-16be") {
+		const bytes = [];
+		for (let index = 0; index < string.length; index++) {
+			const code = string.charCodeAt(index);
+			bytes.push(code >> 8 & 255, code & 255);
+		}
+		return bytes;
+	}
+	return [...string].map((character) => character.charCodeAt(0));
+}
+/**
+Checks whether the TAR checksum is valid.
+
+@param {Uint8Array} arrayBuffer - The TAR header `[offset ... offset + 512]`.
+@param {number} offset - TAR header offset.
+@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);
+	if (Number.isNaN(readSum)) return false;
+	let sum = 256;
+	for (let index = offset; index < offset + 148; index++) sum += arrayBuffer[index];
+	for (let index = offset + 156; index < offset + 512; index++) sum += arrayBuffer[index];
+	return readSum === sum;
+}
+/**
+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,
+	len: 4
+};
+
+//#endregion
+//#region node_modules/file-type/supported.js
+const extensions = [
+	"jpg",
+	"png",
+	"apng",
+	"gif",
+	"webp",
+	"flif",
+	"xcf",
+	"cr2",
+	"cr3",
+	"orf",
+	"arw",
+	"dng",
+	"nef",
+	"rw2",
+	"raf",
+	"tif",
+	"bmp",
+	"icns",
+	"jxr",
+	"psd",
+	"indd",
+	"zip",
+	"tar",
+	"rar",
+	"gz",
+	"bz2",
+	"7z",
+	"dmg",
+	"mp4",
+	"mid",
+	"mkv",
+	"webm",
+	"mov",
+	"avi",
+	"mpg",
+	"mp2",
+	"mp3",
+	"m4a",
+	"oga",
+	"ogg",
+	"ogv",
+	"opus",
+	"flac",
+	"wav",
+	"spx",
+	"amr",
+	"pdf",
+	"epub",
+	"elf",
+	"macho",
+	"exe",
+	"swf",
+	"rtf",
+	"wasm",
+	"woff",
+	"woff2",
+	"eot",
+	"ttf",
+	"otf",
+	"ttc",
+	"ico",
+	"flv",
+	"ps",
+	"xz",
+	"sqlite",
+	"nes",
+	"crx",
+	"xpi",
+	"cab",
+	"deb",
+	"ar",
+	"rpm",
+	"Z",
+	"lz",
+	"cfb",
+	"mxf",
+	"mts",
+	"blend",
+	"bpg",
+	"docx",
+	"pptx",
+	"xlsx",
+	"3gp",
+	"3g2",
+	"j2c",
+	"jp2",
+	"jpm",
+	"jpx",
+	"mj2",
+	"aif",
+	"qcp",
+	"odt",
+	"ods",
+	"odp",
+	"xml",
+	"mobi",
+	"heic",
+	"cur",
+	"ktx",
+	"ape",
+	"wv",
+	"dcm",
+	"ics",
+	"glb",
+	"pcap",
+	"dsf",
+	"lnk",
+	"alias",
+	"voc",
+	"ac3",
+	"m4v",
+	"m4p",
+	"m4b",
+	"f4v",
+	"f4p",
+	"f4b",
+	"f4a",
+	"mie",
+	"asf",
+	"ogm",
+	"ogx",
+	"mpc",
+	"arrow",
+	"shp",
+	"aac",
+	"mp1",
+	"it",
+	"s3m",
+	"xm",
+	"skp",
+	"avif",
+	"eps",
+	"lzh",
+	"pgp",
+	"asar",
+	"stl",
+	"chm",
+	"3mf",
+	"zst",
+	"jxl",
+	"vcf",
+	"jls",
+	"pst",
+	"dwg",
+	"parquet",
+	"class",
+	"arj",
+	"cpio",
+	"ace",
+	"avro",
+	"icc",
+	"fbx",
+	"vsdx",
+	"vtt",
+	"apk",
+	"drc",
+	"lz4",
+	"potx",
+	"xltx",
+	"dotx",
+	"xltm",
+	"ott",
+	"ots",
+	"otp",
+	"odg",
+	"otg",
+	"xlsm",
+	"docm",
+	"dotm",
+	"potm",
+	"pptm",
+	"jar",
+	"jmp",
+	"rm",
+	"sav",
+	"ppsm",
+	"ppsx",
+	"tar.gz",
+	"reg",
+	"dat"
+];
+const mimeTypes = [
+	"image/jpeg",
+	"image/png",
+	"image/gif",
+	"image/webp",
+	"image/flif",
+	"image/x-xcf",
+	"image/x-canon-cr2",
+	"image/x-canon-cr3",
+	"image/tiff",
+	"image/bmp",
+	"image/vnd.ms-photo",
+	"image/vnd.adobe.photoshop",
+	"application/x-indesign",
+	"application/epub+zip",
+	"application/x-xpinstall",
+	"application/vnd.ms-powerpoint.slideshow.macroenabled.12",
+	"application/vnd.oasis.opendocument.text",
+	"application/vnd.oasis.opendocument.spreadsheet",
+	"application/vnd.oasis.opendocument.presentation",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	"application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	"application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+	"application/zip",
+	"application/x-tar",
+	"application/x-rar-compressed",
+	"application/gzip",
+	"application/x-bzip2",
+	"application/x-7z-compressed",
+	"application/x-apple-diskimage",
+	"application/vnd.apache.arrow.file",
+	"video/mp4",
+	"audio/midi",
+	"video/matroska",
+	"video/webm",
+	"video/quicktime",
+	"video/vnd.avi",
+	"audio/wav",
+	"audio/qcelp",
+	"audio/x-ms-asf",
+	"video/x-ms-asf",
+	"application/vnd.ms-asf",
+	"video/mpeg",
+	"video/3gpp",
+	"audio/mpeg",
+	"audio/mp4",
+	"video/ogg",
+	"audio/ogg",
+	"audio/ogg; codecs=opus",
+	"application/ogg",
+	"audio/flac",
+	"audio/ape",
+	"audio/wavpack",
+	"audio/amr",
+	"application/pdf",
+	"application/x-elf",
+	"application/x-mach-binary",
+	"application/x-msdownload",
+	"application/x-shockwave-flash",
+	"application/rtf",
+	"application/wasm",
+	"font/woff",
+	"font/woff2",
+	"application/vnd.ms-fontobject",
+	"font/ttf",
+	"font/otf",
+	"font/collection",
+	"image/x-icon",
+	"video/x-flv",
+	"application/postscript",
+	"application/eps",
+	"application/x-xz",
+	"application/x-sqlite3",
+	"application/x-nintendo-nes-rom",
+	"application/x-google-chrome-extension",
+	"application/vnd.ms-cab-compressed",
+	"application/x-deb",
+	"application/x-unix-archive",
+	"application/x-rpm",
+	"application/x-compress",
+	"application/x-lzip",
+	"application/x-cfb",
+	"application/x-mie",
+	"application/mxf",
+	"video/mp2t",
+	"application/x-blender",
+	"image/bpg",
+	"image/j2c",
+	"image/jp2",
+	"image/jpx",
+	"image/jpm",
+	"image/mj2",
+	"audio/aiff",
+	"application/xml",
+	"application/x-mobipocket-ebook",
+	"image/heif",
+	"image/heif-sequence",
+	"image/heic",
+	"image/heic-sequence",
+	"image/icns",
+	"image/ktx",
+	"application/dicom",
+	"audio/x-musepack",
+	"text/calendar",
+	"text/vcard",
+	"text/vtt",
+	"model/gltf-binary",
+	"application/vnd.tcpdump.pcap",
+	"audio/x-dsf",
+	"application/x.ms.shortcut",
+	"application/x.apple.alias",
+	"audio/x-voc",
+	"audio/vnd.dolby.dd-raw",
+	"audio/x-m4a",
+	"image/apng",
+	"image/x-olympus-orf",
+	"image/x-sony-arw",
+	"image/x-adobe-dng",
+	"image/x-nikon-nef",
+	"image/x-panasonic-rw2",
+	"image/x-fujifilm-raf",
+	"video/x-m4v",
+	"video/3gpp2",
+	"application/x-esri-shape",
+	"audio/aac",
+	"audio/x-it",
+	"audio/x-s3m",
+	"audio/x-xm",
+	"video/MP1S",
+	"video/MP2P",
+	"application/vnd.sketchup.skp",
+	"image/avif",
+	"application/x-lzh-compressed",
+	"application/pgp-encrypted",
+	"application/x-asar",
+	"model/stl",
+	"application/vnd.ms-htmlhelp",
+	"model/3mf",
+	"image/jxl",
+	"application/zstd",
+	"image/jls",
+	"application/vnd.ms-outlook",
+	"image/vnd.dwg",
+	"application/vnd.apache.parquet",
+	"application/java-vm",
+	"application/x-arj",
+	"application/x-cpio",
+	"application/x-ace-compressed",
+	"application/avro",
+	"application/vnd.iccprofile",
+	"application/x.autodesk.fbx",
+	"application/vnd.visio",
+	"application/vnd.android.package-archive",
+	"application/vnd.google.draco",
+	"application/x-lz4",
+	"application/vnd.openxmlformats-officedocument.presentationml.template",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.template",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.template",
+	"application/vnd.ms-excel.template.macroenabled.12",
+	"application/vnd.oasis.opendocument.text-template",
+	"application/vnd.oasis.opendocument.spreadsheet-template",
+	"application/vnd.oasis.opendocument.presentation-template",
+	"application/vnd.oasis.opendocument.graphics",
+	"application/vnd.oasis.opendocument.graphics-template",
+	"application/vnd.ms-excel.sheet.macroenabled.12",
+	"application/vnd.ms-word.document.macroenabled.12",
+	"application/vnd.ms-word.template.macroenabled.12",
+	"application/vnd.ms-powerpoint.template.macroenabled.12",
+	"application/vnd.ms-powerpoint.presentation.macroenabled.12",
+	"application/java-archive",
+	"application/vnd.rn-realmedia",
+	"application/x-spss-sav",
+	"application/x-ms-regedit",
+	"application/x-ft-windows-registry-hive",
+	"application/x-jmp-data"
+];
+
+//#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 maximumUntrustedSkipSizeInBytes = 16 * 1024 * 1024;
+const maximumNestedGzipDetectionSizeInBytes = maximumUntrustedSkipSizeInBytes;
+const maximumId3HeaderSizeInBytes = maximumUntrustedSkipSizeInBytes;
+const maximumEbmlDocumentTypeSizeInBytes = 64;
+const maximumEbmlElementPayloadSizeInBytes = maximumUntrustedSkipSizeInBytes;
+const maximumEbmlElementCount = 256;
+const maximumPngChunkSizeInBytes = maximumUntrustedSkipSizeInBytes;
+const maximumTiffIfdOffsetInBytes = maximumUntrustedSkipSizeInBytes;
+const recoverableZipErrorMessages = new Set([
+	"Unexpected signature",
+	"Encrypted ZIP",
+	"Expected Central-File-Header signature"
+]);
+const recoverableZipErrorMessagePrefixes = ["Unsupported ZIP compression method:", "ZIP entry decompressed data exceeds "];
+const recoverableZipErrorCodes = new Set([
+	"Z_BUF_ERROR",
+	"Z_DATA_ERROR",
+	"ERR_INVALID_STATE"
+]);
+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)`);
+	return value;
+}
+async function safeIgnore(tokenizer, length, { maximumLength = maximumUntrustedSkipSizeInBytes, reason = "skip" } = {}) {
+	const safeLength = getSafeBound(length, maximumLength, reason);
+	await tokenizer.ignore(safeLength);
+}
+async function safeReadBuffer(tokenizer, buffer, options, { maximumLength = buffer.length, reason = "read" } = {}) {
+	const safeLength = getSafeBound(options?.length ?? buffer.length, maximumLength, reason);
+	return tokenizer.readBuffer(buffer, {
+		...options,
+		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;
+}
+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: hasUnknownFileSize(this.tokenizer) ? maximumZipEntrySizeInBytes : Number.MAX_SAFE_INTEGER }));
+};
+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);
+		}
+	});
+}
+async function fileTypeFromBlob(blob, options) {
+	return new FileTypeParser(options).fromBlob(blob);
+}
+function getFileTypeFromMimeType(mimeType) {
+	mimeType = mimeType.toLowerCase();
+	switch (mimeType) {
+		case "application/epub+zip": return {
+			ext: "epub",
+			mime: mimeType
+		};
+		case "application/vnd.oasis.opendocument.text": return {
+			ext: "odt",
+			mime: mimeType
+		};
+		case "application/vnd.oasis.opendocument.text-template": return {
+			ext: "ott",
+			mime: mimeType
+		};
+		case "application/vnd.oasis.opendocument.spreadsheet": return {
+			ext: "ods",
+			mime: mimeType
+		};
+		case "application/vnd.oasis.opendocument.spreadsheet-template": return {
+			ext: "ots",
+			mime: mimeType
+		};
+		case "application/vnd.oasis.opendocument.presentation": return {
+			ext: "odp",
+			mime: mimeType
+		};
+		case "application/vnd.oasis.opendocument.presentation-template": return {
+			ext: "otp",
+			mime: mimeType
+		};
+		case "application/vnd.oasis.opendocument.graphics": return {
+			ext: "odg",
+			mime: mimeType
+		};
+		case "application/vnd.oasis.opendocument.graphics-template": return {
+			ext: "otg",
+			mime: mimeType
+		};
+		case "application/vnd.openxmlformats-officedocument.presentationml.slideshow": return {
+			ext: "ppsx",
+			mime: mimeType
+		};
+		case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": return {
+			ext: "xlsx",
+			mime: mimeType
+		};
+		case "application/vnd.ms-excel.sheet.macroenabled": return {
+			ext: "xlsm",
+			mime: "application/vnd.ms-excel.sheet.macroenabled.12"
+		};
+		case "application/vnd.openxmlformats-officedocument.spreadsheetml.template": return {
+			ext: "xltx",
+			mime: mimeType
+		};
+		case "application/vnd.ms-excel.template.macroenabled": return {
+			ext: "xltm",
+			mime: "application/vnd.ms-excel.template.macroenabled.12"
+		};
+		case "application/vnd.ms-powerpoint.slideshow.macroenabled": return {
+			ext: "ppsm",
+			mime: "application/vnd.ms-powerpoint.slideshow.macroenabled.12"
+		};
+		case "application/vnd.openxmlformats-officedocument.wordprocessingml.document": return {
+			ext: "docx",
+			mime: mimeType
+		};
+		case "application/vnd.ms-word.document.macroenabled": return {
+			ext: "docm",
+			mime: "application/vnd.ms-word.document.macroenabled.12"
+		};
+		case "application/vnd.openxmlformats-officedocument.wordprocessingml.template": return {
+			ext: "dotx",
+			mime: mimeType
+		};
+		case "application/vnd.ms-word.template.macroenabledtemplate": return {
+			ext: "dotm",
+			mime: "application/vnd.ms-word.template.macroenabled.12"
+		};
+		case "application/vnd.openxmlformats-officedocument.presentationml.template": return {
+			ext: "potx",
+			mime: mimeType
+		};
+		case "application/vnd.ms-powerpoint.template.macroenabled": return {
+			ext: "potm",
+			mime: "application/vnd.ms-powerpoint.template.macroenabled.12"
+		};
+		case "application/vnd.openxmlformats-officedocument.presentationml.presentation": return {
+			ext: "pptx",
+			mime: mimeType
+		};
+		case "application/vnd.ms-powerpoint.presentation.macroenabled": return {
+			ext: "pptm",
+			mime: "application/vnd.ms-powerpoint.presentation.macroenabled.12"
+		};
+		case "application/vnd.ms-visio.drawing": return {
+			ext: "vsdx",
+			mime: "application/vnd.visio"
+		};
+		case "application/vnd.ms-package.3dmanufacturing-3dmodel+xml": return {
+			ext: "3mf",
+			mime: "model/3mf"
+		};
+		default:
+	}
+}
+function _check(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;
+}
+function normalizeSampleSize(sampleSize) {
+	if (!Number.isFinite(sampleSize)) return reasonableDetectionSizeInBytes;
+	return Math.max(1, Math.trunc(sampleSize));
+}
+function normalizeMpegOffsetTolerance(mpegOffsetTolerance) {
+	if (!Number.isFinite(mpegOffsetTolerance)) return 0;
+	return Math.max(0, Math.min(maximumMpegOffsetTolerance, Math.trunc(mpegOffsetTolerance)));
+}
+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 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 (error instanceof TypeError && 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 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 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 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);
+}
+var FileTypeParser = class {
+	constructor(options) {
+		const normalizedMpegOffsetTolerance = normalizeMpegOffsetTolerance(options?.mpegOffsetTolerance);
+		this.options = {
+			...options,
+			mpegOffsetTolerance: normalizedMpegOffsetTolerance
+		};
+		this.detectors = [
+			...this.options.customDetectors ?? [],
+			{
+				id: "core",
+				detect: this.detectConfident
+			},
+			{
+				id: "core.imprecise",
+				detect: this.detectImprecise
+			}
+		];
+		this.tokenizerOptions = { abortSignal: this.options.signal };
+	}
+	async fromTokenizer(tokenizer) {
+		const initialPosition = tokenizer.position;
+		for (const detector of this.detectors) {
+			let fileType;
+			try {
+				fileType = await detector.detect(tokenizer);
+			} catch (error) {
+				if (error instanceof EndOfStreamError) return;
+				if (error instanceof ParserHardLimitError) return;
+				throw error;
+			}
+			if (fileType) return fileType;
+			if (initialPosition !== tokenizer.position) return;
+		}
+	}
+	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);
+		if (!(buffer?.length > 1)) return;
+		return this.fromTokenizer(fromBuffer(buffer, this.tokenizerOptions));
+	}
+	async fromBlob(blob) {
+		const tokenizer = fromBlob(blob, this.tokenizerOptions);
+		try {
+			return await this.fromTokenizer(tokenizer);
+		} finally {
+			await tokenizer.close();
+		}
+	}
+	async fromStream(stream) {
+		const tokenizer = fromWebStream(stream, this.tokenizerOptions);
+		try {
+			return await this.fromTokenizer(tokenizer);
+		} finally {
+			await tokenizer.close();
+		}
+	}
+	async toDetectionStream(stream, options) {
+		const sampleSize = normalizeSampleSize(options?.sampleSize ?? reasonableDetectionSizeInBytes);
+		let detectedFileType;
+		let firstChunk;
+		const reader = stream.getReader({ mode: "byob" });
+		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));
+			} catch (error) {
+				if (!(error instanceof EndOfStreamError)) throw error;
+				detectedFileType = void 0;
+			}
+			firstChunk = chunk;
+		} finally {
+			reader.releaseLock();
+		}
+		const transformStream = new TransformStream({
+			async start(controller) {
+				controller.enqueue(firstChunk);
+			},
+			transform(chunk, controller) {
+				controller.enqueue(chunk);
+			}
+		});
+		const newStream = stream.pipeThrough(transformStream);
+		newStream.fileType = detectedFileType;
+		return newStream;
+	}
+	check(header, options) {
+		return _check(this.buffer, header, options);
+	}
+	checkString(header, options) {
+		return this.check(stringToBytes(header, options?.encoding), options);
+	}
+	detectConfident = async (tokenizer) => {
+		this.buffer = new Uint8Array(reasonableDetectionSizeInBytes);
+		if (tokenizer.fileInfo.size === void 0) tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
+		this.tokenizer = tokenizer;
+		await tokenizer.peekBuffer(this.buffer, {
+			length: 32,
+			mayBeLess: true
+		});
+		if (this.check([66, 77])) return {
+			ext: "bmp",
+			mime: "image/bmp"
+		};
+		if (this.check([11, 119])) return {
+			ext: "ac3",
+			mime: "audio/vnd.dolby.dd-raw"
+		};
+		if (this.check([120, 1])) return {
+			ext: "dmg",
+			mime: "application/x-apple-diskimage"
+		};
+		if (this.check([77, 90])) return {
+			ext: "exe",
+			mime: "application/x-msdownload"
+		};
+		if (this.check([37, 33])) {
+			await tokenizer.peekBuffer(this.buffer, {
+				length: 24,
+				mayBeLess: true
+			});
+			if (this.checkString("PS-Adobe-", { offset: 2 }) && this.checkString(" EPSF-", { offset: 14 })) return {
+				ext: "eps",
+				mime: "application/eps"
+			};
+			return {
+				ext: "ps",
+				mime: "application/postscript"
+			};
+		}
+		if (this.check([31, 160]) || this.check([31, 157])) return {
+			ext: "Z",
+			mime: "application/x-compress"
+		};
+		if (this.check([199, 113])) return {
+			ext: "cpio",
+			mime: "application/x-cpio"
+		};
+		if (this.check([96, 234])) return {
+			ext: "arj",
+			mime: "application/x-arj"
+		};
+		if (this.check([
+			239,
+			187,
+			191
+		])) {
+			await this.tokenizer.ignore(3);
+			return this.detectConfident(tokenizer);
+		}
+		if (this.check([
+			71,
+			73,
+			70
+		])) return {
+			ext: "gif",
+			mime: "image/gif"
+		};
+		if (this.check([
+			73,
+			73,
+			188
+		])) return {
+			ext: "jxr",
+			mime: "image/vnd.ms-photo"
+		};
+		if (this.check([
+			31,
+			139,
+			8
+		])) {
+			const limitedInflatedStream = createByteLimitedReadableStream(new GzipHandler(tokenizer).inflate(), maximumNestedGzipDetectionSizeInBytes);
+			let compressedFileType;
+			try {
+				compressedFileType = await this.fromStream(limitedInflatedStream);
+			} catch (error) {
+				if (error?.name === "AbortError") throw error;
+			}
+			if (compressedFileType?.ext === "tar") return {
+				ext: "tar.gz",
+				mime: "application/gzip"
+			};
+			return {
+				ext: "gz",
+				mime: "application/gzip"
+			};
+		}
+		if (this.check([
+			66,
+			90,
+			104
+		])) return {
+			ext: "bz2",
+			mime: "application/x-bzip2"
+		};
+		if (this.checkString("ID3")) {
+			await safeIgnore(tokenizer, 6, {
+				maximumLength: 6,
+				reason: "ID3 header prefix"
+			});
+			const id3HeaderLength = await tokenizer.readToken(uint32SyncSafeToken);
+			const isUnknownFileSize = hasUnknownFileSize(tokenizer);
+			if (!Number.isFinite(id3HeaderLength) || id3HeaderLength < 0 || isUnknownFileSize && id3HeaderLength > maximumId3HeaderSizeInBytes) return;
+			if (tokenizer.position + id3HeaderLength > tokenizer.fileInfo.size) {
+				if (isUnknownFileSize) return;
+				return {
+					ext: "mp3",
+					mime: "audio/mpeg"
+				};
+			}
+			try {
+				await safeIgnore(tokenizer, id3HeaderLength, {
+					maximumLength: isUnknownFileSize ? maximumId3HeaderSizeInBytes : tokenizer.fileInfo.size,
+					reason: "ID3 payload"
+				});
+			} catch (error) {
+				if (error instanceof EndOfStreamError) return;
+				throw error;
+			}
+			return this.fromTokenizer(tokenizer);
+		}
+		if (this.checkString("MP+")) return {
+			ext: "mpc",
+			mime: "audio/x-musepack"
+		};
+		if ((this.buffer[0] === 67 || this.buffer[0] === 70) && this.check([87, 83], { offset: 1 })) return {
+			ext: "swf",
+			mime: "application/x-shockwave-flash"
+		};
+		if (this.check([
+			255,
+			216,
+			255
+		])) {
+			if (this.check([247], { offset: 3 })) return {
+				ext: "jls",
+				mime: "image/jls"
+			};
+			return {
+				ext: "jpg",
+				mime: "image/jpeg"
+			};
+		}
+		if (this.check([
+			79,
+			98,
+			106,
+			1
+		])) return {
+			ext: "avro",
+			mime: "application/avro"
+		};
+		if (this.checkString("FLIF")) return {
+			ext: "flif",
+			mime: "image/flif"
+		};
+		if (this.checkString("8BPS")) return {
+			ext: "psd",
+			mime: "image/vnd.adobe.photoshop"
+		};
+		if (this.checkString("MPCK")) return {
+			ext: "mpc",
+			mime: "audio/x-musepack"
+		};
+		if (this.checkString("FORM")) return {
+			ext: "aif",
+			mime: "audio/aiff"
+		};
+		if (this.checkString("icns", { offset: 0 })) return {
+			ext: "icns",
+			mime: "image/icns"
+		};
+		if (this.check([
+			80,
+			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)) 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, hasUnknownFileSize(tokenizer) ? maximumZipEntrySizeInBytes : Number.MAX_SAFE_INTEGER)) {
+								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"
+			};
+		}
+		if (this.checkString("OggS")) {
+			await tokenizer.ignore(28);
+			const type = new Uint8Array(8);
+			await tokenizer.readBuffer(type);
+			if (_check(type, [
+				79,
+				112,
+				117,
+				115,
+				72,
+				101,
+				97,
+				100
+			])) return {
+				ext: "opus",
+				mime: "audio/ogg; codecs=opus"
+			};
+			if (_check(type, [
+				128,
+				116,
+				104,
+				101,
+				111,
+				114,
+				97
+			])) return {
+				ext: "ogv",
+				mime: "video/ogg"
+			};
+			if (_check(type, [
+				1,
+				118,
+				105,
+				100,
+				101,
+				111,
+				0
+			])) return {
+				ext: "ogm",
+				mime: "video/ogg"
+			};
+			if (_check(type, [
+				127,
+				70,
+				76,
+				65,
+				67
+			])) return {
+				ext: "oga",
+				mime: "audio/ogg"
+			};
+			if (_check(type, [
+				83,
+				112,
+				101,
+				101,
+				120,
+				32,
+				32
+			])) return {
+				ext: "spx",
+				mime: "audio/ogg"
+			};
+			if (_check(type, [
+				1,
+				118,
+				111,
+				114,
+				98,
+				105,
+				115
+			])) return {
+				ext: "ogg",
+				mime: "audio/ogg"
+			};
+			return {
+				ext: "ogx",
+				mime: "application/ogg"
+			};
+		}
+		if (this.check([80, 75]) && (this.buffer[2] === 3 || this.buffer[2] === 5 || this.buffer[2] === 7) && (this.buffer[3] === 4 || this.buffer[3] === 6 || this.buffer[3] === 8)) return {
+			ext: "zip",
+			mime: "application/zip"
+		};
+		if (this.checkString("MThd")) return {
+			ext: "mid",
+			mime: "audio/midi"
+		};
+		if (this.checkString("wOFF") && (this.check([
+			0,
+			1,
+			0,
+			0
+		], { offset: 4 }) || this.checkString("OTTO", { offset: 4 }))) return {
+			ext: "woff",
+			mime: "font/woff"
+		};
+		if (this.checkString("wOF2") && (this.check([
+			0,
+			1,
+			0,
+			0
+		], { offset: 4 }) || this.checkString("OTTO", { offset: 4 }))) return {
+			ext: "woff2",
+			mime: "font/woff2"
+		};
+		if (this.check([
+			212,
+			195,
+			178,
+			161
+		]) || this.check([
+			161,
+			178,
+			195,
+			212
+		])) return {
+			ext: "pcap",
+			mime: "application/vnd.tcpdump.pcap"
+		};
+		if (this.checkString("DSD ")) return {
+			ext: "dsf",
+			mime: "audio/x-dsf"
+		};
+		if (this.checkString("LZIP")) return {
+			ext: "lz",
+			mime: "application/x-lzip"
+		};
+		if (this.checkString("fLaC")) return {
+			ext: "flac",
+			mime: "audio/flac"
+		};
+		if (this.check([
+			66,
+			80,
+			71,
+			251
+		])) return {
+			ext: "bpg",
+			mime: "image/bpg"
+		};
+		if (this.checkString("wvpk")) return {
+			ext: "wv",
+			mime: "audio/wavpack"
+		};
+		if (this.checkString("%PDF")) return {
+			ext: "pdf",
+			mime: "application/pdf"
+		};
+		if (this.check([
+			0,
+			97,
+			115,
+			109
+		])) return {
+			ext: "wasm",
+			mime: "application/wasm"
+		};
+		if (this.check([73, 73])) {
+			const fileType = await this.readTiffHeader(false);
+			if (fileType) return fileType;
+		}
+		if (this.check([77, 77])) {
+			const fileType = await this.readTiffHeader(true);
+			if (fileType) return fileType;
+		}
+		if (this.checkString("MAC ")) return {
+			ext: "ape",
+			mime: "audio/ape"
+		};
+		if (this.check([
+			26,
+			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 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;
+				}
+			}
+			switch (await readChildren((await readElement()).len)) {
+				case "webm": return {
+					ext: "webm",
+					mime: "video/webm"
+				};
+				case "matroska": return {
+					ext: "mkv",
+					mime: "video/matroska"
+				};
+				default: return;
+			}
+		}
+		if (this.checkString("SQLi")) return {
+			ext: "sqlite",
+			mime: "application/x-sqlite3"
+		};
+		if (this.check([
+			78,
+			69,
+			83,
+			26
+		])) return {
+			ext: "nes",
+			mime: "application/x-nintendo-nes-rom"
+		};
+		if (this.checkString("Cr24")) return {
+			ext: "crx",
+			mime: "application/x-google-chrome-extension"
+		};
+		if (this.checkString("MSCF") || this.checkString("ISc(")) return {
+			ext: "cab",
+			mime: "application/vnd.ms-cab-compressed"
+		};
+		if (this.check([
+			237,
+			171,
+			238,
+			219
+		])) return {
+			ext: "rpm",
+			mime: "application/x-rpm"
+		};
+		if (this.check([
+			197,
+			208,
+			211,
+			198
+		])) return {
+			ext: "eps",
+			mime: "application/eps"
+		};
+		if (this.check([
+			40,
+			181,
+			47,
+			253
+		])) return {
+			ext: "zst",
+			mime: "application/zstd"
+		};
+		if (this.check([
+			127,
+			69,
+			76,
+			70
+		])) return {
+			ext: "elf",
+			mime: "application/x-elf"
+		};
+		if (this.check([
+			33,
+			66,
+			68,
+			78
+		])) return {
+			ext: "pst",
+			mime: "application/vnd.ms-outlook"
+		};
+		if (this.checkString("PAR1") || this.checkString("PARE")) return {
+			ext: "parquet",
+			mime: "application/vnd.apache.parquet"
+		};
+		if (this.checkString("ttcf")) return {
+			ext: "ttc",
+			mime: "font/collection"
+		};
+		if (this.check([
+			254,
+			237,
+			250,
+			206
+		]) || this.check([
+			254,
+			237,
+			250,
+			207
+		]) || this.check([
+			206,
+			250,
+			237,
+			254
+		]) || this.check([
+			207,
+			250,
+			237,
+			254
+		])) return {
+			ext: "macho",
+			mime: "application/x-mach-binary"
+		};
+		if (this.check([
+			4,
+			34,
+			77,
+			24
+		])) return {
+			ext: "lz4",
+			mime: "application/x-lz4"
+		};
+		if (this.checkString("regf")) return {
+			ext: "dat",
+			mime: "application/x-ft-windows-registry-hive"
+		};
+		if (this.checkString("$FL2") || this.checkString("$FL3")) return {
+			ext: "sav",
+			mime: "application/x-spss-sav"
+		};
+		if (this.check([
+			79,
+			84,
+			84,
+			79,
+			0
+		])) return {
+			ext: "otf",
+			mime: "font/otf"
+		};
+		if (this.checkString("#!AMR")) return {
+			ext: "amr",
+			mime: "audio/amr"
+		};
+		if (this.checkString("{\\rtf")) return {
+			ext: "rtf",
+			mime: "application/rtf"
+		};
+		if (this.check([
+			70,
+			76,
+			86,
+			1
+		])) return {
+			ext: "flv",
+			mime: "video/x-flv"
+		};
+		if (this.checkString("IMPM")) return {
+			ext: "it",
+			mime: "audio/x-it"
+		};
+		if (this.checkString("-lh0-", { offset: 2 }) || this.checkString("-lh1-", { offset: 2 }) || this.checkString("-lh2-", { offset: 2 }) || this.checkString("-lh3-", { offset: 2 }) || this.checkString("-lh4-", { offset: 2 }) || this.checkString("-lh5-", { offset: 2 }) || this.checkString("-lh6-", { offset: 2 }) || this.checkString("-lh7-", { offset: 2 }) || this.checkString("-lzs-", { offset: 2 }) || this.checkString("-lz4-", { offset: 2 }) || this.checkString("-lz5-", { offset: 2 }) || this.checkString("-lhd-", { offset: 2 })) return {
+			ext: "lzh",
+			mime: "application/x-lzh-compressed"
+		};
+		if (this.check([
+			0,
+			0,
+			1,
+			186
+		])) {
+			if (this.check([33], {
+				offset: 4,
+				mask: [241]
+			})) return {
+				ext: "mpg",
+				mime: "video/MP1S"
+			};
+			if (this.check([68], {
+				offset: 4,
+				mask: [196]
+			})) return {
+				ext: "mpg",
+				mime: "video/MP2P"
+			};
+		}
+		if (this.checkString("ITSF")) return {
+			ext: "chm",
+			mime: "application/vnd.ms-htmlhelp"
+		};
+		if (this.check([
+			202,
+			254,
+			186,
+			190
+		])) {
+			const machOArchitectureCount = UINT32_BE.get(this.buffer, 4);
+			const javaClassFileMajorVersion = UINT16_BE.get(this.buffer, 6);
+			if (machOArchitectureCount > 0 && machOArchitectureCount <= 30) return {
+				ext: "macho",
+				mime: "application/x-mach-binary"
+			};
+			if (javaClassFileMajorVersion > 30) return {
+				ext: "class",
+				mime: "application/java-vm"
+			};
+		}
+		if (this.checkString(".RMF")) return {
+			ext: "rm",
+			mime: "application/vnd.rn-realmedia"
+		};
+		if (this.checkString("DRACO")) return {
+			ext: "drc",
+			mime: "application/vnd.google.draco"
+		};
+		if (this.check([
+			253,
+			55,
+			122,
+			88,
+			90,
+			0
+		])) return {
+			ext: "xz",
+			mime: "application/x-xz"
+		};
+		if (this.checkString("<?xml ")) return {
+			ext: "xml",
+			mime: "application/xml"
+		};
+		if (this.check([
+			55,
+			122,
+			188,
+			175,
+			39,
+			28
+		])) return {
+			ext: "7z",
+			mime: "application/x-7z-compressed"
+		};
+		if (this.check([
+			82,
+			97,
+			114,
+			33,
+			26,
+			7
+		]) && (this.buffer[6] === 0 || this.buffer[6] === 1)) return {
+			ext: "rar",
+			mime: "application/x-rar-compressed"
+		};
+		if (this.checkString("solid ")) return {
+			ext: "stl",
+			mime: "model/stl"
+		};
+		if (this.checkString("AC")) {
+			const version = new StringType(4, "latin1").get(this.buffer, 2);
+			if (version.match("^d*") && version >= 1e3 && version <= 1050) return {
+				ext: "dwg",
+				mime: "image/vnd.dwg"
+			};
+		}
+		if (this.checkString("070707")) return {
+			ext: "cpio",
+			mime: "application/x-cpio"
+		};
+		if (this.checkString("BLENDER")) return {
+			ext: "blend",
+			mime: "application/x-blender"
+		};
+		if (this.checkString("!<arch>")) {
+			await tokenizer.ignore(8);
+			if (await tokenizer.readToken(new StringType(13, "ascii")) === "debian-binary") return {
+				ext: "deb",
+				mime: "application/x-deb"
+			};
+			return {
+				ext: "ar",
+				mime: "application/x-unix-archive"
+			};
+		}
+		if (this.checkString("WEBVTT") && [
+			"\n",
+			"\r",
+			"	",
+			" ",
+			"\0"
+		].some((char7) => this.checkString(char7, { offset: 6 }))) return {
+			ext: "vtt",
+			mime: "text/vtt"
+		};
+		if (this.check([
+			137,
+			80,
+			78,
+			71,
+			13,
+			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;
+			do {
+				if (hasExceededUnknownSizeScanBudget(tokenizer, pngScanStart, maximumPngChunkSizeInBytes)) break;
+				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 ? maximumPngChunkSizeInBytes + 4 : tokenizer.fileInfo.size,
+								reason: "PNG chunk payload"
+							});
+						} catch (error) {
+							if (!isUnknownPngStream && (error instanceof ParserHardLimitError || error instanceof EndOfStreamError)) return pngFileType;
+							throw error;
+						}
+				}
+			} while (tokenizer.position + 8 < tokenizer.fileInfo.size);
+			return pngFileType;
+		}
+		if (this.check([
+			65,
+			82,
+			82,
+			79,
+			87,
+			49,
+			0,
+			0
+		])) return {
+			ext: "arrow",
+			mime: "application/vnd.apache.arrow.file"
+		};
+		if (this.check([
+			103,
+			108,
+			84,
+			70,
+			2,
+			0,
+			0,
+			0
+		])) return {
+			ext: "glb",
+			mime: "model/gltf-binary"
+		};
+		if (this.check([
+			102,
+			114,
+			101,
+			101
+		], { offset: 4 }) || this.check([
+			109,
+			100,
+			97,
+			116
+		], { offset: 4 }) || this.check([
+			109,
+			111,
+			111,
+			118
+		], { offset: 4 }) || this.check([
+			119,
+			105,
+			100,
+			101
+		], { offset: 4 })) return {
+			ext: "mov",
+			mime: "video/quicktime"
+		};
+		if (this.check([
+			73,
+			73,
+			82,
+			79,
+			8,
+			0,
+			0,
+			0,
+			24
+		])) return {
+			ext: "orf",
+			mime: "image/x-olympus-orf"
+		};
+		if (this.checkString("gimp xcf ")) return {
+			ext: "xcf",
+			mime: "image/x-xcf"
+		};
+		if (this.checkString("ftyp", { offset: 4 }) && (this.buffer[8] & 96) !== 0) {
+			const brandMajor = new StringType(4, "latin1").get(this.buffer, 8).replace("\0", " ").trim();
+			switch (brandMajor) {
+				case "avif":
+				case "avis": return {
+					ext: "avif",
+					mime: "image/avif"
+				};
+				case "mif1": return {
+					ext: "heic",
+					mime: "image/heif"
+				};
+				case "msf1": return {
+					ext: "heic",
+					mime: "image/heif-sequence"
+				};
+				case "heic":
+				case "heix": return {
+					ext: "heic",
+					mime: "image/heic"
+				};
+				case "hevc":
+				case "hevx": return {
+					ext: "heic",
+					mime: "image/heic-sequence"
+				};
+				case "qt": return {
+					ext: "mov",
+					mime: "video/quicktime"
+				};
+				case "M4V":
+				case "M4VH":
+				case "M4VP": return {
+					ext: "m4v",
+					mime: "video/x-m4v"
+				};
+				case "M4P": return {
+					ext: "m4p",
+					mime: "video/mp4"
+				};
+				case "M4B": return {
+					ext: "m4b",
+					mime: "audio/mp4"
+				};
+				case "M4A": return {
+					ext: "m4a",
+					mime: "audio/x-m4a"
+				};
+				case "F4V": return {
+					ext: "f4v",
+					mime: "video/mp4"
+				};
+				case "F4P": return {
+					ext: "f4p",
+					mime: "video/mp4"
+				};
+				case "F4A": return {
+					ext: "f4a",
+					mime: "audio/mp4"
+				};
+				case "F4B": return {
+					ext: "f4b",
+					mime: "audio/mp4"
+				};
+				case "crx": return {
+					ext: "cr3",
+					mime: "image/x-canon-cr3"
+				};
+				default:
+					if (brandMajor.startsWith("3g")) {
+						if (brandMajor.startsWith("3g2")) return {
+							ext: "3g2",
+							mime: "video/3gpp2"
+						};
+						return {
+							ext: "3gp",
+							mime: "video/3gpp"
+						};
+					}
+					return {
+						ext: "mp4",
+						mime: "video/mp4"
+					};
+			}
+		}
+		if (this.checkString("REGEDIT4\r\n")) return {
+			ext: "reg",
+			mime: "application/x-ms-regedit"
+		};
+		if (this.check([
+			82,
+			73,
+			70,
+			70
+		])) {
+			if (this.checkString("WEBP", { offset: 8 })) return {
+				ext: "webp",
+				mime: "image/webp"
+			};
+			if (this.check([
+				65,
+				86,
+				73
+			], { offset: 8 })) return {
+				ext: "avi",
+				mime: "video/vnd.avi"
+			};
+			if (this.check([
+				87,
+				65,
+				86,
+				69
+			], { offset: 8 })) return {
+				ext: "wav",
+				mime: "audio/wav"
+			};
+			if (this.check([
+				81,
+				76,
+				67,
+				77
+			], { offset: 8 })) return {
+				ext: "qcp",
+				mime: "audio/qcelp"
+			};
+		}
+		if (this.check([
+			73,
+			73,
+			85,
+			0,
+			24,
+			0,
+			0,
+			0,
+			136,
+			231,
+			116,
+			216
+		])) return {
+			ext: "rw2",
+			mime: "image/x-panasonic-rw2"
+		};
+		if (this.check([
+			48,
+			38,
+			178,
+			117,
+			142,
+			102,
+			207,
+			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;
+				while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
+					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"
+			};
+		}
+		if (this.check([
+			171,
+			75,
+			84,
+			88,
+			32,
+			49,
+			49,
+			187,
+			13,
+			10,
+			26,
+			10
+		])) return {
+			ext: "ktx",
+			mime: "image/ktx"
+		};
+		if ((this.check([
+			126,
+			16,
+			4
+		]) || this.check([
+			126,
+			24,
+			4
+		])) && this.check([
+			48,
+			77,
+			73,
+			69
+		], { offset: 4 })) return {
+			ext: "mie",
+			mime: "application/x-mie"
+		};
+		if (this.check([
+			39,
+			10,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		], { offset: 2 })) return {
+			ext: "shp",
+			mime: "application/x-esri-shape"
+		};
+		if (this.check([
+			255,
+			79,
+			255,
+			81
+		])) return {
+			ext: "j2c",
+			mime: "image/j2c"
+		};
+		if (this.check([
+			0,
+			0,
+			0,
+			12,
+			106,
+			80,
+			32,
+			32,
+			13,
+			10,
+			135,
+			10
+		])) {
+			await tokenizer.ignore(20);
+			switch (await tokenizer.readToken(new StringType(4, "ascii"))) {
+				case "jp2 ": return {
+					ext: "jp2",
+					mime: "image/jp2"
+				};
+				case "jpx ": return {
+					ext: "jpx",
+					mime: "image/jpx"
+				};
+				case "jpm ": return {
+					ext: "jpm",
+					mime: "image/jpm"
+				};
+				case "mjp2": return {
+					ext: "mj2",
+					mime: "image/mj2"
+				};
+				default: return;
+			}
+		}
+		if (this.check([255, 10]) || this.check([
+			0,
+			0,
+			0,
+			12,
+			74,
+			88,
+			76,
+			32,
+			13,
+			10,
+			135,
+			10
+		])) return {
+			ext: "jxl",
+			mime: "image/jxl"
+		};
+		if (this.check([254, 255])) {
+			if (this.checkString("<?xml ", {
+				offset: 2,
+				encoding: "utf-16be"
+			})) return {
+				ext: "xml",
+				mime: "application/xml"
+			};
+			return;
+		}
+		if (this.check([
+			208,
+			207,
+			17,
+			224,
+			161,
+			177,
+			26,
+			225
+		])) return {
+			ext: "cfb",
+			mime: "application/x-cfb"
+		};
+		await tokenizer.peekBuffer(this.buffer, {
+			length: Math.min(256, tokenizer.fileInfo.size),
+			mayBeLess: true
+		});
+		if (this.check([
+			97,
+			99,
+			115,
+			112
+		], { offset: 36 })) return {
+			ext: "icc",
+			mime: "application/vnd.iccprofile"
+		};
+		if (this.checkString("**ACE", { offset: 7 }) && this.checkString("**", { offset: 12 })) return {
+			ext: "ace",
+			mime: "application/x-ace-compressed"
+		};
+		if (this.checkString("BEGIN:")) {
+			if (this.checkString("VCARD", { offset: 6 })) return {
+				ext: "vcf",
+				mime: "text/vcard"
+			};
+			if (this.checkString("VCALENDAR", { offset: 6 })) return {
+				ext: "ics",
+				mime: "text/calendar"
+			};
+		}
+		if (this.checkString("FUJIFILMCCD-RAW")) return {
+			ext: "raf",
+			mime: "image/x-fujifilm-raf"
+		};
+		if (this.checkString("Extended Module:")) return {
+			ext: "xm",
+			mime: "audio/x-xm"
+		};
+		if (this.checkString("Creative Voice File")) return {
+			ext: "voc",
+			mime: "audio/x-voc"
+		};
+		if (this.check([
+			4,
+			0,
+			0,
+			0
+		]) && this.buffer.length >= 16) {
+			const jsonSize = new DataView(this.buffer.buffer).getUint32(12, true);
+			if (jsonSize > 12 && this.buffer.length >= jsonSize + 16) try {
+				const header = new TextDecoder().decode(this.buffer.subarray(16, jsonSize + 16));
+				if (JSON.parse(header).files) return {
+					ext: "asar",
+					mime: "application/x-asar"
+				};
+			} catch {}
+		}
+		if (this.check([
+			6,
+			14,
+			43,
+			52,
+			2,
+			5,
+			1,
+			1,
+			13,
+			1,
+			2,
+			1,
+			1,
+			2
+		])) return {
+			ext: "mxf",
+			mime: "application/mxf"
+		};
+		if (this.checkString("SCRM", { offset: 44 })) return {
+			ext: "s3m",
+			mime: "audio/x-s3m"
+		};
+		if (this.check([71]) && this.check([71], { offset: 188 })) return {
+			ext: "mts",
+			mime: "video/mp2t"
+		};
+		if (this.check([71], { offset: 4 }) && this.check([71], { offset: 196 })) return {
+			ext: "mts",
+			mime: "video/mp2t"
+		};
+		if (this.check([
+			66,
+			79,
+			79,
+			75,
+			77,
+			79,
+			66,
+			73
+		], { offset: 60 })) return {
+			ext: "mobi",
+			mime: "application/x-mobipocket-ebook"
+		};
+		if (this.check([
+			68,
+			73,
+			67,
+			77
+		], { offset: 128 })) return {
+			ext: "dcm",
+			mime: "application/dicom"
+		};
+		if (this.check([
+			76,
+			0,
+			0,
+			0,
+			1,
+			20,
+			2,
+			0,
+			0,
+			0,
+			0,
+			0,
+			192,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			70
+		])) return {
+			ext: "lnk",
+			mime: "application/x.ms.shortcut"
+		};
+		if (this.check([
+			98,
+			111,
+			111,
+			107,
+			0,
+			0,
+			0,
+			0,
+			109,
+			97,
+			114,
+			107,
+			0,
+			0,
+			0,
+			0
+		])) return {
+			ext: "alias",
+			mime: "application/x.apple.alias"
+		};
+		if (this.checkString("Kaydara FBX Binary  \0")) return {
+			ext: "fbx",
+			mime: "application/x.autodesk.fbx"
+		};
+		if (this.check([76, 80], { offset: 34 }) && (this.check([
+			0,
+			0,
+			1
+		], { offset: 8 }) || this.check([
+			1,
+			0,
+			2
+		], { offset: 8 }) || this.check([
+			2,
+			0,
+			2
+		], { offset: 8 }))) return {
+			ext: "eot",
+			mime: "application/vnd.ms-fontobject"
+		};
+		if (this.check([
+			6,
+			6,
+			237,
+			245,
+			216,
+			29,
+			70,
+			229,
+			189,
+			49,
+			239,
+			231,
+			254,
+			116,
+			183,
+			29
+		])) return {
+			ext: "indd",
+			mime: "application/x-indesign"
+		};
+		if (this.check([
+			255,
+			255,
+			0,
+			0,
+			7,
+			0,
+			0,
+			0,
+			4,
+			0,
+			0,
+			0,
+			1,
+			0,
+			1,
+			0
+		]) || this.check([
+			0,
+			0,
+			255,
+			255,
+			0,
+			0,
+			0,
+			7,
+			0,
+			0,
+			0,
+			4,
+			0,
+			1,
+			0,
+			1
+		])) return {
+			ext: "jmp",
+			mime: "application/x-jmp-data"
+		};
+		await tokenizer.peekBuffer(this.buffer, {
+			length: Math.min(512, tokenizer.fileInfo.size),
+			mayBeLess: true
+		});
+		if (this.checkString("ustar", { offset: 257 }) && (this.checkString("\0", { offset: 262 }) || this.checkString(" ", { offset: 262 })) || this.check([
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		], { offset: 257 }) && tarHeaderChecksumMatches(this.buffer)) return {
+			ext: "tar",
+			mime: "application/x-tar"
+		};
+		if (this.check([255, 254])) {
+			const encoding = "utf-16le";
+			if (this.checkString("<?xml ", {
+				offset: 2,
+				encoding
+			})) return {
+				ext: "xml",
+				mime: "application/xml"
+			};
+			if (this.check([255, 14], { offset: 2 }) && this.checkString("SketchUp Model", {
+				offset: 4,
+				encoding
+			})) return {
+				ext: "skp",
+				mime: "application/vnd.sketchup.skp"
+			};
+			if (this.checkString("Windows Registry Editor Version 5.00\r\n", {
+				offset: 2,
+				encoding
+			})) return {
+				ext: "reg",
+				mime: "application/x-ms-regedit"
+			};
+			return;
+		}
+		if (this.checkString("-----BEGIN PGP MESSAGE-----")) return {
+			ext: "pgp",
+			mime: "application/pgp-encrypted"
+		};
+	};
+	detectImprecise = async (tokenizer) => {
+		this.buffer = new Uint8Array(reasonableDetectionSizeInBytes);
+		const fileSize = getKnownFileSizeOrMaximum(tokenizer.fileInfo.size);
+		await tokenizer.peekBuffer(this.buffer, {
+			length: Math.min(8, fileSize),
+			mayBeLess: true
+		});
+		if (this.check([
+			0,
+			0,
+			1,
+			186
+		]) || this.check([
+			0,
+			0,
+			1,
+			179
+		])) return {
+			ext: "mpg",
+			mime: "video/mpeg"
+		};
+		if (this.check([
+			0,
+			1,
+			0,
+			0,
+			0
+		])) return {
+			ext: "ttf",
+			mime: "font/ttf"
+		};
+		if (this.check([
+			0,
+			0,
+			1,
+			0
+		])) return {
+			ext: "ico",
+			mime: "image/x-icon"
+		};
+		if (this.check([
+			0,
+			0,
+			2,
+			0
+		])) return {
+			ext: "cur",
+			mime: "image/x-icon"
+		};
+		await tokenizer.peekBuffer(this.buffer, {
+			length: Math.min(2 + this.options.mpegOffsetTolerance, fileSize),
+			mayBeLess: true
+		});
+		if (this.buffer.length >= 2 + this.options.mpegOffsetTolerance) for (let depth = 0; depth <= this.options.mpegOffsetTolerance; ++depth) {
+			const type = this.scanMpeg(depth);
+			if (type) return type;
+		}
+	};
+	async readTiffTag(bigEndian) {
+		const tagId = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
+		await this.tokenizer.ignore(10);
+		switch (tagId) {
+			case 50341: return {
+				ext: "arw",
+				mime: "image/x-sony-arw"
+			};
+			case 50706: return {
+				ext: "dng",
+				mime: "image/x-adobe-dng"
+			};
+			default:
+		}
+	}
+	async readTiffIFD(bigEndian) {
+		const numberOfTags = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
+		if (hasUnknownFileSize(this.tokenizer) && 2 + numberOfTags * 12 > maximumTiffIfdOffsetInBytes) return;
+		for (let n = 0; n < numberOfTags; ++n) {
+			const fileType = await this.readTiffTag(bigEndian);
+			if (fileType) return fileType;
+		}
+	}
+	async readTiffHeader(bigEndian) {
+		const tiffFileType = {
+			ext: "tif",
+			mime: "image/tiff"
+		};
+		const version = (bigEndian ? UINT16_BE : UINT16_LE).get(this.buffer, 2);
+		const ifdOffset = (bigEndian ? UINT32_BE : UINT32_LE).get(this.buffer, 4);
+		if (version === 42) {
+			if (ifdOffset >= 6) {
+				if (this.checkString("CR", { offset: 8 })) return {
+					ext: "cr2",
+					mime: "image/x-canon-cr2"
+				};
+				if (ifdOffset >= 8) {
+					const someId1 = (bigEndian ? UINT16_BE : UINT16_LE).get(this.buffer, 8);
+					const someId2 = (bigEndian ? UINT16_BE : UINT16_LE).get(this.buffer, 10);
+					if (someId1 === 28 && someId2 === 254 || someId1 === 31 && someId2 === 11) return {
+						ext: "nef",
+						mime: "image/x-nikon-nef"
+					};
+				}
+			}
+			const maximumTiffOffset = hasUnknownFileSize(this.tokenizer) ? maximumTiffIfdOffsetInBytes : this.tokenizer.fileInfo.size;
+			try {
+				await safeIgnore(this.tokenizer, ifdOffset, {
+					maximumLength: maximumTiffOffset,
+					reason: "TIFF IFD offset"
+				});
+			} catch (error) {
+				if (error instanceof EndOfStreamError) return;
+				throw error;
+			}
+			let fileType;
+			try {
+				fileType = await this.readTiffIFD(bigEndian);
+			} catch (error) {
+				if (error instanceof EndOfStreamError) return;
+				throw error;
+			}
+			return fileType ?? tiffFileType;
+		}
+		if (version === 43) return tiffFileType;
+	}
+	/**
+	Scan check MPEG 1 or 2 Layer 3 header, or 'layer 0' for ADTS (MPEG sync-word 0xFFE).
+	
+	@param offset - Offset to scan for sync-preamble.
+	@returns {{ext: string, mime: string}}
+	*/
+	scanMpeg(offset) {
+		if (this.check([255, 224], {
+			offset,
+			mask: [255, 224]
+		})) {
+			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"
+				};
+			}
+			if (this.check([2], {
+				offset: offset + 1,
+				mask: [6]
+			})) return {
+				ext: "mp3",
+				mime: "audio/mpeg"
+			};
+			if (this.check([4], {
+				offset: offset + 1,
+				mask: [6]
+			})) return {
+				ext: "mp2",
+				mime: "audio/mpeg"
+			};
+			if (this.check([6], {
+				offset: offset + 1,
+				mask: [6]
+			})) return {
+				ext: "mp1",
+				mime: "audio/mpeg"
+			};
+		}
+	}
+};
+const supportedExtensions = new Set(extensions);
+const supportedMimeTypes = new Set(mimeTypes);
+
+//#endregion
+export { fileTypeFromBlob };
+//# sourceMappingURL=file-type-BNd4XJK1.mjs.map