@burdenoff/vibe-agent 1.3.2 → 2.1.0

package/dist/index-5xngv42g.js

@@ -0,0 +1,2546 @@
+// @bun
+import {
+  __commonJS,
+  __require
+} from "./index-g8dczzvv.js";
+
+// node_modules/strtok3/lib/FsPromise.js
+var require_FsPromise = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.readFile = exports.writeFileSync = exports.writeFile = exports.read = exports.open = exports.close = exports.stat = exports.createReadStream = exports.pathExists = undefined;
+  var fs = __require("fs");
+  exports.pathExists = fs.existsSync;
+  exports.createReadStream = fs.createReadStream;
+  async function stat(path) {
+    return new Promise((resolve2, reject2) => {
+      fs.stat(path, (err, stats) => {
+        if (err)
+          reject2(err);
+        else
+          resolve2(stats);
+      });
+    });
+  }
+  exports.stat = stat;
+  async function close(fd) {
+    return new Promise((resolve2, reject2) => {
+      fs.close(fd, (err) => {
+        if (err)
+          reject2(err);
+        else
+          resolve2();
+      });
+    });
+  }
+  exports.close = close;
+  async function open(path, mode) {
+    return new Promise((resolve2, reject2) => {
+      fs.open(path, mode, (err, fd) => {
+        if (err)
+          reject2(err);
+        else
+          resolve2(fd);
+      });
+    });
+  }
+  exports.open = open;
+  async function read(fd, buffer, offset, length, position) {
+    return new Promise((resolve2, reject2) => {
+      fs.read(fd, buffer, offset, length, position, (err, bytesRead, _buffer) => {
+        if (err)
+          reject2(err);
+        else
+          resolve2({ bytesRead, buffer: _buffer });
+      });
+    });
+  }
+  exports.read = read;
+  async function writeFile(path, data) {
+    return new Promise((resolve2, reject2) => {
+      fs.writeFile(path, data, (err) => {
+        if (err)
+          reject2(err);
+        else
+          resolve2();
+      });
+    });
+  }
+  exports.writeFile = writeFile;
+  function writeFileSync(path, data) {
+    fs.writeFileSync(path, data);
+  }
+  exports.writeFileSync = writeFileSync;
+  async function readFile(path) {
+    return new Promise((resolve2, reject2) => {
+      fs.readFile(path, (err, buffer) => {
+        if (err)
+          reject2(err);
+        else
+          resolve2(buffer);
+      });
+    });
+  }
+  exports.readFile = readFile;
+});
+
+// node_modules/peek-readable/lib/EndOfFileStream.js
+var require_EndOfFileStream = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.EndOfStreamError = exports.defaultMessages = undefined;
+  exports.defaultMessages = "End-Of-Stream";
+
+  class EndOfStreamError extends Error {
+    constructor() {
+      super(exports.defaultMessages);
+    }
+  }
+  exports.EndOfStreamError = EndOfStreamError;
+});
+
+// node_modules/peek-readable/lib/Deferred.js
+var require_Deferred = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Deferred = undefined;
+
+  class Deferred {
+    constructor() {
+      this.resolve = () => null;
+      this.reject = () => null;
+      this.promise = new Promise((resolve2, reject2) => {
+        this.reject = reject2;
+        this.resolve = resolve2;
+      });
+    }
+  }
+  exports.Deferred = Deferred;
+});
+
+// node_modules/peek-readable/lib/StreamReader.js
+var require_StreamReader = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.StreamReader = exports.EndOfStreamError = undefined;
+  var EndOfFileStream_1 = require_EndOfFileStream();
+  var Deferred_1 = require_Deferred();
+  var EndOfFileStream_2 = require_EndOfFileStream();
+  Object.defineProperty(exports, "EndOfStreamError", { enumerable: true, get: function() {
+    return EndOfFileStream_2.EndOfStreamError;
+  } });
+  var maxStreamReadSize = 1 * 1024 * 1024;
+
+  class StreamReader {
+    constructor(s) {
+      this.s = s;
+      this.deferred = null;
+      this.endOfStream = false;
+      this.peekQueue = [];
+      if (!s.read || !s.once) {
+        throw new Error("Expected an instance of stream.Readable");
+      }
+      this.s.once("end", () => this.reject(new EndOfFileStream_1.EndOfStreamError));
+      this.s.once("error", (err) => this.reject(err));
+      this.s.once("close", () => this.reject(new Error("Stream closed")));
+    }
+    async peek(uint8Array, offset, length) {
+      const bytesRead = await this.read(uint8Array, offset, length);
+      this.peekQueue.push(uint8Array.subarray(offset, offset + bytesRead));
+      return bytesRead;
+    }
+    async read(buffer, offset, length) {
+      if (length === 0) {
+        return 0;
+      }
+      if (this.peekQueue.length === 0 && this.endOfStream) {
+        throw new EndOfFileStream_1.EndOfStreamError;
+      }
+      let remaining = 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), offset + bytesRead);
+        bytesRead += lenCopy;
+        remaining -= lenCopy;
+        if (lenCopy < peekData.length) {
+          this.peekQueue.push(peekData.subarray(lenCopy));
+        }
+      }
+      while (remaining > 0 && !this.endOfStream) {
+        const reqLen = Math.min(remaining, maxStreamReadSize);
+        const chunkLen = await this.readFromStream(buffer, offset + bytesRead, reqLen);
+        bytesRead += chunkLen;
+        if (chunkLen < reqLen)
+          break;
+        remaining -= chunkLen;
+      }
+      return bytesRead;
+    }
+    async readFromStream(buffer, offset, length) {
+      const readBuffer = this.s.read(length);
+      if (readBuffer) {
+        buffer.set(readBuffer, offset);
+        return readBuffer.length;
+      } else {
+        const request = {
+          buffer,
+          offset,
+          length,
+          deferred: new Deferred_1.Deferred
+        };
+        this.deferred = request.deferred;
+        this.s.once("readable", () => {
+          this.readDeferred(request);
+        });
+        return request.deferred.promise;
+      }
+    }
+    readDeferred(request) {
+      const readBuffer = this.s.read(request.length);
+      if (readBuffer) {
+        request.buffer.set(readBuffer, request.offset);
+        request.deferred.resolve(readBuffer.length);
+        this.deferred = null;
+      } else {
+        this.s.once("readable", () => {
+          this.readDeferred(request);
+        });
+      }
+    }
+    reject(err) {
+      this.endOfStream = true;
+      if (this.deferred) {
+        this.deferred.reject(err);
+        this.deferred = null;
+      }
+    }
+  }
+  exports.StreamReader = StreamReader;
+});
+
+// node_modules/peek-readable/lib/index.js
+var require_lib = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.StreamReader = exports.EndOfStreamError = undefined;
+  var EndOfFileStream_1 = require_EndOfFileStream();
+  Object.defineProperty(exports, "EndOfStreamError", { enumerable: true, get: function() {
+    return EndOfFileStream_1.EndOfStreamError;
+  } });
+  var StreamReader_1 = require_StreamReader();
+  Object.defineProperty(exports, "StreamReader", { enumerable: true, get: function() {
+    return StreamReader_1.StreamReader;
+  } });
+});
+
+// node_modules/strtok3/lib/AbstractTokenizer.js
+var require_AbstractTokenizer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.AbstractTokenizer = undefined;
+  var peek_readable_1 = require_lib();
+
+  class AbstractTokenizer {
+    constructor(fileInfo) {
+      this.position = 0;
+      this.numBuffer = new Uint8Array(8);
+      this.fileInfo = fileInfo ? fileInfo : {};
+    }
+    async readToken(token, position = this.position) {
+      const uint8Array = Buffer.alloc(token.len);
+      const len = await this.readBuffer(uint8Array, { position });
+      if (len < token.len)
+        throw new peek_readable_1.EndOfStreamError;
+      return token.get(uint8Array, 0);
+    }
+    async peekToken(token, position = this.position) {
+      const uint8Array = Buffer.alloc(token.len);
+      const len = await this.peekBuffer(uint8Array, { position });
+      if (len < token.len)
+        throw new peek_readable_1.EndOfStreamError;
+      return token.get(uint8Array, 0);
+    }
+    async readNumber(token) {
+      const len = await this.readBuffer(this.numBuffer, { length: token.len });
+      if (len < token.len)
+        throw new peek_readable_1.EndOfStreamError;
+      return token.get(this.numBuffer, 0);
+    }
+    async peekNumber(token) {
+      const len = await this.peekBuffer(this.numBuffer, { length: token.len });
+      if (len < token.len)
+        throw new peek_readable_1.EndOfStreamError;
+      return token.get(this.numBuffer, 0);
+    }
+    async ignore(length) {
+      if (this.fileInfo.size !== undefined) {
+        const bytesLeft = this.fileInfo.size - this.position;
+        if (length > bytesLeft) {
+          this.position += bytesLeft;
+          return bytesLeft;
+        }
+      }
+      this.position += length;
+      return length;
+    }
+    async close() {}
+    normalizeOptions(uint8Array, options) {
+      if (options && options.position !== undefined && options.position < this.position) {
+        throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
+      }
+      if (options) {
+        return {
+          mayBeLess: options.mayBeLess === true,
+          offset: options.offset ? options.offset : 0,
+          length: options.length ? options.length : uint8Array.length - (options.offset ? options.offset : 0),
+          position: options.position ? options.position : this.position
+        };
+      }
+      return {
+        mayBeLess: false,
+        offset: 0,
+        length: uint8Array.length,
+        position: this.position
+      };
+    }
+  }
+  exports.AbstractTokenizer = AbstractTokenizer;
+});
+
+// node_modules/strtok3/lib/ReadStreamTokenizer.js
+var require_ReadStreamTokenizer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ReadStreamTokenizer = undefined;
+  var AbstractTokenizer_1 = require_AbstractTokenizer();
+  var peek_readable_1 = require_lib();
+  var maxBufferSize = 256000;
+
+  class ReadStreamTokenizer extends AbstractTokenizer_1.AbstractTokenizer {
+    constructor(stream2, fileInfo) {
+      super(fileInfo);
+      this.streamReader = new peek_readable_1.StreamReader(stream2);
+    }
+    async getFileInfo() {
+      return this.fileInfo;
+    }
+    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);
+      } else 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, normOptions.offset, normOptions.length);
+      this.position += bytesRead;
+      if ((!options || !options.mayBeLess) && bytesRead < normOptions.length) {
+        throw new peek_readable_1.EndOfStreamError;
+      }
+      return bytesRead;
+    }
+    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), normOptions.offset);
+          return bytesRead - skipBytes;
+        } else 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, normOptions.offset, normOptions.length);
+        } catch (err) {
+          if (options && options.mayBeLess && err instanceof peek_readable_1.EndOfStreamError) {
+            return 0;
+          }
+          throw err;
+        }
+        if (!normOptions.mayBeLess && bytesRead < normOptions.length) {
+          throw new peek_readable_1.EndOfStreamError;
+        }
+      }
+      return bytesRead;
+    }
+    async ignore(length) {
+      const bufSize = Math.min(maxBufferSize, length);
+      const buf = new Uint8Array(bufSize);
+      let totBytesRead = 0;
+      while (totBytesRead < length) {
+        const remaining = length - totBytesRead;
+        const bytesRead = await this.readBuffer(buf, { length: Math.min(bufSize, remaining) });
+        if (bytesRead < 0) {
+          return bytesRead;
+        }
+        totBytesRead += bytesRead;
+      }
+      return totBytesRead;
+    }
+  }
+  exports.ReadStreamTokenizer = ReadStreamTokenizer;
+});
+
+// node_modules/strtok3/lib/BufferTokenizer.js
+var require_BufferTokenizer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.BufferTokenizer = undefined;
+  var peek_readable_1 = require_lib();
+  var AbstractTokenizer_1 = require_AbstractTokenizer();
+
+  class BufferTokenizer extends AbstractTokenizer_1.AbstractTokenizer {
+    constructor(uint8Array, fileInfo) {
+      super(fileInfo);
+      this.uint8Array = uint8Array;
+      this.fileInfo.size = this.fileInfo.size ? this.fileInfo.size : uint8Array.length;
+    }
+    async readBuffer(uint8Array, options) {
+      if (options && options.position) {
+        if (options.position < this.position) {
+          throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
+        }
+        this.position = options.position;
+      }
+      const bytesRead = await this.peekBuffer(uint8Array, options);
+      this.position += bytesRead;
+      return bytesRead;
+    }
+    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 peek_readable_1.EndOfStreamError;
+      } else {
+        uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read), normOptions.offset);
+        return bytes2read;
+      }
+    }
+    async close() {}
+  }
+  exports.BufferTokenizer = BufferTokenizer;
+});
+
+// node_modules/strtok3/lib/core.js
+var require_core = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromBuffer = exports.fromStream = exports.EndOfStreamError = undefined;
+  var ReadStreamTokenizer_1 = require_ReadStreamTokenizer();
+  var BufferTokenizer_1 = require_BufferTokenizer();
+  var peek_readable_1 = require_lib();
+  Object.defineProperty(exports, "EndOfStreamError", { enumerable: true, get: function() {
+    return peek_readable_1.EndOfStreamError;
+  } });
+  function fromStream(stream2, fileInfo) {
+    fileInfo = fileInfo ? fileInfo : {};
+    return new ReadStreamTokenizer_1.ReadStreamTokenizer(stream2, fileInfo);
+  }
+  exports.fromStream = fromStream;
+  function fromBuffer(uint8Array, fileInfo) {
+    return new BufferTokenizer_1.BufferTokenizer(uint8Array, fileInfo);
+  }
+  exports.fromBuffer = fromBuffer;
+});
+
+// node_modules/strtok3/lib/FileTokenizer.js
+var require_FileTokenizer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromFile = exports.FileTokenizer = undefined;
+  var AbstractTokenizer_1 = require_AbstractTokenizer();
+  var peek_readable_1 = require_lib();
+  var fs = require_FsPromise();
+
+  class FileTokenizer extends AbstractTokenizer_1.AbstractTokenizer {
+    constructor(fd, fileInfo) {
+      super(fileInfo);
+      this.fd = fd;
+    }
+    async readBuffer(uint8Array, options) {
+      const normOptions = this.normalizeOptions(uint8Array, options);
+      this.position = normOptions.position;
+      const res = await fs.read(this.fd, uint8Array, normOptions.offset, normOptions.length, normOptions.position);
+      this.position += res.bytesRead;
+      if (res.bytesRead < normOptions.length && (!options || !options.mayBeLess)) {
+        throw new peek_readable_1.EndOfStreamError;
+      }
+      return res.bytesRead;
+    }
+    async peekBuffer(uint8Array, options) {
+      const normOptions = this.normalizeOptions(uint8Array, options);
+      const res = await fs.read(this.fd, uint8Array, normOptions.offset, normOptions.length, normOptions.position);
+      if (!normOptions.mayBeLess && res.bytesRead < normOptions.length) {
+        throw new peek_readable_1.EndOfStreamError;
+      }
+      return res.bytesRead;
+    }
+    async close() {
+      return fs.close(this.fd);
+    }
+  }
+  exports.FileTokenizer = FileTokenizer;
+  async function fromFile(sourceFilePath) {
+    const stat = await fs.stat(sourceFilePath);
+    if (!stat.isFile) {
+      throw new Error(`File not a file: ${sourceFilePath}`);
+    }
+    const fd = await fs.open(sourceFilePath, "r");
+    return new FileTokenizer(fd, { path: sourceFilePath, size: stat.size });
+  }
+  exports.fromFile = fromFile;
+});
+
+// node_modules/strtok3/lib/index.js
+var require_lib2 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromStream = exports.fromBuffer = exports.EndOfStreamError = exports.fromFile = undefined;
+  var fs = require_FsPromise();
+  var core = require_core();
+  var FileTokenizer_1 = require_FileTokenizer();
+  Object.defineProperty(exports, "fromFile", { enumerable: true, get: function() {
+    return FileTokenizer_1.fromFile;
+  } });
+  var core_1 = require_core();
+  Object.defineProperty(exports, "EndOfStreamError", { enumerable: true, get: function() {
+    return core_1.EndOfStreamError;
+  } });
+  Object.defineProperty(exports, "fromBuffer", { enumerable: true, get: function() {
+    return core_1.fromBuffer;
+  } });
+  async function fromStream(stream2, fileInfo) {
+    fileInfo = fileInfo ? fileInfo : {};
+    if (stream2.path) {
+      const stat = await fs.stat(stream2.path);
+      fileInfo.path = stream2.path;
+      fileInfo.size = stat.size;
+    }
+    return core.fromStream(stream2, fileInfo);
+  }
+  exports.fromStream = fromStream;
+});
+
+// node_modules/ieee754/index.js
+var require_ieee754 = __commonJS((exports) => {
+  /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+  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/token-types/lib/index.js
+var require_lib3 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.AnsiStringType = exports.StringType = exports.BufferType = exports.Uint8ArrayType = exports.IgnoreType = exports.Float80_LE = exports.Float80_BE = exports.Float64_LE = exports.Float64_BE = exports.Float32_LE = exports.Float32_BE = exports.Float16_LE = exports.Float16_BE = exports.INT64_BE = exports.UINT64_BE = exports.INT64_LE = exports.UINT64_LE = exports.INT32_LE = exports.INT32_BE = exports.INT24_BE = exports.INT24_LE = exports.INT16_LE = exports.INT16_BE = exports.INT8 = exports.UINT32_BE = exports.UINT32_LE = exports.UINT24_BE = exports.UINT24_LE = exports.UINT16_BE = exports.UINT16_LE = exports.UINT8 = undefined;
+  var ieee754 = require_ieee754();
+  function dv(array) {
+    return new DataView(array.buffer, array.byteOffset);
+  }
+  exports.UINT8 = {
+    len: 1,
+    get(array, offset) {
+      return dv(array).getUint8(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setUint8(offset, value);
+      return offset + 1;
+    }
+  };
+  exports.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;
+    }
+  };
+  exports.UINT16_BE = {
+    len: 2,
+    get(array, offset) {
+      return dv(array).getUint16(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setUint16(offset, value);
+      return offset + 2;
+    }
+  };
+  exports.UINT24_LE = {
+    len: 3,
+    get(array, offset) {
+      const dataView = dv(array);
+      return dataView.getUint8(offset) + (dataView.getUint16(offset + 1, true) << 8);
+    },
+    put(array, offset, value) {
+      const dataView = dv(array);
+      dataView.setUint8(offset, value & 255);
+      dataView.setUint16(offset + 1, value >> 8, true);
+      return offset + 3;
+    }
+  };
+  exports.UINT24_BE = {
+    len: 3,
+    get(array, offset) {
+      const dataView = dv(array);
+      return (dataView.getUint16(offset) << 8) + dataView.getUint8(offset + 2);
+    },
+    put(array, offset, value) {
+      const dataView = dv(array);
+      dataView.setUint16(offset, value >> 8);
+      dataView.setUint8(offset + 2, value & 255);
+      return offset + 3;
+    }
+  };
+  exports.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;
+    }
+  };
+  exports.UINT32_BE = {
+    len: 4,
+    get(array, offset) {
+      return dv(array).getUint32(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setUint32(offset, value);
+      return offset + 4;
+    }
+  };
+  exports.INT8 = {
+    len: 1,
+    get(array, offset) {
+      return dv(array).getInt8(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setInt8(offset, value);
+      return offset + 1;
+    }
+  };
+  exports.INT16_BE = {
+    len: 2,
+    get(array, offset) {
+      return dv(array).getInt16(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setInt16(offset, value);
+      return offset + 2;
+    }
+  };
+  exports.INT16_LE = {
+    len: 2,
+    get(array, offset) {
+      return dv(array).getInt16(offset, true);
+    },
+    put(array, offset, value) {
+      dv(array).setInt16(offset, value, true);
+      return offset + 2;
+    }
+  };
+  exports.INT24_LE = {
+    len: 3,
+    get(array, offset) {
+      const unsigned = exports.UINT24_LE.get(array, offset);
+      return unsigned > 8388607 ? unsigned - 16777216 : unsigned;
+    },
+    put(array, offset, value) {
+      const dataView = dv(array);
+      dataView.setUint8(offset, value & 255);
+      dataView.setUint16(offset + 1, value >> 8, true);
+      return offset + 3;
+    }
+  };
+  exports.INT24_BE = {
+    len: 3,
+    get(array, offset) {
+      const unsigned = exports.UINT24_BE.get(array, offset);
+      return unsigned > 8388607 ? unsigned - 16777216 : unsigned;
+    },
+    put(array, offset, value) {
+      const dataView = dv(array);
+      dataView.setUint16(offset, value >> 8);
+      dataView.setUint8(offset + 2, value & 255);
+      return offset + 3;
+    }
+  };
+  exports.INT32_BE = {
+    len: 4,
+    get(array, offset) {
+      return dv(array).getInt32(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setInt32(offset, value);
+      return offset + 4;
+    }
+  };
+  exports.INT32_LE = {
+    len: 4,
+    get(array, offset) {
+      return dv(array).getInt32(offset, true);
+    },
+    put(array, offset, value) {
+      dv(array).setInt32(offset, value, true);
+      return offset + 4;
+    }
+  };
+  exports.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;
+    }
+  };
+  exports.INT64_LE = {
+    len: 8,
+    get(array, offset) {
+      return dv(array).getBigInt64(offset, true);
+    },
+    put(array, offset, value) {
+      dv(array).setBigInt64(offset, value, true);
+      return offset + 8;
+    }
+  };
+  exports.UINT64_BE = {
+    len: 8,
+    get(array, offset) {
+      return dv(array).getBigUint64(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setBigUint64(offset, value);
+      return offset + 8;
+    }
+  };
+  exports.INT64_BE = {
+    len: 8,
+    get(array, offset) {
+      return dv(array).getBigInt64(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setBigInt64(offset, value);
+      return offset + 8;
+    }
+  };
+  exports.Float16_BE = {
+    len: 2,
+    get(dataView, offset) {
+      return ieee754.read(dataView, offset, false, 10, this.len);
+    },
+    put(dataView, offset, value) {
+      ieee754.write(dataView, value, offset, false, 10, this.len);
+      return offset + this.len;
+    }
+  };
+  exports.Float16_LE = {
+    len: 2,
+    get(array, offset) {
+      return ieee754.read(array, offset, true, 10, this.len);
+    },
+    put(array, offset, value) {
+      ieee754.write(array, value, offset, true, 10, this.len);
+      return offset + this.len;
+    }
+  };
+  exports.Float32_BE = {
+    len: 4,
+    get(array, offset) {
+      return dv(array).getFloat32(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setFloat32(offset, value);
+      return offset + 4;
+    }
+  };
+  exports.Float32_LE = {
+    len: 4,
+    get(array, offset) {
+      return dv(array).getFloat32(offset, true);
+    },
+    put(array, offset, value) {
+      dv(array).setFloat32(offset, value, true);
+      return offset + 4;
+    }
+  };
+  exports.Float64_BE = {
+    len: 8,
+    get(array, offset) {
+      return dv(array).getFloat64(offset);
+    },
+    put(array, offset, value) {
+      dv(array).setFloat64(offset, value);
+      return offset + 8;
+    }
+  };
+  exports.Float64_LE = {
+    len: 8,
+    get(array, offset) {
+      return dv(array).getFloat64(offset, true);
+    },
+    put(array, offset, value) {
+      dv(array).setFloat64(offset, value, true);
+      return offset + 8;
+    }
+  };
+  exports.Float80_BE = {
+    len: 10,
+    get(array, offset) {
+      return ieee754.read(array, offset, false, 63, this.len);
+    },
+    put(array, offset, value) {
+      ieee754.write(array, value, offset, false, 63, this.len);
+      return offset + this.len;
+    }
+  };
+  exports.Float80_LE = {
+    len: 10,
+    get(array, offset) {
+      return ieee754.read(array, offset, true, 63, this.len);
+    },
+    put(array, offset, value) {
+      ieee754.write(array, value, offset, true, 63, this.len);
+      return offset + this.len;
+    }
+  };
+
+  class IgnoreType {
+    constructor(len) {
+      this.len = len;
+    }
+    get(array, off) {}
+  }
+  exports.IgnoreType = IgnoreType;
+
+  class Uint8ArrayType {
+    constructor(len) {
+      this.len = len;
+    }
+    get(array, offset) {
+      return array.subarray(offset, offset + this.len);
+    }
+  }
+  exports.Uint8ArrayType = Uint8ArrayType;
+
+  class BufferType {
+    constructor(len) {
+      this.len = len;
+    }
+    get(uint8Array, off) {
+      return Buffer.from(uint8Array.subarray(off, off + this.len));
+    }
+  }
+  exports.BufferType = BufferType;
+
+  class StringType {
+    constructor(len, encoding) {
+      this.len = len;
+      this.encoding = encoding;
+    }
+    get(uint8Array, offset) {
+      return Buffer.from(uint8Array).toString(this.encoding, offset, offset + this.len);
+    }
+  }
+  exports.StringType = StringType;
+
+  class AnsiStringType {
+    constructor(len) {
+      this.len = len;
+    }
+    static decode(buffer, offset, until) {
+      let str = "";
+      for (let i = offset;i < until; ++i) {
+        str += AnsiStringType.codePointToString(AnsiStringType.singleByteDecoder(buffer[i]));
+      }
+      return str;
+    }
+    static inRange(a, min, max) {
+      return min <= a && a <= max;
+    }
+    static codePointToString(cp) {
+      if (cp <= 65535) {
+        return String.fromCharCode(cp);
+      } else {
+        cp -= 65536;
+        return String.fromCharCode((cp >> 10) + 55296, (cp & 1023) + 56320);
+      }
+    }
+    static singleByteDecoder(bite) {
+      if (AnsiStringType.inRange(bite, 0, 127)) {
+        return bite;
+      }
+      const codePoint = AnsiStringType.windows1252[bite - 128];
+      if (codePoint === null) {
+        throw Error("invaliding encoding");
+      }
+      return codePoint;
+    }
+    get(buffer, offset = 0) {
+      return AnsiStringType.decode(buffer, offset, offset + this.len);
+    }
+  }
+  exports.AnsiStringType = AnsiStringType;
+  AnsiStringType.windows1252 = [
+    8364,
+    129,
+    8218,
+    402,
+    8222,
+    8230,
+    8224,
+    8225,
+    710,
+    8240,
+    352,
+    8249,
+    338,
+    141,
+    381,
+    143,
+    144,
+    8216,
+    8217,
+    8220,
+    8221,
+    8226,
+    8211,
+    8212,
+    732,
+    8482,
+    353,
+    8250,
+    339,
+    157,
+    382,
+    376,
+    160,
+    161,
+    162,
+    163,
+    164,
+    165,
+    166,
+    167,
+    168,
+    169,
+    170,
+    171,
+    172,
+    173,
+    174,
+    175,
+    176,
+    177,
+    178,
+    179,
+    180,
+    181,
+    182,
+    183,
+    184,
+    185,
+    186,
+    187,
+    188,
+    189,
+    190,
+    191,
+    192,
+    193,
+    194,
+    195,
+    196,
+    197,
+    198,
+    199,
+    200,
+    201,
+    202,
+    203,
+    204,
+    205,
+    206,
+    207,
+    208,
+    209,
+    210,
+    211,
+    212,
+    213,
+    214,
+    215,
+    216,
+    217,
+    218,
+    219,
+    220,
+    221,
+    222,
+    223,
+    224,
+    225,
+    226,
+    227,
+    228,
+    229,
+    230,
+    231,
+    232,
+    233,
+    234,
+    235,
+    236,
+    237,
+    238,
+    239,
+    240,
+    241,
+    242,
+    243,
+    244,
+    245,
+    246,
+    247,
+    248,
+    249,
+    250,
+    251,
+    252,
+    253,
+    254,
+    255
+  ];
+});
+
+// node_modules/file-type/util.js
+var require_util = __commonJS((exports) => {
+  exports.stringToBytes = (string) => [...string].map((character) => character.charCodeAt(0));
+  exports.tarHeaderChecksumMatches = (buffer, offset = 0) => {
+    const readSum = parseInt(buffer.toString("utf8", 148, 154).replace(/\0.*$/, "").trim(), 8);
+    if (isNaN(readSum)) {
+      return false;
+    }
+    let sum = 8 * 32;
+    for (let i = offset;i < offset + 148; i++) {
+      sum += buffer[i];
+    }
+    for (let i = offset + 156;i < offset + 512; i++) {
+      sum += buffer[i];
+    }
+    return readSum === sum;
+  };
+  exports.uint32SyncSafeToken = {
+    get: (buffer, offset) => {
+      return buffer[offset + 3] & 127 | buffer[offset + 2] << 7 | buffer[offset + 1] << 14 | buffer[offset] << 21;
+    },
+    len: 4
+  };
+});
+
+// node_modules/file-type/supported.js
+var require_supported = __commonJS((exports, module) => {
+  module.exports = {
+    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",
+      "exe",
+      "swf",
+      "rtf",
+      "wasm",
+      "woff",
+      "woff2",
+      "eot",
+      "ttf",
+      "otf",
+      "ico",
+      "flv",
+      "ps",
+      "xz",
+      "sqlite",
+      "nes",
+      "crx",
+      "xpi",
+      "cab",
+      "deb",
+      "ar",
+      "rpm",
+      "Z",
+      "lz",
+      "cfb",
+      "mxf",
+      "mts",
+      "blend",
+      "bpg",
+      "docx",
+      "pptx",
+      "xlsx",
+      "3gp",
+      "3g2",
+      "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",
+      "ai",
+      "skp",
+      "avif",
+      "eps",
+      "lzh",
+      "pgp",
+      "asar",
+      "stl",
+      "chm",
+      "3mf",
+      "zst",
+      "jxl",
+      "vcf"
+    ],
+    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.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/zip",
+      "application/x-tar",
+      "application/x-rar-compressed",
+      "application/gzip",
+      "application/x-bzip2",
+      "application/x-7z-compressed",
+      "application/x-apple-diskimage",
+      "application/x-apache-arrow",
+      "video/mp4",
+      "audio/midi",
+      "video/x-matroska",
+      "video/webm",
+      "video/quicktime",
+      "video/vnd.avi",
+      "audio/vnd.wave",
+      "audio/qcelp",
+      "audio/x-ms-asf",
+      "video/x-ms-asf",
+      "application/vnd.ms-asf",
+      "video/mpeg",
+      "video/3gpp",
+      "audio/mpeg",
+      "audio/mp4",
+      "audio/opus",
+      "video/ogg",
+      "audio/ogg",
+      "application/ogg",
+      "audio/x-flac",
+      "audio/ape",
+      "audio/wavpack",
+      "audio/amr",
+      "application/pdf",
+      "application/x-msdownload",
+      "application/x-shockwave-flash",
+      "application/rtf",
+      "application/wasm",
+      "font/woff",
+      "font/woff2",
+      "application/vnd.ms-fontobject",
+      "font/ttf",
+      "font/otf",
+      "image/x-icon",
+      "video/x-flv",
+      "application/postscript",
+      "application/eps",
+      "application/x-xz",
+      "application/x-sqlite3",
+      "application/x-nintendo-nes-rom",
+      "application/x-google-chrome-extension",
+      "application/vnd.ms-cab-compressed",
+      "application/x-deb",
+      "application/x-unix-archive",
+      "application/x-rpm",
+      "application/x-compress",
+      "application/x-lzip",
+      "application/x-cfb",
+      "application/x-mie",
+      "application/mxf",
+      "video/mp2t",
+      "application/x-blender",
+      "image/bpg",
+      "image/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",
+      "model/gltf-binary",
+      "application/vnd.tcpdump.pcap",
+      "audio/x-dsf",
+      "application/x.ms.shortcut",
+      "application/x.apple.alias",
+      "audio/x-voc",
+      "audio/vnd.dolby.dd-raw",
+      "audio/x-m4a",
+      "image/apng",
+      "image/x-olympus-orf",
+      "image/x-sony-arw",
+      "image/x-adobe-dng",
+      "image/x-nikon-nef",
+      "image/x-panasonic-rw2",
+      "image/x-fujifilm-raf",
+      "video/x-m4v",
+      "video/3gpp2",
+      "application/x-esri-shape",
+      "audio/aac",
+      "audio/x-it",
+      "audio/x-s3m",
+      "audio/x-xm",
+      "video/MP1S",
+      "video/MP2P",
+      "application/vnd.sketchup.skp",
+      "image/avif",
+      "application/x-lzh-compressed",
+      "application/pgp-encrypted",
+      "application/x-asar",
+      "model/stl",
+      "application/vnd.ms-htmlhelp",
+      "model/3mf",
+      "image/jxl",
+      "application/zstd"
+    ]
+  };
+});
+
+// node_modules/file-type/core.js
+var require_core2 = __commonJS((exports, module) => {
+  var Token = require_lib3();
+  var strtok3 = require_core();
+  var {
+    stringToBytes,
+    tarHeaderChecksumMatches,
+    uint32SyncSafeToken
+  } = require_util();
+  var supported = require_supported();
+  var minimumBytes = 4100;
+  async function fromStream(stream3) {
+    const tokenizer = await strtok3.fromStream(stream3);
+    try {
+      return await fromTokenizer(tokenizer);
+    } finally {
+      await tokenizer.close();
+    }
+  }
+  async function fromBuffer(input) {
+    if (!(input instanceof Uint8Array || input instanceof ArrayBuffer || Buffer.isBuffer(input))) {
+      throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\` or \`ArrayBuffer\`, got \`${typeof input}\``);
+    }
+    const buffer = input instanceof Buffer ? input : Buffer.from(input);
+    if (!(buffer && buffer.length > 1)) {
+      return;
+    }
+    const tokenizer = strtok3.fromBuffer(buffer);
+    return fromTokenizer(tokenizer);
+  }
+  function _check(buffer, headers, options) {
+    options = {
+      offset: 0,
+      ...options
+    };
+    for (const [index, header] of headers.entries()) {
+      if (options.mask) {
+        if (header !== (options.mask[index] & buffer[index + options.offset])) {
+          return false;
+        }
+      } else if (header !== buffer[index + options.offset]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async function fromTokenizer(tokenizer) {
+    try {
+      return _fromTokenizer(tokenizer);
+    } catch (error) {
+      if (!(error instanceof strtok3.EndOfStreamError)) {
+        throw error;
+      }
+    }
+  }
+  async function _fromTokenizer(tokenizer) {
+    let buffer = Buffer.alloc(minimumBytes);
+    const bytesRead = 12;
+    const check = (header, options) => _check(buffer, header, options);
+    const checkString = (header, options) => check(stringToBytes(header), options);
+    if (!tokenizer.fileInfo.size) {
+      tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
+    }
+    await tokenizer.peekBuffer(buffer, { length: bytesRead, mayBeLess: true });
+    if (check([66, 77])) {
+      return {
+        ext: "bmp",
+        mime: "image/bmp"
+      };
+    }
+    if (check([11, 119])) {
+      return {
+        ext: "ac3",
+        mime: "audio/vnd.dolby.dd-raw"
+      };
+    }
+    if (check([120, 1])) {
+      return {
+        ext: "dmg",
+        mime: "application/x-apple-diskimage"
+      };
+    }
+    if (check([77, 90])) {
+      return {
+        ext: "exe",
+        mime: "application/x-msdownload"
+      };
+    }
+    if (check([37, 33])) {
+      await tokenizer.peekBuffer(buffer, { length: 24, mayBeLess: true });
+      if (checkString("PS-Adobe-", { offset: 2 }) && checkString(" EPSF-", { offset: 14 })) {
+        return {
+          ext: "eps",
+          mime: "application/eps"
+        };
+      }
+      return {
+        ext: "ps",
+        mime: "application/postscript"
+      };
+    }
+    if (check([31, 160]) || check([31, 157])) {
+      return {
+        ext: "Z",
+        mime: "application/x-compress"
+      };
+    }
+    if (check([255, 216, 255])) {
+      return {
+        ext: "jpg",
+        mime: "image/jpeg"
+      };
+    }
+    if (check([73, 73, 188])) {
+      return {
+        ext: "jxr",
+        mime: "image/vnd.ms-photo"
+      };
+    }
+    if (check([31, 139, 8])) {
+      return {
+        ext: "gz",
+        mime: "application/gzip"
+      };
+    }
+    if (check([66, 90, 104])) {
+      return {
+        ext: "bz2",
+        mime: "application/x-bzip2"
+      };
+    }
+    if (checkString("ID3")) {
+      await tokenizer.ignore(6);
+      const id3HeaderLen = await tokenizer.readToken(uint32SyncSafeToken);
+      if (tokenizer.position + id3HeaderLen > tokenizer.fileInfo.size) {
+        return {
+          ext: "mp3",
+          mime: "audio/mpeg"
+        };
+      }
+      await tokenizer.ignore(id3HeaderLen);
+      return fromTokenizer(tokenizer);
+    }
+    if (checkString("MP+")) {
+      return {
+        ext: "mpc",
+        mime: "audio/x-musepack"
+      };
+    }
+    if ((buffer[0] === 67 || buffer[0] === 70) && check([87, 83], { offset: 1 })) {
+      return {
+        ext: "swf",
+        mime: "application/x-shockwave-flash"
+      };
+    }
+    if (check([71, 73, 70])) {
+      return {
+        ext: "gif",
+        mime: "image/gif"
+      };
+    }
+    if (checkString("FLIF")) {
+      return {
+        ext: "flif",
+        mime: "image/flif"
+      };
+    }
+    if (checkString("8BPS")) {
+      return {
+        ext: "psd",
+        mime: "image/vnd.adobe.photoshop"
+      };
+    }
+    if (checkString("WEBP", { offset: 8 })) {
+      return {
+        ext: "webp",
+        mime: "image/webp"
+      };
+    }
+    if (checkString("MPCK")) {
+      return {
+        ext: "mpc",
+        mime: "audio/x-musepack"
+      };
+    }
+    if (checkString("FORM")) {
+      return {
+        ext: "aif",
+        mime: "audio/aiff"
+      };
+    }
+    if (checkString("icns", { offset: 0 })) {
+      return {
+        ext: "icns",
+        mime: "image/icns"
+      };
+    }
+    if (check([80, 75, 3, 4])) {
+      try {
+        while (tokenizer.position + 30 < tokenizer.fileInfo.size) {
+          await tokenizer.readBuffer(buffer, { length: 30 });
+          const zipHeader = {
+            compressedSize: buffer.readUInt32LE(18),
+            uncompressedSize: buffer.readUInt32LE(22),
+            filenameLength: buffer.readUInt16LE(26),
+            extraFieldLength: buffer.readUInt16LE(28)
+          };
+          zipHeader.filename = await tokenizer.readToken(new Token.StringType(zipHeader.filenameLength, "utf-8"));
+          await tokenizer.ignore(zipHeader.extraFieldLength);
+          if (zipHeader.filename === "META-INF/mozilla.rsa") {
+            return {
+              ext: "xpi",
+              mime: "application/x-xpinstall"
+            };
+          }
+          if (zipHeader.filename.endsWith(".rels") || zipHeader.filename.endsWith(".xml")) {
+            const type = zipHeader.filename.split("/")[0];
+            switch (type) {
+              case "_rels":
+                break;
+              case "word":
+                return {
+                  ext: "docx",
+                  mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                };
+              case "ppt":
+                return {
+                  ext: "pptx",
+                  mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+                };
+              case "xl":
+                return {
+                  ext: "xlsx",
+                  mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                };
+              default:
+                break;
+            }
+          }
+          if (zipHeader.filename.startsWith("xl/")) {
+            return {
+              ext: "xlsx",
+              mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            };
+          }
+          if (zipHeader.filename.startsWith("3D/") && zipHeader.filename.endsWith(".model")) {
+            return {
+              ext: "3mf",
+              mime: "model/3mf"
+            };
+          }
+          if (zipHeader.filename === "mimetype" && zipHeader.compressedSize === zipHeader.uncompressedSize) {
+            const mimeType = await tokenizer.readToken(new Token.StringType(zipHeader.compressedSize, "utf-8"));
+            switch (mimeType) {
+              case "application/epub+zip":
+                return {
+                  ext: "epub",
+                  mime: "application/epub+zip"
+                };
+              case "application/vnd.oasis.opendocument.text":
+                return {
+                  ext: "odt",
+                  mime: "application/vnd.oasis.opendocument.text"
+                };
+              case "application/vnd.oasis.opendocument.spreadsheet":
+                return {
+                  ext: "ods",
+                  mime: "application/vnd.oasis.opendocument.spreadsheet"
+                };
+              case "application/vnd.oasis.opendocument.presentation":
+                return {
+                  ext: "odp",
+                  mime: "application/vnd.oasis.opendocument.presentation"
+                };
+              default:
+            }
+          }
+          if (zipHeader.compressedSize === 0) {
+            let nextHeaderIndex = -1;
+            while (nextHeaderIndex < 0 && tokenizer.position < tokenizer.fileInfo.size) {
+              await tokenizer.peekBuffer(buffer, { mayBeLess: true });
+              nextHeaderIndex = buffer.indexOf("504B0304", 0, "hex");
+              await tokenizer.ignore(nextHeaderIndex >= 0 ? nextHeaderIndex : buffer.length);
+            }
+          } else {
+            await tokenizer.ignore(zipHeader.compressedSize);
+          }
+        }
+      } catch (error) {
+        if (!(error instanceof strtok3.EndOfStreamError)) {
+          throw error;
+        }
+      }
+      return {
+        ext: "zip",
+        mime: "application/zip"
+      };
+    }
+    if (checkString("OggS")) {
+      await tokenizer.ignore(28);
+      const type = Buffer.alloc(8);
+      await tokenizer.readBuffer(type);
+      if (_check(type, [79, 112, 117, 115, 72, 101, 97, 100])) {
+        return {
+          ext: "opus",
+          mime: "audio/opus"
+        };
+      }
+      if (_check(type, [128, 116, 104, 101, 111, 114, 97])) {
+        return {
+          ext: "ogv",
+          mime: "video/ogg"
+        };
+      }
+      if (_check(type, [1, 118, 105, 100, 101, 111, 0])) {
+        return {
+          ext: "ogm",
+          mime: "video/ogg"
+        };
+      }
+      if (_check(type, [127, 70, 76, 65, 67])) {
+        return {
+          ext: "oga",
+          mime: "audio/ogg"
+        };
+      }
+      if (_check(type, [83, 112, 101, 101, 120, 32, 32])) {
+        return {
+          ext: "spx",
+          mime: "audio/ogg"
+        };
+      }
+      if (_check(type, [1, 118, 111, 114, 98, 105, 115])) {
+        return {
+          ext: "ogg",
+          mime: "audio/ogg"
+        };
+      }
+      return {
+        ext: "ogx",
+        mime: "application/ogg"
+      };
+    }
+    if (check([80, 75]) && (buffer[2] === 3 || buffer[2] === 5 || buffer[2] === 7) && (buffer[3] === 4 || buffer[3] === 6 || buffer[3] === 8)) {
+      return {
+        ext: "zip",
+        mime: "application/zip"
+      };
+    }
+    if (checkString("ftyp", { offset: 4 }) && (buffer[8] & 96) !== 0) {
+      const brandMajor = buffer.toString("binary", 8, 12).replace("\x00", " ").trim();
+      switch (brandMajor) {
+        case "avif":
+          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 (checkString("MThd")) {
+      return {
+        ext: "mid",
+        mime: "audio/midi"
+      };
+    }
+    if (checkString("wOFF") && (check([0, 1, 0, 0], { offset: 4 }) || checkString("OTTO", { offset: 4 }))) {
+      return {
+        ext: "woff",
+        mime: "font/woff"
+      };
+    }
+    if (checkString("wOF2") && (check([0, 1, 0, 0], { offset: 4 }) || checkString("OTTO", { offset: 4 }))) {
+      return {
+        ext: "woff2",
+        mime: "font/woff2"
+      };
+    }
+    if (check([212, 195, 178, 161]) || check([161, 178, 195, 212])) {
+      return {
+        ext: "pcap",
+        mime: "application/vnd.tcpdump.pcap"
+      };
+    }
+    if (checkString("DSD ")) {
+      return {
+        ext: "dsf",
+        mime: "audio/x-dsf"
+      };
+    }
+    if (checkString("LZIP")) {
+      return {
+        ext: "lz",
+        mime: "application/x-lzip"
+      };
+    }
+    if (checkString("fLaC")) {
+      return {
+        ext: "flac",
+        mime: "audio/x-flac"
+      };
+    }
+    if (check([66, 80, 71, 251])) {
+      return {
+        ext: "bpg",
+        mime: "image/bpg"
+      };
+    }
+    if (checkString("wvpk")) {
+      return {
+        ext: "wv",
+        mime: "audio/wavpack"
+      };
+    }
+    if (checkString("%PDF")) {
+      await tokenizer.ignore(1350);
+      const maxBufferSize = 10 * 1024 * 1024;
+      const buffer2 = Buffer.alloc(Math.min(maxBufferSize, tokenizer.fileInfo.size));
+      await tokenizer.readBuffer(buffer2, { mayBeLess: true });
+      if (buffer2.includes(Buffer.from("AIPrivateData"))) {
+        return {
+          ext: "ai",
+          mime: "application/postscript"
+        };
+      }
+      return {
+        ext: "pdf",
+        mime: "application/pdf"
+      };
+    }
+    if (check([0, 97, 115, 109])) {
+      return {
+        ext: "wasm",
+        mime: "application/wasm"
+      };
+    }
+    if (check([73, 73, 42, 0])) {
+      if (checkString("CR", { offset: 8 })) {
+        return {
+          ext: "cr2",
+          mime: "image/x-canon-cr2"
+        };
+      }
+      if (check([28, 0, 254, 0], { offset: 8 }) || check([31, 0, 11, 0], { offset: 8 })) {
+        return {
+          ext: "nef",
+          mime: "image/x-nikon-nef"
+        };
+      }
+      if (check([8, 0, 0, 0], { offset: 4 }) && (check([45, 0, 254, 0], { offset: 8 }) || check([39, 0, 254, 0], { offset: 8 }))) {
+        return {
+          ext: "dng",
+          mime: "image/x-adobe-dng"
+        };
+      }
+      buffer = Buffer.alloc(24);
+      await tokenizer.peekBuffer(buffer);
+      if ((check([16, 251, 134, 1], { offset: 4 }) || check([8, 0, 0, 0], { offset: 4 })) && check([0, 254, 0, 4, 0, 1, 0, 0, 0, 1, 0, 0, 0, 3, 1], { offset: 9 })) {
+        return {
+          ext: "arw",
+          mime: "image/x-sony-arw"
+        };
+      }
+      return {
+        ext: "tif",
+        mime: "image/tiff"
+      };
+    }
+    if (check([77, 77, 0, 42])) {
+      return {
+        ext: "tif",
+        mime: "image/tiff"
+      };
+    }
+    if (checkString("MAC ")) {
+      return {
+        ext: "ape",
+        mime: "audio/ape"
+      };
+    }
+    if (check([26, 69, 223, 163])) {
+      async function readField() {
+        const msb = await tokenizer.peekNumber(Token.UINT8);
+        let mask = 128;
+        let ic = 0;
+        while ((msb & mask) === 0 && mask !== 0) {
+          ++ic;
+          mask >>= 1;
+        }
+        const id = Buffer.alloc(ic + 1);
+        await tokenizer.readBuffer(id);
+        return id;
+      }
+      async function readElement() {
+        const id = await readField();
+        const lenField = await readField();
+        lenField[0] ^= 128 >> lenField.length - 1;
+        const nrLen = Math.min(6, lenField.length);
+        return {
+          id: id.readUIntBE(0, id.length),
+          len: lenField.readUIntBE(lenField.length - nrLen, nrLen)
+        };
+      }
+      async function readChildren(level, children) {
+        while (children > 0) {
+          const e = await readElement();
+          if (e.id === 17026) {
+            return tokenizer.readToken(new Token.StringType(e.len, "utf-8"));
+          }
+          await tokenizer.ignore(e.len);
+          --children;
+        }
+      }
+      const re = await readElement();
+      const docType = await readChildren(1, re.len);
+      switch (docType) {
+        case "webm":
+          return {
+            ext: "webm",
+            mime: "video/webm"
+          };
+        case "matroska":
+          return {
+            ext: "mkv",
+            mime: "video/x-matroska"
+          };
+        default:
+          return;
+      }
+    }
+    if (check([82, 73, 70, 70])) {
+      if (check([65, 86, 73], { offset: 8 })) {
+        return {
+          ext: "avi",
+          mime: "video/vnd.avi"
+        };
+      }
+      if (check([87, 65, 86, 69], { offset: 8 })) {
+        return {
+          ext: "wav",
+          mime: "audio/vnd.wave"
+        };
+      }
+      if (check([81, 76, 67, 77], { offset: 8 })) {
+        return {
+          ext: "qcp",
+          mime: "audio/qcelp"
+        };
+      }
+    }
+    if (checkString("SQLi")) {
+      return {
+        ext: "sqlite",
+        mime: "application/x-sqlite3"
+      };
+    }
+    if (check([78, 69, 83, 26])) {
+      return {
+        ext: "nes",
+        mime: "application/x-nintendo-nes-rom"
+      };
+    }
+    if (checkString("Cr24")) {
+      return {
+        ext: "crx",
+        mime: "application/x-google-chrome-extension"
+      };
+    }
+    if (checkString("MSCF") || checkString("ISc(")) {
+      return {
+        ext: "cab",
+        mime: "application/vnd.ms-cab-compressed"
+      };
+    }
+    if (check([237, 171, 238, 219])) {
+      return {
+        ext: "rpm",
+        mime: "application/x-rpm"
+      };
+    }
+    if (check([197, 208, 211, 198])) {
+      return {
+        ext: "eps",
+        mime: "application/eps"
+      };
+    }
+    if (check([40, 181, 47, 253])) {
+      return {
+        ext: "zst",
+        mime: "application/zstd"
+      };
+    }
+    if (check([79, 84, 84, 79, 0])) {
+      return {
+        ext: "otf",
+        mime: "font/otf"
+      };
+    }
+    if (checkString("#!AMR")) {
+      return {
+        ext: "amr",
+        mime: "audio/amr"
+      };
+    }
+    if (checkString("{\\rtf")) {
+      return {
+        ext: "rtf",
+        mime: "application/rtf"
+      };
+    }
+    if (check([70, 76, 86, 1])) {
+      return {
+        ext: "flv",
+        mime: "video/x-flv"
+      };
+    }
+    if (checkString("IMPM")) {
+      return {
+        ext: "it",
+        mime: "audio/x-it"
+      };
+    }
+    if (checkString("-lh0-", { offset: 2 }) || checkString("-lh1-", { offset: 2 }) || checkString("-lh2-", { offset: 2 }) || checkString("-lh3-", { offset: 2 }) || checkString("-lh4-", { offset: 2 }) || checkString("-lh5-", { offset: 2 }) || checkString("-lh6-", { offset: 2 }) || checkString("-lh7-", { offset: 2 }) || checkString("-lzs-", { offset: 2 }) || checkString("-lz4-", { offset: 2 }) || checkString("-lz5-", { offset: 2 }) || checkString("-lhd-", { offset: 2 })) {
+      return {
+        ext: "lzh",
+        mime: "application/x-lzh-compressed"
+      };
+    }
+    if (check([0, 0, 1, 186])) {
+      if (check([33], { offset: 4, mask: [241] })) {
+        return {
+          ext: "mpg",
+          mime: "video/MP1S"
+        };
+      }
+      if (check([68], { offset: 4, mask: [196] })) {
+        return {
+          ext: "mpg",
+          mime: "video/MP2P"
+        };
+      }
+    }
+    if (checkString("ITSF")) {
+      return {
+        ext: "chm",
+        mime: "application/vnd.ms-htmlhelp"
+      };
+    }
+    if (check([253, 55, 122, 88, 90, 0])) {
+      return {
+        ext: "xz",
+        mime: "application/x-xz"
+      };
+    }
+    if (checkString("<?xml ")) {
+      return {
+        ext: "xml",
+        mime: "application/xml"
+      };
+    }
+    if (check([55, 122, 188, 175, 39, 28])) {
+      return {
+        ext: "7z",
+        mime: "application/x-7z-compressed"
+      };
+    }
+    if (check([82, 97, 114, 33, 26, 7]) && (buffer[6] === 0 || buffer[6] === 1)) {
+      return {
+        ext: "rar",
+        mime: "application/x-rar-compressed"
+      };
+    }
+    if (checkString("solid ")) {
+      return {
+        ext: "stl",
+        mime: "model/stl"
+      };
+    }
+    if (checkString("BLENDER")) {
+      return {
+        ext: "blend",
+        mime: "application/x-blender"
+      };
+    }
+    if (checkString("!<arch>")) {
+      await tokenizer.ignore(8);
+      const str = await tokenizer.readToken(new Token.StringType(13, "ascii"));
+      if (str === "debian-binary") {
+        return {
+          ext: "deb",
+          mime: "application/x-deb"
+        };
+      }
+      return {
+        ext: "ar",
+        mime: "application/x-unix-archive"
+      };
+    }
+    if (check([137, 80, 78, 71, 13, 10, 26, 10])) {
+      await tokenizer.ignore(8);
+      async function readChunkHeader() {
+        return {
+          length: await tokenizer.readToken(Token.INT32_BE),
+          type: await tokenizer.readToken(new Token.StringType(4, "binary"))
+        };
+      }
+      do {
+        const chunk = await readChunkHeader();
+        if (chunk.length < 0) {
+          return;
+        }
+        switch (chunk.type) {
+          case "IDAT":
+            return {
+              ext: "png",
+              mime: "image/png"
+            };
+          case "acTL":
+            return {
+              ext: "apng",
+              mime: "image/apng"
+            };
+          default:
+            await tokenizer.ignore(chunk.length + 4);
+        }
+      } while (tokenizer.position + 8 < tokenizer.fileInfo.size);
+      return {
+        ext: "png",
+        mime: "image/png"
+      };
+    }
+    if (check([65, 82, 82, 79, 87, 49, 0, 0])) {
+      return {
+        ext: "arrow",
+        mime: "application/x-apache-arrow"
+      };
+    }
+    if (check([103, 108, 84, 70, 2, 0, 0, 0])) {
+      return {
+        ext: "glb",
+        mime: "model/gltf-binary"
+      };
+    }
+    if (check([102, 114, 101, 101], { offset: 4 }) || check([109, 100, 97, 116], { offset: 4 }) || check([109, 111, 111, 118], { offset: 4 }) || check([119, 105, 100, 101], { offset: 4 })) {
+      return {
+        ext: "mov",
+        mime: "video/quicktime"
+      };
+    }
+    if (check([73, 73, 82, 79, 8, 0, 0, 0, 24])) {
+      return {
+        ext: "orf",
+        mime: "image/x-olympus-orf"
+      };
+    }
+    if (checkString("gimp xcf ")) {
+      return {
+        ext: "xcf",
+        mime: "image/x-xcf"
+      };
+    }
+    if (check([73, 73, 85, 0, 24, 0, 0, 0, 136, 231, 116, 216])) {
+      return {
+        ext: "rw2",
+        mime: "image/x-panasonic-rw2"
+      };
+    }
+    if (check([48, 38, 178, 117, 142, 102, 207, 17, 166, 217])) {
+      async function readHeader() {
+        const guid = Buffer.alloc(16);
+        await tokenizer.readBuffer(guid);
+        return {
+          id: guid,
+          size: Number(await tokenizer.readToken(Token.UINT64_LE))
+        };
+      }
+      await tokenizer.ignore(30);
+      while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
+        const header = await readHeader();
+        let payload = header.size - 24;
+        if (_check(header.id, [145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101])) {
+          const typeId = Buffer.alloc(16);
+          payload -= await tokenizer.readBuffer(typeId);
+          if (_check(typeId, [64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
+            return {
+              ext: "asf",
+              mime: "audio/x-ms-asf"
+            };
+          }
+          if (_check(typeId, [192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
+            return {
+              ext: "asf",
+              mime: "video/x-ms-asf"
+            };
+          }
+          break;
+        }
+        await tokenizer.ignore(payload);
+      }
+      return {
+        ext: "asf",
+        mime: "application/vnd.ms-asf"
+      };
+    }
+    if (check([171, 75, 84, 88, 32, 49, 49, 187, 13, 10, 26, 10])) {
+      return {
+        ext: "ktx",
+        mime: "image/ktx"
+      };
+    }
+    if ((check([126, 16, 4]) || check([126, 24, 4])) && check([48, 77, 73, 69], { offset: 4 })) {
+      return {
+        ext: "mie",
+        mime: "application/x-mie"
+      };
+    }
+    if (check([39, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], { offset: 2 })) {
+      return {
+        ext: "shp",
+        mime: "application/x-esri-shape"
+      };
+    }
+    if (check([0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10])) {
+      await tokenizer.ignore(20);
+      const type = await tokenizer.readToken(new Token.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 (check([255, 10]) || check([0, 0, 0, 12, 74, 88, 76, 32, 13, 10, 135, 10])) {
+      return {
+        ext: "jxl",
+        mime: "image/jxl"
+      };
+    }
+    if (check([0, 0, 1, 186]) || check([0, 0, 1, 179])) {
+      return {
+        ext: "mpg",
+        mime: "video/mpeg"
+      };
+    }
+    if (check([0, 1, 0, 0, 0])) {
+      return {
+        ext: "ttf",
+        mime: "font/ttf"
+      };
+    }
+    if (check([0, 0, 1, 0])) {
+      return {
+        ext: "ico",
+        mime: "image/x-icon"
+      };
+    }
+    if (check([0, 0, 2, 0])) {
+      return {
+        ext: "cur",
+        mime: "image/x-icon"
+      };
+    }
+    if (check([208, 207, 17, 224, 161, 177, 26, 225])) {
+      return {
+        ext: "cfb",
+        mime: "application/x-cfb"
+      };
+    }
+    await tokenizer.peekBuffer(buffer, { length: Math.min(256, tokenizer.fileInfo.size), mayBeLess: true });
+    if (checkString("BEGIN:")) {
+      if (checkString("VCARD", { offset: 6 })) {
+        return {
+          ext: "vcf",
+          mime: "text/vcard"
+        };
+      }
+      if (checkString("VCALENDAR", { offset: 6 })) {
+        return {
+          ext: "ics",
+          mime: "text/calendar"
+        };
+      }
+    }
+    if (checkString("FUJIFILMCCD-RAW")) {
+      return {
+        ext: "raf",
+        mime: "image/x-fujifilm-raf"
+      };
+    }
+    if (checkString("Extended Module:")) {
+      return {
+        ext: "xm",
+        mime: "audio/x-xm"
+      };
+    }
+    if (checkString("Creative Voice File")) {
+      return {
+        ext: "voc",
+        mime: "audio/x-voc"
+      };
+    }
+    if (check([4, 0, 0, 0]) && buffer.length >= 16) {
+      const jsonSize = buffer.readUInt32LE(12);
+      if (jsonSize > 12 && buffer.length >= jsonSize + 16) {
+        try {
+          const header = buffer.slice(16, jsonSize + 16).toString();
+          const json = JSON.parse(header);
+          if (json.files) {
+            return {
+              ext: "asar",
+              mime: "application/x-asar"
+            };
+          }
+        } catch (_) {}
+      }
+    }
+    if (check([6, 14, 43, 52, 2, 5, 1, 1, 13, 1, 2, 1, 1, 2])) {
+      return {
+        ext: "mxf",
+        mime: "application/mxf"
+      };
+    }
+    if (checkString("SCRM", { offset: 44 })) {
+      return {
+        ext: "s3m",
+        mime: "audio/x-s3m"
+      };
+    }
+    if (check([71], { offset: 4 }) && (check([71], { offset: 192 }) || check([71], { offset: 196 }))) {
+      return {
+        ext: "mts",
+        mime: "video/mp2t"
+      };
+    }
+    if (check([66, 79, 79, 75, 77, 79, 66, 73], { offset: 60 })) {
+      return {
+        ext: "mobi",
+        mime: "application/x-mobipocket-ebook"
+      };
+    }
+    if (check([68, 73, 67, 77], { offset: 128 })) {
+      return {
+        ext: "dcm",
+        mime: "application/dicom"
+      };
+    }
+    if (check([76, 0, 0, 0, 1, 20, 2, 0, 0, 0, 0, 0, 192, 0, 0, 0, 0, 0, 0, 70])) {
+      return {
+        ext: "lnk",
+        mime: "application/x.ms.shortcut"
+      };
+    }
+    if (check([98, 111, 111, 107, 0, 0, 0, 0, 109, 97, 114, 107, 0, 0, 0, 0])) {
+      return {
+        ext: "alias",
+        mime: "application/x.apple.alias"
+      };
+    }
+    if (check([76, 80], { offset: 34 }) && (check([0, 0, 1], { offset: 8 }) || check([1, 0, 2], { offset: 8 }) || check([2, 0, 2], { offset: 8 }))) {
+      return {
+        ext: "eot",
+        mime: "application/vnd.ms-fontobject"
+      };
+    }
+    if (check([6, 6, 237, 245, 216, 29, 70, 229, 189, 49, 239, 231, 254, 116, 183, 29])) {
+      return {
+        ext: "indd",
+        mime: "application/x-indesign"
+      };
+    }
+    await tokenizer.peekBuffer(buffer, { length: Math.min(512, tokenizer.fileInfo.size), mayBeLess: true });
+    if (tarHeaderChecksumMatches(buffer)) {
+      return {
+        ext: "tar",
+        mime: "application/x-tar"
+      };
+    }
+    if (check([255, 254, 255, 14, 83, 0, 107, 0, 101, 0, 116, 0, 99, 0, 104, 0, 85, 0, 112, 0, 32, 0, 77, 0, 111, 0, 100, 0, 101, 0, 108, 0])) {
+      return {
+        ext: "skp",
+        mime: "application/vnd.sketchup.skp"
+      };
+    }
+    if (checkString("-----BEGIN PGP MESSAGE-----")) {
+      return {
+        ext: "pgp",
+        mime: "application/pgp-encrypted"
+      };
+    }
+    if (buffer.length >= 2 && check([255, 224], { offset: 0, mask: [255, 224] })) {
+      if (check([16], { offset: 1, mask: [22] })) {
+        if (check([8], { offset: 1, mask: [8] })) {
+          return {
+            ext: "aac",
+            mime: "audio/aac"
+          };
+        }
+        return {
+          ext: "aac",
+          mime: "audio/aac"
+        };
+      }
+      if (check([2], { offset: 1, mask: [6] })) {
+        return {
+          ext: "mp3",
+          mime: "audio/mpeg"
+        };
+      }
+      if (check([4], { offset: 1, mask: [6] })) {
+        return {
+          ext: "mp2",
+          mime: "audio/mpeg"
+        };
+      }
+      if (check([6], { offset: 1, mask: [6] })) {
+        return {
+          ext: "mp1",
+          mime: "audio/mpeg"
+        };
+      }
+    }
+  }
+  var stream2 = (readableStream) => new Promise((resolve, reject) => {
+    const stream = eval("require")("stream");
+    readableStream.on("error", reject);
+    readableStream.once("readable", async () => {
+      const pass = new stream.PassThrough;
+      let outputStream;
+      if (stream.pipeline) {
+        outputStream = stream.pipeline(readableStream, pass, () => {});
+      } else {
+        outputStream = readableStream.pipe(pass);
+      }
+      const chunk = readableStream.read(minimumBytes) || readableStream.read() || Buffer.alloc(0);
+      try {
+        const fileType2 = await fromBuffer(chunk);
+        pass.fileType = fileType2;
+      } catch (error) {
+        reject(error);
+      }
+      resolve(outputStream);
+    });
+  });
+  var fileType = {
+    fromStream,
+    fromTokenizer,
+    fromBuffer,
+    stream: stream2
+  };
+  Object.defineProperty(fileType, "extensions", {
+    get() {
+      return new Set(supported.extensions);
+    }
+  });
+  Object.defineProperty(fileType, "mimeTypes", {
+    get() {
+      return new Set(supported.mimeTypes);
+    }
+  });
+  module.exports = fileType;
+});
+
+// node_modules/file-type/index.js
+var require_file_type = __commonJS((exports, module) => {
+  var strtok3 = require_lib2();
+  var core = require_core2();
+  async function fromFile(path) {
+    const tokenizer = await strtok3.fromFile(path);
+    try {
+      return await core.fromTokenizer(tokenizer);
+    } finally {
+      await tokenizer.close();
+    }
+  }
+  var fileType = {
+    fromFile
+  };
+  Object.assign(fileType, core);
+  Object.defineProperty(fileType, "extensions", {
+    get() {
+      return core.extensions;
+    }
+  });
+  Object.defineProperty(fileType, "mimeTypes", {
+    get() {
+      return core.mimeTypes;
+    }
+  });
+  module.exports = fileType;
+});
+export default require_file_type();
+
+//# debugId=6AA92663F11DE46064756E2164756E21
+//# sourceMappingURL=index-5xngv42g.js.map