@agentdocumentformat/cli 0.7.2

package/dist/chunks/lib-N7FCZWKH.mjs

@@ -0,0 +1,4038 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import "./chunk-2DIECGFL.mjs";
+import {
+  TrackType,
+  TrackTypeValueToKeyMap
+} from "./chunk-EWL5FG4I.mjs";
+import {
+  hasID3v1Header
+} from "./chunk-VAUOM3IN.mjs";
+import {
+  LyricsContentType,
+  TimestampFormat
+} from "./chunk-DXWDD5XJ.mjs";
+import {
+  APEv2Parser
+} from "./chunk-NBTUWMGP.mjs";
+import {
+  decodeString,
+  getUintBE,
+  toRatio
+} from "./chunk-XX7OSWTO.mjs";
+import {
+  EndOfStreamError,
+  fromBlob,
+  fromBuffer,
+  fromFile,
+  fromStream,
+  fromWebStream
+} from "./chunk-HBUENVQL.mjs";
+import {
+  CouldNotDetermineFileTypeError,
+  FieldDecodingError,
+  INT32_BE,
+  InternalParserError,
+  StringType,
+  UINT16_BE,
+  UINT16_LE,
+  UINT32_BE,
+  UINT32_LE,
+  UINT64_LE,
+  UINT8,
+  UnsupportedFileTypeError,
+  makeParseError,
+  makeUnexpectedFileContentError,
+  textDecode
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import "./chunk-NZ7JTHEO.mjs";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/node_modules/content-type/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/music-metadata/node_modules/content-type/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.format = format;
+    exports.parse = parse2;
+    var TEXT_REGEXP = /^[\u0009\u0020-\u007e\u0080-\u00ff]*$/, TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/, QUOTE_REGEXP = /[\\"]/g, TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/, NullObject = /* @__PURE__ */ (() => {
+      let C = function() {
+      };
+      return C.prototype = /* @__PURE__ */ Object.create(null), C;
+    })();
+    function format(obj) {
+      let { type, parameters } = obj;
+      if (!type || !TYPE_REGEXP.test(type))
+        throw new TypeError(`Invalid type: ${type}`);
+      let result = type;
+      if (parameters)
+        for (let param of Object.keys(parameters)) {
+          if (!TOKEN_REGEXP.test(param))
+            throw new TypeError(`Invalid parameter name: ${param}`);
+          result += `; ${param}=${qstring(parameters[param])}`;
+        }
+      return result;
+    }
+    function parse2(header, options) {
+      let len = header.length, index = skipOWS(header, 0, len), valueStart = index;
+      index = skipValue(header, index, len);
+      let valueEnd = trailingOWS(header, valueStart, index), type = header.slice(valueStart, valueEnd).toLowerCase(), parameters = options?.parameters === !1 ? new NullObject() : parseParameters(header, index, len);
+      return { type, parameters };
+    }
+    var SP = 32, HTAB = 9, SEMI = 59, EQ = 61, DQUOTE = 34, BSLASH = 92;
+    function parseParameters(header, index, len) {
+      let parameters = new NullObject();
+      parameter: for (; index < len; ) {
+        index = skipOWS(header, index + 1, len);
+        let keyStart = index;
+        for (; index < len; ) {
+          let code = header.charCodeAt(index);
+          if (code === SEMI)
+            continue parameter;
+          if (code === EQ) {
+            let keyEnd = trailingOWS(header, keyStart, index), key = header.slice(keyStart, keyEnd).toLowerCase();
+            if (index = skipOWS(header, index + 1, len), index < len && header.charCodeAt(index) === DQUOTE) {
+              index++;
+              let value = "";
+              for (; index < len; ) {
+                let code2 = header.charCodeAt(index++);
+                if (code2 === DQUOTE) {
+                  index = skipValue(header, index, len), parameters[key] === void 0 && (parameters[key] = value);
+                  break;
+                }
+                if (code2 === BSLASH && index < len) {
+                  value += header[index++];
+                  continue;
+                }
+                value += String.fromCharCode(code2);
+              }
+              continue parameter;
+            }
+            let valueStart = index;
+            if (index = skipValue(header, index, len), parameters[key] === void 0) {
+              let valueEnd = trailingOWS(header, valueStart, index);
+              parameters[key] = header.slice(valueStart, valueEnd);
+            }
+            continue parameter;
+          }
+          index++;
+        }
+      }
+      return parameters;
+    }
+    function skipValue(str, index, len) {
+      for (; index < len && str.charCodeAt(index) !== SEMI; )
+        index++;
+      return index;
+    }
+    function skipOWS(header, index, len) {
+      for (; index < len; ) {
+        let char = header.charCodeAt(index);
+        if (char !== SP && char !== HTAB)
+          break;
+        index++;
+      }
+      return index;
+    }
+    function trailingOWS(header, start, end) {
+      for (; end > start; ) {
+        let char = header.charCodeAt(end - 1);
+        if (char !== SP && char !== HTAB)
+          break;
+        end--;
+      }
+      return end;
+    }
+    function qstring(str) {
+      if (TOKEN_REGEXP.test(str))
+        return str;
+      if (TEXT_REGEXP.test(str))
+        return `"${str.replace(QUOTE_REGEXP, "\\$&")}"`;
+      throw new TypeError(`Invalid parameter value: ${str}`);
+    }
+  }
+});
+
+// node_modules/music-metadata/lib/index.js
+var import_debug4 = __toESM(require_src(), 1);
+
+// node_modules/@tokenizer/inflate/lib/ZipHandler.js
+var import_debug = __toESM(require_src(), 1);
+
+// node_modules/@tokenizer/inflate/lib/ZipToken.js
+var 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) {
+    let 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) {
+    let 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/@tokenizer/inflate/lib/ZipHandler.js
+function signatureToArray(signature) {
+  let signatureBytes = new Uint8Array(UINT32_LE.len);
+  return UINT32_LE.put(signatureBytes, 0, signature), signatureBytes;
+}
+var 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() {
+    let randomReadTokenizer = this.tokenizer, chunkLength = Math.min(16 * 1024, randomReadTokenizer.fileInfo.size), 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...");
+    let pos = this.tokenizer.position, offset = await this.findEndOfCentralDirectoryLocator();
+    if (offset > 0) {
+      debug("Central-directory 32-bit signature found");
+      let eocdHeader = await this.tokenizer.readToken(EndOfCentralDirectoryRecordToken, offset), files = [];
+      this.tokenizer.setPosition(eocdHeader.offsetOfStartOfCd);
+      for (let n = 0; n < eocdHeader.nrOfEntriesOfSize; ++n) {
+        let 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}`);
+      }
+      return this.tokenizer.setPosition(pos), files;
+    }
+    this.tokenizer.setPosition(pos);
+  }
+  async unzip(fileCb) {
+    let entries = await this.readCentralDirectory();
+    if (entries)
+      return this.iterateOverCentralDirectory(entries, fileCb);
+    let stop = !1;
+    do {
+      let zipHeader = await this.readLocalFileHeader();
+      if (!zipHeader)
+        break;
+      let next = fileCb(zipHeader);
+      stop = !!next.stop;
+      let fileData;
+      if (await this.tokenizer.ignore(zipHeader.extraFieldLength), zipHeader.dataDescriptor && zipHeader.compressedSize === 0) {
+        let chunks = [], len = syncBufferSize;
+        debug("Compressed-file-size unknown, scanning for next data-descriptor-signature....");
+        let nextHeaderIndex = -1;
+        for (; nextHeaderIndex < 0 && len === syncBufferSize; ) {
+          len = await this.tokenizer.peekBuffer(this.syncBuffer, { mayBeLess: !0 }), nextHeaderIndex = indexOf(this.syncBuffer.subarray(0, len), ddSignatureArray);
+          let size = nextHeaderIndex >= 0 ? nextHeaderIndex : len;
+          if (next.handler) {
+            let 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}`), next.handler && await this.inflate(zipHeader, mergeArrays(chunks), next.handler);
+      } else
+        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)) : (debug(`Ignoring compressed-file-data: ${zipHeader.compressedSize} bytes`), await this.tokenizer.ignore(zipHeader.compressedSize));
+      if (debug(`Reading data-descriptor at pos=${this.tokenizer.position}`), zipHeader.dataDescriptor && (await this.tokenizer.readToken(DataDescriptor)).signature !== 134695760)
+        throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - DataDescriptor.len}`);
+    } while (!stop);
+  }
+  async iterateOverCentralDirectory(entries, fileCb) {
+    for (let fileHeader of entries) {
+      let next = fileCb(fileHeader);
+      if (next.handler) {
+        this.tokenizer.setPosition(fileHeader.relativeOffsetOfLocalHeader);
+        let zipHeader = await this.readLocalFileHeader();
+        if (zipHeader) {
+          await this.tokenizer.ignore(zipHeader.extraFieldLength);
+          let 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}`);
+    let uncompressedData = await _ZipHandler.decompressDeflateRaw(fileData);
+    return cb(uncompressedData);
+  }
+  static async decompressDeflateRaw(data) {
+    let input = new ReadableStream({
+      start(controller) {
+        controller.enqueue(data), controller.close();
+      }
+    }), ds = new DecompressionStream("deflate-raw"), output = input.pipeThrough(ds);
+    try {
+      let buffer = await new Response(output).arrayBuffer();
+      return new Uint8Array(buffer);
+    } catch (err) {
+      let message = err instanceof Error ? `Failed to deflate ZIP entry: ${err.message}` : "Unknown decompression error in ZIP entry";
+      throw new TypeError(message);
+    }
+  }
+  async readLocalFileHeader() {
+    let signature = await this.tokenizer.peekToken(UINT32_LE);
+    if (signature === Signature.LocalFileHeader) {
+      let header = await this.tokenizer.readToken(LocalFileHeaderToken);
+      return header.filename = await this.tokenizer.readToken(new StringType(header.filenameLength, "utf-8")), header;
+    }
+    if (signature === Signature.CentralFileHeader)
+      return !1;
+    throw signature === 3759263696 ? new Error("Encrypted ZIP") : new Error("Unexpected signature");
+  }
+};
+function indexOf(buffer, portion) {
+  let bufferLength = buffer.length, portionLength = portion.length;
+  if (portionLength > bufferLength)
+    return -1;
+  for (let i = 0; i <= bufferLength - portionLength; i++) {
+    let found = !0;
+    for (let j = 0; j < portionLength; j++)
+      if (buffer[i + j] !== portion[j]) {
+        found = !1;
+        break;
+      }
+    if (found)
+      return i;
+  }
+  return -1;
+}
+function mergeArrays(chunks) {
+  let totalLength = chunks.reduce((acc, curr) => acc + curr.length, 0), mergedArray = new Uint8Array(totalLength), offset = 0;
+  for (let chunk of chunks)
+    mergedArray.set(chunk, offset), offset += chunk.length;
+  return mergedArray;
+}
+
+// node_modules/@tokenizer/inflate/lib/GzipHandler.js
+var GzipHandler = class {
+  constructor(tokenizer) {
+    this.tokenizer = tokenizer;
+  }
+  inflate() {
+    let tokenizer = this.tokenizer;
+    return new ReadableStream({
+      async pull(controller) {
+        let buffer = new Uint8Array(1024), size = await tokenizer.readBuffer(buffer, { mayBeLess: !0 });
+        if (size === 0) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(buffer.subarray(0, size));
+      }
+    }).pipeThrough(new DecompressionStream("gzip"));
+  }
+};
+
+// node_modules/file-type/util.js
+function stringToBytes(string, encoding) {
+  if (encoding === "utf-16le") {
+    let bytes = [];
+    for (let index = 0; index < string.length; index++) {
+      let code = string.charCodeAt(index);
+      bytes.push(code & 255, code >> 8 & 255);
+    }
+    return bytes;
+  }
+  if (encoding === "utf-16be") {
+    let bytes = [];
+    for (let index = 0; index < string.length; index++) {
+      let 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) {
+  let readSum = Number.parseInt(new StringType(6).get(arrayBuffer, 148).replace(/\0.*$/, "").trim(), 8);
+  if (Number.isNaN(readSum))
+    return !1;
+  let sum = 256;
+  for (let index = offset; index < offset + 148; index++)
+    sum += arrayBuffer[index];
+  for (let index = offset + 156; index < offset + 512; index++)
+    sum += arrayBuffer[index];
+  return readSum === sum;
+}
+var uint32SyncSafeToken = {
+  get: (buffer, offset) => buffer[offset + 3] & 127 | buffer[offset + 2] << 7 | buffer[offset + 1] << 14 | buffer[offset] << 21,
+  len: 4
+};
+
+// node_modules/file-type/supported.js
+var 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"
+], 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/x-lzip",
+  "application/x-cfb",
+  "application/x-mie",
+  "application/mxf",
+  "video/mp2t",
+  "application/x-blender",
+  "image/bpg",
+  "image/j2c",
+  "image/jp2",
+  "image/jpx",
+  "image/jpm",
+  "image/mj2",
+  "audio/aiff",
+  "application/xml",
+  "application/x-mobipocket-ebook",
+  "image/heif",
+  "image/heif-sequence",
+  "image/heic",
+  "image/heic-sequence",
+  "image/icns",
+  "image/ktx",
+  "application/dicom",
+  "audio/x-musepack",
+  "text/calendar",
+  "text/vcard",
+  "text/vtt",
+  "model/gltf-binary",
+  "application/vnd.tcpdump.pcap",
+  "audio/x-dsf",
+  // Non-standard
+  "application/x.ms.shortcut",
+  // Invented by us
+  "application/x.apple.alias",
+  // Invented by us
+  "audio/x-voc",
+  "audio/vnd.dolby.dd-raw",
+  "audio/x-m4a",
+  "image/apng",
+  "image/x-olympus-orf",
+  "image/x-sony-arw",
+  "image/x-adobe-dng",
+  "image/x-nikon-nef",
+  "image/x-panasonic-rw2",
+  "image/x-fujifilm-raf",
+  "video/x-m4v",
+  "video/3gpp2",
+  "application/x-esri-shape",
+  "audio/aac",
+  "audio/x-it",
+  "audio/x-s3m",
+  "audio/x-xm",
+  "video/MP1S",
+  "video/MP2P",
+  "application/vnd.sketchup.skp",
+  "image/avif",
+  "application/x-lzh-compressed",
+  "application/pgp-encrypted",
+  "application/x-asar",
+  "model/stl",
+  "application/vnd.ms-htmlhelp",
+  "model/3mf",
+  "image/jxl",
+  "application/zstd",
+  "image/jls",
+  "application/vnd.ms-outlook",
+  "image/vnd.dwg",
+  "application/vnd.apache.parquet",
+  "application/java-vm",
+  "application/x-arj",
+  "application/x-cpio",
+  "application/x-ace-compressed",
+  "application/avro",
+  "application/vnd.iccprofile",
+  "application/x.autodesk.fbx",
+  // Invented by us
+  "application/vnd.visio",
+  "application/vnd.android.package-archive",
+  "application/vnd.google.draco",
+  // Invented by us
+  "application/x-lz4",
+  // Invented by us
+  "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"
+];
+
+// node_modules/file-type/core.js
+var reasonableDetectionSizeInBytes = 4100, maximumMpegOffsetTolerance = reasonableDetectionSizeInBytes - 2, maximumZipEntrySizeInBytes = 1024 * 1024, maximumZipEntryCount = 1024, maximumZipBufferedReadSizeInBytes = 2 ** 31 - 1, maximumUntrustedSkipSizeInBytes = 16 * 1024 * 1024, maximumUnknownSizePayloadProbeSizeInBytes = maximumZipEntrySizeInBytes, maximumZipTextEntrySizeInBytes = maximumZipEntrySizeInBytes, maximumNestedGzipDetectionSizeInBytes = maximumUntrustedSkipSizeInBytes, maximumNestedGzipProbeDepth = 1, unknownSizeGzipProbeTimeoutInMilliseconds = 100, maximumId3HeaderSizeInBytes = maximumUntrustedSkipSizeInBytes, maximumEbmlDocumentTypeSizeInBytes = 64, maximumEbmlElementPayloadSizeInBytes = maximumUnknownSizePayloadProbeSizeInBytes, maximumEbmlElementCount = 256, maximumPngChunkCount = 512, maximumPngStreamScanBudgetInBytes = maximumUntrustedSkipSizeInBytes, maximumAsfHeaderObjectCount = 512, maximumTiffTagCount = 512, maximumDetectionReentryCount = 256, maximumPngChunkSizeInBytes = maximumUnknownSizePayloadProbeSizeInBytes, maximumAsfHeaderPayloadSizeInBytes = maximumUnknownSizePayloadProbeSizeInBytes, maximumTiffStreamIfdOffsetInBytes = maximumUnknownSizePayloadProbeSizeInBytes, maximumTiffIfdOffsetInBytes = maximumUntrustedSkipSizeInBytes, 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"
+]), ParserHardLimitError = class extends Error {
+};
+function patchWebByobTokenizerClose(tokenizer) {
+  let streamReader = tokenizer?.streamReader;
+  if (streamReader?.constructor?.name !== "WebStreamByobReader")
+    return tokenizer;
+  let { reader } = streamReader, cancelAndRelease = async () => {
+    await reader.cancel(), reader.releaseLock();
+  };
+  return streamReader.close = cancelAndRelease, streamReader.abort = async () => {
+    streamReader.interrupted = !0, await cancelAndRelease();
+  }, tokenizer;
+}
+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" } = {}) {
+  let safeLength = getSafeBound(length, maximumLength, reason);
+  await tokenizer.ignore(safeLength);
+}
+async function safeReadBuffer(tokenizer, buffer, options, { maximumLength = buffer.length, reason = "read" } = {}) {
+  let length = options?.length ?? buffer.length, safeLength = getSafeBound(length, maximumLength, reason);
+  return tokenizer.readBuffer(buffer, {
+    ...options,
+    length: safeLength
+  });
+}
+async function decompressDeflateRawWithLimit(data, { maximumLength = maximumZipEntrySizeInBytes } = {}) {
+  let reader = new ReadableStream({
+    start(controller) {
+      controller.enqueue(data), controller.close();
+    }
+  }).pipeThrough(new DecompressionStream("deflate-raw")).getReader(), chunks = [], totalLength = 0;
+  try {
+    for (; ; ) {
+      let { done, value } = await reader.read();
+      if (done)
+        break;
+      if (totalLength += value.length, totalLength > maximumLength)
+        throw await reader.cancel(), new Error(`ZIP entry decompressed data exceeds ${maximumLength} bytes`);
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  let uncompressedData = new Uint8Array(totalLength), offset = 0;
+  for (let chunk of chunks)
+    uncompressedData.set(chunk, offset), offset += chunk.length;
+  return uncompressedData;
+}
+var zipDataDescriptorSignature = 134695760, zipDataDescriptorLengthInBytes = 16, zipDataDescriptorOverlapLengthInBytes = zipDataDescriptorLengthInBytes - 1;
+function findZipDataDescriptorOffset(buffer, bytesConsumed) {
+  if (buffer.length < zipDataDescriptorLengthInBytes)
+    return -1;
+  let lastPossibleDescriptorOffset = buffer.length - zipDataDescriptorLengthInBytes;
+  for (let index = 0; index <= lastPossibleDescriptorOffset; index++)
+    if (UINT32_LE.get(buffer, index) === zipDataDescriptorSignature && UINT32_LE.get(buffer, index + 8) === bytesConsumed + index)
+      return index;
+  return -1;
+}
+function isPngAncillaryChunk(type) {
+  return (type.codePointAt(0) & 32) !== 0;
+}
+function mergeByteChunks(chunks, totalLength) {
+  let merged = new Uint8Array(totalLength), offset = 0;
+  for (let chunk of chunks)
+    merged.set(chunk, offset), offset += chunk.length;
+  return merged;
+}
+async function readZipDataDescriptorEntryWithLimit(zipHandler, { shouldBuffer, maximumLength = maximumZipEntrySizeInBytes } = {}) {
+  let { syncBuffer } = zipHandler, { length: syncBufferLength } = syncBuffer, chunks = [], bytesConsumed = 0;
+  for (; ; ) {
+    let length = await zipHandler.tokenizer.peekBuffer(syncBuffer, { mayBeLess: !0 }), dataDescriptorOffset = findZipDataDescriptorOffset(syncBuffer.subarray(0, length), bytesConsumed), retainedLength = dataDescriptorOffset >= 0 ? 0 : length === syncBufferLength ? Math.min(zipDataDescriptorOverlapLengthInBytes, length - 1) : 0, chunkLength = dataDescriptorOffset >= 0 ? dataDescriptorOffset : length - retainedLength;
+    if (chunkLength === 0)
+      break;
+    if (bytesConsumed += chunkLength, bytesConsumed > maximumLength)
+      throw new Error(`ZIP entry compressed data exceeds ${maximumLength} bytes`);
+    if (shouldBuffer) {
+      let 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), !!shouldBuffer)
+    return mergeByteChunks(chunks, bytesConsumed);
+}
+function getRemainingZipScanBudget(zipHandler, startOffset) {
+  return hasUnknownFileSize(zipHandler.tokenizer) ? Math.max(0, maximumUntrustedSkipSizeInBytes - (zipHandler.tokenizer.position - startOffset)) : 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;
+  }
+  let 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`);
+  let fileData = new Uint8Array(zipHeader.compressedSize);
+  return await zipHandler.tokenizer.readBuffer(fileData), fileData;
+}
+ZipHandler.prototype.inflate = async function(zipHeader, fileData, callback) {
+  if (zipHeader.compressedMethod === 0)
+    return callback(fileData);
+  if (zipHeader.compressedMethod !== 8)
+    throw new Error(`Unsupported ZIP compression method: ${zipHeader.compressedMethod}`);
+  let uncompressedData = await decompressDeflateRawWithLimit(fileData, { maximumLength: maximumZipEntrySizeInBytes });
+  return callback(uncompressedData);
+};
+ZipHandler.prototype.unzip = async function(fileCallback) {
+  let stop = !1, zipEntryCount = 0, zipScanStart = this.tokenizer.position;
+  this.knownSizeDescriptorScannedBytes = 0;
+  do {
+    if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, maximumUntrustedSkipSizeInBytes))
+      throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
+    let zipHeader = await this.readLocalFileHeader();
+    if (!zipHeader)
+      break;
+    if (zipEntryCount++, zipEntryCount > maximumZipEntryCount)
+      throw new Error(`ZIP entry count exceeds ${maximumZipEntryCount}`);
+    let next = fileCallback(zipHeader);
+    stop = !!next.stop, await this.tokenizer.ignore(zipHeader.extraFieldLength);
+    let fileData = await readZipEntryData(this, zipHeader, {
+      shouldBuffer: !!next.handler,
+      maximumDescriptorLength: Math.min(maximumZipEntrySizeInBytes, getRemainingZipScanBudget(this, zipScanStart))
+    });
+    if (next.handler && await this.inflate(zipHeader, fileData, next.handler), zipHeader.dataDescriptor) {
+      let dataDescriptor = new Uint8Array(zipDataDescriptorLengthInBytes);
+      if (await this.tokenizer.readBuffer(dataDescriptor), 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);
+};
+function createByteLimitedReadableStream(stream, maximumBytes) {
+  let reader = stream.getReader(), emittedBytes = 0, sourceDone = !1, sourceCanceled = !1, cancelSource = async (reason) => {
+    sourceDone || sourceCanceled || (sourceCanceled = !0, await reader.cancel(reason));
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      if (emittedBytes >= maximumBytes) {
+        controller.close(), await cancelSource();
+        return;
+      }
+      let { done, value } = await reader.read();
+      if (done || !value) {
+        sourceDone = !0, controller.close();
+        return;
+      }
+      let 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 fileTypeFromBuffer(input, options) {
+  return new FileTypeParser(options).fromBuffer(input);
+}
+function getFileTypeFromMimeType(mimeType) {
+  switch (mimeType = mimeType.toLowerCase(), mimeType) {
+    case "application/epub+zip":
+      return {
+        ext: "epub",
+        mime: mimeType
+      };
+    case "application/vnd.oasis.opendocument.text":
+      return {
+        ext: "odt",
+        mime: mimeType
+      };
+    case "application/vnd.oasis.opendocument.text-template":
+      return {
+        ext: "ott",
+        mime: mimeType
+      };
+    case "application/vnd.oasis.opendocument.spreadsheet":
+      return {
+        ext: "ods",
+        mime: mimeType
+      };
+    case "application/vnd.oasis.opendocument.spreadsheet-template":
+      return {
+        ext: "ots",
+        mime: mimeType
+      };
+    case "application/vnd.oasis.opendocument.presentation":
+      return {
+        ext: "odp",
+        mime: mimeType
+      };
+    case "application/vnd.oasis.opendocument.presentation-template":
+      return {
+        ext: "otp",
+        mime: mimeType
+      };
+    case "application/vnd.oasis.opendocument.graphics":
+      return {
+        ext: "odg",
+        mime: mimeType
+      };
+    case "application/vnd.oasis.opendocument.graphics-template":
+      return {
+        ext: "otg",
+        mime: mimeType
+      };
+    case "application/vnd.openxmlformats-officedocument.presentationml.slideshow":
+      return {
+        ext: "ppsx",
+        mime: mimeType
+      };
+    case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+      return {
+        ext: "xlsx",
+        mime: mimeType
+      };
+    case "application/vnd.ms-excel.sheet.macroenabled":
+      return {
+        ext: "xlsm",
+        mime: "application/vnd.ms-excel.sheet.macroenabled.12"
+      };
+    case "application/vnd.openxmlformats-officedocument.spreadsheetml.template":
+      return {
+        ext: "xltx",
+        mime: mimeType
+      };
+    case "application/vnd.ms-excel.template.macroenabled":
+      return {
+        ext: "xltm",
+        mime: "application/vnd.ms-excel.template.macroenabled.12"
+      };
+    case "application/vnd.ms-powerpoint.slideshow.macroenabled":
+      return {
+        ext: "ppsm",
+        mime: "application/vnd.ms-powerpoint.slideshow.macroenabled.12"
+      };
+    case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+      return {
+        ext: "docx",
+        mime: mimeType
+      };
+    case "application/vnd.ms-word.document.macroenabled":
+      return {
+        ext: "docm",
+        mime: "application/vnd.ms-word.document.macroenabled.12"
+      };
+    case "application/vnd.openxmlformats-officedocument.wordprocessingml.template":
+      return {
+        ext: "dotx",
+        mime: mimeType
+      };
+    case "application/vnd.ms-word.template.macroenabledtemplate":
+      return {
+        ext: "dotm",
+        mime: "application/vnd.ms-word.template.macroenabled.12"
+      };
+    case "application/vnd.openxmlformats-officedocument.presentationml.template":
+      return {
+        ext: "potx",
+        mime: mimeType
+      };
+    case "application/vnd.ms-powerpoint.template.macroenabled":
+      return {
+        ext: "potm",
+        mime: "application/vnd.ms-powerpoint.template.macroenabled.12"
+      };
+    case "application/vnd.openxmlformats-officedocument.presentationml.presentation":
+      return {
+        ext: "pptx",
+        mime: mimeType
+      };
+    case "application/vnd.ms-powerpoint.presentation.macroenabled":
+      return {
+        ext: "pptm",
+        mime: "application/vnd.ms-powerpoint.presentation.macroenabled.12"
+      };
+    case "application/vnd.ms-visio.drawing":
+      return {
+        ext: "vsdx",
+        mime: "application/vnd.visio"
+      };
+    case "application/vnd.ms-package.3dmanufacturing-3dmodel+xml":
+      return {
+        ext: "3mf",
+        mime: "model/3mf"
+      };
+    default:
+  }
+}
+function _check(buffer, headers, options) {
+  options = {
+    offset: 0,
+    ...options
+  };
+  for (let [index, header] of headers.entries())
+    if (options.mask) {
+      if (header !== (options.mask[index] & buffer[index + options.offset]))
+        return !1;
+    } else if (header !== buffer[index + options.offset])
+      return !1;
+  return !0;
+}
+function normalizeSampleSize(sampleSize) {
+  return Number.isFinite(sampleSize) ? Math.max(1, Math.trunc(sampleSize)) : reasonableDetectionSizeInBytes;
+}
+function readByobReaderWithSignal(reader, buffer, signal) {
+  return signal === void 0 ? reader.read(buffer) : (signal.throwIfAborted(), new Promise((resolve, reject) => {
+    let cleanup = () => {
+      signal.removeEventListener("abort", onAbort);
+    }, onAbort = () => {
+      let abortReason = signal.reason;
+      cleanup(), (async () => {
+        try {
+          await reader.cancel(abortReason);
+        } catch {
+        }
+      })(), reject(abortReason);
+    };
+    signal.addEventListener("abort", onAbort, { once: !0 }), (async () => {
+      try {
+        let result = await reader.read(buffer);
+        cleanup(), resolve(result);
+      } catch (error) {
+        cleanup(), reject(error);
+      }
+    })();
+  }));
+}
+function normalizeMpegOffsetTolerance(mpegOffsetTolerance) {
+  return Number.isFinite(mpegOffsetTolerance) ? Math.max(0, Math.min(maximumMpegOffsetTolerance, Math.trunc(mpegOffsetTolerance))) : 0;
+}
+function getKnownFileSizeOrMaximum(fileSize) {
+  return Number.isFinite(fileSize) ? Math.max(0, fileSize) : Number.MAX_SAFE_INTEGER;
+}
+function hasUnknownFileSize(tokenizer) {
+  let fileSize = tokenizer.fileInfo.size;
+  return !Number.isFinite(fileSize) || fileSize === Number.MAX_SAFE_INTEGER;
+}
+function hasExceededUnknownSizeScanBudget(tokenizer, startOffset, maximumBytes) {
+  return hasUnknownFileSize(tokenizer) && tokenizer.position - startOffset > maximumBytes;
+}
+function getMaximumZipBufferedReadLength(tokenizer) {
+  let fileSize = tokenizer.fileInfo.size, 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 || error instanceof ParserHardLimitError)
+    return !0;
+  if (!(error instanceof Error))
+    return !1;
+  if (recoverableZipErrorMessages.has(error.message) || recoverableZipErrorCodes.has(error.code))
+    return !0;
+  for (let prefix of recoverableZipErrorMessagePrefixes)
+    if (error.message.startsWith(prefix))
+      return !0;
+  return !1;
+}
+function canReadZipEntryForDetection(zipHeader, maximumSize = maximumZipEntrySizeInBytes) {
+  let sizes = [zipHeader.compressedSize, zipHeader.uncompressedSize];
+  for (let size of sizes)
+    if (!Number.isFinite(size) || size < 0 || size > maximumSize)
+      return !1;
+  return !0;
+}
+function createOpenXmlZipDetectionState() {
+  return {
+    hasContentTypesEntry: !1,
+    hasParsedContentTypesEntry: !1,
+    isParsingContentTypes: !1,
+    hasUnparseableContentTypes: !1,
+    hasWordDirectory: !1,
+    hasPresentationDirectory: !1,
+    hasSpreadsheetDirectory: !1,
+    hasThreeDimensionalModelEntry: !1
+  };
+}
+function updateOpenXmlZipDetectionStateFromFilename(openXmlState, filename) {
+  filename.startsWith("word/") && (openXmlState.hasWordDirectory = !0), filename.startsWith("ppt/") && (openXmlState.hasPresentationDirectory = !0), filename.startsWith("xl/") && (openXmlState.hasSpreadsheetDirectory = !0), filename.startsWith("3D/") && filename.endsWith(".model") && (openXmlState.hasThreeDimensionalModelEntry = !0);
+}
+function getOpenXmlFileTypeFromZipEntries(openXmlState) {
+  if (!(!openXmlState.hasContentTypesEntry || openXmlState.hasUnparseableContentTypes || openXmlState.isParsingContentTypes || openXmlState.hasParsedContentTypesEntry)) {
+    if (openXmlState.hasWordDirectory)
+      return {
+        ext: "docx",
+        mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+      };
+    if (openXmlState.hasPresentationDirectory)
+      return {
+        ext: "pptx",
+        mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+      };
+    if (openXmlState.hasSpreadsheetDirectory)
+      return {
+        ext: "xlsx",
+        mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+      };
+    if (openXmlState.hasThreeDimensionalModelEntry)
+      return {
+        ext: "3mf",
+        mime: "model/3mf"
+      };
+  }
+}
+function getOpenXmlMimeTypeFromContentTypesXml(xmlContent) {
+  let endPosition = xmlContent.indexOf('.main+xml"');
+  if (endPosition === -1) {
+    let mimeType = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml";
+    return xmlContent.includes(`ContentType="${mimeType}"`) ? mimeType : void 0;
+  }
+  let truncatedContent = xmlContent.slice(0, endPosition), firstQuotePosition = truncatedContent.lastIndexOf('"');
+  return truncatedContent.slice(firstQuotePosition + 1);
+}
+var FileTypeParser = class _FileTypeParser {
+  constructor(options) {
+    let 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 patchWebByobTokenizerClose(fromWebStream(stream, this.getTokenizerOptions()));
+  }
+  async parseTokenizer(tokenizer, detectionReentryCount = 0) {
+    this.detectionReentryCount = detectionReentryCount;
+    let initialPosition = tokenizer.position;
+    for (let detector of this.detectors) {
+      let fileType;
+      try {
+        fileType = await detector.detect(tokenizer);
+      } catch (error) {
+        if (error instanceof EndOfStreamError || error instanceof ParserHardLimitError)
+          return;
+        throw error;
+      }
+      if (fileType)
+        return fileType;
+      if (initialPosition !== tokenizer.position)
+        return;
+    }
+  }
+  async fromTokenizer(tokenizer) {
+    try {
+      return await this.parseTokenizer(tokenizer);
+    } finally {
+      await tokenizer.close();
+    }
+  }
+  async fromBuffer(input) {
+    if (!(input instanceof Uint8Array || input instanceof ArrayBuffer))
+      throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof input}\``);
+    let buffer = input instanceof Uint8Array ? input : new Uint8Array(input);
+    if (buffer?.length > 1)
+      return this.fromTokenizer(fromBuffer(buffer, this.getTokenizerOptions()));
+  }
+  async fromBlob(blob) {
+    this.options.signal?.throwIfAborted();
+    let tokenizer = fromBlob(blob, this.getTokenizerOptions());
+    return this.fromTokenizer(tokenizer);
+  }
+  async fromStream(stream) {
+    this.options.signal?.throwIfAborted();
+    let tokenizer = this.createTokenizerFromWebStream(stream);
+    return this.fromTokenizer(tokenizer);
+  }
+  async toDetectionStream(stream, options) {
+    let sampleSize = normalizeSampleSize(options?.sampleSize ?? reasonableDetectionSizeInBytes), detectedFileType, firstChunk, reader = stream.getReader({ mode: "byob" });
+    try {
+      let { value: chunk, done } = await readByobReaderWithSignal(reader, new Uint8Array(sampleSize), this.options.signal);
+      if (firstChunk = chunk, !done && chunk)
+        try {
+          detectedFileType = await this.fromBuffer(chunk.subarray(0, sampleSize));
+        } catch (error) {
+          if (!(error instanceof EndOfStreamError))
+            throw error;
+          detectedFileType = void 0;
+        }
+      firstChunk = chunk;
+    } finally {
+      reader.releaseLock();
+    }
+    let transformStream = new TransformStream({
+      async start(controller) {
+        controller.enqueue(firstChunk);
+      },
+      transform(chunk, controller) {
+        controller.enqueue(chunk);
+      }
+    }), newStream = stream.pipeThrough(transformStream);
+    return newStream.fileType = detectedFileType, newStream;
+  }
+  async detectGzip(tokenizer) {
+    if (this.gzipProbeDepth >= maximumNestedGzipProbeDepth)
+      return {
+        ext: "gz",
+        mime: "application/gzip"
+      };
+    let gzipHandler = new GzipHandler(tokenizer), limitedInflatedStream = createByteLimitedReadableStream(gzipHandler.inflate(), maximumNestedGzipDetectionSizeInBytes), hasUnknownSize = hasUnknownFileSize(tokenizer), timeout, probeSignal, probeParser, compressedFileType;
+    if (hasUnknownSize) {
+      let 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), hasUnknownSize || this.gzipProbeDepth--;
+    }
+    return compressedFileType?.ext === "tar" ? {
+      ext: "tar.gz",
+      mime: "application/gzip"
+    } : {
+      ext: "gz",
+      mime: "application/gzip"
+    };
+  }
+  check(header, options) {
+    return _check(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) => {
+    if (this.buffer = new Uint8Array(reasonableDetectionSizeInBytes), tokenizer.fileInfo.size === void 0 && (tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER), this.tokenizer = tokenizer, hasUnknownFileSize(tokenizer) && (await tokenizer.peekBuffer(this.buffer, { length: 3, mayBeLess: !0 }), this.check([31, 139, 8])))
+      return this.detectGzip(tokenizer);
+    if (await tokenizer.peekBuffer(this.buffer, { length: 32, mayBeLess: !0 }), 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]))
+      return await tokenizer.peekBuffer(this.buffer, { length: 24, mayBeLess: !0 }), this.checkString("PS-Adobe-", { offset: 2 }) && this.checkString(" EPSF-", { offset: 14 }) ? {
+        ext: "eps",
+        mime: "application/eps"
+      } : {
+        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]))
+      return this.detectionReentryCount >= maximumDetectionReentryCount ? void 0 : (this.detectionReentryCount++, await this.tokenizer.ignore(3), 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"
+      });
+      let id3HeaderLength = await tokenizer.readToken(uint32SyncSafeToken), isUnknownFileSize = hasUnknownFileSize(tokenizer);
+      if (!Number.isFinite(id3HeaderLength) || id3HeaderLength < 0 || isUnknownFileSize && (id3HeaderLength > maximumId3HeaderSizeInBytes || tokenizer.position + id3HeaderLength > maximumId3HeaderSizeInBytes))
+        return;
+      if (tokenizer.position + id3HeaderLength > tokenizer.fileInfo.size)
+        return isUnknownFileSize ? void 0 : {
+          ext: "mp3",
+          mime: "audio/mpeg"
+        };
+      try {
+        await safeIgnore(tokenizer, id3HeaderLength, {
+          maximumLength: isUnknownFileSize ? maximumId3HeaderSizeInBytes : tokenizer.fileInfo.size,
+          reason: "ID3 payload"
+        });
+      } catch (error) {
+        if (error instanceof EndOfStreamError)
+          return;
+        throw error;
+      }
+      return this.detectionReentryCount >= maximumDetectionReentryCount ? void 0 : (this.detectionReentryCount++, 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]))
+      return this.check([247], { offset: 3 }) ? {
+        ext: "jls",
+        mime: "image/jls"
+      } : {
+        ext: "jpg",
+        mime: "image/jpeg"
+      };
+    if (this.check([79, 98, 106, 1]))
+      return {
+        ext: "avro",
+        mime: "application/avro"
+      };
+    if (this.checkString("FLIF"))
+      return {
+        ext: "flif",
+        mime: "image/flif"
+      };
+    if (this.checkString("8BPS"))
+      return {
+        ext: "psd",
+        mime: "image/vnd.adobe.photoshop"
+      };
+    if (this.checkString("MPCK"))
+      return {
+        ext: "mpc",
+        mime: "audio/x-musepack"
+      };
+    if (this.checkString("FORM"))
+      return {
+        ext: "aif",
+        mime: "audio/aiff"
+      };
+    if (this.checkString("icns", { offset: 0 }))
+      return {
+        ext: "icns",
+        mime: "image/icns"
+      };
+    if (this.check([80, 75, 3, 4])) {
+      let fileType, openXmlState = createOpenXmlZipDetectionState();
+      try {
+        await new ZipHandler(tokenizer).unzip((zipHeader) => {
+          updateOpenXmlZipDetectionStateFromFilename(openXmlState, zipHeader.filename);
+          let isOpenXmlContentTypesEntry = zipHeader.filename === "[Content_Types].xml", openXmlFileTypeFromEntries = getOpenXmlFileTypeFromZipEntries(openXmlState);
+          if (!isOpenXmlContentTypesEntry && openXmlFileTypeFromEntries)
+            return fileType = openXmlFileTypeFromEntries, {
+              stop: !0
+            };
+          switch (zipHeader.filename) {
+            case "META-INF/mozilla.rsa":
+              return fileType = {
+                ext: "xpi",
+                mime: "application/x-xpinstall"
+              }, {
+                stop: !0
+              };
+            case "META-INF/MANIFEST.MF":
+              return fileType = {
+                ext: "jar",
+                mime: "application/java-archive"
+              }, {
+                stop: !0
+              };
+            case "mimetype":
+              return canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes) ? {
+                async handler(fileData) {
+                  let mimeType = new TextDecoder("utf-8").decode(fileData).trim();
+                  fileType = getFileTypeFromMimeType(mimeType);
+                },
+                stop: !0
+              } : {};
+            case "[Content_Types].xml":
+              return openXmlState.hasContentTypesEntry = !0, canReadZipEntryForDetection(zipHeader, maximumZipTextEntrySizeInBytes) ? (openXmlState.isParsingContentTypes = !0, {
+                async handler(fileData) {
+                  let xmlContent = new TextDecoder("utf-8").decode(fileData), mimeType = getOpenXmlMimeTypeFromContentTypesXml(xmlContent);
+                  mimeType && (fileType = getFileTypeFromMimeType(mimeType)), openXmlState.hasParsedContentTypesEntry = !0, openXmlState.isParsingContentTypes = !1;
+                },
+                stop: !0
+              }) : (openXmlState.hasUnparseableContentTypes = !0, {});
+            default:
+              return /classes\d*\.dex/.test(zipHeader.filename) ? (fileType = {
+                ext: "apk",
+                mime: "application/vnd.android.package-archive"
+              }, { stop: !0 }) : {};
+          }
+        });
+      } catch (error) {
+        if (!isRecoverableZipError(error))
+          throw error;
+        openXmlState.isParsingContentTypes && (openXmlState.isParsingContentTypes = !1, openXmlState.hasUnparseableContentTypes = !0);
+      }
+      return fileType ?? getOpenXmlFileTypeFromZipEntries(openXmlState) ?? {
+        ext: "zip",
+        mime: "application/zip"
+      };
+    }
+    if (this.checkString("OggS")) {
+      await tokenizer.ignore(28);
+      let type = new Uint8Array(8);
+      return await tokenizer.readBuffer(type), _check(type, [79, 112, 117, 115, 72, 101, 97, 100]) ? {
+        ext: "opus",
+        mime: "audio/ogg; codecs=opus"
+      } : _check(type, [128, 116, 104, 101, 111, 114, 97]) ? {
+        ext: "ogv",
+        mime: "video/ogg"
+      } : _check(type, [1, 118, 105, 100, 101, 111, 0]) ? {
+        ext: "ogm",
+        mime: "video/ogg"
+      } : _check(type, [127, 70, 76, 65, 67]) ? {
+        ext: "oga",
+        mime: "audio/ogg"
+      } : _check(type, [83, 112, 101, 101, 120, 32, 32]) ? {
+        ext: "spx",
+        mime: "audio/ogg"
+      } : _check(type, [1, 118, 111, 114, 98, 105, 115]) ? {
+        ext: "ogg",
+        mime: "audio/ogg"
+      } : {
+        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/x-lzip"
+      };
+    if (this.checkString("fLaC"))
+      return {
+        ext: "flac",
+        mime: "audio/flac"
+      };
+    if (this.check([66, 80, 71, 251]))
+      return {
+        ext: "bpg",
+        mime: "image/bpg"
+      };
+    if (this.checkString("wvpk"))
+      return {
+        ext: "wv",
+        mime: "audio/wavpack"
+      };
+    if (this.checkString("%PDF"))
+      return {
+        ext: "pdf",
+        mime: "application/pdf"
+      };
+    if (this.check([0, 97, 115, 109]))
+      return {
+        ext: "wasm",
+        mime: "application/wasm"
+      };
+    if (this.check([73, 73])) {
+      let fileType = await this.readTiffHeader(!1);
+      if (fileType)
+        return fileType;
+    }
+    if (this.check([77, 77])) {
+      let fileType = await this.readTiffHeader(!0);
+      if (fileType)
+        return fileType;
+    }
+    if (this.checkString("MAC "))
+      return {
+        ext: "ape",
+        mime: "audio/ape"
+      };
+    if (this.check([26, 69, 223, 163])) {
+      async function readField() {
+        let msb = await tokenizer.peekNumber(UINT8), mask = 128, ic = 0;
+        for (; (msb & mask) === 0 && mask !== 0; )
+          ++ic, mask >>= 1;
+        let id = new Uint8Array(ic + 1);
+        return await safeReadBuffer(tokenizer, id, void 0, {
+          maximumLength: id.length,
+          reason: "EBML field"
+        }), id;
+      }
+      async function readElement() {
+        let idField = await readField(), lengthField = await readField();
+        lengthField[0] ^= 128 >> lengthField.length - 1;
+        let nrLength = Math.min(6, lengthField.length), idView = new DataView(idField.buffer), lengthView = new DataView(lengthField.buffer, lengthField.length - nrLength, nrLength);
+        return {
+          id: getUintBE(idView),
+          len: getUintBE(lengthView)
+        };
+      }
+      async function readChildren(children) {
+        let ebmlElementCount = 0;
+        for (; children > 0; ) {
+          if (ebmlElementCount++, ebmlElementCount > maximumEbmlElementCount || hasExceededUnknownSizeScanBudget(tokenizer, ebmlScanStart, maximumUntrustedSkipSizeInBytes))
+            return;
+          let previousPosition = tokenizer.position, element = await readElement();
+          if (element.id === 17026) {
+            if (element.len > maximumEbmlDocumentTypeSizeInBytes)
+              return;
+            let documentTypeLength = getSafeBound(element.len, maximumEbmlDocumentTypeSizeInBytes, "EBML DocType");
+            return (await tokenizer.readToken(new StringType(documentTypeLength))).replaceAll(/\00.*$/g, "");
+          }
+          if (hasUnknownFileSize(tokenizer) && (!Number.isFinite(element.len) || element.len < 0 || element.len > maximumEbmlElementPayloadSizeInBytes) || (await safeIgnore(tokenizer, element.len, {
+            maximumLength: hasUnknownFileSize(tokenizer) ? maximumEbmlElementPayloadSizeInBytes : tokenizer.fileInfo.size,
+            reason: "EBML payload"
+          }), --children, tokenizer.position <= previousPosition))
+            return;
+        }
+      }
+      let rootElement = await readElement(), ebmlScanStart = tokenizer.position;
+      switch (await readChildren(rootElement.len)) {
+        case "webm":
+          return {
+            ext: "webm",
+            mime: "video/webm"
+          };
+        case "matroska":
+          return {
+            ext: "mkv",
+            mime: "video/matroska"
+          };
+        default:
+          return;
+      }
+    }
+    if (this.checkString("SQLi"))
+      return {
+        ext: "sqlite",
+        mime: "application/x-sqlite3"
+      };
+    if (this.check([78, 69, 83, 26]))
+      return {
+        ext: "nes",
+        mime: "application/x-nintendo-nes-rom"
+      };
+    if (this.checkString("Cr24"))
+      return {
+        ext: "crx",
+        mime: "application/x-google-chrome-extension"
+      };
+    if (this.checkString("MSCF") || this.checkString("ISc("))
+      return {
+        ext: "cab",
+        mime: "application/vnd.ms-cab-compressed"
+      };
+    if (this.check([237, 171, 238, 219]))
+      return {
+        ext: "rpm",
+        mime: "application/x-rpm"
+      };
+    if (this.check([197, 208, 211, 198]))
+      return {
+        ext: "eps",
+        mime: "application/eps"
+      };
+    if (this.check([40, 181, 47, 253]))
+      return {
+        ext: "zst",
+        mime: "application/zstd"
+      };
+    if (this.check([127, 69, 76, 70]))
+      return {
+        ext: "elf",
+        mime: "application/x-elf"
+      };
+    if (this.check([33, 66, 68, 78]))
+      return {
+        ext: "pst",
+        mime: "application/vnd.ms-outlook"
+      };
+    if (this.checkString("PAR1") || this.checkString("PARE"))
+      return {
+        ext: "parquet",
+        mime: "application/vnd.apache.parquet"
+      };
+    if (this.checkString("ttcf"))
+      return {
+        ext: "ttc",
+        mime: "font/collection"
+      };
+    if (this.check([254, 237, 250, 206]) || this.check([254, 237, 250, 207]) || this.check([206, 250, 237, 254]) || this.check([207, 250, 237, 254]))
+      return {
+        ext: "macho",
+        mime: "application/x-mach-binary"
+      };
+    if (this.check([4, 34, 77, 24]))
+      return {
+        ext: "lz4",
+        mime: "application/x-lz4"
+        // Invented by us
+      };
+    if (this.checkString("regf"))
+      return {
+        ext: "dat",
+        mime: "application/x-ft-windows-registry-hive"
+      };
+    if (this.checkString("$FL2") || this.checkString("$FL3"))
+      return {
+        ext: "sav",
+        mime: "application/x-spss-sav"
+      };
+    if (this.check([79, 84, 84, 79, 0]))
+      return {
+        ext: "otf",
+        mime: "font/otf"
+      };
+    if (this.checkString("#!AMR"))
+      return {
+        ext: "amr",
+        mime: "audio/amr"
+      };
+    if (this.checkString("{\\rtf"))
+      return {
+        ext: "rtf",
+        mime: "application/rtf"
+      };
+    if (this.check([70, 76, 86, 1]))
+      return {
+        ext: "flv",
+        mime: "video/x-flv"
+      };
+    if (this.checkString("IMPM"))
+      return {
+        ext: "it",
+        mime: "audio/x-it"
+      };
+    if (this.checkString("-lh0-", { offset: 2 }) || this.checkString("-lh1-", { offset: 2 }) || this.checkString("-lh2-", { offset: 2 }) || this.checkString("-lh3-", { offset: 2 }) || this.checkString("-lh4-", { offset: 2 }) || this.checkString("-lh5-", { offset: 2 }) || this.checkString("-lh6-", { offset: 2 }) || this.checkString("-lh7-", { offset: 2 }) || this.checkString("-lzs-", { offset: 2 }) || this.checkString("-lz4-", { offset: 2 }) || this.checkString("-lz5-", { offset: 2 }) || this.checkString("-lhd-", { offset: 2 }))
+      return {
+        ext: "lzh",
+        mime: "application/x-lzh-compressed"
+      };
+    if (this.check([0, 0, 1, 186])) {
+      if (this.check([33], { offset: 4, mask: [241] }))
+        return {
+          ext: "mpg",
+          // 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])) {
+      let machOArchitectureCount = UINT32_BE.get(this.buffer, 4), javaClassFileMajorVersion = UINT16_BE.get(this.buffer, 6);
+      if (machOArchitectureCount > 0 && machOArchitectureCount <= 30)
+        return {
+          ext: "macho",
+          mime: "application/x-mach-binary"
+        };
+      if (javaClassFileMajorVersion > 30)
+        return {
+          ext: "class",
+          mime: "application/java-vm"
+        };
+    }
+    if (this.checkString(".RMF"))
+      return {
+        ext: "rm",
+        mime: "application/vnd.rn-realmedia"
+      };
+    if (this.checkString("DRACO"))
+      return {
+        ext: "drc",
+        mime: "application/vnd.google.draco"
+        // Invented by us
+      };
+    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")) {
+      let version = new StringType(4, "latin1").get(this.buffer, 2);
+      if (version.match("^d*") && version >= 1e3 && version <= 1050)
+        return {
+          ext: "dwg",
+          mime: "image/vnd.dwg"
+        };
+    }
+    if (this.checkString("070707"))
+      return {
+        ext: "cpio",
+        mime: "application/x-cpio"
+      };
+    if (this.checkString("BLENDER"))
+      return {
+        ext: "blend",
+        mime: "application/x-blender"
+      };
+    if (this.checkString("!<arch>"))
+      return await tokenizer.ignore(8), await tokenizer.readToken(new StringType(13, "ascii")) === "debian-binary" ? {
+        ext: "deb",
+        mime: "application/x-deb"
+      } : {
+        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.
+    [`
+`, "\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])) {
+      let pngFileType = {
+        ext: "png",
+        mime: "image/png"
+      }, 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"))
+        };
+      }
+      let isUnknownPngStream = hasUnknownFileSize(tokenizer), pngScanStart = tokenizer.position, pngChunkCount = 0, hasSeenImageHeader = !1;
+      do {
+        if (pngChunkCount++, pngChunkCount > maximumPngChunkCount || hasExceededUnknownSizeScanBudget(tokenizer, pngScanStart, maximumPngStreamScanBudgetInBytes))
+          break;
+        let previousPosition = tokenizer.position, chunk = await readChunkHeader();
+        if (chunk.length < 0)
+          return;
+        if (chunk.type === "IHDR") {
+          if (chunk.length !== 13)
+            return;
+          hasSeenImageHeader = !0;
+        }
+        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;
+    }
+    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) {
+      let 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:
+          return brandMajor.startsWith("3g") ? brandMajor.startsWith("3g2") ? { ext: "3g2", mime: "video/3gpp2" } : { ext: "3gp", mime: "video/3gpp" } : { ext: "mp4", mime: "video/mp4" };
+      }
+    }
+    if (this.checkString(`REGEDIT4\r
+`))
+      return {
+        ext: "reg",
+        mime: "application/x-ms-regedit"
+      };
+    if (this.check([82, 73, 70, 70])) {
+      if (this.checkString("WEBP", { offset: 8 }))
+        return {
+          ext: "webp",
+          mime: "image/webp"
+        };
+      if (this.check([65, 86, 73], { offset: 8 }))
+        return {
+          ext: "avi",
+          mime: "video/vnd.avi"
+        };
+      if (this.check([87, 65, 86, 69], { offset: 8 }))
+        return {
+          ext: "wav",
+          mime: "audio/wav"
+        };
+      if (this.check([81, 76, 67, 77], { offset: 8 }))
+        return {
+          ext: "qcp",
+          mime: "audio/qcelp"
+        };
+    }
+    if (this.check([73, 73, 85, 0, 24, 0, 0, 0, 136, 231, 116, 216]))
+      return {
+        ext: "rw2",
+        mime: "image/x-panasonic-rw2"
+      };
+    if (this.check([48, 38, 178, 117, 142, 102, 207, 17, 166, 217])) {
+      let isMalformedAsf = !1;
+      try {
+        async function readHeader() {
+          let guid = new Uint8Array(16);
+          return await safeReadBuffer(tokenizer, guid, void 0, {
+            maximumLength: guid.length,
+            reason: "ASF header GUID"
+          }), {
+            id: guid,
+            size: Number(await tokenizer.readToken(UINT64_LE))
+          };
+        }
+        await safeIgnore(tokenizer, 30, {
+          maximumLength: 30,
+          reason: "ASF header prelude"
+        });
+        let isUnknownFileSize = hasUnknownFileSize(tokenizer), asfHeaderScanStart = tokenizer.position, asfHeaderObjectCount = 0;
+        for (; tokenizer.position + 24 < tokenizer.fileInfo.size && (asfHeaderObjectCount++, !(asfHeaderObjectCount > maximumAsfHeaderObjectCount || hasExceededUnknownSizeScanBudget(tokenizer, asfHeaderScanStart, maximumUntrustedSkipSizeInBytes))); ) {
+          let previousPosition = tokenizer.position, header = await readHeader(), payload = header.size - 24;
+          if (!Number.isFinite(payload) || payload < 0) {
+            isMalformedAsf = !0;
+            break;
+          }
+          if (_check(header.id, [145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101])) {
+            let typeId = new Uint8Array(16);
+            if (payload -= await safeReadBuffer(tokenizer, typeId, void 0, {
+              maximumLength: typeId.length,
+              reason: "ASF stream type GUID"
+            }), _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;
+          }
+          if (isUnknownFileSize && payload > maximumAsfHeaderPayloadSizeInBytes) {
+            isMalformedAsf = !0;
+            break;
+          }
+          if (await safeIgnore(tokenizer, payload, {
+            maximumLength: isUnknownFileSize ? maximumAsfHeaderPayloadSizeInBytes : tokenizer.fileInfo.size,
+            reason: "ASF header payload"
+          }), tokenizer.position <= previousPosition) {
+            isMalformedAsf = !0;
+            break;
+          }
+        }
+      } catch (error) {
+        if (error instanceof EndOfStreamError || error instanceof ParserHardLimitError)
+          hasUnknownFileSize(tokenizer) && (isMalformedAsf = !0);
+        else
+          throw error;
+      }
+      return isMalformedAsf ? void 0 : {
+        ext: "asf",
+        mime: "application/vnd.ms-asf"
+      };
+    }
+    if (this.check([171, 75, 84, 88, 32, 49, 49, 187, 13, 10, 26, 10]))
+      return {
+        ext: "ktx",
+        mime: "image/ktx"
+      };
+    if ((this.check([126, 16, 4]) || this.check([126, 24, 4])) && this.check([48, 77, 73, 69], { offset: 4 }))
+      return {
+        ext: "mie",
+        mime: "application/x-mie"
+      };
+    if (this.check([39, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], { offset: 2 }))
+      return {
+        ext: "shp",
+        mime: "application/x-esri-shape"
+      };
+    if (this.check([255, 79, 255, 81]))
+      return {
+        ext: "j2c",
+        mime: "image/j2c"
+      };
+    if (this.check([0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10]))
+      switch (await tokenizer.ignore(20), await tokenizer.readToken(new StringType(4, "ascii"))) {
+        case "jp2 ":
+          return {
+            ext: "jp2",
+            mime: "image/jp2"
+          };
+        case "jpx ":
+          return {
+            ext: "jpx",
+            mime: "image/jpx"
+          };
+        case "jpm ":
+          return {
+            ext: "jpm",
+            mime: "image/jpm"
+          };
+        case "mjp2":
+          return {
+            ext: "mj2",
+            mime: "image/mj2"
+          };
+        default:
+          return;
+      }
+    if (this.check([255, 10]) || this.check([0, 0, 0, 12, 74, 88, 76, 32, 13, 10, 135, 10]))
+      return {
+        ext: "jxl",
+        mime: "image/jxl"
+      };
+    if (this.check([254, 255]))
+      return this.checkString("<?xml ", { offset: 2, encoding: "utf-16be" }) ? {
+        ext: "xml",
+        mime: "application/xml"
+      } : void 0;
+    if (this.check([208, 207, 17, 224, 161, 177, 26, 225]))
+      return {
+        ext: "cfb",
+        mime: "application/x-cfb"
+      };
+    if (await tokenizer.peekBuffer(this.buffer, { length: Math.min(256, tokenizer.fileInfo.size), mayBeLess: !0 }), 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) {
+      let jsonSize = new DataView(this.buffer.buffer).getUint32(12, !0);
+      if (jsonSize > 12 && this.buffer.length >= jsonSize + 16)
+        try {
+          let header = new TextDecoder().decode(this.buffer.subarray(16, jsonSize + 16));
+          if (JSON.parse(header).files)
+            return {
+              ext: "asar",
+              mime: "application/x-asar"
+            };
+        } catch {
+        }
+    }
+    if (this.check([6, 14, 43, 52, 2, 5, 1, 1, 13, 1, 2, 1, 1, 2]))
+      return {
+        ext: "mxf",
+        mime: "application/mxf"
+      };
+    if (this.checkString("SCRM", { offset: 44 }))
+      return {
+        ext: "s3m",
+        mime: "audio/x-s3m"
+      };
+    if (this.check([71]) && this.check([71], { offset: 188 }))
+      return {
+        ext: "mts",
+        mime: "video/mp2t"
+      };
+    if (this.check([71], { offset: 4 }) && this.check([71], { offset: 196 }))
+      return {
+        ext: "mts",
+        mime: "video/mp2t"
+      };
+    if (this.check([66, 79, 79, 75, 77, 79, 66, 73], { offset: 60 }))
+      return {
+        ext: "mobi",
+        mime: "application/x-mobipocket-ebook"
+      };
+    if (this.check([68, 73, 67, 77], { offset: 128 }))
+      return {
+        ext: "dcm",
+        mime: "application/dicom"
+      };
+    if (this.check([76, 0, 0, 0, 1, 20, 2, 0, 0, 0, 0, 0, 192, 0, 0, 0, 0, 0, 0, 70]))
+      return {
+        ext: "lnk",
+        mime: "application/x.ms.shortcut"
+        // Invented by us
+      };
+    if (this.check([98, 111, 111, 107, 0, 0, 0, 0, 109, 97, 114, 107, 0, 0, 0, 0]))
+      return {
+        ext: "alias",
+        mime: "application/x.apple.alias"
+        // Invented by us
+      };
+    if (this.checkString("Kaydara FBX Binary  \0"))
+      return {
+        ext: "fbx",
+        mime: "application/x.autodesk.fbx"
+        // Invented by us
+      };
+    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"
+      };
+    if (await tokenizer.peekBuffer(this.buffer, { length: Math.min(512, tokenizer.fileInfo.size), mayBeLess: !0 }), 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])) {
+      let encoding = "utf-16le";
+      return this.checkString("<?xml ", { offset: 2, encoding }) ? {
+        ext: "xml",
+        mime: "application/xml"
+      } : this.check([255, 14], { offset: 2 }) && this.checkString("SketchUp Model", { offset: 4, encoding }) ? {
+        ext: "skp",
+        mime: "application/vnd.sketchup.skp"
+      } : this.checkString(`Windows Registry Editor Version 5.00\r
+`, { offset: 2, encoding }) ? {
+        ext: "reg",
+        mime: "application/x-ms-regedit"
+      } : 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);
+    let fileSize = getKnownFileSizeOrMaximum(tokenizer.fileInfo.size);
+    if (await tokenizer.peekBuffer(this.buffer, { length: Math.min(8, fileSize), mayBeLess: !0 }), 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"
+      };
+    if (await tokenizer.peekBuffer(this.buffer, { length: Math.min(2 + this.options.mpegOffsetTolerance, fileSize), mayBeLess: !0 }), this.buffer.length >= 2 + this.options.mpegOffsetTolerance)
+      for (let depth = 0; depth <= this.options.mpegOffsetTolerance; ++depth) {
+        let type = this.scanMpeg(depth);
+        if (type)
+          return type;
+      }
+  };
+  async readTiffTag(bigEndian) {
+    let tagId = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
+    switch (await this.tokenizer.ignore(10), 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) {
+    let numberOfTags = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
+    if (!(numberOfTags > maximumTiffTagCount) && !(hasUnknownFileSize(this.tokenizer) && 2 + numberOfTags * 12 > maximumTiffIfdOffsetInBytes))
+      for (let n = 0; n < numberOfTags; ++n) {
+        let fileType = await this.readTiffTag(bigEndian);
+        if (fileType)
+          return fileType;
+      }
+  }
+  async readTiffHeader(bigEndian) {
+    let tiffFileType = {
+      ext: "tif",
+      mime: "image/tiff"
+    }, version = (bigEndian ? UINT16_BE : UINT16_LE).get(this.buffer, 2), 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) {
+          let someId1 = (bigEndian ? UINT16_BE : UINT16_LE).get(this.buffer, 8), 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;
+      let 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] }))
+        return this.check([8], { offset: offset + 1, mask: [8] }) ? {
+          ext: "aac",
+          mime: "audio/aac"
+        } : {
+          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);
+
+// node_modules/music-metadata/lib/ParserFactory.js
+var import_content_type = __toESM(require_dist(), 1);
+
+// node_modules/music-metadata/node_modules/media-typer/dist/index.js
+var typeRegExp = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}\/[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}$/;
+function parse(str) {
+  if (!typeRegExp.test(str))
+    throw new TypeError(`Invalid media type: ${str}`);
+  let slashIndex = str.indexOf("/"), type = str.slice(0, slashIndex).toLowerCase(), subtype = str.slice(slashIndex + 1).toLowerCase(), suffix, index = subtype.lastIndexOf("+");
+  return index !== -1 && (suffix = subtype.slice(index + 1), subtype = subtype.slice(0, index)), { type, subtype, suffix };
+}
+
+// node_modules/music-metadata/lib/ParserFactory.js
+var import_debug3 = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/common/MetadataCollector.js
+var import_debug2 = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/common/GenericTagTypes.js
+var defaultTagInfo = {
+  multiple: !1
+}, commonTags = {
+  year: defaultTagInfo,
+  track: defaultTagInfo,
+  disk: defaultTagInfo,
+  title: defaultTagInfo,
+  artist: defaultTagInfo,
+  artists: { multiple: !0, unique: !0 },
+  albumartist: defaultTagInfo,
+  albumartists: { multiple: !0, unique: !0 },
+  album: defaultTagInfo,
+  date: defaultTagInfo,
+  originaldate: defaultTagInfo,
+  originalyear: defaultTagInfo,
+  releasedate: defaultTagInfo,
+  comment: { multiple: !0, unique: !1 },
+  genre: { multiple: !0, unique: !0 },
+  picture: { multiple: !0, unique: !0 },
+  composer: { multiple: !0, unique: !0 },
+  lyrics: { multiple: !0, unique: !1 },
+  albumsort: { multiple: !1, unique: !0 },
+  titlesort: { multiple: !1, unique: !0 },
+  work: { multiple: !1, unique: !0 },
+  artistsort: { multiple: !1, unique: !0 },
+  albumartistsort: { multiple: !1, unique: !0 },
+  composersort: { multiple: !1, unique: !0 },
+  lyricist: { multiple: !0, unique: !0 },
+  writer: { multiple: !0, unique: !0 },
+  conductor: { multiple: !0, unique: !0 },
+  remixer: { multiple: !0, unique: !0 },
+  arranger: { multiple: !0, unique: !0 },
+  engineer: { multiple: !0, unique: !0 },
+  producer: { multiple: !0, unique: !0 },
+  technician: { multiple: !0, unique: !0 },
+  djmixer: { multiple: !0, unique: !0 },
+  mixer: { multiple: !0, unique: !0 },
+  label: { multiple: !0, unique: !0 },
+  grouping: defaultTagInfo,
+  subtitle: { multiple: !0 },
+  discsubtitle: defaultTagInfo,
+  totaltracks: defaultTagInfo,
+  totaldiscs: defaultTagInfo,
+  compilation: defaultTagInfo,
+  rating: { multiple: !0 },
+  bpm: defaultTagInfo,
+  mood: defaultTagInfo,
+  media: defaultTagInfo,
+  catalognumber: { multiple: !0, unique: !0 },
+  tvShow: defaultTagInfo,
+  tvShowSort: defaultTagInfo,
+  tvSeason: defaultTagInfo,
+  tvEpisode: defaultTagInfo,
+  tvEpisodeId: defaultTagInfo,
+  tvNetwork: defaultTagInfo,
+  podcast: defaultTagInfo,
+  podcasturl: defaultTagInfo,
+  releasestatus: defaultTagInfo,
+  releasetype: { multiple: !0 },
+  releasecountry: defaultTagInfo,
+  script: defaultTagInfo,
+  language: defaultTagInfo,
+  copyright: defaultTagInfo,
+  license: defaultTagInfo,
+  encodedby: defaultTagInfo,
+  encodersettings: defaultTagInfo,
+  gapless: defaultTagInfo,
+  barcode: defaultTagInfo,
+  isrc: { multiple: !0 },
+  asin: defaultTagInfo,
+  musicbrainz_recordingid: defaultTagInfo,
+  musicbrainz_trackid: defaultTagInfo,
+  musicbrainz_albumid: defaultTagInfo,
+  musicbrainz_artistid: { multiple: !0 },
+  musicbrainz_albumartistid: { multiple: !0 },
+  musicbrainz_releasegroupid: defaultTagInfo,
+  musicbrainz_workid: defaultTagInfo,
+  musicbrainz_trmid: defaultTagInfo,
+  musicbrainz_discid: defaultTagInfo,
+  acoustid_id: defaultTagInfo,
+  acoustid_fingerprint: defaultTagInfo,
+  musicip_puid: defaultTagInfo,
+  musicip_fingerprint: defaultTagInfo,
+  website: defaultTagInfo,
+  "performer:instrument": { multiple: !0, unique: !0 },
+  averageLevel: defaultTagInfo,
+  peakLevel: defaultTagInfo,
+  notes: { multiple: !0, unique: !1 },
+  key: defaultTagInfo,
+  originalalbum: defaultTagInfo,
+  originalartist: defaultTagInfo,
+  discogs_artist_id: { multiple: !0, unique: !0 },
+  discogs_release_id: defaultTagInfo,
+  discogs_label_id: defaultTagInfo,
+  discogs_master_release_id: defaultTagInfo,
+  discogs_votes: defaultTagInfo,
+  discogs_rating: defaultTagInfo,
+  replaygain_track_peak: defaultTagInfo,
+  replaygain_track_gain: defaultTagInfo,
+  replaygain_album_peak: defaultTagInfo,
+  replaygain_album_gain: defaultTagInfo,
+  replaygain_track_minmax: defaultTagInfo,
+  replaygain_album_minmax: defaultTagInfo,
+  replaygain_undo: defaultTagInfo,
+  description: { multiple: !0 },
+  longDescription: defaultTagInfo,
+  category: { multiple: !0 },
+  hdVideo: defaultTagInfo,
+  keywords: { multiple: !0 },
+  movement: defaultTagInfo,
+  movementIndex: defaultTagInfo,
+  movementTotal: defaultTagInfo,
+  podcastId: defaultTagInfo,
+  showMovement: defaultTagInfo,
+  stik: defaultTagInfo,
+  playCounter: defaultTagInfo
+};
+function isSingleton(alias) {
+  return commonTags[alias] && !commonTags[alias].multiple;
+}
+function isUnique(alias) {
+  return !commonTags[alias].multiple || commonTags[alias].unique || !1;
+}
+
+// node_modules/music-metadata/lib/common/GenericTagMapper.js
+var CommonTagMapper = class {
+  static toIntOrNull(str) {
+    let cleaned = Number.parseInt(str, 10);
+    return Number.isNaN(cleaned) ? null : cleaned;
+  }
+  // TODO: a string of 1of1 would fail to be converted
+  // converts 1/10 to no : 1, of : 10
+  // or 1 to no : 1, of : 0
+  static normalizeTrack(origVal) {
+    let split = origVal.toString().split("/");
+    return {
+      no: Number.parseInt(split[0], 10) || null,
+      of: Number.parseInt(split[1], 10) || null
+    };
+  }
+  constructor(tagTypes, tagMap2) {
+    this.tagTypes = tagTypes, this.tagMap = tagMap2;
+  }
+  /**
+   * Process and set common tags
+   * write common tags to
+   * @param tag Native tag
+   * @param warnings Register warnings
+   * @return common name
+   */
+  mapGenericTag(tag, warnings) {
+    tag = { id: tag.id, value: tag.value }, this.postMap(tag, warnings);
+    let id = this.getCommonName(tag.id);
+    return id ? { id, value: tag.value } : null;
+  }
+  /**
+   * Convert native tag key to common tag key
+   * @param tag Native header tag
+   * @return common tag name (alias)
+   */
+  getCommonName(tag) {
+    return this.tagMap[tag];
+  }
+  /**
+   * Handle post mapping exceptions / correction
+   * @param tag Tag e.g. {"©alb", "Buena Vista Social Club")
+   * @param warnings Used to register warnings
+   */
+  postMap(_tag, _warnings) {
+  }
+};
+CommonTagMapper.maxRatingScore = 1;
+
+// node_modules/music-metadata/lib/id3v1/ID3v1TagMap.js
+var id3v1TagMap = {
+  title: "title",
+  artist: "artist",
+  album: "album",
+  year: "year",
+  comment: "comment",
+  track: "track",
+  genre: "genre"
+}, ID3v1TagMapper = class extends CommonTagMapper {
+  constructor() {
+    super(["ID3v1"], id3v1TagMap);
+  }
+};
+
+// node_modules/music-metadata/lib/common/CaseInsensitiveTagMap.js
+var CaseInsensitiveTagMap = class extends CommonTagMapper {
+  constructor(tagTypes, tagMap2) {
+    let upperCaseMap = {};
+    for (let tag of Object.keys(tagMap2))
+      upperCaseMap[tag.toUpperCase()] = tagMap2[tag];
+    super(tagTypes, upperCaseMap);
+  }
+  /**
+   * @tag  Native header tag
+   * @return common tag name (alias)
+   */
+  getCommonName(tag) {
+    return this.tagMap[tag.toUpperCase()];
+  }
+};
+
+// node_modules/music-metadata/lib/id3v2/ID3v24TagMapper.js
+var id3v24TagMap = {
+  // id3v2.3
+  TIT2: "title",
+  TPE1: "artist",
+  "TXXX:Artists": "artists",
+  TPE2: "albumartist",
+  TALB: "album",
+  TDRV: "date",
+  // [ 'date', 'year' ] ToDo: improve 'year' mapping
+  /**
+   * Original release year
+   */
+  TORY: "originalyear",
+  TPOS: "disk",
+  TCON: "genre",
+  APIC: "picture",
+  TCOM: "composer",
+  USLT: "lyrics",
+  TSOA: "albumsort",
+  TSOT: "titlesort",
+  TOAL: "originalalbum",
+  TSOP: "artistsort",
+  TSO2: "albumartistsort",
+  TSOC: "composersort",
+  TEXT: "lyricist",
+  "TXXX:Writer": "writer",
+  TPE3: "conductor",
+  // 'IPLS:instrument': 'performer:instrument', // ToDo
+  TPE4: "remixer",
+  "IPLS:arranger": "arranger",
+  "IPLS:engineer": "engineer",
+  "IPLS:producer": "producer",
+  "IPLS:DJ-mix": "djmixer",
+  "IPLS:mix": "mixer",
+  TPUB: "label",
+  TIT1: "grouping",
+  TIT3: "subtitle",
+  TRCK: "track",
+  TCMP: "compilation",
+  POPM: "rating",
+  TBPM: "bpm",
+  TMED: "media",
+  "TXXX:CATALOGNUMBER": "catalognumber",
+  "TXXX:MusicBrainz Album Status": "releasestatus",
+  "TXXX:MusicBrainz Album Type": "releasetype",
+  /**
+   * Release country as documented: https://picard.musicbrainz.org/docs/mappings/#cite_note-0
+   */
+  "TXXX:MusicBrainz Album Release Country": "releasecountry",
+  /**
+   * Release country as implemented // ToDo: report
+   */
+  "TXXX:RELEASECOUNTRY": "releasecountry",
+  "TXXX:SCRIPT": "script",
+  TLAN: "language",
+  TCOP: "copyright",
+  WCOP: "license",
+  TENC: "encodedby",
+  TSSE: "encodersettings",
+  "TXXX:BARCODE": "barcode",
+  "TXXX:ISRC": "isrc",
+  TSRC: "isrc",
+  "TXXX:ASIN": "asin",
+  "TXXX:originalyear": "originalyear",
+  "UFID:http://musicbrainz.org": "musicbrainz_recordingid",
+  "TXXX:MusicBrainz Release Track Id": "musicbrainz_trackid",
+  "TXXX:MusicBrainz Album Id": "musicbrainz_albumid",
+  "TXXX:MusicBrainz Artist Id": "musicbrainz_artistid",
+  "TXXX:MusicBrainz Album Artist Id": "musicbrainz_albumartistid",
+  "TXXX:MusicBrainz Release Group Id": "musicbrainz_releasegroupid",
+  "TXXX:MusicBrainz Work Id": "musicbrainz_workid",
+  "TXXX:MusicBrainz TRM Id": "musicbrainz_trmid",
+  "TXXX:MusicBrainz Disc Id": "musicbrainz_discid",
+  "TXXX:ACOUSTID_ID": "acoustid_id",
+  "TXXX:Acoustid Id": "acoustid_id",
+  "TXXX:Acoustid Fingerprint": "acoustid_fingerprint",
+  "TXXX:MusicIP PUID": "musicip_puid",
+  "TXXX:MusicMagic Fingerprint": "musicip_fingerprint",
+  WOAR: "website",
+  // id3v2.4
+  // ToDo: In same sequence as defined at http://id3.org/id3v2.4.0-frames
+  TDRC: "date",
+  // date YYYY-MM-DD
+  TYER: "year",
+  TDOR: "originaldate",
+  // 'TMCL:instrument': 'performer:instrument',
+  "TIPL:arranger": "arranger",
+  "TIPL:engineer": "engineer",
+  "TIPL:producer": "producer",
+  "TIPL:DJ-mix": "djmixer",
+  "TIPL:mix": "mixer",
+  TMOO: "mood",
+  // additional mappings:
+  SYLT: "lyrics",
+  TSST: "discsubtitle",
+  TKEY: "key",
+  COMM: "comment",
+  TOPE: "originalartist",
+  // Windows Media Player
+  "PRIV:AverageLevel": "averageLevel",
+  "PRIV:PeakLevel": "peakLevel",
+  // Discogs
+  "TXXX:DISCOGS_ARTIST_ID": "discogs_artist_id",
+  "TXXX:DISCOGS_ARTISTS": "artists",
+  "TXXX:DISCOGS_ARTIST_NAME": "artists",
+  "TXXX:DISCOGS_ALBUM_ARTISTS": "albumartist",
+  "TXXX:DISCOGS_CATALOG": "catalognumber",
+  "TXXX:DISCOGS_COUNTRY": "releasecountry",
+  "TXXX:DISCOGS_DATE": "originaldate",
+  "TXXX:DISCOGS_LABEL": "label",
+  "TXXX:DISCOGS_LABEL_ID": "discogs_label_id",
+  "TXXX:DISCOGS_MASTER_RELEASE_ID": "discogs_master_release_id",
+  "TXXX:DISCOGS_RATING": "discogs_rating",
+  "TXXX:DISCOGS_RELEASED": "date",
+  "TXXX:DISCOGS_RELEASE_ID": "discogs_release_id",
+  "TXXX:DISCOGS_VOTES": "discogs_votes",
+  "TXXX:CATALOGID": "catalognumber",
+  "TXXX:STYLE": "genre",
+  "TXXX:REPLAYGAIN_TRACK_PEAK": "replaygain_track_peak",
+  "TXXX:REPLAYGAIN_TRACK_GAIN": "replaygain_track_gain",
+  "TXXX:REPLAYGAIN_ALBUM_PEAK": "replaygain_album_peak",
+  "TXXX:REPLAYGAIN_ALBUM_GAIN": "replaygain_album_gain",
+  "TXXX:MP3GAIN_MINMAX": "replaygain_track_minmax",
+  "TXXX:MP3GAIN_ALBUM_MINMAX": "replaygain_album_minmax",
+  "TXXX:MP3GAIN_UNDO": "replaygain_undo",
+  MVNM: "movement",
+  MVIN: "movementIndex",
+  PCST: "podcast",
+  TCAT: "category",
+  TDES: "description",
+  TDRL: "releasedate",
+  TGID: "podcastId",
+  TKWD: "keywords",
+  WFED: "podcasturl",
+  GRP1: "grouping",
+  PCNT: "playCounter"
+}, ID3v24TagMapper = class _ID3v24TagMapper extends CaseInsensitiveTagMap {
+  static toRating(popm) {
+    return {
+      source: popm.email,
+      rating: popm.rating > 0 ? (popm.rating - 1) / 254 * CommonTagMapper.maxRatingScore : void 0
+    };
+  }
+  constructor() {
+    super(["ID3v2.3", "ID3v2.4"], id3v24TagMap);
+  }
+  /**
+   * Handle post mapping exceptions / correction
+   * @param tag to post map
+   * @param warnings Wil be used to register (collect) warnings
+   */
+  postMap(tag, warnings) {
+    switch (tag.id) {
+      case "UFID":
+        {
+          let idTag = tag.value;
+          idTag.owner_identifier === "http://musicbrainz.org" && (tag.id += `:${idTag.owner_identifier}`, tag.value = decodeString(idTag.identifier, "latin1"));
+        }
+        break;
+      case "PRIV":
+        {
+          let customTag = tag.value;
+          switch (customTag.owner_identifier) {
+            // decode Windows Media Player
+            case "AverageLevel":
+            case "PeakValue":
+              tag.id += `:${customTag.owner_identifier}`, tag.value = customTag.data.length === 4 ? UINT32_LE.get(customTag.data, 0) : null, tag.value === null && warnings.addWarning("Failed to parse PRIV:PeakValue");
+              break;
+            default:
+              warnings.addWarning(`Unknown PRIV owner-identifier: ${customTag.data}`);
+          }
+        }
+        break;
+      case "POPM":
+        tag.value = _ID3v24TagMapper.toRating(tag.value);
+        break;
+      default:
+        break;
+    }
+  }
+};
+
+// node_modules/music-metadata/lib/asf/AsfTagMapper.js
+var asfTagMap = {
+  Title: "title",
+  Author: "artist",
+  "WM/AlbumArtist": "albumartist",
+  "WM/AlbumTitle": "album",
+  "WM/Year": "date",
+  // changed to 'year' to 'date' based on Picard mappings; ToDo: check me
+  "WM/OriginalReleaseTime": "originaldate",
+  "WM/OriginalReleaseYear": "originalyear",
+  Description: "comment",
+  "WM/TrackNumber": "track",
+  "WM/PartOfSet": "disk",
+  "WM/Genre": "genre",
+  "WM/Composer": "composer",
+  "WM/Lyrics": "lyrics",
+  "WM/AlbumSortOrder": "albumsort",
+  "WM/TitleSortOrder": "titlesort",
+  "WM/ArtistSortOrder": "artistsort",
+  "WM/AlbumArtistSortOrder": "albumartistsort",
+  "WM/ComposerSortOrder": "composersort",
+  "WM/Writer": "lyricist",
+  "WM/Conductor": "conductor",
+  "WM/ModifiedBy": "remixer",
+  "WM/Engineer": "engineer",
+  "WM/Producer": "producer",
+  "WM/DJMixer": "djmixer",
+  "WM/Mixer": "mixer",
+  "WM/Publisher": "label",
+  "WM/ContentGroupDescription": "grouping",
+  "WM/SubTitle": "subtitle",
+  "WM/SetSubTitle": "discsubtitle",
+  // 'WM/PartOfSet': 'totaldiscs',
+  "WM/IsCompilation": "compilation",
+  "WM/SharedUserRating": "rating",
+  "WM/BeatsPerMinute": "bpm",
+  "WM/Mood": "mood",
+  "WM/Media": "media",
+  "WM/CatalogNo": "catalognumber",
+  "MusicBrainz/Album Status": "releasestatus",
+  "MusicBrainz/Album Type": "releasetype",
+  "MusicBrainz/Album Release Country": "releasecountry",
+  "WM/Script": "script",
+  "WM/Language": "language",
+  Copyright: "copyright",
+  LICENSE: "license",
+  "WM/EncodedBy": "encodedby",
+  "WM/EncodingSettings": "encodersettings",
+  "WM/Barcode": "barcode",
+  "WM/ISRC": "isrc",
+  "MusicBrainz/Track Id": "musicbrainz_recordingid",
+  "MusicBrainz/Release Track Id": "musicbrainz_trackid",
+  "MusicBrainz/Album Id": "musicbrainz_albumid",
+  "MusicBrainz/Artist Id": "musicbrainz_artistid",
+  "MusicBrainz/Album Artist Id": "musicbrainz_albumartistid",
+  "MusicBrainz/Release Group Id": "musicbrainz_releasegroupid",
+  "MusicBrainz/Work Id": "musicbrainz_workid",
+  "MusicBrainz/TRM Id": "musicbrainz_trmid",
+  "MusicBrainz/Disc Id": "musicbrainz_discid",
+  "Acoustid/Id": "acoustid_id",
+  "Acoustid/Fingerprint": "acoustid_fingerprint",
+  "MusicIP/PUID": "musicip_puid",
+  "WM/ARTISTS": "artists",
+  "WM/InitialKey": "key",
+  ASIN: "asin",
+  "WM/Work": "work",
+  "WM/AuthorURL": "website",
+  "WM/Picture": "picture"
+}, AsfTagMapper = class _AsfTagMapper extends CommonTagMapper {
+  static toRating(rating) {
+    return {
+      rating: Number.parseFloat(rating + 1) / 5
+    };
+  }
+  constructor() {
+    super(["asf"], asfTagMap);
+  }
+  postMap(tag) {
+    if (tag.id === "WM/SharedUserRating") {
+      let keys = tag.id.split(":");
+      tag.value = _AsfTagMapper.toRating(tag.value), tag.id = keys[0];
+    }
+  }
+};
+
+// node_modules/music-metadata/lib/id3v2/ID3v22TagMapper.js
+var id3v22TagMap = {
+  TT2: "title",
+  TP1: "artist",
+  TP2: "albumartist",
+  TAL: "album",
+  TYE: "year",
+  COM: "comment",
+  TRK: "track",
+  TPA: "disk",
+  TCO: "genre",
+  PIC: "picture",
+  TCM: "composer",
+  TOR: "originaldate",
+  TOT: "originalalbum",
+  TXT: "lyricist",
+  TP3: "conductor",
+  TPB: "label",
+  TT1: "grouping",
+  TT3: "subtitle",
+  TLA: "language",
+  TCR: "copyright",
+  WCP: "license",
+  TEN: "encodedby",
+  TSS: "encodersettings",
+  WAR: "website",
+  PCS: "podcast",
+  TCP: "compilation",
+  TDR: "date",
+  TS2: "albumartistsort",
+  TSA: "albumsort",
+  TSC: "composersort",
+  TSP: "artistsort",
+  TST: "titlesort",
+  WFD: "podcasturl",
+  TBP: "bpm",
+  GP1: "grouping"
+}, ID3v22TagMapper = class extends CaseInsensitiveTagMap {
+  constructor() {
+    super(["ID3v2.2"], id3v22TagMap);
+  }
+};
+
+// node_modules/music-metadata/lib/apev2/APEv2TagMapper.js
+var apev2TagMap = {
+  Title: "title",
+  Artist: "artist",
+  Artists: "artists",
+  "Album Artist": "albumartist",
+  Album: "album",
+  Year: "date",
+  Originalyear: "originalyear",
+  Originaldate: "originaldate",
+  Releasedate: "releasedate",
+  Comment: "comment",
+  Track: "track",
+  Disc: "disk",
+  DISCNUMBER: "disk",
+  // ToDo: backwards compatibility', valid tag?
+  Genre: "genre",
+  "Cover Art (Front)": "picture",
+  "Cover Art (Back)": "picture",
+  Composer: "composer",
+  Lyrics: "lyrics",
+  ALBUMSORT: "albumsort",
+  TITLESORT: "titlesort",
+  WORK: "work",
+  ARTISTSORT: "artistsort",
+  ALBUMARTISTSORT: "albumartistsort",
+  COMPOSERSORT: "composersort",
+  Lyricist: "lyricist",
+  Writer: "writer",
+  Conductor: "conductor",
+  // 'Performer=artist (instrument)': 'performer:instrument',
+  MixArtist: "remixer",
+  Arranger: "arranger",
+  Engineer: "engineer",
+  Producer: "producer",
+  DJMixer: "djmixer",
+  Mixer: "mixer",
+  Label: "label",
+  Grouping: "grouping",
+  Subtitle: "subtitle",
+  DiscSubtitle: "discsubtitle",
+  Compilation: "compilation",
+  BPM: "bpm",
+  Mood: "mood",
+  Media: "media",
+  CatalogNumber: "catalognumber",
+  MUSICBRAINZ_ALBUMSTATUS: "releasestatus",
+  MUSICBRAINZ_ALBUMTYPE: "releasetype",
+  RELEASECOUNTRY: "releasecountry",
+  Script: "script",
+  Language: "language",
+  Copyright: "copyright",
+  LICENSE: "license",
+  EncodedBy: "encodedby",
+  EncoderSettings: "encodersettings",
+  Barcode: "barcode",
+  ISRC: "isrc",
+  ASIN: "asin",
+  musicbrainz_trackid: "musicbrainz_recordingid",
+  musicbrainz_releasetrackid: "musicbrainz_trackid",
+  MUSICBRAINZ_ALBUMID: "musicbrainz_albumid",
+  MUSICBRAINZ_ARTISTID: "musicbrainz_artistid",
+  MUSICBRAINZ_ALBUMARTISTID: "musicbrainz_albumartistid",
+  MUSICBRAINZ_RELEASEGROUPID: "musicbrainz_releasegroupid",
+  MUSICBRAINZ_WORKID: "musicbrainz_workid",
+  MUSICBRAINZ_TRMID: "musicbrainz_trmid",
+  MUSICBRAINZ_DISCID: "musicbrainz_discid",
+  Acoustid_Id: "acoustid_id",
+  ACOUSTID_FINGERPRINT: "acoustid_fingerprint",
+  MUSICIP_PUID: "musicip_puid",
+  Weblink: "website",
+  REPLAYGAIN_TRACK_GAIN: "replaygain_track_gain",
+  REPLAYGAIN_TRACK_PEAK: "replaygain_track_peak",
+  MP3GAIN_MINMAX: "replaygain_track_minmax",
+  MP3GAIN_UNDO: "replaygain_undo"
+}, APEv2TagMapper = class extends CaseInsensitiveTagMap {
+  constructor() {
+    super(["APEv2"], apev2TagMap);
+  }
+};
+
+// node_modules/music-metadata/lib/mp4/MP4TagMapper.js
+var mp4TagMap = {
+  "\xA9nam": "title",
+  "\xA9ART": "artist",
+  aART: "albumartist",
+  /**
+   * ToDo: Album artist seems to be stored here while Picard documentation says: aART
+   */
+  "----:com.apple.iTunes:Band": "albumartist",
+  "\xA9alb": "album",
+  "\xA9day": "date",
+  "\xA9cmt": "comment",
+  "\xA9com": "comment",
+  trkn: "track",
+  disk: "disk",
+  "\xA9gen": "genre",
+  covr: "picture",
+  "\xA9wrt": "composer",
+  "\xA9lyr": "lyrics",
+  soal: "albumsort",
+  sonm: "titlesort",
+  soar: "artistsort",
+  soaa: "albumartistsort",
+  soco: "composersort",
+  "----:com.apple.iTunes:LYRICIST": "lyricist",
+  "----:com.apple.iTunes:CONDUCTOR": "conductor",
+  "----:com.apple.iTunes:REMIXER": "remixer",
+  "----:com.apple.iTunes:ENGINEER": "engineer",
+  "----:com.apple.iTunes:PRODUCER": "producer",
+  "----:com.apple.iTunes:DJMIXER": "djmixer",
+  "----:com.apple.iTunes:MIXER": "mixer",
+  "----:com.apple.iTunes:LABEL": "label",
+  "\xA9grp": "grouping",
+  "----:com.apple.iTunes:SUBTITLE": "subtitle",
+  "----:com.apple.iTunes:DISCSUBTITLE": "discsubtitle",
+  cpil: "compilation",
+  tmpo: "bpm",
+  "----:com.apple.iTunes:MOOD": "mood",
+  "----:com.apple.iTunes:MEDIA": "media",
+  "----:com.apple.iTunes:CATALOGNUMBER": "catalognumber",
+  tvsh: "tvShow",
+  tvsn: "tvSeason",
+  tves: "tvEpisode",
+  sosn: "tvShowSort",
+  tven: "tvEpisodeId",
+  tvnn: "tvNetwork",
+  pcst: "podcast",
+  purl: "podcasturl",
+  "----:com.apple.iTunes:MusicBrainz Album Status": "releasestatus",
+  "----:com.apple.iTunes:MusicBrainz Album Type": "releasetype",
+  "----:com.apple.iTunes:MusicBrainz Album Release Country": "releasecountry",
+  "----:com.apple.iTunes:SCRIPT": "script",
+  "----:com.apple.iTunes:LANGUAGE": "language",
+  cprt: "copyright",
+  "\xA9cpy": "copyright",
+  "----:com.apple.iTunes:LICENSE": "license",
+  "\xA9too": "encodedby",
+  pgap: "gapless",
+  "----:com.apple.iTunes:BARCODE": "barcode",
+  "----:com.apple.iTunes:ISRC": "isrc",
+  "----:com.apple.iTunes:ASIN": "asin",
+  "----:com.apple.iTunes:NOTES": "comment",
+  "----:com.apple.iTunes:MusicBrainz Track Id": "musicbrainz_recordingid",
+  "----:com.apple.iTunes:MusicBrainz Release Track Id": "musicbrainz_trackid",
+  "----:com.apple.iTunes:MusicBrainz Album Id": "musicbrainz_albumid",
+  "----:com.apple.iTunes:MusicBrainz Artist Id": "musicbrainz_artistid",
+  "----:com.apple.iTunes:MusicBrainz Album Artist Id": "musicbrainz_albumartistid",
+  "----:com.apple.iTunes:MusicBrainz Release Group Id": "musicbrainz_releasegroupid",
+  "----:com.apple.iTunes:MusicBrainz Work Id": "musicbrainz_workid",
+  "----:com.apple.iTunes:MusicBrainz TRM Id": "musicbrainz_trmid",
+  "----:com.apple.iTunes:MusicBrainz Disc Id": "musicbrainz_discid",
+  "----:com.apple.iTunes:Acoustid Id": "acoustid_id",
+  "----:com.apple.iTunes:Acoustid Fingerprint": "acoustid_fingerprint",
+  "----:com.apple.iTunes:MusicIP PUID": "musicip_puid",
+  "----:com.apple.iTunes:fingerprint": "musicip_fingerprint",
+  "----:com.apple.iTunes:replaygain_track_gain": "replaygain_track_gain",
+  "----:com.apple.iTunes:replaygain_track_peak": "replaygain_track_peak",
+  "----:com.apple.iTunes:replaygain_album_gain": "replaygain_album_gain",
+  "----:com.apple.iTunes:replaygain_album_peak": "replaygain_album_peak",
+  "----:com.apple.iTunes:replaygain_track_minmax": "replaygain_track_minmax",
+  "----:com.apple.iTunes:replaygain_album_minmax": "replaygain_album_minmax",
+  "----:com.apple.iTunes:replaygain_undo": "replaygain_undo",
+  // Additional mappings:
+  gnre: "genre",
+  // ToDo: check mapping
+  "----:com.apple.iTunes:ALBUMARTISTSORT": "albumartistsort",
+  "----:com.apple.iTunes:ARTISTS": "artists",
+  "----:com.apple.iTunes:ORIGINALDATE": "originaldate",
+  "----:com.apple.iTunes:ORIGINALYEAR": "originalyear",
+  "----:com.apple.iTunes:RELEASEDATE": "releasedate",
+  // '----:com.apple.iTunes:PERFORMER': 'performer'
+  desc: "description",
+  ldes: "longDescription",
+  "\xA9mvn": "movement",
+  "\xA9mvi": "movementIndex",
+  "\xA9mvc": "movementTotal",
+  "\xA9wrk": "work",
+  catg: "category",
+  egid: "podcastId",
+  hdvd: "hdVideo",
+  keyw: "keywords",
+  shwm: "showMovement",
+  stik: "stik",
+  rate: "rating"
+}, tagType = "iTunes", MP4TagMapper = class extends CaseInsensitiveTagMap {
+  constructor() {
+    super([tagType], mp4TagMap);
+  }
+  postMap(tag, _warnings) {
+    tag.id === "rate" && (tag.value = {
+      source: void 0,
+      rating: Number.parseFloat(tag.value) / 100
+    });
+  }
+};
+
+// node_modules/music-metadata/lib/ogg/vorbis/VorbisTagMapper.js
+var vorbisTagMap = {
+  TITLE: "title",
+  ARTIST: "artist",
+  ARTISTS: "artists",
+  ALBUMARTIST: "albumartist",
+  "ALBUM ARTIST": "albumartist",
+  ALBUM: "album",
+  DATE: "date",
+  ORIGINALDATE: "originaldate",
+  ORIGINALYEAR: "originalyear",
+  RELEASEDATE: "releasedate",
+  COMMENT: "comment",
+  TRACKNUMBER: "track",
+  DISCNUMBER: "disk",
+  GENRE: "genre",
+  METADATA_BLOCK_PICTURE: "picture",
+  COMPOSER: "composer",
+  LYRICS: "lyrics",
+  ALBUMSORT: "albumsort",
+  TITLESORT: "titlesort",
+  WORK: "work",
+  ARTISTSORT: "artistsort",
+  ALBUMARTISTSORT: "albumartistsort",
+  COMPOSERSORT: "composersort",
+  LYRICIST: "lyricist",
+  WRITER: "writer",
+  CONDUCTOR: "conductor",
+  // 'PERFORMER=artist (instrument)': 'performer:instrument', // ToDo
+  REMIXER: "remixer",
+  ARRANGER: "arranger",
+  ENGINEER: "engineer",
+  PRODUCER: "producer",
+  DJMIXER: "djmixer",
+  MIXER: "mixer",
+  LABEL: "label",
+  GROUPING: "grouping",
+  SUBTITLE: "subtitle",
+  DISCSUBTITLE: "discsubtitle",
+  TRACKTOTAL: "totaltracks",
+  DISCTOTAL: "totaldiscs",
+  COMPILATION: "compilation",
+  RATING: "rating",
+  BPM: "bpm",
+  KEY: "key",
+  MOOD: "mood",
+  MEDIA: "media",
+  CATALOGNUMBER: "catalognumber",
+  RELEASESTATUS: "releasestatus",
+  RELEASETYPE: "releasetype",
+  RELEASECOUNTRY: "releasecountry",
+  SCRIPT: "script",
+  LANGUAGE: "language",
+  COPYRIGHT: "copyright",
+  LICENSE: "license",
+  ENCODEDBY: "encodedby",
+  ENCODERSETTINGS: "encodersettings",
+  BARCODE: "barcode",
+  ISRC: "isrc",
+  ASIN: "asin",
+  MUSICBRAINZ_TRACKID: "musicbrainz_recordingid",
+  MUSICBRAINZ_RELEASETRACKID: "musicbrainz_trackid",
+  MUSICBRAINZ_ALBUMID: "musicbrainz_albumid",
+  MUSICBRAINZ_ARTISTID: "musicbrainz_artistid",
+  MUSICBRAINZ_ALBUMARTISTID: "musicbrainz_albumartistid",
+  MUSICBRAINZ_RELEASEGROUPID: "musicbrainz_releasegroupid",
+  MUSICBRAINZ_WORKID: "musicbrainz_workid",
+  MUSICBRAINZ_TRMID: "musicbrainz_trmid",
+  MUSICBRAINZ_DISCID: "musicbrainz_discid",
+  ACOUSTID_ID: "acoustid_id",
+  ACOUSTID_ID_FINGERPRINT: "acoustid_fingerprint",
+  MUSICIP_PUID: "musicip_puid",
+  // 'FINGERPRINT=MusicMagic Fingerprint {fingerprint}': 'musicip_fingerprint', // ToDo
+  WEBSITE: "website",
+  NOTES: "notes",
+  TOTALTRACKS: "totaltracks",
+  TOTALDISCS: "totaldiscs",
+  // Discogs
+  DISCOGS_ARTIST_ID: "discogs_artist_id",
+  DISCOGS_ARTISTS: "artists",
+  DISCOGS_ARTIST_NAME: "artists",
+  DISCOGS_ALBUM_ARTISTS: "albumartist",
+  DISCOGS_CATALOG: "catalognumber",
+  DISCOGS_COUNTRY: "releasecountry",
+  DISCOGS_DATE: "originaldate",
+  DISCOGS_LABEL: "label",
+  DISCOGS_LABEL_ID: "discogs_label_id",
+  DISCOGS_MASTER_RELEASE_ID: "discogs_master_release_id",
+  DISCOGS_RATING: "discogs_rating",
+  DISCOGS_RELEASED: "date",
+  DISCOGS_RELEASE_ID: "discogs_release_id",
+  DISCOGS_VOTES: "discogs_votes",
+  CATALOGID: "catalognumber",
+  STYLE: "genre",
+  //
+  REPLAYGAIN_TRACK_GAIN: "replaygain_track_gain",
+  REPLAYGAIN_TRACK_PEAK: "replaygain_track_peak",
+  REPLAYGAIN_ALBUM_GAIN: "replaygain_album_gain",
+  REPLAYGAIN_ALBUM_PEAK: "replaygain_album_peak",
+  // To Sure if these (REPLAYGAIN_MINMAX, REPLAYGAIN_ALBUM_MINMAX & REPLAYGAIN_UNDO) are used for Vorbis:
+  REPLAYGAIN_MINMAX: "replaygain_track_minmax",
+  REPLAYGAIN_ALBUM_MINMAX: "replaygain_album_minmax",
+  REPLAYGAIN_UNDO: "replaygain_undo"
+}, VorbisTagMapper = class _VorbisTagMapper extends CommonTagMapper {
+  static toRating(email, rating, maxScore) {
+    return {
+      source: email ? email.toLowerCase() : void 0,
+      rating: Number.parseFloat(rating) / maxScore * CommonTagMapper.maxRatingScore
+    };
+  }
+  constructor() {
+    super(["vorbis"], vorbisTagMap);
+  }
+  postMap(tag) {
+    if (tag.id === "RATING")
+      tag.value = _VorbisTagMapper.toRating(void 0, tag.value, 100);
+    else if (tag.id.indexOf("RATING:") === 0) {
+      let keys = tag.id.split(":");
+      tag.value = _VorbisTagMapper.toRating(keys[1], tag.value, 1), tag.id = keys[0];
+    }
+  }
+};
+
+// node_modules/music-metadata/lib/riff/RiffInfoTagMap.js
+var riffInfoTagMap = {
+  IART: "artist",
+  // Artist
+  ICRD: "date",
+  // DateCreated
+  INAM: "title",
+  // Title
+  TITL: "title",
+  IPRD: "album",
+  // Product
+  ITRK: "track",
+  IPRT: "track",
+  // Additional tag for track index
+  COMM: "comment",
+  // Comments
+  ICMT: "comment",
+  // Country
+  ICNT: "releasecountry",
+  GNRE: "genre",
+  // Genre
+  IWRI: "writer",
+  // WrittenBy
+  RATE: "rating",
+  YEAR: "year",
+  ISFT: "encodedby",
+  // Software
+  CODE: "encodedby",
+  // EncodedBy
+  TURL: "website",
+  // URL,
+  IGNR: "genre",
+  // Genre
+  IENG: "engineer",
+  // Engineer
+  ITCH: "technician",
+  // Technician
+  IMED: "media",
+  // Original Media
+  IRPD: "album"
+  // Product, where the file was intended for
+}, RiffInfoTagMapper = class extends CommonTagMapper {
+  constructor() {
+    super(["exif"], riffInfoTagMap);
+  }
+};
+
+// node_modules/music-metadata/lib/matroska/MatroskaTagMapper.js
+var ebmlTagMap = {
+  "segment:title": "title",
+  "album:ARTIST": "albumartist",
+  "album:ARTISTSORT": "albumartistsort",
+  "album:TITLE": "album",
+  "album:DATE_RECORDED": "originaldate",
+  "album:DATE_RELEASED": "releasedate",
+  "album:PART_NUMBER": "disk",
+  "album:TOTAL_PARTS": "totaltracks",
+  "track:ARTIST": "artist",
+  "track:ARTISTSORT": "artistsort",
+  "track:TITLE": "title",
+  "track:PART_NUMBER": "track",
+  "track:MUSICBRAINZ_TRACKID": "musicbrainz_recordingid",
+  "track:MUSICBRAINZ_ALBUMID": "musicbrainz_albumid",
+  "track:MUSICBRAINZ_ARTISTID": "musicbrainz_artistid",
+  "track:PUBLISHER": "label",
+  "track:GENRE": "genre",
+  "track:ENCODER": "encodedby",
+  "track:ENCODER_OPTIONS": "encodersettings",
+  "edition:TOTAL_PARTS": "totaldiscs",
+  picture: "picture"
+}, MatroskaTagMapper = class extends CaseInsensitiveTagMap {
+  constructor() {
+    super(["matroska"], ebmlTagMap);
+  }
+};
+
+// node_modules/music-metadata/lib/aiff/AiffTagMap.js
+var tagMap = {
+  NAME: "title",
+  AUTH: "artist",
+  "(c) ": "copyright",
+  ANNO: "comment"
+}, AiffTagMapper = class extends CommonTagMapper {
+  constructor() {
+    super(["AIFF"], tagMap);
+  }
+};
+
+// node_modules/music-metadata/lib/common/CombinedTagMapper.js
+var CombinedTagMapper = class {
+  constructor() {
+    this.tagMappers = {}, [
+      new ID3v1TagMapper(),
+      new ID3v22TagMapper(),
+      new ID3v24TagMapper(),
+      new MP4TagMapper(),
+      new MP4TagMapper(),
+      new VorbisTagMapper(),
+      new APEv2TagMapper(),
+      new AsfTagMapper(),
+      new RiffInfoTagMapper(),
+      new MatroskaTagMapper(),
+      new AiffTagMapper()
+    ].forEach((mapper) => {
+      this.registerTagMapper(mapper);
+    });
+  }
+  /**
+   * Convert native to generic (common) tags
+   * @param tagType Originating tag format
+   * @param tag     Native tag to map to a generic tag id
+   * @param warnings
+   * @return Generic tag result (output of this function)
+   */
+  mapTag(tagType2, tag, warnings) {
+    if (this.tagMappers[tagType2])
+      return this.tagMappers[tagType2].mapGenericTag(tag, warnings);
+    throw new InternalParserError(`No generic tag mapper defined for tag-format: ${tagType2}`);
+  }
+  registerTagMapper(genericTagMapper) {
+    for (let tagType2 of genericTagMapper.tagTypes)
+      this.tagMappers[tagType2] = genericTagMapper;
+  }
+};
+
+// node_modules/music-metadata/lib/lrc/LyricsParser.js
+var TIMESTAMP_REGEX = /\[(\d{2}):(\d{2})\.(\d{2,3})]/;
+function parseLyrics(input) {
+  return TIMESTAMP_REGEX.test(input) ? parseLrc(input) : toUnsyncedLyrics(input);
+}
+function toUnsyncedLyrics(lyrics) {
+  return {
+    contentType: LyricsContentType.lyrics,
+    timeStampFormat: TimestampFormat.notSynchronized,
+    text: lyrics.trim(),
+    syncText: []
+  };
+}
+function parseLrc(lrcString) {
+  let lines = lrcString.split(`
+`), syncText = [];
+  for (let line of lines) {
+    let match = line.match(TIMESTAMP_REGEX);
+    if (match) {
+      let minutes = Number.parseInt(match[1], 10), seconds = Number.parseInt(match[2], 10), ms = match[3].length === 3 ? Number.parseInt(match[3], 10) : Number.parseInt(match[3], 10) * 10, timestamp = (minutes * 60 + seconds) * 1e3 + ms, text = line.replace(TIMESTAMP_REGEX, "").trim();
+      syncText.push({ timestamp, text });
+    }
+  }
+  return {
+    contentType: LyricsContentType.lyrics,
+    timeStampFormat: TimestampFormat.milliseconds,
+    text: syncText.map((line) => line.text).join(`
+`),
+    syncText
+  };
+}
+
+// node_modules/music-metadata/lib/common/MetadataCollector.js
+var debug2 = (0, import_debug2.default)("music-metadata:collector"), TagPriority = ["matroska", "APEv2", "vorbis", "ID3v2.4", "ID3v2.3", "ID3v2.2", "exif", "asf", "iTunes", "AIFF", "ID3v1"], MetadataCollector = class {
+  constructor(opts) {
+    this.format = {
+      tagTypes: [],
+      trackInfo: []
+    }, this.native = {}, this.common = {
+      track: { no: null, of: null },
+      disk: { no: null, of: null },
+      movementIndex: { no: null, of: null }
+    }, this.quality = {
+      warnings: []
+    }, this.commonOrigin = {}, this.originPriority = {}, this.tagMapper = new CombinedTagMapper(), this.opts = opts;
+    let priority = 1;
+    for (let tagType2 of TagPriority)
+      this.originPriority[tagType2] = priority++;
+    this.originPriority.artificial = 500, this.originPriority.id3v1 = 600;
+  }
+  /**
+   * @returns {boolean} true if one or more tags have been found
+   */
+  hasAny() {
+    return Object.keys(this.native).length > 0;
+  }
+  addStreamInfo(streamInfo) {
+    debug2(`streamInfo: type=${streamInfo.type ? TrackTypeValueToKeyMap[streamInfo.type] : "?"}, codec=${streamInfo.codecName}`), this.format.trackInfo.push(streamInfo);
+  }
+  setFormat(key, value) {
+    debug2(`format: ${key} = ${value}`), this.format[key] = value, this.opts?.observer && this.opts.observer({ metadata: this, tag: { type: "format", id: key, value } });
+  }
+  setAudioOnly() {
+    this.setFormat("hasAudio", !0), this.setFormat("hasVideo", !1);
+  }
+  async addTag(tagType2, tagId, value) {
+    debug2(`tag ${tagType2}.${tagId} = ${value}`), this.native[tagType2] || (this.format.tagTypes.push(tagType2), this.native[tagType2] = []), this.native[tagType2].push({ id: tagId, value }), await this.toCommon(tagType2, tagId, value);
+  }
+  addWarning(warning) {
+    this.quality.warnings.push({ message: warning });
+  }
+  async postMap(tagType2, tag) {
+    switch (tag.id) {
+      case "artist":
+        return this.handleSingularArtistTag(tagType2, tag, "artist", "artists");
+      case "albumartist":
+        return this.handleSingularArtistTag(tagType2, tag, "albumartist", "albumartists");
+      case "artists":
+        return this.handlePluralArtistTag(tagType2, tag, "artist", "artists");
+      case "albumartists":
+        return this.handlePluralArtistTag(tagType2, tag, "albumartist", "albumartists");
+      case "picture":
+        return this.postFixPicture(tag.value).then((picture) => {
+          picture !== null && (tag.value = picture, this.setGenericTag(tagType2, tag));
+        });
+      case "totaltracks":
+        this.common.track.of = CommonTagMapper.toIntOrNull(tag.value);
+        return;
+      case "totaldiscs":
+        this.common.disk.of = CommonTagMapper.toIntOrNull(tag.value);
+        return;
+      case "movementTotal":
+        this.common.movementIndex.of = CommonTagMapper.toIntOrNull(tag.value);
+        return;
+      case "track":
+      case "disk":
+      case "movementIndex": {
+        let of = this.common[tag.id].of;
+        this.common[tag.id] = CommonTagMapper.normalizeTrack(tag.value), this.common[tag.id].of = of ?? this.common[tag.id].of;
+        return;
+      }
+      case "bpm":
+      case "year":
+      case "originalyear":
+        tag.value = Number.parseInt(tag.value, 10);
+        break;
+      case "date": {
+        let year = Number.parseInt(tag.value.substr(0, 4), 10);
+        Number.isNaN(year) || (this.common.year = year);
+        break;
+      }
+      case "discogs_label_id":
+      case "discogs_release_id":
+      case "discogs_master_release_id":
+      case "discogs_artist_id":
+      case "discogs_votes":
+        tag.value = typeof tag.value == "string" ? Number.parseInt(tag.value, 10) : tag.value;
+        break;
+      case "replaygain_track_gain":
+      case "replaygain_track_peak":
+      case "replaygain_album_gain":
+      case "replaygain_album_peak":
+        tag.value = toRatio(tag.value);
+        break;
+      case "replaygain_track_minmax":
+        tag.value = tag.value.split(",").map((v) => Number.parseInt(v, 10));
+        break;
+      case "replaygain_undo": {
+        let minMix = tag.value.split(",").map((v) => Number.parseInt(v, 10));
+        tag.value = {
+          leftChannel: minMix[0],
+          rightChannel: minMix[1]
+        };
+        break;
+      }
+      case "gapless":
+      // iTunes gap-less flag
+      case "compilation":
+      case "podcast":
+      case "showMovement":
+        tag.value = tag.value === "1" || tag.value === 1;
+        break;
+      case "isrc": {
+        let commonTag = this.common[tag.id];
+        if (commonTag && commonTag.indexOf(tag.value) !== -1)
+          return;
+        break;
+      }
+      case "comment":
+        typeof tag.value == "string" && (tag.value = { text: tag.value }), tag.value.descriptor === "iTunPGAP" && this.setGenericTag(tagType2, { id: "gapless", value: tag.value.text === "1" });
+        break;
+      case "lyrics":
+        typeof tag.value == "string" && (tag.value = parseLyrics(tag.value));
+        break;
+      default:
+    }
+    tag.value !== null && this.setGenericTag(tagType2, tag);
+  }
+  /**
+   * Convert native tags to common tags
+   * @returns {IAudioMetadata} Native + common tags
+   */
+  toCommonMetadata() {
+    return {
+      format: this.format,
+      native: this.native,
+      quality: this.quality,
+      common: this.common
+    };
+  }
+  /**
+   * Handle singular artist tags (artist, albumartist) and cross-populate to plural form
+   */
+  handleSingularArtistTag(tagType2, tag, singularId, pluralId) {
+    if (this.commonOrigin[singularId] === this.originPriority[tagType2])
+      return this.postMap("artificial", { id: pluralId, value: tag.value });
+    this.common[pluralId] || this.setGenericTag("artificial", { id: pluralId, value: tag.value }), this.setGenericTag(tagType2, tag);
+  }
+  /**
+   * Handle plural artist tags (artists, albumartists) and cross-populate to singular form
+   */
+  handlePluralArtistTag(tagType2, tag, singularId, pluralId) {
+    if ((!this.common[singularId] || this.commonOrigin[singularId] === this.originPriority.artificial) && (!this.common[pluralId] || this.common[pluralId].indexOf(tag.value) === -1)) {
+      let values = (this.common[pluralId] || []).concat([tag.value]), value = joinArtists(values);
+      this.setGenericTag("artificial", { id: singularId, value });
+    }
+    this.setGenericTag(tagType2, tag);
+  }
+  /**
+   * Fix some common issues with picture object
+   * @param picture Picture
+   */
+  async postFixPicture(picture) {
+    if (picture.data && picture.data.length > 0) {
+      if (!picture.format) {
+        let fileType = await fileTypeFromBuffer(Uint8Array.from(picture.data));
+        if (fileType)
+          picture.format = fileType.mime;
+        else
+          return null;
+      }
+      return picture.format = picture.format.toLocaleLowerCase(), picture.format === "image/jpg" && (picture.format = "image/jpeg"), picture;
+    }
+    return this.addWarning("Empty picture tag found"), null;
+  }
+  /**
+   * Convert native tag to common tags
+   */
+  async toCommon(tagType2, tagId, value) {
+    let tag = { id: tagId, value }, genericTag = this.tagMapper.mapTag(tagType2, tag, this);
+    genericTag && await this.postMap(tagType2, genericTag);
+  }
+  /**
+   * Set generic tag
+   */
+  setGenericTag(tagType2, tag) {
+    debug2(`common.${tag.id} = ${tag.value}`);
+    let prio0 = this.commonOrigin[tag.id] || 1e3, prio1 = this.originPriority[tagType2];
+    if (isSingleton(tag.id))
+      if (prio1 <= prio0)
+        this.common[tag.id] = tag.value, this.commonOrigin[tag.id] = prio1;
+      else
+        return debug2(`Ignore native tag (singleton): ${tagType2}.${tag.id} = ${tag.value}`);
+    else if (prio1 === prio0)
+      !isUnique(tag.id) || this.common[tag.id].indexOf(tag.value) === -1 ? this.common[tag.id].push(tag.value) : debug2(`Ignore duplicate value: ${tagType2}.${tag.id} = ${tag.value}`);
+    else if (prio1 < prio0)
+      this.common[tag.id] = [tag.value], this.commonOrigin[tag.id] = prio1;
+    else
+      return debug2(`Ignore native tag (list): ${tagType2}.${tag.id} = ${tag.value}`);
+    this.opts?.observer && this.opts.observer({ metadata: this, tag: { type: "common", id: tag.id, value: tag.value } });
+  }
+};
+function joinArtists(artists) {
+  return artists.length > 2 ? `${artists.slice(0, artists.length - 1).join(", ")} & ${artists[artists.length - 1]}` : artists.join(" & ");
+}
+
+// node_modules/music-metadata/lib/mpeg/MpegLoader.js
+var mpegParserLoader = {
+  parserType: "mpeg",
+  extensions: [".mp2", ".mp3", ".m2a", ".aac", "aacp"],
+  mimeTypes: ["audio/mpeg", "audio/mp3", "audio/aacs", "audio/aacp"],
+  async load() {
+    return (await import("./MpegParser-YW6LIUEW.mjs")).MpegParser;
+  }
+};
+
+// node_modules/music-metadata/lib/apev2/Apev2Loader.js
+var apeParserLoader = {
+  parserType: "apev2",
+  extensions: [".ape"],
+  mimeTypes: ["audio/ape", "audio/monkeys-audio"],
+  async load() {
+    return (await import("./APEv2Parser-2CNNHMXV.mjs")).APEv2Parser;
+  }
+};
+
+// node_modules/music-metadata/lib/asf/AsfLoader.js
+var asfParserLoader = {
+  parserType: "asf",
+  extensions: [".asf", ".wma", ".wmv"],
+  mimeTypes: ["audio/ms-wma", "video/ms-wmv", "audio/ms-asf", "video/ms-asf", "application/vnd.ms-asf"],
+  async load() {
+    return (await import("./AsfParser-VVRSLFOM.mjs")).AsfParser;
+  }
+};
+
+// node_modules/music-metadata/lib/dsdiff/DsdiffLoader.js
+var dsdiffParserLoader = {
+  parserType: "dsdiff",
+  extensions: [".dff"],
+  mimeTypes: ["audio/dsf", "audio/dsd"],
+  async load() {
+    return (await import("./DsdiffParser-CMD4AX7A.mjs")).DsdiffParser;
+  }
+};
+
+// node_modules/music-metadata/lib/aiff/AiffLoader.js
+var aiffParserLoader = {
+  parserType: "aiff",
+  extensions: [".aif", "aiff", "aifc"],
+  mimeTypes: ["audio/aiff", "audio/aif", "audio/aifc", "application/aiff"],
+  async load() {
+    return (await import("./AiffParser-7BR4RL6G.mjs")).AIFFParser;
+  }
+};
+
+// node_modules/music-metadata/lib/dsf/DsfLoader.js
+var dsfParserLoader = {
+  parserType: "dsf",
+  extensions: [".dsf"],
+  mimeTypes: ["audio/dsf"],
+  async load() {
+    return (await import("./DsfParser-UOGZDS2M.mjs")).DsfParser;
+  }
+};
+
+// node_modules/music-metadata/lib/flac/FlacLoader.js
+var flacParserLoader = {
+  parserType: "flac",
+  extensions: [".flac"],
+  mimeTypes: ["audio/flac"],
+  async load() {
+    return (await import("./FlacParser-HB3T3CD4.mjs")).FlacParser;
+  }
+};
+
+// node_modules/music-metadata/lib/matroska/MatroskaLoader.js
+var matroskaParserLoader = {
+  parserType: "matroska",
+  extensions: [".mka", ".mkv", ".mk3d", ".mks", "webm"],
+  mimeTypes: ["audio/matroska", "video/matroska", "audio/webm", "video/webm"],
+  async load() {
+    return (await import("./MatroskaParser-J3HUIMEW.mjs")).MatroskaParser;
+  }
+};
+
+// node_modules/music-metadata/lib/mp4/Mp4Loader.js
+var mp4ParserLoader = {
+  parserType: "mp4",
+  extensions: [".mp4", ".m4a", ".m4b", ".m4pa", "m4v", "m4r", "3gp", ".mov", ".movie", ".qt"],
+  mimeTypes: ["audio/mp4", "audio/m4a", "video/m4v", "video/mp4", "video/quicktime"],
+  async load() {
+    return (await import("./MP4Parser-66HBRUSX.mjs")).MP4Parser;
+  }
+};
+
+// node_modules/music-metadata/lib/musepack/MusepackLoader.js
+var musepackParserLoader = {
+  parserType: "musepack",
+  extensions: [".mpc"],
+  mimeTypes: ["audio/musepack"],
+  async load() {
+    return (await import("./MusepackParser-PAUSXP7D.mjs")).MusepackParser;
+  }
+};
+
+// node_modules/music-metadata/lib/ogg/OggLoader.js
+var oggParserLoader = {
+  parserType: "ogg",
+  extensions: [".ogg", ".ogv", ".oga", ".ogm", ".ogx", ".opus", ".spx"],
+  mimeTypes: ["audio/ogg", "audio/opus", "audio/speex", "video/ogg"],
+  // RFC 7845, RFC 6716, RFC 5574
+  async load() {
+    return (await import("./OggParser-NUBV3GWC.mjs")).OggParser;
+  }
+};
+
+// node_modules/music-metadata/lib/wavpack/WavPackLoader.js
+var wavpackParserLoader = {
+  parserType: "wavpack",
+  extensions: [".wv", ".wvp"],
+  mimeTypes: ["audio/wavpack"],
+  async load() {
+    return (await import("./WavPackParser-WQAGT7TC.mjs")).WavPackParser;
+  }
+};
+
+// node_modules/music-metadata/lib/wav/WaveLoader.js
+var riffParserLoader = {
+  parserType: "riff",
+  extensions: [".wav", "wave", ".bwf"],
+  mimeTypes: ["audio/vnd.wave", "audio/wav", "audio/wave"],
+  async load() {
+    return (await import("./WaveParser-EWLQVDX4.mjs")).WaveParser;
+  }
+};
+
+// node_modules/music-metadata/lib/ParserFactory.js
+var debug3 = (0, import_debug3.default)("music-metadata:parser:factory");
+function parseHttpContentType(contentType) {
+  let type = import_content_type.default.parse(contentType), mime = parse(type.type);
+  return {
+    type: mime.type,
+    subtype: mime.subtype,
+    suffix: mime.suffix,
+    parameters: type.parameters
+  };
+}
+var ParserFactory = class {
+  constructor() {
+    this.parsers = [], [
+      flacParserLoader,
+      mpegParserLoader,
+      apeParserLoader,
+      mp4ParserLoader,
+      matroskaParserLoader,
+      riffParserLoader,
+      oggParserLoader,
+      asfParserLoader,
+      aiffParserLoader,
+      wavpackParserLoader,
+      musepackParserLoader,
+      dsfParserLoader,
+      dsdiffParserLoader
+    ].forEach((parser) => {
+      this.registerParser(parser);
+    });
+  }
+  registerParser(parser) {
+    this.parsers.push(parser);
+  }
+  async parse(tokenizer, parserLoader, opts) {
+    if (tokenizer.supportsRandomAccess() ? (debug3("tokenizer supports random-access, scanning for appending headers"), await scanAppendingHeaders(tokenizer, opts)) : debug3("tokenizer does not support random-access, cannot scan for appending headers"), !parserLoader) {
+      let buf = new Uint8Array(4100);
+      if (tokenizer.fileInfo.mimeType && (parserLoader = this.findLoaderForContentType(tokenizer.fileInfo.mimeType)), !parserLoader && tokenizer.fileInfo.path && (parserLoader = this.findLoaderForExtension(tokenizer.fileInfo.path)), !parserLoader) {
+        debug3("Guess parser on content..."), await tokenizer.peekBuffer(buf, { mayBeLess: !0 });
+        let guessedType = await fileTypeFromBuffer(buf, { mpegOffsetTolerance: 10 });
+        if (!guessedType || !guessedType.mime)
+          throw new CouldNotDetermineFileTypeError("Failed to determine audio format");
+        if (debug3(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`), parserLoader = this.findLoaderForContentType(guessedType.mime), !parserLoader)
+          throw new UnsupportedFileTypeError(`Guessed MIME-type not supported: ${guessedType.mime}`);
+      }
+    }
+    debug3(`Loading ${parserLoader.parserType} parser...`);
+    let metadata = new MetadataCollector(opts), ParserImpl = await parserLoader.load(), parser = new ParserImpl(metadata, tokenizer, opts ?? {});
+    return debug3(`Parser ${parserLoader.parserType} loaded`), await parser.parse(), metadata.format.trackInfo && (metadata.format.hasAudio === void 0 && metadata.setFormat("hasAudio", !!metadata.format.trackInfo.find((track) => track.type === TrackType.audio)), metadata.format.hasVideo === void 0 && metadata.setFormat("hasVideo", !!metadata.format.trackInfo.find((track) => track.type === TrackType.video))), metadata.toCommonMetadata();
+  }
+  /**
+   * @param filePath - Path, filename or extension to audio file
+   * @return Parser submodule name
+   */
+  findLoaderForExtension(filePath) {
+    if (!filePath)
+      return;
+    let extension = getExtension(filePath).toLocaleLowerCase() || filePath;
+    return this.parsers.find((parser) => parser.extensions.indexOf(extension) !== -1);
+  }
+  findLoaderForContentType(httpContentType) {
+    let mime;
+    if (!httpContentType)
+      return;
+    try {
+      mime = parseHttpContentType(httpContentType);
+    } catch {
+      debug3(`Invalid HTTP Content-Type header value: ${httpContentType}`);
+      return;
+    }
+    let subType = mime.subtype.indexOf("x-") === 0 ? mime.subtype.substring(2) : mime.subtype;
+    return this.parsers.find((parser) => parser.mimeTypes.find((loader) => loader.indexOf(`${mime.type}/${subType}`) !== -1));
+  }
+  getSupportedMimeTypes() {
+    let mimeTypeSet = /* @__PURE__ */ new Set();
+    return this.parsers.forEach((loader) => {
+      loader.mimeTypes.forEach((mimeType) => {
+        mimeTypeSet.add(mimeType), mimeTypeSet.add(mimeType.replace("/", "/x-"));
+      });
+    }), Array.from(mimeTypeSet);
+  }
+};
+function getExtension(fname) {
+  let i = fname.lastIndexOf(".");
+  return i === -1 ? "" : fname.substring(i);
+}
+
+// node_modules/music-metadata/lib/lyrics3/Lyrics3.js
+var endTag2 = "LYRICS200";
+async function getLyricsHeaderLength(tokenizer) {
+  let fileSize = tokenizer.fileInfo.size;
+  if (fileSize >= 143) {
+    let buf = new Uint8Array(15), position = tokenizer.position;
+    await tokenizer.readBuffer(buf, { position: fileSize - 143 }), tokenizer.setPosition(position);
+    let txt = textDecode(buf, "latin1");
+    if (txt.substring(6) === endTag2)
+      return Number.parseInt(txt.substring(0, 6), 10) + 15;
+  }
+  return 0;
+}
+
+// node_modules/music-metadata/lib/core.js
+async function parseBlob(blob, options = {}) {
+  let tokenizer = fromBlob(blob);
+  try {
+    return await parseFromTokenizer(tokenizer, options);
+  } finally {
+    await tokenizer.close();
+  }
+}
+async function parseWebStream(webStream, fileInfo, options = {}) {
+  let tokenizer = fromWebStream(webStream, { fileInfo: typeof fileInfo == "string" ? { mimeType: fileInfo } : fileInfo });
+  try {
+    return await parseFromTokenizer(tokenizer, options);
+  } finally {
+    await tokenizer.close();
+  }
+}
+async function parseBuffer(uint8Array, fileInfo, options = {}) {
+  let tokenizer = fromBuffer(uint8Array, { fileInfo: typeof fileInfo == "string" ? { mimeType: fileInfo } : fileInfo });
+  return parseFromTokenizer(tokenizer, options);
+}
+function parseFromTokenizer(tokenizer, options) {
+  return new ParserFactory().parse(tokenizer, void 0, options);
+}
+function orderTags(nativeTags) {
+  let tags = {};
+  for (let { id, value } of nativeTags)
+    (tags[id] || (tags[id] = [])).push(value);
+  return tags;
+}
+function ratingToStars(rating) {
+  return rating === void 0 ? 0 : 1 + Math.round(rating * 4);
+}
+function selectCover(pictures) {
+  return pictures ? pictures.reduce((acc, cur) => cur.name && cur.name.toLowerCase() in ["front", "cover", "cover (front)"] ? cur : acc) : null;
+}
+async function scanAppendingHeaders(tokenizer, options = {}) {
+  let apeOffset = tokenizer.fileInfo.size;
+  if (await hasID3v1Header(tokenizer)) {
+    apeOffset -= 128;
+    let lyricsLen = await getLyricsHeaderLength(tokenizer);
+    apeOffset -= lyricsLen;
+  }
+  options.apeHeader = await APEv2Parser.findApeFooterOffset(tokenizer, apeOffset);
+}
+function getSupportedMimeTypes() {
+  return new ParserFactory().getSupportedMimeTypes();
+}
+
+// node_modules/music-metadata/lib/index.js
+var debug4 = (0, import_debug4.default)("music-metadata:parser");
+async function parseStream(stream, fileInfo, options = {}) {
+  let tokenizer = await fromStream(stream, { fileInfo: typeof fileInfo == "string" ? { mimeType: fileInfo } : fileInfo });
+  try {
+    return await parseFromTokenizer(tokenizer, options);
+  } finally {
+    await tokenizer.close();
+  }
+}
+async function parseFile(filePath, options = {}) {
+  debug4(`parseFile: ${filePath}`);
+  let fileTokenizer = await fromFile(filePath), parserFactory = new ParserFactory();
+  try {
+    let parserLoader = parserFactory.findLoaderForExtension(filePath);
+    parserLoader || debug4("Parser could not be determined by file extension");
+    try {
+      return await parserFactory.parse(fileTokenizer, parserLoader, options);
+    } catch (error) {
+      throw (error instanceof CouldNotDetermineFileTypeError || error instanceof UnsupportedFileTypeError) && (error.message += `: ${filePath}`), error;
+    }
+  } finally {
+    await fileTokenizer.close();
+  }
+}
+export {
+  CouldNotDetermineFileTypeError,
+  FieldDecodingError,
+  InternalParserError,
+  LyricsContentType,
+  TimestampFormat,
+  UnsupportedFileTypeError,
+  getSupportedMimeTypes,
+  makeParseError,
+  makeUnexpectedFileContentError,
+  orderTags,
+  parseBlob,
+  parseBuffer,
+  parseFile,
+  parseFromTokenizer,
+  parseStream,
+  parseWebStream,
+  ratingToStars,
+  scanAppendingHeaders,
+  selectCover
+};