@slicemachine/manager 0.0.0-alpha.dev-new-release-process.1

package/dist/_node_modules/file-type/core.cjs

@@ -0,0 +1,1234 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_buffer = require("node:buffer");
+const index = require("../token-types/lib/index.cjs");
+const core = require("../strtok3/lib/core.cjs");
+const util = require("./util.cjs");
+const supported = require("./supported.cjs");
+const EndOfFileStream = require("../peek-readable/lib/EndOfFileStream.cjs");
+const minimumBytes = 4100;
+async function fileTypeFromBuffer(input) {
+  if (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) {
+    throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\` or \`ArrayBuffer\`, got \`${typeof input}\``);
+  }
+  const buffer = input instanceof Uint8Array ? input : new Uint8Array(input);
+  if (!((buffer == null ? void 0 : buffer.length) > 1)) {
+    return;
+  }
+  return fileTypeFromTokenizer(core.fromBuffer(buffer));
+}
+function _check(buffer, headers, options) {
+  options = {
+    offset: 0,
+    ...options
+  };
+  for (const [index2, header] of headers.entries()) {
+    if (options.mask) {
+      if (header !== (options.mask[index2] & buffer[index2 + options.offset])) {
+        return false;
+      }
+    } else if (header !== buffer[index2 + options.offset]) {
+      return false;
+    }
+  }
+  return true;
+}
+async function fileTypeFromTokenizer(tokenizer) {
+  try {
+    return new FileTypeParser().parse(tokenizer);
+  } catch (error) {
+    if (!(error instanceof EndOfFileStream.EndOfStreamError)) {
+      throw error;
+    }
+  }
+}
+class FileTypeParser {
+  check(header, options) {
+    return _check(this.buffer, header, options);
+  }
+  checkString(header, options) {
+    return this.check(util.stringToBytes(header), options);
+  }
+  async parse(tokenizer) {
+    this.buffer = node_buffer.Buffer.alloc(minimumBytes);
+    if (tokenizer.fileInfo.size === void 0) {
+      tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
+    }
+    this.tokenizer = tokenizer;
+    await tokenizer.peekBuffer(this.buffer, { length: 12, mayBeLess: true });
+    if (this.check([66, 77])) {
+      return {
+        ext: "bmp",
+        mime: "image/bmp"
+      };
+    }
+    if (this.check([11, 119])) {
+      return {
+        ext: "ac3",
+        mime: "audio/vnd.dolby.dd-raw"
+      };
+    }
+    if (this.check([120, 1])) {
+      return {
+        ext: "dmg",
+        mime: "application/x-apple-diskimage"
+      };
+    }
+    if (this.check([77, 90])) {
+      return {
+        ext: "exe",
+        mime: "application/x-msdownload"
+      };
+    }
+    if (this.check([37, 33])) {
+      await tokenizer.peekBuffer(this.buffer, { length: 24, mayBeLess: true });
+      if (this.checkString("PS-Adobe-", { offset: 2 }) && this.checkString(" EPSF-", { offset: 14 })) {
+        return {
+          ext: "eps",
+          mime: "application/eps"
+        };
+      }
+      return {
+        ext: "ps",
+        mime: "application/postscript"
+      };
+    }
+    if (this.check([31, 160]) || this.check([31, 157])) {
+      return {
+        ext: "Z",
+        mime: "application/x-compress"
+      };
+    }
+    if (this.check([199, 113])) {
+      return {
+        ext: "cpio",
+        mime: "application/x-cpio"
+      };
+    }
+    if (this.check([96, 234])) {
+      return {
+        ext: "arj",
+        mime: "application/x-arj"
+      };
+    }
+    if (this.check([239, 187, 191])) {
+      this.tokenizer.ignore(3);
+      return this.parse(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 {
+        ext: "gz",
+        mime: "application/gzip"
+      };
+    }
+    if (this.check([66, 90, 104])) {
+      return {
+        ext: "bz2",
+        mime: "application/x-bzip2"
+      };
+    }
+    if (this.checkString("ID3")) {
+      await tokenizer.ignore(6);
+      const id3HeaderLength = await tokenizer.readToken(util.uint32SyncSafeToken);
+      if (tokenizer.position + id3HeaderLength > tokenizer.fileInfo.size) {
+        return {
+          ext: "mp3",
+          mime: "audio/mpeg"
+        };
+      }
+      await tokenizer.ignore(id3HeaderLength);
+      return fileTypeFromTokenizer(tokenizer);
+    }
+    if (this.checkString("MP+")) {
+      return {
+        ext: "mpc",
+        mime: "audio/x-musepack"
+      };
+    }
+    if ((this.buffer[0] === 67 || this.buffer[0] === 70) && this.check([87, 83], { offset: 1 })) {
+      return {
+        ext: "swf",
+        mime: "application/x-shockwave-flash"
+      };
+    }
+    if (this.check([255, 216, 255])) {
+      if (this.check([247], { offset: 3 })) {
+        return {
+          ext: "jls",
+          mime: "image/jls"
+        };
+      }
+      return {
+        ext: "jpg",
+        mime: "image/jpeg"
+      };
+    }
+    if (this.check([79, 98, 106, 1])) {
+      return {
+        ext: "avro",
+        mime: "application/avro"
+      };
+    }
+    if (this.checkString("FLIF")) {
+      return {
+        ext: "flif",
+        mime: "image/flif"
+      };
+    }
+    if (this.checkString("8BPS")) {
+      return {
+        ext: "psd",
+        mime: "image/vnd.adobe.photoshop"
+      };
+    }
+    if (this.checkString("WEBP", { offset: 8 })) {
+      return {
+        ext: "webp",
+        mime: "image/webp"
+      };
+    }
+    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])) {
+      try {
+        while (tokenizer.position + 30 < tokenizer.fileInfo.size) {
+          await tokenizer.readBuffer(this.buffer, { length: 30 });
+          const zipHeader = {
+            compressedSize: this.buffer.readUInt32LE(18),
+            uncompressedSize: this.buffer.readUInt32LE(22),
+            filenameLength: this.buffer.readUInt16LE(26),
+            extraFieldLength: this.buffer.readUInt16LE(28)
+          };
+          zipHeader.filename = await tokenizer.readToken(new index.StringType(zipHeader.filenameLength, "utf-8"));
+          await tokenizer.ignore(zipHeader.extraFieldLength);
+          if (zipHeader.filename === "META-INF/mozilla.rsa") {
+            return {
+              ext: "xpi",
+              mime: "application/x-xpinstall"
+            };
+          }
+          if (zipHeader.filename.endsWith(".rels") || zipHeader.filename.endsWith(".xml")) {
+            const type = zipHeader.filename.split("/")[0];
+            switch (type) {
+              case "_rels":
+                break;
+              case "word":
+                return {
+                  ext: "docx",
+                  mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                };
+              case "ppt":
+                return {
+                  ext: "pptx",
+                  mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+                };
+              case "xl":
+                return {
+                  ext: "xlsx",
+                  mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                };
+              default:
+                break;
+            }
+          }
+          if (zipHeader.filename.startsWith("xl/")) {
+            return {
+              ext: "xlsx",
+              mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            };
+          }
+          if (zipHeader.filename.startsWith("3D/") && zipHeader.filename.endsWith(".model")) {
+            return {
+              ext: "3mf",
+              mime: "model/3mf"
+            };
+          }
+          if (zipHeader.filename === "mimetype" && zipHeader.compressedSize === zipHeader.uncompressedSize) {
+            let mimeType = await tokenizer.readToken(new index.StringType(zipHeader.compressedSize, "utf-8"));
+            mimeType = mimeType.trim();
+            switch (mimeType) {
+              case "application/epub+zip":
+                return {
+                  ext: "epub",
+                  mime: "application/epub+zip"
+                };
+              case "application/vnd.oasis.opendocument.text":
+                return {
+                  ext: "odt",
+                  mime: "application/vnd.oasis.opendocument.text"
+                };
+              case "application/vnd.oasis.opendocument.spreadsheet":
+                return {
+                  ext: "ods",
+                  mime: "application/vnd.oasis.opendocument.spreadsheet"
+                };
+              case "application/vnd.oasis.opendocument.presentation":
+                return {
+                  ext: "odp",
+                  mime: "application/vnd.oasis.opendocument.presentation"
+                };
+              default:
+            }
+          }
+          if (zipHeader.compressedSize === 0) {
+            let nextHeaderIndex = -1;
+            while (nextHeaderIndex < 0 && tokenizer.position < tokenizer.fileInfo.size) {
+              await tokenizer.peekBuffer(this.buffer, { mayBeLess: true });
+              nextHeaderIndex = this.buffer.indexOf("504B0304", 0, "hex");
+              await tokenizer.ignore(nextHeaderIndex >= 0 ? nextHeaderIndex : this.buffer.length);
+            }
+          } else {
+            await tokenizer.ignore(zipHeader.compressedSize);
+          }
+        }
+      } catch (error) {
+        if (!(error instanceof EndOfFileStream.EndOfStreamError)) {
+          throw error;
+        }
+      }
+      return {
+        ext: "zip",
+        mime: "application/zip"
+      };
+    }
+    if (this.checkString("OggS")) {
+      await tokenizer.ignore(28);
+      const type = node_buffer.Buffer.alloc(8);
+      await tokenizer.readBuffer(type);
+      if (_check(type, [79, 112, 117, 115, 72, 101, 97, 100])) {
+        return {
+          ext: "opus",
+          mime: "audio/opus"
+        };
+      }
+      if (_check(type, [128, 116, 104, 101, 111, 114, 97])) {
+        return {
+          ext: "ogv",
+          mime: "video/ogg"
+        };
+      }
+      if (_check(type, [1, 118, 105, 100, 101, 111, 0])) {
+        return {
+          ext: "ogm",
+          mime: "video/ogg"
+        };
+      }
+      if (_check(type, [127, 70, 76, 65, 67])) {
+        return {
+          ext: "oga",
+          mime: "audio/ogg"
+        };
+      }
+      if (_check(type, [83, 112, 101, 101, 120, 32, 32])) {
+        return {
+          ext: "spx",
+          mime: "audio/ogg"
+        };
+      }
+      if (_check(type, [1, 118, 111, 114, 98, 105, 115])) {
+        return {
+          ext: "ogg",
+          mime: "audio/ogg"
+        };
+      }
+      return {
+        ext: "ogx",
+        mime: "application/ogg"
+      };
+    }
+    if (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("ftyp", { offset: 4 }) && (this.buffer[8] & 96) !== 0) {
+      const brandMajor = this.buffer.toString("binary", 8, 12).replace("\0", " ").trim();
+      switch (brandMajor) {
+        case "avif":
+        case "avis":
+          return { ext: "avif", mime: "image/avif" };
+        case "mif1":
+          return { ext: "heic", mime: "image/heif" };
+        case "msf1":
+          return { ext: "heic", mime: "image/heif-sequence" };
+        case "heic":
+        case "heix":
+          return { ext: "heic", mime: "image/heic" };
+        case "hevc":
+        case "hevx":
+          return { ext: "heic", mime: "image/heic-sequence" };
+        case "qt":
+          return { ext: "mov", mime: "video/quicktime" };
+        case "M4V":
+        case "M4VH":
+        case "M4VP":
+          return { ext: "m4v", mime: "video/x-m4v" };
+        case "M4P":
+          return { ext: "m4p", mime: "video/mp4" };
+        case "M4B":
+          return { ext: "m4b", mime: "audio/mp4" };
+        case "M4A":
+          return { ext: "m4a", mime: "audio/x-m4a" };
+        case "F4V":
+          return { ext: "f4v", mime: "video/mp4" };
+        case "F4P":
+          return { ext: "f4p", mime: "video/mp4" };
+        case "F4A":
+          return { ext: "f4a", mime: "audio/mp4" };
+        case "F4B":
+          return { ext: "f4b", mime: "audio/mp4" };
+        case "crx":
+          return { ext: "cr3", mime: "image/x-canon-cr3" };
+        default:
+          if (brandMajor.startsWith("3g")) {
+            if (brandMajor.startsWith("3g2")) {
+              return { ext: "3g2", mime: "video/3gpp2" };
+            }
+            return { ext: "3gp", mime: "video/3gpp" };
+          }
+          return { ext: "mp4", mime: "video/mp4" };
+      }
+    }
+    if (this.checkString("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/x-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")) {
+      try {
+        await tokenizer.ignore(1350);
+        const maxBufferSize = 10 * 1024 * 1024;
+        const buffer = node_buffer.Buffer.alloc(Math.min(maxBufferSize, tokenizer.fileInfo.size));
+        await tokenizer.readBuffer(buffer, { mayBeLess: true });
+        if (buffer.includes(node_buffer.Buffer.from("AIPrivateData"))) {
+          return {
+            ext: "ai",
+            mime: "application/postscript"
+          };
+        }
+      } catch (error) {
+        if (!(error instanceof EndOfFileStream.EndOfStreamError)) {
+          throw error;
+        }
+      }
+      return {
+        ext: "pdf",
+        mime: "application/pdf"
+      };
+    }
+    if (this.check([0, 97, 115, 109])) {
+      return {
+        ext: "wasm",
+        mime: "application/wasm"
+      };
+    }
+    if (this.check([73, 73])) {
+      const fileType = await this.readTiffHeader(false);
+      if (fileType) {
+        return fileType;
+      }
+    }
+    if (this.check([77, 77])) {
+      const fileType = await this.readTiffHeader(true);
+      if (fileType) {
+        return fileType;
+      }
+    }
+    if (this.checkString("MAC ")) {
+      return {
+        ext: "ape",
+        mime: "audio/ape"
+      };
+    }
+    if (this.check([26, 69, 223, 163])) {
+      async function readField() {
+        const msb = await tokenizer.peekNumber(index.UINT8);
+        let mask = 128;
+        let ic = 0;
+        while ((msb & mask) === 0 && mask !== 0) {
+          ++ic;
+          mask >>= 1;
+        }
+        const id = node_buffer.Buffer.alloc(ic + 1);
+        await tokenizer.readBuffer(id);
+        return id;
+      }
+      async function readElement() {
+        const id = await readField();
+        const lengthField = await readField();
+        lengthField[0] ^= 128 >> lengthField.length - 1;
+        const nrLength = Math.min(6, lengthField.length);
+        return {
+          id: id.readUIntBE(0, id.length),
+          len: lengthField.readUIntBE(lengthField.length - nrLength, nrLength)
+        };
+      }
+      async function readChildren(children) {
+        while (children > 0) {
+          const element = await readElement();
+          if (element.id === 17026) {
+            const rawValue = await tokenizer.readToken(new index.StringType(element.len, "utf-8"));
+            return rawValue.replace(/\00.*$/g, "");
+          }
+          await tokenizer.ignore(element.len);
+          --children;
+        }
+      }
+      const re = await readElement();
+      const docType = await readChildren(re.len);
+      switch (docType) {
+        case "webm":
+          return {
+            ext: "webm",
+            mime: "video/webm"
+          };
+        case "matroska":
+          return {
+            ext: "mkv",
+            mime: "video/x-matroska"
+          };
+        default:
+          return;
+      }
+    }
+    if (this.check([82, 73, 70, 70])) {
+      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/vnd.wave"
+        };
+      }
+      if (this.check([81, 76, 67, 77], { offset: 8 })) {
+        return {
+          ext: "qcp",
+          mime: "audio/qcelp"
+        };
+      }
+    }
+    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")) {
+      return {
+        ext: "parquet",
+        mime: "application/x-parquet"
+      };
+    }
+    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])) {
+      return {
+        ext: "class",
+        mime: "application/java-vm"
+      };
+    }
+    if (this.check([253, 55, 122, 88, 90, 0])) {
+      return {
+        ext: "xz",
+        mime: "application/x-xz"
+      };
+    }
+    if (this.checkString("<?xml ")) {
+      return {
+        ext: "xml",
+        mime: "application/xml"
+      };
+    }
+    if (this.check([55, 122, 188, 175, 39, 28])) {
+      return {
+        ext: "7z",
+        mime: "application/x-7z-compressed"
+      };
+    }
+    if (this.check([82, 97, 114, 33, 26, 7]) && (this.buffer[6] === 0 || this.buffer[6] === 1)) {
+      return {
+        ext: "rar",
+        mime: "application/x-rar-compressed"
+      };
+    }
+    if (this.checkString("solid ")) {
+      return {
+        ext: "stl",
+        mime: "model/stl"
+      };
+    }
+    if (this.checkString("AC")) {
+      const version = this.buffer.toString("binary", 2, 6);
+      if (version.match("^d*") && version >= 1e3 && version <= 1050) {
+        return {
+          ext: "dwg",
+          mime: "image/vnd.dwg"
+        };
+      }
+    }
+    if (this.checkString("070707")) {
+      return {
+        ext: "cpio",
+        mime: "application/x-cpio"
+      };
+    }
+    if (this.checkString("BLENDER")) {
+      return {
+        ext: "blend",
+        mime: "application/x-blender"
+      };
+    }
+    if (this.checkString("!<arch>")) {
+      await tokenizer.ignore(8);
+      const string = await tokenizer.readToken(new index.StringType(13, "ascii"));
+      if (string === "debian-binary") {
+        return {
+          ext: "deb",
+          mime: "application/x-deb"
+        };
+      }
+      return {
+        ext: "ar",
+        mime: "application/x-unix-archive"
+      };
+    }
+    if (this.checkString("**ACE", { offset: 7 })) {
+      await tokenizer.peekBuffer(this.buffer, { length: 14, mayBeLess: true });
+      if (this.checkString("**", { offset: 12 })) {
+        return {
+          ext: "ace",
+          mime: "application/x-ace-compressed"
+        };
+      }
+    }
+    if (this.check([137, 80, 78, 71, 13, 10, 26, 10])) {
+      await tokenizer.ignore(8);
+      async function readChunkHeader() {
+        return {
+          length: await tokenizer.readToken(index.INT32_BE),
+          type: await tokenizer.readToken(new index.StringType(4, "binary"))
+        };
+      }
+      do {
+        const chunk = await readChunkHeader();
+        if (chunk.length < 0) {
+          return;
+        }
+        switch (chunk.type) {
+          case "IDAT":
+            return {
+              ext: "png",
+              mime: "image/png"
+            };
+          case "acTL":
+            return {
+              ext: "apng",
+              mime: "image/apng"
+            };
+          default:
+            await tokenizer.ignore(chunk.length + 4);
+        }
+      } while (tokenizer.position + 8 < tokenizer.fileInfo.size);
+      return {
+        ext: "png",
+        mime: "image/png"
+      };
+    }
+    if (this.check([65, 82, 82, 79, 87, 49, 0, 0])) {
+      return {
+        ext: "arrow",
+        mime: "application/x-apache-arrow"
+      };
+    }
+    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.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])) {
+      async function readHeader() {
+        const guid = node_buffer.Buffer.alloc(16);
+        await tokenizer.readBuffer(guid);
+        return {
+          id: guid,
+          size: Number(await tokenizer.readToken(index.UINT64_LE))
+        };
+      }
+      await tokenizer.ignore(30);
+      while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
+        const header = await readHeader();
+        let payload = header.size - 24;
+        if (_check(header.id, [145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101])) {
+          const typeId = node_buffer.Buffer.alloc(16);
+          payload -= await tokenizer.readBuffer(typeId);
+          if (_check(typeId, [64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
+            return {
+              ext: "asf",
+              mime: "audio/x-ms-asf"
+            };
+          }
+          if (_check(typeId, [192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
+            return {
+              ext: "asf",
+              mime: "video/x-ms-asf"
+            };
+          }
+          break;
+        }
+        await tokenizer.ignore(payload);
+      }
+      return {
+        ext: "asf",
+        mime: "application/vnd.ms-asf"
+      };
+    }
+    if (this.check([171, 75, 84, 88, 32, 49, 49, 187, 13, 10, 26, 10])) {
+      return {
+        ext: "ktx",
+        mime: "image/ktx"
+      };
+    }
+    if ((this.check([126, 16, 4]) || this.check([126, 24, 4])) && this.check([48, 77, 73, 69], { offset: 4 })) {
+      return {
+        ext: "mie",
+        mime: "application/x-mie"
+      };
+    }
+    if (this.check([39, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], { offset: 2 })) {
+      return {
+        ext: "shp",
+        mime: "application/x-esri-shape"
+      };
+    }
+    if (this.check([255, 79, 255, 81])) {
+      return {
+        ext: "j2c",
+        mime: "image/j2c"
+      };
+    }
+    if (this.check([0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10])) {
+      await tokenizer.ignore(20);
+      const type = await tokenizer.readToken(new index.StringType(4, "ascii"));
+      switch (type) {
+        case "jp2 ":
+          return {
+            ext: "jp2",
+            mime: "image/jp2"
+          };
+        case "jpx ":
+          return {
+            ext: "jpx",
+            mime: "image/jpx"
+          };
+        case "jpm ":
+          return {
+            ext: "jpm",
+            mime: "image/jpm"
+          };
+        case "mjp2":
+          return {
+            ext: "mj2",
+            mime: "image/mj2"
+          };
+        default:
+          return;
+      }
+    }
+    if (this.check([255, 10]) || this.check([0, 0, 0, 12, 74, 88, 76, 32, 13, 10, 135, 10])) {
+      return {
+        ext: "jxl",
+        mime: "image/jxl"
+      };
+    }
+    if (this.check([254, 255])) {
+      if (this.check([0, 60, 0, 63, 0, 120, 0, 109, 0, 108], { offset: 2 })) {
+        return {
+          ext: "xml",
+          mime: "application/xml"
+        };
+      }
+      return void 0;
+    }
+    if (this.check([0, 0, 1, 186]) || this.check([0, 0, 1, 179])) {
+      return {
+        ext: "mpg",
+        mime: "video/mpeg"
+      };
+    }
+    if (this.check([0, 1, 0, 0, 0])) {
+      return {
+        ext: "ttf",
+        mime: "font/ttf"
+      };
+    }
+    if (this.check([0, 0, 1, 0])) {
+      return {
+        ext: "ico",
+        mime: "image/x-icon"
+      };
+    }
+    if (this.check([0, 0, 2, 0])) {
+      return {
+        ext: "cur",
+        mime: "image/x-icon"
+      };
+    }
+    if (this.check([208, 207, 17, 224, 161, 177, 26, 225])) {
+      return {
+        ext: "cfb",
+        mime: "application/x-cfb"
+      };
+    }
+    await tokenizer.peekBuffer(this.buffer, { length: Math.min(256, tokenizer.fileInfo.size), mayBeLess: true });
+    if (this.check([97, 99, 115, 112], { offset: 36 })) {
+      return {
+        ext: "icc",
+        mime: "application/vnd.iccprofile"
+      };
+    }
+    if (this.checkString("BEGIN:")) {
+      if (this.checkString("VCARD", { offset: 6 })) {
+        return {
+          ext: "vcf",
+          mime: "text/vcard"
+        };
+      }
+      if (this.checkString("VCALENDAR", { offset: 6 })) {
+        return {
+          ext: "ics",
+          mime: "text/calendar"
+        };
+      }
+    }
+    if (this.checkString("FUJIFILMCCD-RAW")) {
+      return {
+        ext: "raf",
+        mime: "image/x-fujifilm-raf"
+      };
+    }
+    if (this.checkString("Extended Module:")) {
+      return {
+        ext: "xm",
+        mime: "audio/x-xm"
+      };
+    }
+    if (this.checkString("Creative Voice File")) {
+      return {
+        ext: "voc",
+        mime: "audio/x-voc"
+      };
+    }
+    if (this.check([4, 0, 0, 0]) && this.buffer.length >= 16) {
+      const jsonSize = this.buffer.readUInt32LE(12);
+      if (jsonSize > 12 && this.buffer.length >= jsonSize + 16) {
+        try {
+          const header = this.buffer.slice(16, jsonSize + 16).toString();
+          const json = JSON.parse(header);
+          if (json.files) {
+            return {
+              ext: "asar",
+              mime: "application/x-asar"
+            };
+          }
+        } catch {
+        }
+      }
+    }
+    if (this.check([6, 14, 43, 52, 2, 5, 1, 1, 13, 1, 2, 1, 1, 2])) {
+      return {
+        ext: "mxf",
+        mime: "application/mxf"
+      };
+    }
+    if (this.checkString("SCRM", { offset: 44 })) {
+      return {
+        ext: "s3m",
+        mime: "audio/x-s3m"
+      };
+    }
+    if (this.check([71]) && this.check([71], { offset: 188 })) {
+      return {
+        ext: "mts",
+        mime: "video/mp2t"
+      };
+    }
+    if (this.check([71], { offset: 4 }) && this.check([71], { offset: 196 })) {
+      return {
+        ext: "mts",
+        mime: "video/mp2t"
+      };
+    }
+    if (this.check([66, 79, 79, 75, 77, 79, 66, 73], { offset: 60 })) {
+      return {
+        ext: "mobi",
+        mime: "application/x-mobipocket-ebook"
+      };
+    }
+    if (this.check([68, 73, 67, 77], { offset: 128 })) {
+      return {
+        ext: "dcm",
+        mime: "application/dicom"
+      };
+    }
+    if (this.check([76, 0, 0, 0, 1, 20, 2, 0, 0, 0, 0, 0, 192, 0, 0, 0, 0, 0, 0, 70])) {
+      return {
+        ext: "lnk",
+        mime: "application/x.ms.shortcut"
+        // 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.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"
+      };
+    }
+    await tokenizer.peekBuffer(this.buffer, { length: Math.min(512, tokenizer.fileInfo.size), mayBeLess: true });
+    if (util.tarHeaderChecksumMatches(this.buffer)) {
+      return {
+        ext: "tar",
+        mime: "application/x-tar"
+      };
+    }
+    if (this.check([255, 254])) {
+      if (this.check([60, 0, 63, 0, 120, 0, 109, 0, 108, 0], { offset: 2 })) {
+        return {
+          ext: "xml",
+          mime: "application/xml"
+        };
+      }
+      if (this.check([255, 14, 83, 0, 107, 0, 101, 0, 116, 0, 99, 0, 104, 0, 85, 0, 112, 0, 32, 0, 77, 0, 111, 0, 100, 0, 101, 0, 108, 0], { offset: 2 })) {
+        return {
+          ext: "skp",
+          mime: "application/vnd.sketchup.skp"
+        };
+      }
+      return void 0;
+    }
+    if (this.checkString("-----BEGIN PGP MESSAGE-----")) {
+      return {
+        ext: "pgp",
+        mime: "application/pgp-encrypted"
+      };
+    }
+    if (this.buffer.length >= 2 && this.check([255, 224], { offset: 0, mask: [255, 224] })) {
+      if (this.check([16], { offset: 1, mask: [22] })) {
+        if (this.check([8], { offset: 1, mask: [8] })) {
+          return {
+            ext: "aac",
+            mime: "audio/aac"
+          };
+        }
+        return {
+          ext: "aac",
+          mime: "audio/aac"
+        };
+      }
+      if (this.check([2], { offset: 1, mask: [6] })) {
+        return {
+          ext: "mp3",
+          mime: "audio/mpeg"
+        };
+      }
+      if (this.check([4], { offset: 1, mask: [6] })) {
+        return {
+          ext: "mp2",
+          mime: "audio/mpeg"
+        };
+      }
+      if (this.check([6], { offset: 1, mask: [6] })) {
+        return {
+          ext: "mp1",
+          mime: "audio/mpeg"
+        };
+      }
+    }
+  }
+  async readTiffTag(bigEndian) {
+    const tagId = await this.tokenizer.readToken(bigEndian ? index.UINT16_BE : index.UINT16_LE);
+    this.tokenizer.ignore(10);
+    switch (tagId) {
+      case 50341:
+        return {
+          ext: "arw",
+          mime: "image/x-sony-arw"
+        };
+      case 50706:
+        return {
+          ext: "dng",
+          mime: "image/x-adobe-dng"
+        };
+    }
+  }
+  async readTiffIFD(bigEndian) {
+    const numberOfTags = await this.tokenizer.readToken(bigEndian ? index.UINT16_BE : index.UINT16_LE);
+    for (let n = 0; n < numberOfTags; ++n) {
+      const fileType = await this.readTiffTag(bigEndian);
+      if (fileType) {
+        return fileType;
+      }
+    }
+  }
+  async readTiffHeader(bigEndian) {
+    const version = (bigEndian ? index.UINT16_BE : index.UINT16_LE).get(this.buffer, 2);
+    const ifdOffset = (bigEndian ? index.UINT32_BE : index.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 && (this.check([28, 0, 254, 0], { offset: 8 }) || this.check([31, 0, 11, 0], { offset: 8 }))) {
+          return {
+            ext: "nef",
+            mime: "image/x-nikon-nef"
+          };
+        }
+      }
+      await this.tokenizer.ignore(ifdOffset);
+      const fileType = await this.readTiffIFD(bigEndian);
+      return fileType ?? {
+        ext: "tif",
+        mime: "image/tiff"
+      };
+    }
+    if (version === 43) {
+      return {
+        ext: "tif",
+        mime: "image/tiff"
+      };
+    }
+  }
+}
+new Set(supported.extensions);
+new Set(supported.mimeTypes);
+exports.fileTypeFromBuffer = fileTypeFromBuffer;
+exports.fileTypeFromTokenizer = fileTypeFromTokenizer;
+//# sourceMappingURL=core.cjs.map