@slicemachine/manager 0.1.1-dev-plugins.13 → 0.1.1-dev-plugins-validation.1

package/dist/__node_modules/file-type/core.js

@@ -1,1147 +0,0 @@
-import { Buffer } from "node:buffer";
-import { StringType, UINT16_BE, UINT16_LE, UINT32_BE, UINT32_LE, INT32_BE, UINT64_LE, UINT8 } from "../token-types/lib/index.js";
-import { fromBuffer } from "../strtok3/lib/core.js";
-import { stringToBytes, uint32SyncSafeToken, tarHeaderChecksumMatches } from "./util.js";
-import { EndOfStreamError } from "../peek-readable/lib/EndOfFileStream.js";
-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(fromBuffer(buffer));
-}
-function _check(buffer, headers, options) {
-  options = {
-    offset: 0,
-    ...options
-  };
-  for (const [index, header] of headers.entries()) {
-    if (options.mask) {
-      if (header !== (options.mask[index] & buffer[index + options.offset])) {
-        return false;
-      }
-    } else if (header !== buffer[index + options.offset]) {
-      return false;
-    }
-  }
-  return true;
-}
-async function fileTypeFromTokenizer(tokenizer) {
-  try {
-    return new FileTypeParser().parse(tokenizer);
-  } catch (error) {
-    if (!(error instanceof EndOfStreamError)) {
-      throw error;
-    }
-  }
-}
-class FileTypeParser {
-  check(header, options) {
-    return _check(this.buffer, header, options);
-  }
-  checkString(header, options) {
-    return this.check(stringToBytes(header), options);
-  }
-  async parse(tokenizer) {
-    this.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([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([255, 216, 255])) {
-      return {
-        ext: "jpg",
-        mime: "image/jpeg"
-      };
-    }
-    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(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.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 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 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 EndOfStreamError)) {
-          throw error;
-        }
-      }
-      return {
-        ext: "zip",
-        mime: "application/zip"
-      };
-    }
-    if (this.checkString("OggS")) {
-      await tokenizer.ignore(28);
-      const type = Buffer.alloc(8);
-      await tokenizer.readBuffer(type);
-      if (_check(type, [79, 112, 117, 115, 72, 101, 97, 100])) {
-        return {
-          ext: "opus",
-          mime: "audio/opus"
-        };
-      }
-      if (_check(type, [128, 116, 104, 101, 111, 114, 97])) {
-        return {
-          ext: "ogv",
-          mime: "video/ogg"
-        };
-      }
-      if (_check(type, [1, 118, 105, 100, 101, 111, 0])) {
-        return {
-          ext: "ogm",
-          mime: "video/ogg"
-        };
-      }
-      if (_check(type, [127, 70, 76, 65, 67])) {
-        return {
-          ext: "oga",
-          mime: "audio/ogg"
-        };
-      }
-      if (_check(type, [83, 112, 101, 101, 120, 32, 32])) {
-        return {
-          ext: "spx",
-          mime: "audio/ogg"
-        };
-      }
-      if (_check(type, [1, 118, 111, 114, 98, 105, 115])) {
-        return {
-          ext: "ogg",
-          mime: "audio/ogg"
-        };
-      }
-      return {
-        ext: "ogx",
-        mime: "application/ogg"
-      };
-    }
-    if (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")) {
-      await tokenizer.ignore(1350);
-      const maxBufferSize = 10 * 1024 * 1024;
-      const buffer = Buffer.alloc(Math.min(maxBufferSize, tokenizer.fileInfo.size));
-      await tokenizer.readBuffer(buffer, { mayBeLess: true });
-      if (buffer.includes(Buffer.from("AIPrivateData"))) {
-        return {
-          ext: "ai",
-          mime: "application/postscript"
-        };
-      }
-      return {
-        ext: "pdf",
-        mime: "application/pdf"
-      };
-    }
-    if (this.check([0, 97, 115, 109])) {
-      return {
-        ext: "wasm",
-        mime: "application/wasm"
-      };
-    }
-    if (this.check([73, 73])) {
-      const fileType = await this.readTiffHeader(false);
-      if (fileType) {
-        return fileType;
-      }
-    }
-    if (this.check([77, 77])) {
-      const fileType = await this.readTiffHeader(true);
-      if (fileType) {
-        return fileType;
-      }
-    }
-    if (this.checkString("MAC ")) {
-      return {
-        ext: "ape",
-        mime: "audio/ape"
-      };
-    }
-    if (this.check([26, 69, 223, 163])) {
-      async function readField() {
-        const msb = await tokenizer.peekNumber(UINT8);
-        let mask = 128;
-        let ic = 0;
-        while ((msb & mask) === 0 && mask !== 0) {
-          ++ic;
-          mask >>= 1;
-        }
-        const id = 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 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([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([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("BLENDER")) {
-      return {
-        ext: "blend",
-        mime: "application/x-blender"
-      };
-    }
-    if (this.checkString("!<arch>")) {
-      await tokenizer.ignore(8);
-      const string = await tokenizer.readToken(new StringType(13, "ascii"));
-      if (string === "debian-binary") {
-        return {
-          ext: "deb",
-          mime: "application/x-deb"
-        };
-      }
-      return {
-        ext: "ar",
-        mime: "application/x-unix-archive"
-      };
-    }
-    if (this.check([137, 80, 78, 71, 13, 10, 26, 10])) {
-      await tokenizer.ignore(8);
-      async function readChunkHeader() {
-        return {
-          length: await tokenizer.readToken(INT32_BE),
-          type: await tokenizer.readToken(new 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 = Buffer.alloc(16);
-        await tokenizer.readBuffer(guid);
-        return {
-          id: guid,
-          size: Number(await tokenizer.readToken(UINT64_LE))
-        };
-      }
-      await tokenizer.ignore(30);
-      while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
-        const header = await readHeader();
-        let payload = header.size - 24;
-        if (_check(header.id, [145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101])) {
-          const typeId = Buffer.alloc(16);
-          payload -= await tokenizer.readBuffer(typeId);
-          if (_check(typeId, [64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
-            return {
-              ext: "asf",
-              mime: "audio/x-ms-asf"
-            };
-          }
-          if (_check(typeId, [192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
-            return {
-              ext: "asf",
-              mime: "video/x-ms-asf"
-            };
-          }
-          break;
-        }
-        await tokenizer.ignore(payload);
-      }
-      return {
-        ext: "asf",
-        mime: "application/vnd.ms-asf"
-      };
-    }
-    if (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([0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10])) {
-      await tokenizer.ignore(20);
-      const type = await tokenizer.readToken(new StringType(4, "ascii"));
-      switch (type) {
-        case "jp2 ":
-          return {
-            ext: "jp2",
-            mime: "image/jp2"
-          };
-        case "jpx ":
-          return {
-            ext: "jpx",
-            mime: "image/jpx"
-          };
-        case "jpm ":
-          return {
-            ext: "jpm",
-            mime: "image/jpm"
-          };
-        case "mjp2":
-          return {
-            ext: "mj2",
-            mime: "image/mj2"
-          };
-        default:
-          return;
-      }
-    }
-    if (this.check([255, 10]) || this.check([0, 0, 0, 12, 74, 88, 76, 32, 13, 10, 135, 10])) {
-      return {
-        ext: "jxl",
-        mime: "image/jxl"
-      };
-    }
-    if (this.check([254, 255])) {
-      if (this.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.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 (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 ? UINT16_BE : 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 ? UINT16_BE : 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 ? UINT16_BE : UINT16_LE).get(this.buffer, 2);
-    const ifdOffset = (bigEndian ? UINT32_BE : UINT32_LE).get(this.buffer, 4);
-    if (version === 42) {
-      if (ifdOffset >= 6) {
-        if (this.checkString("CR", { offset: 8 })) {
-          return {
-            ext: "cr2",
-            mime: "image/x-canon-cr2"
-          };
-        }
-        if (ifdOffset >= 8 && (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(false);
-      return fileType ? fileType : {
-        ext: "tif",
-        mime: "image/tiff"
-      };
-    }
-    if (version === 43) {
-      return {
-        ext: "tif",
-        mime: "image/tiff"
-      };
-    }
-  }
-}
-export {
-  fileTypeFromBuffer,
-  fileTypeFromTokenizer
-};
-//# sourceMappingURL=core.js.map