@fangyb/ahchat-bridge 0.1.23 → 0.1.24

package/dist/source-QQGKQ3LF.js

@@ -0,0 +1,4974 @@
+import {
+  __commonJS,
+  __esm,
+  __require,
+  __toESM
+} from "./chunk-2ESYSVXG.js";
+
+// ../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js
+var require_ieee754 = __commonJS({
+  "../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js"(exports) {
+    "use strict";
+    exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+      var e, m;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var nBits = -7;
+      var i = isLE ? nBytes - 1 : 0;
+      var d = isLE ? -1 : 1;
+      var s = buffer[offset + i];
+      i += d;
+      e = s & (1 << -nBits) - 1;
+      s >>= -nBits;
+      nBits += eLen;
+      for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
+      }
+      m = e & (1 << -nBits) - 1;
+      e >>= -nBits;
+      nBits += mLen;
+      for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
+      }
+      if (e === 0) {
+        e = 1 - eBias;
+      } else if (e === eMax) {
+        return m ? NaN : (s ? -1 : 1) * Infinity;
+      } else {
+        m = m + Math.pow(2, mLen);
+        e = e - eBias;
+      }
+      return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+    };
+    exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+      var e, m, c;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+      var i = isLE ? 0 : nBytes - 1;
+      var d = isLE ? 1 : -1;
+      var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+      value = Math.abs(value);
+      if (isNaN(value) || value === Infinity) {
+        m = isNaN(value) ? 1 : 0;
+        e = eMax;
+      } else {
+        e = Math.floor(Math.log(value) / Math.LN2);
+        if (value * (c = Math.pow(2, -e)) < 1) {
+          e--;
+          c *= 2;
+        }
+        if (e + eBias >= 1) {
+          value += rt / c;
+        } else {
+          value += rt * Math.pow(2, 1 - eBias);
+        }
+        if (value * c >= 2) {
+          e++;
+          c /= 2;
+        }
+        if (e + eBias >= eMax) {
+          m = 0;
+          e = eMax;
+        } else if (e + eBias >= 1) {
+          m = (value * c - 1) * Math.pow(2, mLen);
+          e = e + eBias;
+        } else {
+          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+          e = 0;
+        }
+      }
+      for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+      }
+      e = e << mLen | m;
+      eLen += mLen;
+      for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+      }
+      buffer[offset + i - d] |= s * 128;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@borewit+text-codec@0.2.2/node_modules/@borewit/text-codec/lib/index.js
+function utf8Decoder() {
+  if (typeof globalThis.TextDecoder === "undefined")
+    return void 0;
+  return _utf8Decoder !== null && _utf8Decoder !== void 0 ? _utf8Decoder : _utf8Decoder = new globalThis.TextDecoder("utf-8");
+}
+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 b22 = bytes[i + 1];
+      if ((b22 & 192) !== 128) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const cp2 = (b1 & 31) << 6 | b22 & 63;
+      pushCodeUnit(parts, chunk, cp2);
+      i += 2;
+      continue;
+    }
+    if (b1 <= 239) {
+      if (i + 2 >= bytes.length) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const b22 = bytes[i + 1];
+      const b32 = bytes[i + 2];
+      const valid2 = (b22 & 192) === 128 && (b32 & 192) === 128 && !(b1 === 224 && b22 < 160) && // overlong
+      !(b1 === 237 && b22 >= 160);
+      if (!valid2) {
+        pushCodeUnit(parts, chunk, REPLACEMENT);
+        i++;
+        continue;
+      }
+      const cp2 = (b1 & 15) << 12 | (b22 & 63) << 6 | b32 & 63;
+      pushCodeUnit(parts, chunk, cp2);
+      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];
+    const valid = (b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128 && !(b1 === 240 && b2 < 144) && // overlong
+    !(b1 === 244 && b2 > 143);
+    if (!valid) {
+      pushCodeUnit(parts, chunk, REPLACEMENT);
+      i++;
+      continue;
+    }
+    const cp = (b1 & 7) << 18 | (b2 & 63) << 12 | (b3 & 63) << 6 | b4 & 63;
+    pushCodePoint(parts, chunk, cp);
+    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("");
+}
+var WINDOWS_1252_EXTRA, WINDOWS_1252_REVERSE, _utf8Decoder, CHUNK, REPLACEMENT;
+var init_lib = __esm({
+  "../../node_modules/.pnpm/@borewit+text-codec@0.2.2/node_modules/@borewit/text-codec/lib/index.js"() {
+    "use strict";
+    WINDOWS_1252_EXTRA = {
+      128: "\u20AC",
+      130: "\u201A",
+      131: "\u0192",
+      132: "\u201E",
+      133: "\u2026",
+      134: "\u2020",
+      135: "\u2021",
+      136: "\u02C6",
+      137: "\u2030",
+      138: "\u0160",
+      139: "\u2039",
+      140: "\u0152",
+      142: "\u017D",
+      145: "\u2018",
+      146: "\u2019",
+      147: "\u201C",
+      148: "\u201D",
+      149: "\u2022",
+      150: "\u2013",
+      151: "\u2014",
+      152: "\u02DC",
+      153: "\u2122",
+      154: "\u0161",
+      155: "\u203A",
+      156: "\u0153",
+      158: "\u017E",
+      159: "\u0178"
+    };
+    WINDOWS_1252_REVERSE = {};
+    for (const [code, char] of Object.entries(WINDOWS_1252_EXTRA)) {
+      WINDOWS_1252_REVERSE[char] = Number.parseInt(code, 10);
+    }
+    CHUNK = 32 * 1024;
+    REPLACEMENT = 65533;
+  }
+});
+
+// ../../node_modules/.pnpm/token-types@6.1.2/node_modules/token-types/lib/index.js
+function dv(array) {
+  return new DataView(array.buffer, array.byteOffset);
+}
+var ieee754, UINT8, UINT16_LE, UINT16_BE, UINT32_LE, UINT32_BE, INT32_BE, UINT64_LE, StringType;
+var init_lib2 = __esm({
+  "../../node_modules/.pnpm/token-types@6.1.2/node_modules/token-types/lib/index.js"() {
+    "use strict";
+    ieee754 = __toESM(require_ieee754(), 1);
+    init_lib();
+    UINT8 = {
+      len: 1,
+      get(array, offset) {
+        return dv(array).getUint8(offset);
+      },
+      put(array, offset, value) {
+        dv(array).setUint8(offset, value);
+        return offset + 1;
+      }
+    };
+    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;
+      }
+    };
+    UINT16_BE = {
+      len: 2,
+      get(array, offset) {
+        return dv(array).getUint16(offset);
+      },
+      put(array, offset, value) {
+        dv(array).setUint16(offset, value);
+        return offset + 2;
+      }
+    };
+    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;
+      }
+    };
+    UINT32_BE = {
+      len: 4,
+      get(array, offset) {
+        return dv(array).getUint32(offset);
+      },
+      put(array, offset, value) {
+        dv(array).setUint32(offset, value);
+        return offset + 4;
+      }
+    };
+    INT32_BE = {
+      len: 4,
+      get(array, offset) {
+        return dv(array).getInt32(offset);
+      },
+      put(array, offset, value) {
+        dv(array).setInt32(offset, value);
+        return offset + 4;
+      }
+    };
+    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;
+      }
+    };
+    StringType = class {
+      constructor(len, encoding) {
+        this.len = len;
+        this.encoding = encoding;
+      }
+      get(data, offset = 0) {
+        const bytes = data.subarray(offset, offset + this.len);
+        return textDecode(bytes, this.encoding);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/Errors.js
+var defaultMessages, EndOfStreamError, AbortError;
+var init_Errors = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/Errors.js"() {
+    "use strict";
+    defaultMessages = "End-Of-Stream";
+    EndOfStreamError = class extends Error {
+      constructor() {
+        super(defaultMessages);
+        this.name = "EndOfStreamError";
+      }
+    };
+    AbortError = class extends Error {
+      constructor(message = "The operation was aborted") {
+        super(message);
+        this.name = "AbortError";
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/Deferred.js
+var init_Deferred = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/Deferred.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/AbstractStreamReader.js
+var AbstractStreamReader;
+var init_AbstractStreamReader = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/AbstractStreamReader.js"() {
+    "use strict";
+    init_Errors();
+    AbstractStreamReader = class {
+      constructor() {
+        this.endOfStream = false;
+        this.interrupted = false;
+        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;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/StreamReader.js
+var init_StreamReader = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/StreamReader.js"() {
+    "use strict";
+    init_Errors();
+    init_Deferred();
+    init_AbstractStreamReader();
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/WebStreamReader.js
+var WebStreamReader;
+var init_WebStreamReader = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/WebStreamReader.js"() {
+    "use strict";
+    init_AbstractStreamReader();
+    WebStreamReader = class extends AbstractStreamReader {
+      constructor(reader) {
+        super();
+        this.reader = reader;
+      }
+      async abort() {
+        return this.close();
+      }
+      async close() {
+        this.reader.releaseLock();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/WebStreamByobReader.js
+var WebStreamByobReader;
+var init_WebStreamByobReader = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/WebStreamByobReader.js"() {
+    "use strict";
+    init_WebStreamReader();
+    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;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/WebStreamDefaultReader.js
+var WebStreamDefaultReader;
+var init_WebStreamDefaultReader = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/WebStreamDefaultReader.js"() {
+    "use strict";
+    init_Errors();
+    init_AbstractStreamReader();
+    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();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/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;
+  }
+}
+var init_WebStreamReaderFactory = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/WebStreamReaderFactory.js"() {
+    "use strict";
+    init_WebStreamByobReader();
+    init_WebStreamDefaultReader();
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/index.js
+var init_stream = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/stream/index.js"() {
+    "use strict";
+    init_Errors();
+    init_StreamReader();
+    init_WebStreamByobReader();
+    init_WebStreamDefaultReader();
+    init_WebStreamReaderFactory();
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/AbstractTokenizer.js
+var AbstractTokenizer;
+var init_AbstractTokenizer = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/AbstractTokenizer.js"() {
+    "use strict";
+    init_stream();
+    AbstractTokenizer = class {
+      /**
+       * Constructor
+       * @param options Tokenizer options
+       * @protected
+       */
+      constructor(options) {
+        this.numBuffer = new Uint8Array(8);
+        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);
+        const len = await this.readBuffer(uint8Array, { position });
+        if (len < 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);
+        const len = await this.peekBuffer(uint8Array, { position });
+        if (len < 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) {
+        const len = await this.readBuffer(this.numBuffer, { length: token.len });
+        if (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) {
+        const len = await this.peekBuffer(this.numBuffer, { length: token.len });
+        if (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.  Must be ≥ 0.
+       * @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
+       */
+      async ignore(length) {
+        if (length < 0) {
+          throw new RangeError("ignore length must be \u2265 0 bytes");
+        }
+        if (this.fileInfo.size !== void 0) {
+          const bytesLeft = this.fileInfo.size - this.position;
+          if (length > bytesLeft) {
+            this.position += bytesLeft;
+            return bytesLeft;
+          }
+        }
+        this.position += length;
+        return length;
+      }
+      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();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/ReadStreamTokenizer.js
+var maxBufferSize, ReadStreamTokenizer;
+var init_ReadStreamTokenizer = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/ReadStreamTokenizer.js"() {
+    "use strict";
+    init_AbstractTokenizer();
+    init_stream();
+    maxBufferSize = 256e3;
+    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;
+      }
+      /**
+       * @param length Number of bytes to ignore. Must be ≥ 0.
+       */
+      async ignore(length) {
+        if (length < 0) {
+          throw new RangeError("ignore length must be \u2265 0 bytes");
+        }
+        const bufSize = Math.min(maxBufferSize, length);
+        const buf = new Uint8Array(bufSize);
+        let totBytesRead = 0;
+        while (totBytesRead < length) {
+          const remaining = length - totBytesRead;
+          const bytesRead = await this.readBuffer(buf, { length: Math.min(bufSize, remaining) });
+          if (bytesRead < 0) {
+            return bytesRead;
+          }
+          totBytesRead += bytesRead;
+        }
+        return totBytesRead;
+      }
+      abort() {
+        return this.streamReader.abort();
+      }
+      async close() {
+        return this.streamReader.close();
+      }
+      supportsRandomAccess() {
+        return false;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/BufferTokenizer.js
+var BufferTokenizer;
+var init_BufferTokenizer = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/BufferTokenizer.js"() {
+    "use strict";
+    init_stream();
+    init_AbstractTokenizer();
+    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;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/BlobTokenizer.js
+var BlobTokenizer;
+var init_BlobTokenizer = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/BlobTokenizer.js"() {
+    "use strict";
+    init_stream();
+    init_AbstractTokenizer();
+    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;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/core.js
+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);
+}
+function fromBuffer(uint8Array, options) {
+  return new BufferTokenizer(uint8Array, options);
+}
+function fromBlob(blob, options) {
+  return new BlobTokenizer(blob, options);
+}
+var init_core = __esm({
+  "../../node_modules/.pnpm/strtok3@10.3.5/node_modules/strtok3/lib/core.js"() {
+    "use strict";
+    init_stream();
+    init_ReadStreamTokenizer();
+    init_BufferTokenizer();
+    init_BlobTokenizer();
+    init_stream();
+    init_AbstractTokenizer();
+  }
+});
+
+// ../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js
+var require_ms = __commonJS({
+  "../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js"(exports, module) {
+    "use strict";
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    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)
+      );
+    };
+    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]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        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 void 0;
+      }
+    }
+    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";
+    }
+    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";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js"(exports, module) {
+    "use strict";
+    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];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      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;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug2(...args) {
+          if (!debug2.enabled) {
+            return;
+          }
+          const self = debug2;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self.diff = ms;
+          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);
+          const logFn = self.log || createDebug.log;
+          logFn.apply(self, args);
+        }
+        debug2.namespace = namespace;
+        debug2.useColors = createDebug.useColors();
+        debug2.color = createDebug.selectColor(namespace);
+        debug2.extend = extend;
+        debug2.destroy = createDebug.destroy;
+        Object.defineProperty(debug2, "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(debug2);
+        }
+        return debug2;
+      }
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      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);
+          }
+        }
+      }
+      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;
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug.names,
+          ...createDebug.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      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;
+      }
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      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;
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js"(exports, module) {
+    "use strict";
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      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`.");
+        }
+      };
+    })();
+    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"
+    ];
+    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 || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    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);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    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;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports, module) {
+    "use strict";
+    module.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/supports-color@8.1.1/node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "../../node_modules/.pnpm/supports-color@8.1.1/node_modules/supports-color/index.js"(exports, module) {
+    "use strict";
+    var os = __require("os");
+    var tty = __require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var flagForceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      flagForceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      flagForceColor = 1;
+    }
+    function envForceColor() {
+      if ("FORCE_COLOR" in env) {
+        if (env.FORCE_COLOR === "true") {
+          return 1;
+        }
+        if (env.FORCE_COLOR === "false") {
+          return 0;
+        }
+        return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+      const noFlagForceColor = envForceColor();
+      if (noFlagForceColor !== void 0) {
+        flagForceColor = noFlagForceColor;
+      }
+      const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (sniffFlags) {
+        if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+          return 3;
+        }
+        if (hasFlag("color=256")) {
+          return 2;
+        }
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream, options = {}) {
+      const level = supportsColor(stream, {
+        streamIsTTY: stream && stream.isTTY,
+        ...options
+      });
+      return translateLevel(level);
+    }
+    module.exports = {
+      supportsColor: getSupportLevel,
+      stdout: getSupportLevel({ isTTY: tty.isatty(1) }),
+      stderr: getSupportLevel({ isTTY: tty.isatty(2) })
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js"(exports, module) {
+    "use strict";
+    var tty = __require("tty");
+    var util = __require("util");
+    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`."
+    );
+    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) {
+    }
+    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;
+    }, {});
+    function useColors() {
+      return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c = this.color;
+        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+        const prefix = `  ${colorCode};1m${name} \x1B[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() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug2) {
+      debug2.inspectOpts = {};
+      const keys = Object.keys(exports.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug2.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module.exports = require_browser();
+    } else {
+      module.exports = require_node();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@tokenizer+inflate@0.4.1/node_modules/@tokenizer/inflate/lib/ZipToken.js
+var Signature, DataDescriptor, LocalFileHeaderToken, EndOfCentralDirectoryRecordToken, FileHeader;
+var init_ZipToken = __esm({
+  "../../node_modules/.pnpm/@tokenizer+inflate@0.4.1/node_modules/@tokenizer/inflate/lib/ZipToken.js"() {
+    "use strict";
+    init_lib2();
+    Signature = {
+      LocalFileHeader: 67324752,
+      DataDescriptor: 134695760,
+      CentralFileHeader: 33639248,
+      EndOfCentralDirectory: 101010256
+    };
+    DataDescriptor = {
+      get(array) {
+        return {
+          signature: UINT32_LE.get(array, 0),
+          compressedSize: UINT32_LE.get(array, 8),
+          uncompressedSize: UINT32_LE.get(array, 12)
+        };
+      },
+      len: 16
+    };
+    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
+    };
+    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
+    };
+    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
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tokenizer+inflate@0.4.1/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;
+}
+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;
+}
+var import_debug, debug, syncBufferSize, ddSignatureArray, eocdSignatureBytes, ZipHandler;
+var init_ZipHandler = __esm({
+  "../../node_modules/.pnpm/@tokenizer+inflate@0.4.1/node_modules/@tokenizer/inflate/lib/ZipHandler.js"() {
+    "use strict";
+    init_lib2();
+    import_debug = __toESM(require_src(), 1);
+    init_ZipToken();
+    debug = (0, import_debug.default)("tokenizer:inflate");
+    syncBufferSize = 256 * 1024;
+    ddSignatureArray = signatureToArray(Signature.DataDescriptor);
+    eocdSignatureBytes = signatureToArray(Signature.EndOfCentralDirectory);
+    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) {
+            const dataDescriptor = await this.tokenizer.readToken(DataDescriptor);
+            if (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}`);
+        const uncompressedData = await _ZipHandler.decompressDeflateRaw(fileData);
+        return cb(uncompressedData);
+      }
+      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 response = new Response(output);
+          const buffer = await response.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");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tokenizer+inflate@0.4.1/node_modules/@tokenizer/inflate/lib/GzipHandler.js
+var GzipHandler;
+var init_GzipHandler = __esm({
+  "../../node_modules/.pnpm/@tokenizer+inflate@0.4.1/node_modules/@tokenizer/inflate/lib/GzipHandler.js"() {
+    "use strict";
+    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"));
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tokenizer+inflate@0.4.1/node_modules/@tokenizer/inflate/lib/index.js
+var init_lib3 = __esm({
+  "../../node_modules/.pnpm/@tokenizer+inflate@0.4.1/node_modules/@tokenizer/inflate/lib/index.js"() {
+    "use strict";
+    init_ZipHandler();
+    init_GzipHandler();
+  }
+});
+
+// ../../node_modules/.pnpm/uint8array-extras@1.5.0/node_modules/uint8array-extras/index.js
+function isType(value, typeConstructor, typeStringified) {
+  if (!value) {
+    return false;
+  }
+  if (value.constructor === typeConstructor) {
+    return true;
+  }
+  return objectToString.call(value) === typeStringified;
+}
+function isUint8Array(value) {
+  return isType(value, Uint8Array, uint8ArrayStringified);
+}
+function assertUint8Array(value) {
+  if (!isUint8Array(value)) {
+    throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``);
+  }
+}
+function concatUint8Arrays(arrays, totalLength) {
+  if (arrays.length === 0) {
+    return new Uint8Array(0);
+  }
+  totalLength ??= arrays.reduce((accumulator, currentValue) => accumulator + currentValue.length, 0);
+  const returnValue = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const array of arrays) {
+    assertUint8Array(array);
+    returnValue.set(array, offset);
+    offset += array.length;
+  }
+  return returnValue;
+}
+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);
+  }
+}
+var objectToString, uint8ArrayStringified, cachedDecoders, cachedEncoder, byteToHexLookupTable;
+var init_uint8array_extras = __esm({
+  "../../node_modules/.pnpm/uint8array-extras@1.5.0/node_modules/uint8array-extras/index.js"() {
+    "use strict";
+    objectToString = Object.prototype.toString;
+    uint8ArrayStringified = "[object Uint8Array]";
+    cachedDecoders = {
+      utf8: new globalThis.TextDecoder("utf8")
+    };
+    cachedEncoder = new globalThis.TextEncoder();
+    byteToHexLookupTable = Array.from({ length: 256 }, (_, index) => index.toString(16).padStart(2, "0"));
+  }
+});
+
+// ../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/tokens.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));
+}
+function tarHeaderChecksumMatches(arrayBuffer, offset = 0) {
+  const readSum = Number.parseInt(new StringType(6).get(arrayBuffer, 148).replace(new RegExp("\\0.*$", "v"), "").trim(), 8);
+  if (Number.isNaN(readSum)) {
+    return false;
+  }
+  let sum = 8 * 32;
+  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;
+}
+var uint32SyncSafeToken;
+var init_tokens = __esm({
+  "../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/tokens.js"() {
+    "use strict";
+    init_lib2();
+    uint32SyncSafeToken = {
+      get: (buffer, offset) => buffer[offset + 3] & 127 | (buffer[offset + 2] & 127) << 7 | (buffer[offset + 1] & 127) << 14 | (buffer[offset] & 127) << 21,
+      len: 4
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/supported.js
+var extensions, mimeTypes;
+var init_supported = __esm({
+  "../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/supported.js"() {
+    "use strict";
+    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",
+      "key",
+      "numbers",
+      "pages"
+    ];
+    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",
+      // RFC 4337
+      "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/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",
+      // Non-standard
+      "application/x-ms-shortcut",
+      // Informal, used by freedesktop.org shared-mime-info
+      "application/x-ft-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-ft-fbx",
+      "application/vnd.visio",
+      "application/vnd.android.package-archive",
+      "application/x-ft-draco",
+      "application/x-lz4",
+      // Informal, used by freedesktop.org shared-mime-info
+      "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",
+      "application/vnd.apple.keynote",
+      "application/vnd.apple.numbers",
+      "application/vnd.apple.pages"
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/parser.js
+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 length = options?.length ?? buffer.length;
+  const safeLength = getSafeBound(length, maximumLength, reason);
+  return tokenizer.readBuffer(buffer, {
+    ...options,
+    length: safeLength
+  });
+}
+function checkBytes(buffer, headers, options) {
+  options = {
+    offset: 0,
+    ...options
+  };
+  for (const [index, header] of headers.entries()) {
+    if (options.mask) {
+      if (header !== (options.mask[index] & buffer[index + options.offset])) {
+        return false;
+      }
+    } else if (header !== buffer[index + options.offset]) {
+      return false;
+    }
+  }
+  return true;
+}
+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;
+}
+var maximumUntrustedSkipSizeInBytes, ParserHardLimitError;
+var init_parser = __esm({
+  "../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/parser.js"() {
+    "use strict";
+    maximumUntrustedSkipSizeInBytes = 16 * 1024 * 1024;
+    ParserHardLimitError = class extends Error {
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/detectors/zip.js
+async function decompressDeflateRawWithLimit(data, { maximumLength = maximumZipEntrySizeInBytes } = {}) {
+  const input = new ReadableStream({
+    start(controller) {
+      controller.enqueue(data);
+      controller.close();
+    }
+  });
+  const output = input.pipeThrough(new DecompressionStream("deflate-raw"));
+  const reader = output.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;
+}
+function mergeByteChunks(chunks, totalLength) {
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return merged;
+}
+function getMaximumZipBufferedReadLength(tokenizer) {
+  const fileSize = tokenizer.fileInfo.size;
+  const remainingBytes = Number.isFinite(fileSize) ? Math.max(0, fileSize - tokenizer.position) : Number.MAX_SAFE_INTEGER;
+  return Math.min(remainingBytes, maximumZipBufferedReadSizeInBytes);
+}
+function isRecoverableZipError(error) {
+  if (error instanceof EndOfStreamError) {
+    return true;
+  }
+  if (error instanceof ParserHardLimitError) {
+    return true;
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if (recoverableZipErrorMessages.has(error.message)) {
+    return true;
+  }
+  if (recoverableZipErrorCodes.has(error.code)) {
+    return true;
+  }
+  for (const prefix of recoverableZipErrorMessagePrefixes) {
+    if (error.message.startsWith(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
+function canReadZipEntryForDetection(zipHeader, maximumSize = maximumZipEntrySizeInBytes) {
+  const sizes = [zipHeader.compressedSize, zipHeader.uncompressedSize];
+  for (const size of sizes) {
+    if (!Number.isFinite(size) || size < 0 || size > maximumSize) {
+      return false;
+    }
+  }
+  return true;
+}
+function createIWorkZipDetectionState() {
+  return {
+    hasDocumentEntry: false,
+    hasMasterSlideEntry: false,
+    hasTablesEntry: false,
+    hasCalculationEngineEntry: false
+  };
+}
+function updateIWorkZipDetectionStateFromFilename(iWorkState, filename) {
+  if (filename === "Index/Document.iwa") {
+    iWorkState.hasDocumentEntry = true;
+  }
+  if (filename.startsWith("Index/MasterSlide")) {
+    iWorkState.hasMasterSlideEntry = true;
+  }
+  if (filename.startsWith("Index/Tables/")) {
+    iWorkState.hasTablesEntry = true;
+  }
+  if (filename === "Index/CalculationEngine.iwa") {
+    iWorkState.hasCalculationEngineEntry = true;
+  }
+}
+function getIWorkFileTypeFromZipEntries(iWorkState) {
+  if (!iWorkState.hasDocumentEntry) {
+    return;
+  }
+  if (iWorkState.hasMasterSlideEntry) {
+    return { ext: "key", mime: "application/vnd.apple.keynote" };
+  }
+  if (iWorkState.hasTablesEntry) {
+    return { ext: "numbers", mime: "application/vnd.apple.numbers" };
+  }
+  return { ext: "pages", mime: "application/vnd.apple.pages" };
+}
+function getFileTypeFromMimeType(mimeType) {
+  mimeType = mimeType.toLowerCase();
+  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 createOpenXmlZipDetectionState() {
+  return {
+    hasContentTypesEntry: false,
+    hasParsedContentTypesEntry: false,
+    isParsingContentTypes: false,
+    hasUnparseableContentTypes: false,
+    hasWordDirectory: false,
+    hasPresentationDirectory: false,
+    hasSpreadsheetDirectory: false,
+    hasThreeDimensionalModelEntry: false
+  };
+}
+function updateOpenXmlZipDetectionStateFromFilename(openXmlState, filename) {
+  if (filename.startsWith("word/")) {
+    openXmlState.hasWordDirectory = true;
+  }
+  if (filename.startsWith("ppt/")) {
+    openXmlState.hasPresentationDirectory = true;
+  }
+  if (filename.startsWith("xl/")) {
+    openXmlState.hasSpreadsheetDirectory = true;
+  }
+  if (filename.startsWith("3D/") && filename.endsWith(".model")) {
+    openXmlState.hasThreeDimensionalModelEntry = true;
+  }
+}
+function getOpenXmlFileTypeFromDirectoryNames(openXmlState) {
+  if (openXmlState.hasWordDirectory) {
+    return {
+      ext: "docx",
+      mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    };
+  }
+  if (openXmlState.hasPresentationDirectory) {
+    return {
+      ext: "pptx",
+      mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    };
+  }
+  if (openXmlState.hasSpreadsheetDirectory) {
+    return {
+      ext: "xlsx",
+      mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    };
+  }
+  if (openXmlState.hasThreeDimensionalModelEntry) {
+    return {
+      ext: "3mf",
+      mime: "model/3mf"
+    };
+  }
+}
+function getOpenXmlFileTypeFromZipEntries(openXmlState) {
+  if (!openXmlState.hasContentTypesEntry || openXmlState.hasUnparseableContentTypes || openXmlState.isParsingContentTypes || openXmlState.hasParsedContentTypesEntry) {
+    return;
+  }
+  return getOpenXmlFileTypeFromDirectoryNames(openXmlState);
+}
+function getOpenXmlMimeTypeFromContentTypesXml(xmlContent) {
+  const endPosition = xmlContent.indexOf('.main+xml"');
+  if (endPosition === -1) {
+    const mimeType = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml";
+    if (xmlContent.includes(`ContentType="${mimeType}"`)) {
+      return mimeType;
+    }
+    return;
+  }
+  const truncatedContent = xmlContent.slice(0, endPosition);
+  const firstQuotePosition = truncatedContent.lastIndexOf('"');
+  return truncatedContent.slice(firstQuotePosition + 1);
+}
+function findZipDataDescriptorOffset(buffer, bytesConsumed) {
+  if (buffer.length < zipDataDescriptorLengthInBytes) {
+    return -1;
+  }
+  const lastPossibleDescriptorOffset = buffer.length - zipDataDescriptorLengthInBytes;
+  for (let index = 0; index <= lastPossibleDescriptorOffset; index++) {
+    if (UINT32_LE.get(buffer, index) === zipDataDescriptorSignature && UINT32_LE.get(buffer, index + 8) === bytesConsumed + index) {
+      return index;
+    }
+  }
+  return -1;
+}
+async function readZipDataDescriptorEntryWithLimit(zipHandler, { shouldBuffer, maximumLength = maximumZipEntrySizeInBytes } = {}) {
+  const { syncBuffer } = zipHandler;
+  const { length: syncBufferLength } = syncBuffer;
+  const chunks = [];
+  let bytesConsumed = 0;
+  for (; ; ) {
+    const length = await zipHandler.tokenizer.peekBuffer(syncBuffer, { mayBeLess: true });
+    const dataDescriptorOffset = findZipDataDescriptorOffset(syncBuffer.subarray(0, length), bytesConsumed);
+    const retainedLength = dataDescriptorOffset >= 0 ? 0 : length === syncBufferLength ? Math.min(zipDataDescriptorOverlapLengthInBytes, length - 1) : 0;
+    const chunkLength = dataDescriptorOffset >= 0 ? dataDescriptorOffset : length - retainedLength;
+    if (chunkLength === 0) {
+      break;
+    }
+    bytesConsumed += chunkLength;
+    if (bytesConsumed > maximumLength) {
+      throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+    }
+    if (shouldBuffer) {
+      const data = new Uint8Array(chunkLength);
+      await zipHandler.tokenizer.readBuffer(data);
+      chunks.push(data);
+    } else {
+      await zipHandler.tokenizer.ignore(chunkLength);
+    }
+    if (dataDescriptorOffset >= 0) {
+      break;
+    }
+  }
+  if (!hasUnknownFileSize(zipHandler.tokenizer)) {
+    zipHandler.knownSizeDescriptorScannedBytes += bytesConsumed;
+  }
+  if (!shouldBuffer) {
+    return;
+  }
+  return mergeByteChunks(chunks, bytesConsumed);
+}
+function getRemainingZipScanBudget(zipHandler, startOffset) {
+  if (hasUnknownFileSize(zipHandler.tokenizer)) {
+    return Math.max(0, maximumUntrustedSkipSizeInBytes - (zipHandler.tokenizer.position - startOffset));
+  }
+  return Math.max(0, maximumZipEntrySizeInBytes - zipHandler.knownSizeDescriptorScannedBytes);
+}
+async function readZipEntryData(zipHandler, zipHeader, { shouldBuffer, maximumDescriptorLength = maximumZipEntrySizeInBytes } = {}) {
+  if (zipHeader.dataDescriptor && zipHeader.compressedSize === 0) {
+    return readZipDataDescriptorEntryWithLimit(zipHandler, {
+      shouldBuffer,
+      maximumLength: maximumDescriptorLength
+    });
+  }
+  if (!shouldBuffer) {
+    await safeIgnore(zipHandler.tokenizer, zipHeader.compressedSize, {
+      maximumLength: hasUnknownFileSize(zipHandler.tokenizer) ? maximumZipEntrySizeInBytes : zipHandler.tokenizer.fileInfo.size,
+      reason: "ZIP entry compressed data"
+    });
+    return;
+  }
+  const maximumLength = getMaximumZipBufferedReadLength(zipHandler.tokenizer);
+  if (!Number.isFinite(zipHeader.compressedSize) || zipHeader.compressedSize < 0 || zipHeader.compressedSize > maximumLength) {
+    throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+  }
+  const fileData = new Uint8Array(zipHeader.compressedSize);
+  await zipHandler.tokenizer.readBuffer(fileData);
+  return fileData;
+}
+async function detectZip(tokenizer) {
+  let fileType;
+  const openXmlState = createOpenXmlZipDetectionState();
+  const iWorkState = createIWorkZipDetectionState();
+  try {
+    await new ZipHandler(tokenizer).unzip((zipHeader) => {
+      updateOpenXmlZipDetectionStateFromFilename(openXmlState, zipHeader.filename);
+      updateIWorkZipDetectionStateFromFilename(iWorkState, zipHeader.filename);
+      if (iWorkState.hasDocumentEntry && (iWorkState.hasMasterSlideEntry || iWorkState.hasTablesEntry)) {
+        fileType = getIWorkFileTypeFromZipEntries(iWorkState);
+        return { stop: true };
+      }
+      const isOpenXmlContentTypesEntry = zipHeader.filename === "[Content_Types].xml";
+      const openXmlFileTypeFromEntries = getOpenXmlFileTypeFromZipEntries(openXmlState);
+      if (!isOpenXmlContentTypesEntry && openXmlFileTypeFromEntries) {
+        fileType = openXmlFileTypeFromEntries;
+        return {
+          stop: true
+        };
+      }
+      switch (zipHeader.filename) {
+        case "META-INF/mozilla.rsa":
+          fileType = {
+            ext: "xpi",
+            mime: "application/x-xpinstall"
+          };
+          return {
+            stop: true
+          };
+        case "META-INF/MANIFEST.MF":
+          fileType = {
+            ext: "jar",
+            mime: "application/java-archive"
+          };
+          return {
+            stop: true
+          };
+        case "mimetype":
+          if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) {
+            return {};
+          }
+          return {
+            async handler(fileData) {
+              const mimeType = new TextDecoder("utf-8").decode(fileData).trim();
+              fileType = getFileTypeFromMimeType(mimeType);
+            },
+            stop: true
+          };
+        case "[Content_Types].xml": {
+          openXmlState.hasContentTypesEntry = true;
+          if (!canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes)) {
+            openXmlState.hasUnparseableContentTypes = true;
+            return {};
+          }
+          openXmlState.isParsingContentTypes = true;
+          return {
+            async handler(fileData) {
+              const xmlContent = new TextDecoder("utf-8").decode(fileData);
+              const mimeType = getOpenXmlMimeTypeFromContentTypesXml(xmlContent);
+              if (mimeType) {
+                fileType = getFileTypeFromMimeType(mimeType);
+              }
+              openXmlState.hasParsedContentTypesEntry = true;
+              openXmlState.isParsingContentTypes = false;
+            },
+            stop: true
+          };
+        }
+        default:
+          if (new RegExp("classes\\d*\\.dex", "v").test(zipHeader.filename)) {
+            fileType = {
+              ext: "apk",
+              mime: "application/vnd.android.package-archive"
+            };
+            return { stop: true };
+          }
+          return {};
+      }
+    });
+  } catch (error) {
+    if (!isRecoverableZipError(error)) {
+      throw error;
+    }
+    if (openXmlState.isParsingContentTypes) {
+      openXmlState.isParsingContentTypes = false;
+      openXmlState.hasUnparseableContentTypes = true;
+    }
+    if (!fileType && error instanceof EndOfStreamError && !openXmlState.hasContentTypesEntry) {
+      fileType = getOpenXmlFileTypeFromDirectoryNames(openXmlState);
+    }
+  }
+  const iWorkFileType = hasUnknownFileSize(tokenizer) && iWorkState.hasDocumentEntry && !iWorkState.hasMasterSlideEntry && !iWorkState.hasTablesEntry && !iWorkState.hasCalculationEngineEntry ? void 0 : getIWorkFileTypeFromZipEntries(iWorkState);
+  return fileType ?? getOpenXmlFileTypeFromZipEntries(openXmlState) ?? iWorkFileType ?? {
+    ext: "zip",
+    mime: "application/zip"
+  };
+}
+var maximumZipEntrySizeInBytes, maximumZipEntryCount, maximumZipBufferedReadSizeInBytes, maximumZipTextEntrySizeInBytes, recoverableZipErrorMessages, recoverableZipErrorMessagePrefixes, recoverableZipErrorCodes, zipDataDescriptorSignature, zipDataDescriptorLengthInBytes, zipDataDescriptorOverlapLengthInBytes;
+var init_zip = __esm({
+  "../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/detectors/zip.js"() {
+    "use strict";
+    init_lib2();
+    init_core();
+    init_lib3();
+    init_parser();
+    maximumZipEntrySizeInBytes = 1024 * 1024;
+    maximumZipEntryCount = 1024;
+    maximumZipBufferedReadSizeInBytes = 2 ** 31 - 1;
+    maximumZipTextEntrySizeInBytes = maximumZipEntrySizeInBytes;
+    recoverableZipErrorMessages = /* @__PURE__ */ new Set([
+      "Unexpected signature",
+      "Encrypted ZIP",
+      "Expected Central-File-Header signature"
+    ]);
+    recoverableZipErrorMessagePrefixes = [
+      "ZIP entry count exceeds ",
+      "Unsupported ZIP compression method:",
+      "ZIP entry compressed data exceeds ",
+      "ZIP entry decompressed data exceeds ",
+      "Expected data-descriptor-signature at position "
+    ];
+    recoverableZipErrorCodes = /* @__PURE__ */ new Set([
+      "Z_BUF_ERROR",
+      "Z_DATA_ERROR",
+      "ERR_INVALID_STATE"
+    ]);
+    zipDataDescriptorSignature = 134695760;
+    zipDataDescriptorLengthInBytes = 16;
+    zipDataDescriptorOverlapLengthInBytes = zipDataDescriptorLengthInBytes - 1;
+    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}`);
+      }
+      const uncompressedData = await decompressDeflateRawWithLimit(fileData, { maximumLength: maximumZipEntrySizeInBytes });
+      return callback(uncompressedData);
+    };
+    ZipHandler.prototype.unzip = async function(fileCallback) {
+      let stop = false;
+      let zipEntryCount = 0;
+      const zipScanStart = this.tokenizer.position;
+      this.knownSizeDescriptorScannedBytes = 0;
+      do {
+        if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, maximumUntrustedSkipSizeInBytes)) {
+          throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
+        }
+        const zipHeader = await this.readLocalFileHeader();
+        if (!zipHeader) {
+          break;
+        }
+        zipEntryCount++;
+        if (zipEntryCount > maximumZipEntryCount) {
+          throw new Error(`ZIP entry count exceeds ${maximumZipEntryCount}`);
+        }
+        const next = fileCallback(zipHeader);
+        stop = Boolean(next.stop);
+        await this.tokenizer.ignore(zipHeader.extraFieldLength);
+        const fileData = await readZipEntryData(this, zipHeader, {
+          shouldBuffer: Boolean(next.handler),
+          maximumDescriptorLength: Math.min(maximumZipEntrySizeInBytes, getRemainingZipScanBudget(this, zipScanStart))
+        });
+        if (next.handler) {
+          await this.inflate(zipHeader, fileData, next.handler);
+        }
+        if (zipHeader.dataDescriptor) {
+          const dataDescriptor = new Uint8Array(zipDataDescriptorLengthInBytes);
+          await this.tokenizer.readBuffer(dataDescriptor);
+          if (UINT32_LE.get(dataDescriptor, 0) !== zipDataDescriptorSignature) {
+            throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - dataDescriptor.length}`);
+          }
+        }
+        if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, maximumUntrustedSkipSizeInBytes)) {
+          throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
+        }
+      } while (!stop);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/detectors/ebml.js
+async function detectEbml(tokenizer) {
+  async function readField() {
+    const msb = await tokenizer.peekNumber(UINT8);
+    let mask = 128;
+    let ic = 0;
+    while ((msb & mask) === 0 && mask !== 0) {
+      ++ic;
+      mask >>= 1;
+    }
+    const id = new Uint8Array(ic + 1);
+    await safeReadBuffer(tokenizer, id, void 0, {
+      maximumLength: id.length,
+      reason: "EBML field"
+    });
+    return id;
+  }
+  async function readElement() {
+    const idField = await readField();
+    const lengthField = await readField();
+    lengthField[0] ^= 128 >> lengthField.length - 1;
+    const nrLength = Math.min(6, lengthField.length);
+    const idView = new DataView(idField.buffer);
+    const lengthView = new DataView(lengthField.buffer, lengthField.length - nrLength, nrLength);
+    return {
+      id: getUintBE(idView),
+      len: getUintBE(lengthView)
+    };
+  }
+  async function readChildren(children) {
+    let ebmlElementCount = 0;
+    while (children > 0) {
+      ebmlElementCount++;
+      if (ebmlElementCount > maximumEbmlElementCount) {
+        return;
+      }
+      if (hasExceededUnknownSizeScanBudget(tokenizer, ebmlScanStart, maximumUntrustedSkipSizeInBytes)) {
+        return;
+      }
+      const previousPosition = tokenizer.position;
+      const element = await readElement();
+      if (element.id === 17026) {
+        if (element.len > maximumEbmlDocumentTypeSizeInBytes) {
+          return;
+        }
+        const documentTypeLength = getSafeBound(element.len, maximumEbmlDocumentTypeSizeInBytes, "EBML DocType");
+        const rawValue = await tokenizer.readToken(new StringType(documentTypeLength));
+        return rawValue.replaceAll(new RegExp("\\0.*$", "gv"), "");
+      }
+      if (hasUnknownFileSize(tokenizer) && (!Number.isFinite(element.len) || element.len < 0 || element.len > maximumEbmlElementPayloadSizeInBytes)) {
+        return;
+      }
+      await safeIgnore(tokenizer, element.len, {
+        maximumLength: hasUnknownFileSize(tokenizer) ? maximumEbmlElementPayloadSizeInBytes : tokenizer.fileInfo.size,
+        reason: "EBML payload"
+      });
+      --children;
+      if (tokenizer.position <= previousPosition) {
+        return;
+      }
+    }
+  }
+  const rootElement = await readElement();
+  const ebmlScanStart = tokenizer.position;
+  const documentType = await readChildren(rootElement.len);
+  switch (documentType) {
+    case "webm":
+      return {
+        ext: "webm",
+        mime: "video/webm"
+      };
+    case "matroska":
+      return {
+        ext: "mkv",
+        mime: "video/matroska"
+      };
+    default:
+  }
+}
+var maximumEbmlDocumentTypeSizeInBytes, maximumEbmlElementPayloadSizeInBytes, maximumEbmlElementCount;
+var init_ebml = __esm({
+  "../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/detectors/ebml.js"() {
+    "use strict";
+    init_lib2();
+    init_uint8array_extras();
+    init_parser();
+    maximumEbmlDocumentTypeSizeInBytes = 64;
+    maximumEbmlElementPayloadSizeInBytes = 1024 * 1024;
+    maximumEbmlElementCount = 256;
+  }
+});
+
+// ../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/detectors/png.js
+function isPngAncillaryChunk(type) {
+  return (type.codePointAt(0) & 32) !== 0;
+}
+async function detectPng(tokenizer) {
+  const pngFileType = {
+    ext: "png",
+    mime: "image/png"
+  };
+  const apngFileType = {
+    ext: "apng",
+    mime: "image/apng"
+  };
+  await tokenizer.ignore(8);
+  async function readChunkHeader() {
+    return {
+      length: await tokenizer.readToken(INT32_BE),
+      type: await tokenizer.readToken(new StringType(4, "latin1"))
+    };
+  }
+  const isUnknownPngStream = hasUnknownFileSize(tokenizer);
+  const pngScanStart = tokenizer.position;
+  let pngChunkCount = 0;
+  let hasSeenImageHeader = false;
+  do {
+    pngChunkCount++;
+    if (pngChunkCount > maximumPngChunkCount) {
+      break;
+    }
+    if (hasExceededUnknownSizeScanBudget(tokenizer, pngScanStart, maximumPngStreamScanBudgetInBytes)) {
+      break;
+    }
+    const previousPosition = tokenizer.position;
+    const chunk = await readChunkHeader();
+    if (chunk.length < 0) {
+      return;
+    }
+    if (chunk.type === "IHDR") {
+      if (chunk.length !== 13) {
+        return;
+      }
+      hasSeenImageHeader = true;
+    }
+    switch (chunk.type) {
+      case "IDAT":
+        return pngFileType;
+      case "acTL":
+        return apngFileType;
+      default:
+        if (!hasSeenImageHeader && chunk.type !== "CgBI") {
+          return;
+        }
+        if (isUnknownPngStream && chunk.length > maximumPngChunkSizeInBytes) {
+          return hasSeenImageHeader && isPngAncillaryChunk(chunk.type) ? pngFileType : void 0;
+        }
+        try {
+          await safeIgnore(tokenizer, chunk.length + 4, {
+            maximumLength: isUnknownPngStream ? maximumPngChunkSizeInBytes + 4 : tokenizer.fileInfo.size,
+            reason: "PNG chunk payload"
+          });
+        } catch (error) {
+          if (!isUnknownPngStream && (error instanceof ParserHardLimitError || error instanceof EndOfStreamError)) {
+            return pngFileType;
+          }
+          throw error;
+        }
+    }
+    if (tokenizer.position <= previousPosition) {
+      break;
+    }
+  } while (tokenizer.position + 8 < tokenizer.fileInfo.size);
+  return pngFileType;
+}
+var maximumPngChunkCount, maximumPngStreamScanBudgetInBytes, maximumPngChunkSizeInBytes;
+var init_png = __esm({
+  "../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/detectors/png.js"() {
+    "use strict";
+    init_lib2();
+    init_core();
+    init_parser();
+    maximumPngChunkCount = 512;
+    maximumPngStreamScanBudgetInBytes = 16 * 1024 * 1024;
+    maximumPngChunkSizeInBytes = 1024 * 1024;
+  }
+});
+
+// ../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/detectors/asf.js
+async function detectAsf(tokenizer) {
+  let isMalformedAsf = false;
+  try {
+    async function readHeader() {
+      const guid = new Uint8Array(16);
+      await safeReadBuffer(tokenizer, guid, void 0, {
+        maximumLength: guid.length,
+        reason: "ASF header GUID"
+      });
+      return {
+        id: guid,
+        size: Number(await tokenizer.readToken(UINT64_LE))
+      };
+    }
+    await safeIgnore(tokenizer, 30, {
+      maximumLength: 30,
+      reason: "ASF header prelude"
+    });
+    const isUnknownFileSize = hasUnknownFileSize(tokenizer);
+    const asfHeaderScanStart = tokenizer.position;
+    let asfHeaderObjectCount = 0;
+    while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
+      asfHeaderObjectCount++;
+      if (asfHeaderObjectCount > maximumAsfHeaderObjectCount) {
+        break;
+      }
+      if (hasExceededUnknownSizeScanBudget(tokenizer, asfHeaderScanStart, maximumUntrustedSkipSizeInBytes)) {
+        break;
+      }
+      const previousPosition = tokenizer.position;
+      const header = await readHeader();
+      let payload = header.size - 24;
+      if (!Number.isFinite(payload) || payload < 0) {
+        isMalformedAsf = true;
+        break;
+      }
+      if (checkBytes(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 (checkBytes(typeId, [64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
+          return {
+            ext: "asf",
+            mime: "audio/x-ms-asf"
+          };
+        }
+        if (checkBytes(typeId, [192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
+          return {
+            ext: "asf",
+            mime: "video/x-ms-asf"
+          };
+        }
+        break;
+      }
+      if (isUnknownFileSize && payload > maximumAsfHeaderPayloadSizeInBytes) {
+        isMalformedAsf = true;
+        break;
+      }
+      await safeIgnore(tokenizer, payload, {
+        maximumLength: isUnknownFileSize ? maximumAsfHeaderPayloadSizeInBytes : tokenizer.fileInfo.size,
+        reason: "ASF header payload"
+      });
+      if (tokenizer.position <= previousPosition) {
+        isMalformedAsf = true;
+        break;
+      }
+    }
+  } catch (error) {
+    if (error instanceof EndOfStreamError || error instanceof ParserHardLimitError) {
+      if (hasUnknownFileSize(tokenizer)) {
+        isMalformedAsf = true;
+      }
+    } else {
+      throw error;
+    }
+  }
+  if (isMalformedAsf) {
+    return;
+  }
+  return {
+    ext: "asf",
+    mime: "application/vnd.ms-asf"
+  };
+}
+var maximumAsfHeaderObjectCount, maximumAsfHeaderPayloadSizeInBytes;
+var init_asf = __esm({
+  "../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/detectors/asf.js"() {
+    "use strict";
+    init_lib2();
+    init_core();
+    init_parser();
+    maximumAsfHeaderObjectCount = 512;
+    maximumAsfHeaderPayloadSizeInBytes = 1024 * 1024;
+  }
+});
+
+// ../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/index.js
+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 importAtRuntime(specifier) {
+  return import(specifier);
+}
+function toDefaultStream(stream) {
+  return stream.pipeThrough(new TransformStream());
+}
+function readWithSignal(reader, signal) {
+  if (signal === void 0) {
+    return reader.read();
+  }
+  signal.throwIfAborted();
+  return Promise.race([
+    reader.read(),
+    new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => {
+        reject(signal.reason);
+        reader.cancel(signal.reason).catch(() => {
+        });
+      }, { once: true });
+    })
+  ]);
+}
+function 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 fileTypeFromStream(stream, options) {
+  return new FileTypeParser(options).fromStream(stream);
+}
+async function fileTypeFromBuffer(input, options) {
+  return new FileTypeParser(options).fromBuffer(input);
+}
+async function fileTypeFromBlob(blob, options) {
+  return new FileTypeParser(options).fromBlob(blob);
+}
+async function fileTypeFromTokenizer(tokenizer, options) {
+  return new FileTypeParser(options).fromTokenizer(tokenizer);
+}
+async function fileTypeStream(webStream, options) {
+  return new FileTypeParser(options).toDetectionStream(webStream, options);
+}
+async function fileTypeFromFile(path, options) {
+  return new FileTypeParser(options).fromFile(path);
+}
+var reasonableDetectionSizeInBytes, maximumMpegOffsetTolerance, maximumNestedGzipDetectionSizeInBytes, maximumNestedGzipProbeDepth, unknownSizeGzipProbeTimeoutInMilliseconds, maximumId3HeaderSizeInBytes, maximumTiffTagCount, maximumDetectionReentryCount, maximumTiffStreamIfdOffsetInBytes, maximumTiffIfdOffsetInBytes, FileTypeParser, supportedExtensions, supportedMimeTypes;
+var init_source = __esm({
+  "../../node_modules/.pnpm/file-type@22.0.1/node_modules/file-type/source/index.js"() {
+    init_lib2();
+    init_core();
+    init_lib3();
+    init_uint8array_extras();
+    init_tokens();
+    init_supported();
+    init_parser();
+    init_zip();
+    init_ebml();
+    init_png();
+    init_asf();
+    reasonableDetectionSizeInBytes = 4100;
+    maximumMpegOffsetTolerance = reasonableDetectionSizeInBytes - 2;
+    maximumNestedGzipDetectionSizeInBytes = maximumUntrustedSkipSizeInBytes;
+    maximumNestedGzipProbeDepth = 1;
+    unknownSizeGzipProbeTimeoutInMilliseconds = 100;
+    maximumId3HeaderSizeInBytes = maximumUntrustedSkipSizeInBytes;
+    maximumTiffTagCount = 512;
+    maximumDetectionReentryCount = 256;
+    maximumTiffStreamIfdOffsetInBytes = 1024 * 1024;
+    maximumTiffIfdOffsetInBytes = maximumUntrustedSkipSizeInBytes;
+    FileTypeParser = class _FileTypeParser {
+      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
+        };
+        this.gzipProbeDepth = 0;
+      }
+      getTokenizerOptions() {
+        return {
+          ...this.tokenizerOptions
+        };
+      }
+      createTokenizerFromWebStream(stream) {
+        return fromWebStream(toDefaultStream(stream), this.getTokenizerOptions());
+      }
+      async parseTokenizer(tokenizer, detectionReentryCount = 0) {
+        this.detectionReentryCount = detectionReentryCount;
+        const initialPosition = tokenizer.position;
+        for (const detector of this.detectors) {
+          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 void 0;
+          }
+        }
+      }
+      async fromTokenizer(tokenizer) {
+        try {
+          return await this.parseTokenizer(tokenizer);
+        } finally {
+          await tokenizer.close();
+        }
+      }
+      async fromBuffer(input) {
+        if (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) {
+          throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof input}\``);
+        }
+        const buffer = input instanceof Uint8Array ? input : new Uint8Array(input);
+        if (!(buffer?.length > 1)) {
+          return;
+        }
+        return this.fromTokenizer(fromBuffer(buffer, this.getTokenizerOptions()));
+      }
+      async fromBlob(blob) {
+        this.options.signal?.throwIfAborted();
+        const tokenizer = fromBlob(blob, this.getTokenizerOptions());
+        return this.fromTokenizer(tokenizer);
+      }
+      async fromStream(stream) {
+        this.options.signal?.throwIfAborted();
+        const tokenizer = this.createTokenizerFromWebStream(stream);
+        return this.fromTokenizer(tokenizer);
+      }
+      async fromFile(path) {
+        this.options.signal?.throwIfAborted();
+        const [{ default: fsPromises }, { FileTokenizer }] = await Promise.all([
+          importAtRuntime("node:fs/promises"),
+          importAtRuntime("strtok3")
+        ]);
+        const fileHandle = await fsPromises.open(path, fsPromises.constants.O_RDONLY | fsPromises.constants.O_NONBLOCK);
+        const fileStat = await fileHandle.stat();
+        if (!fileStat.isFile()) {
+          await fileHandle.close();
+          return;
+        }
+        const tokenizer = new FileTokenizer(fileHandle, {
+          ...this.getTokenizerOptions(),
+          fileInfo: { path, size: fileStat.size }
+        });
+        return this.fromTokenizer(tokenizer);
+      }
+      async toDetectionStream(stream, options) {
+        this.options.signal?.throwIfAborted();
+        const sampleSize = normalizeSampleSize(options?.sampleSize ?? reasonableDetectionSizeInBytes);
+        let detectedFileType;
+        let streamEnded = false;
+        const reader = stream.getReader();
+        const chunks = [];
+        let totalSize = 0;
+        try {
+          while (totalSize < sampleSize) {
+            const { value, done } = await readWithSignal(reader, this.options.signal);
+            if (done || !value) {
+              streamEnded = true;
+              break;
+            }
+            chunks.push(value);
+            totalSize += value.length;
+          }
+          if (!streamEnded && totalSize === sampleSize) {
+            const { value, done } = await readWithSignal(reader, this.options.signal);
+            if (done || !value) {
+              streamEnded = true;
+            } else {
+              chunks.push(value);
+              totalSize += value.length;
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+        if (totalSize > 0) {
+          const sample = chunks.length === 1 ? chunks[0] : concatUint8Arrays(chunks);
+          try {
+            detectedFileType = await this.fromBuffer(sample.subarray(0, sampleSize));
+          } catch (error) {
+            if (!(error instanceof EndOfStreamError)) {
+              throw error;
+            }
+            detectedFileType = void 0;
+          }
+          if (!streamEnded && detectedFileType?.ext === "pages") {
+            detectedFileType = {
+              ext: "zip",
+              mime: "application/zip"
+            };
+          }
+        }
+        const transformStream = new TransformStream({
+          start(controller) {
+            for (const chunk of chunks) {
+              controller.enqueue(chunk);
+            }
+          },
+          transform(chunk, controller) {
+            controller.enqueue(chunk);
+          }
+        });
+        const newStream = stream.pipeThrough(transformStream);
+        newStream.fileType = detectedFileType;
+        return newStream;
+      }
+      async detectGzip(tokenizer) {
+        if (this.gzipProbeDepth >= maximumNestedGzipProbeDepth) {
+          return {
+            ext: "gz",
+            mime: "application/gzip"
+          };
+        }
+        const gzipHandler = new GzipHandler(tokenizer);
+        const limitedInflatedStream = createByteLimitedReadableStream(gzipHandler.inflate(), maximumNestedGzipDetectionSizeInBytes);
+        const hasUnknownSize = hasUnknownFileSize(tokenizer);
+        let timeout;
+        let probeSignal;
+        let probeParser;
+        let compressedFileType;
+        if (hasUnknownSize) {
+          const timeoutController = new AbortController();
+          timeout = setTimeout(() => {
+            timeoutController.abort(new DOMException(`Operation timed out after ${unknownSizeGzipProbeTimeoutInMilliseconds} ms`, "TimeoutError"));
+          }, unknownSizeGzipProbeTimeoutInMilliseconds);
+          probeSignal = this.options.signal === void 0 ? timeoutController.signal : AbortSignal.any([this.options.signal, timeoutController.signal]);
+          probeParser = new _FileTypeParser({
+            ...this.options,
+            signal: probeSignal
+          });
+          probeParser.gzipProbeDepth = this.gzipProbeDepth + 1;
+        } else {
+          this.gzipProbeDepth++;
+        }
+        try {
+          compressedFileType = await (probeParser ?? this).fromStream(limitedInflatedStream);
+        } catch (error) {
+          if (error?.name === "AbortError" && probeSignal?.reason?.name !== "TimeoutError") {
+            throw error;
+          }
+        } finally {
+          clearTimeout(timeout);
+          if (!hasUnknownSize) {
+            this.gzipProbeDepth--;
+          }
+        }
+        if (compressedFileType?.ext === "tar") {
+          return {
+            ext: "tar.gz",
+            mime: "application/gzip"
+          };
+        }
+        return {
+          ext: "gz",
+          mime: "application/gzip"
+        };
+      }
+      check(header, options) {
+        return checkBytes(this.buffer, header, options);
+      }
+      checkString(header, options) {
+        return this.check(stringToBytes(header, options?.encoding), options);
+      }
+      // Detections with a high degree of certainty in identifying the correct file type
+      detectConfident = async (tokenizer) => {
+        this.buffer = new Uint8Array(reasonableDetectionSizeInBytes);
+        if (tokenizer.fileInfo.size === void 0) {
+          tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
+        }
+        this.tokenizer = tokenizer;
+        if (hasUnknownFileSize(tokenizer)) {
+          await tokenizer.peekBuffer(this.buffer, { length: 3, mayBeLess: true });
+          if (this.check([31, 139, 8])) {
+            return this.detectGzip(tokenizer);
+          }
+        }
+        await tokenizer.peekBuffer(this.buffer, { length: 32, mayBeLess: true });
+        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])) {
+          if (this.detectionReentryCount >= maximumDetectionReentryCount) {
+            return;
+          }
+          this.detectionReentryCount++;
+          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])) {
+          return this.detectGzip(tokenizer);
+        }
+        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 || tokenizer.position + 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;
+          }
+          if (this.detectionReentryCount >= maximumDetectionReentryCount) {
+            return;
+          }
+          this.detectionReentryCount++;
+          return this.parseTokenizer(tokenizer, this.detectionReentryCount);
+        }
+        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])) {
+          return detectZip(tokenizer);
+        }
+        if (this.checkString("OggS")) {
+          await tokenizer.ignore(28);
+          const type = new Uint8Array(8);
+          await tokenizer.readBuffer(type);
+          if (checkBytes(type, [79, 112, 117, 115, 72, 101, 97, 100])) {
+            return {
+              ext: "opus",
+              mime: "audio/ogg; codecs=opus"
+            };
+          }
+          if (checkBytes(type, [128, 116, 104, 101, 111, 114, 97])) {
+            return {
+              ext: "ogv",
+              mime: "video/ogg"
+            };
+          }
+          if (checkBytes(type, [1, 118, 105, 100, 101, 111, 0])) {
+            return {
+              ext: "ogm",
+              mime: "video/ogg"
+            };
+          }
+          if (checkBytes(type, [127, 70, 76, 65, 67])) {
+            return {
+              ext: "oga",
+              mime: "audio/ogg"
+            };
+          }
+          if (checkBytes(type, [83, 112, 101, 101, 120, 32, 32])) {
+            return {
+              ext: "spx",
+              mime: "audio/ogg"
+            };
+          }
+          if (checkBytes(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"
+            // Non-standard
+          };
+        }
+        if (this.checkString("LZIP")) {
+          return {
+            ext: "lz",
+            mime: "application/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])) {
+          return detectEbml(tokenizer);
+        }
+        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"
+            // Informal, used by freedesktop.org shared-mime-info
+          };
+        }
+        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(String.raw`{\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",
+              // May also be .ps, .mpeg
+              mime: "video/MP1S"
+            };
+          }
+          if (this.check([68], { offset: 4, mask: [196] })) {
+            return {
+              ext: "mpg",
+              // May also be .mpg, .m2p, .vob or .sub
+              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/x-ft-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 (new RegExp("^\\d+$", "v").test(version) && 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);
+          const string = await tokenizer.readToken(new StringType(13, "ascii"));
+          if (string === "debian-binary") {
+            return {
+              ext: "deb",
+              mime: "application/x-deb"
+            };
+          }
+          return {
+            ext: "ar",
+            mime: "application/x-unix-archive"
+          };
+        }
+        if (this.checkString("WEBVTT") && // One of LF, CR, tab, space, or end of file must follow "WEBVTT" per the spec (see `fixture/fixture-vtt-*.vtt` for examples). Note that `\0` is technically the null character (there is no such thing as an EOF character). However, checking for `\0` gives us the same result as checking for the end of the stream.
+        ["\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])) {
+          return detectPng(tokenizer);
+        }
+        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])) {
+          return detectAsf(tokenizer);
+        }
+        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);
+          const type = await tokenizer.readToken(new StringType(4, "ascii"));
+          switch (type) {
+            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 void 0;
+        }
+        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));
+              const json = JSON.parse(header);
+              if (json.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"
+            // Informal, used by freedesktop.org shared-mime-info
+          };
+        }
+        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-ft-apple.alias"
+          };
+        }
+        if (this.checkString("Kaydara FBX Binary  \0")) {
+          return {
+            ext: "fbx",
+            mime: "application/x-ft-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 void 0;
+        }
+        if (this.checkString("-----BEGIN PGP MESSAGE-----")) {
+          return {
+            ext: "pgp",
+            mime: "application/pgp-encrypted"
+          };
+        }
+      };
+      // Detections with limited supporting data, resulting in a higher likelihood of false positives
+      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 (numberOfTags > maximumTiffTagCount) {
+          return;
+        }
+        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"
+                };
+              }
+            }
+          }
+          if (hasUnknownFileSize(this.tokenizer) && ifdOffset > maximumTiffStreamIfdOffsetInBytes) {
+            return tiffFileType;
+          }
+          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"
+            };
+          }
+        }
+      }
+    };
+    supportedExtensions = new Set(extensions);
+    supportedMimeTypes = new Set(mimeTypes);
+  }
+});
+init_source();
+export {
+  FileTypeParser,
+  fileTypeFromBlob,
+  fileTypeFromBuffer,
+  fileTypeFromFile,
+  fileTypeFromStream,
+  fileTypeFromTokenizer,
+  fileTypeStream,
+  normalizeSampleSize,
+  reasonableDetectionSizeInBytes,
+  supportedExtensions,
+  supportedMimeTypes
+};
+/*! Bundled license information:
+
+ieee754/index.js:
+  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+*/