module-develop-kit 1.1.0 → 1.2.1

package/dist/vendor/file-type/source/index.js

@@ -0,0 +1,1135 @@
+import { UINT32_BE as T, UINT16_BE as p, StringType as S, UINT16_LE as g, UINT32_LE as C } from "../../token-types/lib/index.js";
+import { fromWebStream as z, fromBuffer as I, fromBlob as M } from "../../strtok3/lib/core.js";
+import "../../@tokenizer/inflate/lib/ZipHandler.js";
+import { GzipHandler as O } from "../../@tokenizer/inflate/lib/GzipHandler.js";
+import { concatUint8Arrays as P } from "../../uint8array-extras/index.js";
+import { stringToBytes as j, uint32SyncSafeToken as R, tarHeaderChecksumMatches as L } from "./tokens.js";
+import { mimeTypes as N, extensions as U } from "./supported.js";
+import { ParserHardLimitError as q, hasUnknownFileSize as l, checkBytes as h, safeIgnore as F, maximumUntrustedSkipSizeInBytes as b } from "./parser.js";
+import { detectZip as G } from "./detectors/zip.js";
+import { detectEbml as _ } from "./detectors/ebml.js";
+import { detectPng as H } from "./detectors/png.js";
+import { detectAsf as V } from "./detectors/asf.js";
+import { EndOfStreamError as d } from "../../strtok3/lib/stream/Errors.js";
+const k = 4100, W = k - 2, $ = b, K = 1, A = 100, w = b, X = 512, v = 256, Z = 1024 * 1024, B = b;
+function J(n) {
+  return Number.isFinite(n) ? Math.max(1, Math.trunc(n)) : k;
+}
+function Q(n) {
+  return Number.isFinite(n) ? Math.max(0, Math.min(W, Math.trunc(n))) : 0;
+}
+function Y(n) {
+  return Number.isFinite(n) ? Math.max(0, n) : Number.MAX_SAFE_INTEGER;
+}
+function D(n) {
+  return import(n);
+}
+function ee(n) {
+  return n.pipeThrough(new TransformStream());
+}
+function E(n, e) {
+  return e === void 0 ? n.read() : (e.throwIfAborted(), Promise.race([
+    n.read(),
+    new Promise((t, i) => {
+      e.addEventListener("abort", () => {
+        i(e.reason), n.cancel(e.reason).catch(() => {
+        });
+      }, { once: !0 });
+    })
+  ]));
+}
+function te(n, e) {
+  const t = n.getReader();
+  let i = 0, r = !1, s = !1;
+  const c = async (x) => {
+    r || s || (s = !0, await t.cancel(x));
+  };
+  return new ReadableStream({
+    async pull(x) {
+      if (i >= e) {
+        x.close(), await c();
+        return;
+      }
+      const { done: f, value: a } = await t.read();
+      if (f || !a) {
+        r = !0, x.close();
+        return;
+      }
+      const u = e - i;
+      if (a.length > u) {
+        x.enqueue(a.subarray(0, u)), i += u, x.close(), await c();
+        return;
+      }
+      x.enqueue(a), i += a.length;
+    },
+    async cancel(x) {
+      await c(x);
+    }
+  });
+}
+async function le(n, e) {
+  return new y(e).fromStream(n);
+}
+class y {
+  constructor(e) {
+    const t = Q(e?.mpegOffsetTolerance);
+    this.options = {
+      ...e,
+      mpegOffsetTolerance: t
+    }, 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(e) {
+    return z(ee(e), this.getTokenizerOptions());
+  }
+  async parseTokenizer(e, t = 0) {
+    this.detectionReentryCount = t;
+    const i = e.position;
+    for (const r of this.detectors) {
+      let s;
+      try {
+        s = await r.detect(e);
+      } catch (c) {
+        if (c instanceof d || c instanceof q)
+          return;
+        throw c;
+      }
+      if (s)
+        return s;
+      if (i !== e.position)
+        return;
+    }
+  }
+  async fromTokenizer(e) {
+    try {
+      return await this.parseTokenizer(e);
+    } finally {
+      await e.close();
+    }
+  }
+  async fromBuffer(e) {
+    if (!(e instanceof Uint8Array || e instanceof ArrayBuffer))
+      throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof e}\``);
+    const t = e instanceof Uint8Array ? e : new Uint8Array(e);
+    if (t?.length > 1)
+      return this.fromTokenizer(I(t, this.getTokenizerOptions()));
+  }
+  async fromBlob(e) {
+    this.options.signal?.throwIfAborted();
+    const t = M(e, this.getTokenizerOptions());
+    return this.fromTokenizer(t);
+  }
+  async fromStream(e) {
+    this.options.signal?.throwIfAborted();
+    const t = this.createTokenizerFromWebStream(e);
+    return this.fromTokenizer(t);
+  }
+  async fromFile(e) {
+    this.options.signal?.throwIfAborted();
+    const [{ default: t }, { FileTokenizer: i }] = await Promise.all([
+      D("node:fs/promises"),
+      D("strtok3")
+    ]), r = await t.open(e, t.constants.O_RDONLY | t.constants.O_NONBLOCK), s = await r.stat();
+    if (!s.isFile()) {
+      await r.close();
+      return;
+    }
+    const c = new i(r, {
+      ...this.getTokenizerOptions(),
+      fileInfo: { path: e, size: s.size }
+    });
+    return this.fromTokenizer(c);
+  }
+  async toDetectionStream(e, t) {
+    this.options.signal?.throwIfAborted();
+    const i = J(t?.sampleSize ?? k);
+    let r, s = !1;
+    const c = e.getReader(), x = [];
+    let f = 0;
+    try {
+      for (; f < i; ) {
+        const { value: m, done: o } = await E(c, this.options.signal);
+        if (o || !m) {
+          s = !0;
+          break;
+        }
+        x.push(m), f += m.length;
+      }
+      if (!s && f === i) {
+        const { value: m, done: o } = await E(c, this.options.signal);
+        o || !m ? s = !0 : (x.push(m), f += m.length);
+      }
+    } finally {
+      c.releaseLock();
+    }
+    if (f > 0) {
+      const m = x.length === 1 ? x[0] : P(x);
+      try {
+        r = await this.fromBuffer(m.subarray(0, i));
+      } catch (o) {
+        if (!(o instanceof d))
+          throw o;
+        r = void 0;
+      }
+      !s && r?.ext === "pages" && (r = {
+        ext: "zip",
+        mime: "application/zip"
+      });
+    }
+    const a = new TransformStream({
+      start(m) {
+        for (const o of x)
+          m.enqueue(o);
+      },
+      transform(m, o) {
+        o.enqueue(m);
+      }
+    }), u = e.pipeThrough(a);
+    return u.fileType = r, u;
+  }
+  async detectGzip(e) {
+    if (this.gzipProbeDepth >= K)
+      return {
+        ext: "gz",
+        mime: "application/gzip"
+      };
+    const t = new O(e), i = te(t.inflate(), $), r = l(e);
+    let s, c, x, f;
+    if (r) {
+      const a = new AbortController();
+      s = setTimeout(() => {
+        a.abort(new DOMException(`Operation timed out after ${A} ms`, "TimeoutError"));
+      }, A), c = this.options.signal === void 0 ? a.signal : AbortSignal.any([this.options.signal, a.signal]), x = new y({
+        ...this.options,
+        signal: c
+      }), x.gzipProbeDepth = this.gzipProbeDepth + 1;
+    } else
+      this.gzipProbeDepth++;
+    try {
+      f = await (x ?? this).fromStream(i);
+    } catch (a) {
+      if (a?.name === "AbortError" && c?.reason?.name !== "TimeoutError")
+        throw a;
+    } finally {
+      clearTimeout(s), r || this.gzipProbeDepth--;
+    }
+    return f?.ext === "tar" ? {
+      ext: "tar.gz",
+      mime: "application/gzip"
+    } : {
+      ext: "gz",
+      mime: "application/gzip"
+    };
+  }
+  check(e, t) {
+    return h(this.buffer, e, t);
+  }
+  checkString(e, t) {
+    return this.check(j(e, t?.encoding), t);
+  }
+  // Detections with a high degree of certainty in identifying the correct file type
+  detectConfident = async (e) => {
+    if (this.buffer = new Uint8Array(k), e.fileInfo.size === void 0 && (e.fileInfo.size = Number.MAX_SAFE_INTEGER), this.tokenizer = e, l(e) && (await e.peekBuffer(this.buffer, { length: 3, mayBeLess: !0 }), this.check([31, 139, 8])))
+      return this.detectGzip(e);
+    if (await e.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 e.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 >= v ? void 0 : (this.detectionReentryCount++, await this.tokenizer.ignore(3), this.detectConfident(e));
+    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(e);
+    if (this.check([66, 90, 104]))
+      return {
+        ext: "bz2",
+        mime: "application/x-bzip2"
+      };
+    if (this.checkString("ID3")) {
+      await F(e, 6, {
+        maximumLength: 6,
+        reason: "ID3 header prefix"
+      });
+      const t = await e.readToken(R), i = l(e);
+      if (!Number.isFinite(t) || t < 0 || i && (t > w || e.position + t > w))
+        return;
+      if (e.position + t > e.fileInfo.size)
+        return i ? void 0 : {
+          ext: "mp3",
+          mime: "audio/mpeg"
+        };
+      try {
+        await F(e, t, {
+          maximumLength: i ? w : e.fileInfo.size,
+          reason: "ID3 payload"
+        });
+      } catch (r) {
+        if (r instanceof d)
+          return;
+        throw r;
+      }
+      return this.detectionReentryCount >= v ? void 0 : (this.detectionReentryCount++, this.parseTokenizer(e, 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]))
+      return G(e);
+    if (this.checkString("OggS")) {
+      await e.ignore(28);
+      const t = new Uint8Array(8);
+      return await e.readBuffer(t), h(t, [79, 112, 117, 115, 72, 101, 97, 100]) ? {
+        ext: "opus",
+        mime: "audio/ogg; codecs=opus"
+      } : h(t, [128, 116, 104, 101, 111, 114, 97]) ? {
+        ext: "ogv",
+        mime: "video/ogg"
+      } : h(t, [1, 118, 105, 100, 101, 111, 0]) ? {
+        ext: "ogm",
+        mime: "video/ogg"
+      } : h(t, [127, 70, 76, 65, 67]) ? {
+        ext: "oga",
+        mime: "audio/ogg"
+      } : h(t, [83, 112, 101, 101, 120, 32, 32]) ? {
+        ext: "spx",
+        mime: "audio/ogg"
+      } : h(t, [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/lzip"
+      };
+    if (this.checkString("fLaC"))
+      return {
+        ext: "flac",
+        mime: "audio/flac"
+      };
+    if (this.check([66, 80, 71, 251]))
+      return {
+        ext: "bpg",
+        mime: "image/bpg"
+      };
+    if (this.checkString("wvpk"))
+      return {
+        ext: "wv",
+        mime: "audio/wavpack"
+      };
+    if (this.checkString("%PDF"))
+      return {
+        ext: "pdf",
+        mime: "application/pdf"
+      };
+    if (this.check([0, 97, 115, 109]))
+      return {
+        ext: "wasm",
+        mime: "application/wasm"
+      };
+    if (this.check([73, 73])) {
+      const t = await this.readTiffHeader(!1);
+      if (t)
+        return t;
+    }
+    if (this.check([77, 77])) {
+      const t = await this.readTiffHeader(!0);
+      if (t)
+        return t;
+    }
+    if (this.checkString("MAC "))
+      return {
+        ext: "ape",
+        mime: "audio/ape"
+      };
+    if (this.check([26, 69, 223, 163]))
+      return _(e);
+    if (this.checkString("SQLi"))
+      return {
+        ext: "sqlite",
+        mime: "application/x-sqlite3"
+      };
+    if (this.check([78, 69, 83, 26]))
+      return {
+        ext: "nes",
+        mime: "application/x-nintendo-nes-rom"
+      };
+    if (this.checkString("Cr24"))
+      return {
+        ext: "crx",
+        mime: "application/x-google-chrome-extension"
+      };
+    if (this.checkString("MSCF") || this.checkString("ISc("))
+      return {
+        ext: "cab",
+        mime: "application/vnd.ms-cab-compressed"
+      };
+    if (this.check([237, 171, 238, 219]))
+      return {
+        ext: "rpm",
+        mime: "application/x-rpm"
+      };
+    if (this.check([197, 208, 211, 198]))
+      return {
+        ext: "eps",
+        mime: "application/eps"
+      };
+    if (this.check([40, 181, 47, 253]))
+      return {
+        ext: "zst",
+        mime: "application/zstd"
+      };
+    if (this.check([127, 69, 76, 70]))
+      return {
+        ext: "elf",
+        mime: "application/x-elf"
+      };
+    if (this.check([33, 66, 68, 78]))
+      return {
+        ext: "pst",
+        mime: "application/vnd.ms-outlook"
+      };
+    if (this.checkString("PAR1") || this.checkString("PARE"))
+      return {
+        ext: "parquet",
+        mime: "application/vnd.apache.parquet"
+      };
+    if (this.checkString("ttcf"))
+      return {
+        ext: "ttc",
+        mime: "font/collection"
+      };
+    if (this.check([254, 237, 250, 206]) || this.check([254, 237, 250, 207]) || this.check([206, 250, 237, 254]) || this.check([207, 250, 237, 254]))
+      return {
+        ext: "macho",
+        mime: "application/x-mach-binary"
+      };
+    if (this.check([4, 34, 77, 24]))
+      return {
+        ext: "lz4",
+        mime: "application/x-lz4"
+        // Informal, used by freedesktop.org shared-mime-info
+      };
+    if (this.checkString("regf"))
+      return {
+        ext: "dat",
+        mime: "application/x-ft-windows-registry-hive"
+      };
+    if (this.checkString("$FL2") || this.checkString("$FL3"))
+      return {
+        ext: "sav",
+        mime: "application/x-spss-sav"
+      };
+    if (this.check([79, 84, 84, 79, 0]))
+      return {
+        ext: "otf",
+        mime: "font/otf"
+      };
+    if (this.checkString("#!AMR"))
+      return {
+        ext: "amr",
+        mime: "audio/amr"
+      };
+    if (this.checkString(String.raw`{\rtf`))
+      return {
+        ext: "rtf",
+        mime: "application/rtf"
+      };
+    if (this.check([70, 76, 86, 1]))
+      return {
+        ext: "flv",
+        mime: "video/x-flv"
+      };
+    if (this.checkString("IMPM"))
+      return {
+        ext: "it",
+        mime: "audio/x-it"
+      };
+    if (this.checkString("-lh0-", { offset: 2 }) || this.checkString("-lh1-", { offset: 2 }) || this.checkString("-lh2-", { offset: 2 }) || this.checkString("-lh3-", { offset: 2 }) || this.checkString("-lh4-", { offset: 2 }) || this.checkString("-lh5-", { offset: 2 }) || this.checkString("-lh6-", { offset: 2 }) || this.checkString("-lh7-", { offset: 2 }) || this.checkString("-lzs-", { offset: 2 }) || this.checkString("-lz4-", { offset: 2 }) || this.checkString("-lz5-", { offset: 2 }) || this.checkString("-lhd-", { offset: 2 }))
+      return {
+        ext: "lzh",
+        mime: "application/x-lzh-compressed"
+      };
+    if (this.check([0, 0, 1, 186])) {
+      if (this.check([33], { offset: 4, mask: [241] }))
+        return {
+          ext: "mpg",
+          // May also be .ps, .mpeg
+          mime: "video/MP1S"
+        };
+      if (this.check([68], { offset: 4, mask: [196] }))
+        return {
+          ext: "mpg",
+          // May also be .mpg, .m2p, .vob or .sub
+          mime: "video/MP2P"
+        };
+    }
+    if (this.checkString("ITSF"))
+      return {
+        ext: "chm",
+        mime: "application/vnd.ms-htmlhelp"
+      };
+    if (this.check([202, 254, 186, 190])) {
+      const t = T.get(this.buffer, 4), i = p.get(this.buffer, 6);
+      if (t > 0 && t <= 30)
+        return {
+          ext: "macho",
+          mime: "application/x-mach-binary"
+        };
+      if (i > 30)
+        return {
+          ext: "class",
+          mime: "application/java-vm"
+        };
+    }
+    if (this.checkString(".RMF"))
+      return {
+        ext: "rm",
+        mime: "application/vnd.rn-realmedia"
+      };
+    if (this.checkString("DRACO"))
+      return {
+        ext: "drc",
+        mime: "application/x-ft-draco"
+      };
+    if (this.check([253, 55, 122, 88, 90, 0]))
+      return {
+        ext: "xz",
+        mime: "application/x-xz"
+      };
+    if (this.checkString("<?xml "))
+      return {
+        ext: "xml",
+        mime: "application/xml"
+      };
+    if (this.check([55, 122, 188, 175, 39, 28]))
+      return {
+        ext: "7z",
+        mime: "application/x-7z-compressed"
+      };
+    if (this.check([82, 97, 114, 33, 26, 7]) && (this.buffer[6] === 0 || this.buffer[6] === 1))
+      return {
+        ext: "rar",
+        mime: "application/x-rar-compressed"
+      };
+    if (this.checkString("solid "))
+      return {
+        ext: "stl",
+        mime: "model/stl"
+      };
+    if (this.checkString("AC")) {
+      const t = new S(4, "latin1").get(this.buffer, 2);
+      if (new RegExp("^\\d+$", "v").test(t) && t >= 1e3 && t <= 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 e.ignore(8), await e.readToken(new S(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((t) => this.checkString(t, { offset: 6 })))
+      return {
+        ext: "vtt",
+        mime: "text/vtt"
+      };
+    if (this.check([137, 80, 78, 71, 13, 10, 26, 10]))
+      return H(e);
+    if (this.check([65, 82, 82, 79, 87, 49, 0, 0]))
+      return {
+        ext: "arrow",
+        mime: "application/vnd.apache.arrow.file"
+      };
+    if (this.check([103, 108, 84, 70, 2, 0, 0, 0]))
+      return {
+        ext: "glb",
+        mime: "model/gltf-binary"
+      };
+    if (this.check([102, 114, 101, 101], { offset: 4 }) || this.check([109, 100, 97, 116], { offset: 4 }) || this.check([109, 111, 111, 118], { offset: 4 }) || this.check([119, 105, 100, 101], { offset: 4 }))
+      return {
+        ext: "mov",
+        mime: "video/quicktime"
+      };
+    if (this.check([73, 73, 82, 79, 8, 0, 0, 0, 24]))
+      return {
+        ext: "orf",
+        mime: "image/x-olympus-orf"
+      };
+    if (this.checkString("gimp xcf "))
+      return {
+        ext: "xcf",
+        mime: "image/x-xcf"
+      };
+    if (this.checkString("ftyp", { offset: 4 }) && (this.buffer[8] & 96) !== 0) {
+      const t = new S(4, "latin1").get(this.buffer, 8).replace("\0", " ").trim();
+      switch (t) {
+        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 t.startsWith("3g") ? t.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]))
+      return V(e);
+    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 e.ignore(20), await e.readToken(new S(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 e.peekBuffer(this.buffer, { length: Math.min(256, e.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) {
+      const t = new DataView(this.buffer.buffer).getUint32(12, !0);
+      if (t > 12 && this.buffer.length >= t + 16)
+        try {
+          const i = new TextDecoder().decode(this.buffer.subarray(16, t + 16));
+          if (JSON.parse(i).files)
+            return {
+              ext: "asar",
+              mime: "application/x-asar"
+            };
+        } catch {
+        }
+    }
+    if (this.check([6, 14, 43, 52, 2, 5, 1, 1, 13, 1, 2, 1, 1, 2]))
+      return {
+        ext: "mxf",
+        mime: "application/mxf"
+      };
+    if (this.checkString("SCRM", { offset: 44 }))
+      return {
+        ext: "s3m",
+        mime: "audio/x-s3m"
+      };
+    if (this.check([71]) && this.check([71], { offset: 188 }))
+      return {
+        ext: "mts",
+        mime: "video/mp2t"
+      };
+    if (this.check([71], { offset: 4 }) && this.check([71], { offset: 196 }))
+      return {
+        ext: "mts",
+        mime: "video/mp2t"
+      };
+    if (this.check([66, 79, 79, 75, 77, 79, 66, 73], { offset: 60 }))
+      return {
+        ext: "mobi",
+        mime: "application/x-mobipocket-ebook"
+      };
+    if (this.check([68, 73, 67, 77], { offset: 128 }))
+      return {
+        ext: "dcm",
+        mime: "application/dicom"
+      };
+    if (this.check([76, 0, 0, 0, 1, 20, 2, 0, 0, 0, 0, 0, 192, 0, 0, 0, 0, 0, 0, 70]))
+      return {
+        ext: "lnk",
+        mime: "application/x-ms-shortcut"
+        // Informal, used by freedesktop.org shared-mime-info
+      };
+    if (this.check([98, 111, 111, 107, 0, 0, 0, 0, 109, 97, 114, 107, 0, 0, 0, 0]))
+      return {
+        ext: "alias",
+        mime: "application/x-ft-apple.alias"
+      };
+    if (this.checkString("Kaydara FBX Binary  \0"))
+      return {
+        ext: "fbx",
+        mime: "application/x-ft-fbx"
+      };
+    if (this.check([76, 80], { offset: 34 }) && (this.check([0, 0, 1], { offset: 8 }) || this.check([1, 0, 2], { offset: 8 }) || this.check([2, 0, 2], { offset: 8 })))
+      return {
+        ext: "eot",
+        mime: "application/vnd.ms-fontobject"
+      };
+    if (this.check([6, 6, 237, 245, 216, 29, 70, 229, 189, 49, 239, 231, 254, 116, 183, 29]))
+      return {
+        ext: "indd",
+        mime: "application/x-indesign"
+      };
+    if (this.check([255, 255, 0, 0, 7, 0, 0, 0, 4, 0, 0, 0, 1, 0, 1, 0]) || this.check([0, 0, 255, 255, 0, 0, 0, 7, 0, 0, 0, 4, 0, 1, 0, 1]))
+      return {
+        ext: "jmp",
+        mime: "application/x-jmp-data"
+      };
+    if (await e.peekBuffer(this.buffer, { length: Math.min(512, e.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 }) && L(this.buffer))
+      return {
+        ext: "tar",
+        mime: "application/x-tar"
+      };
+    if (this.check([255, 254])) {
+      const t = "utf-16le";
+      return this.checkString("<?xml ", { offset: 2, encoding: t }) ? {
+        ext: "xml",
+        mime: "application/xml"
+      } : this.check([255, 14], { offset: 2 }) && this.checkString("SketchUp Model", { offset: 4, encoding: t }) ? {
+        ext: "skp",
+        mime: "application/vnd.sketchup.skp"
+      } : this.checkString(`Windows Registry Editor Version 5.00\r
+`, { offset: 2, encoding: t }) ? {
+        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 (e) => {
+    this.buffer = new Uint8Array(k);
+    const t = Y(e.fileInfo.size);
+    if (await e.peekBuffer(this.buffer, { length: Math.min(8, t), 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 e.peekBuffer(this.buffer, { length: Math.min(2 + this.options.mpegOffsetTolerance, t), mayBeLess: !0 }), this.buffer.length >= 2 + this.options.mpegOffsetTolerance)
+      for (let i = 0; i <= this.options.mpegOffsetTolerance; ++i) {
+        const r = this.scanMpeg(i);
+        if (r)
+          return r;
+      }
+  };
+  async readTiffTag(e) {
+    const t = await this.tokenizer.readToken(e ? p : g);
+    switch (await this.tokenizer.ignore(10), t) {
+      case 50341:
+        return {
+          ext: "arw",
+          mime: "image/x-sony-arw"
+        };
+      case 50706:
+        return {
+          ext: "dng",
+          mime: "image/x-adobe-dng"
+        };
+    }
+  }
+  async readTiffIFD(e) {
+    const t = await this.tokenizer.readToken(e ? p : g);
+    if (!(t > X) && !(l(this.tokenizer) && 2 + t * 12 > B))
+      for (let i = 0; i < t; ++i) {
+        const r = await this.readTiffTag(e);
+        if (r)
+          return r;
+      }
+  }
+  async readTiffHeader(e) {
+    const t = {
+      ext: "tif",
+      mime: "image/tiff"
+    }, i = (e ? p : g).get(this.buffer, 2), r = (e ? T : C).get(this.buffer, 4);
+    if (i === 42) {
+      if (r >= 6) {
+        if (this.checkString("CR", { offset: 8 }))
+          return {
+            ext: "cr2",
+            mime: "image/x-canon-cr2"
+          };
+        if (r >= 8) {
+          const x = (e ? p : g).get(this.buffer, 8), f = (e ? p : g).get(this.buffer, 10);
+          if (x === 28 && f === 254 || x === 31 && f === 11)
+            return {
+              ext: "nef",
+              mime: "image/x-nikon-nef"
+            };
+        }
+      }
+      if (l(this.tokenizer) && r > Z)
+        return t;
+      const s = l(this.tokenizer) ? B : this.tokenizer.fileInfo.size;
+      try {
+        await F(this.tokenizer, r, {
+          maximumLength: s,
+          reason: "TIFF IFD offset"
+        });
+      } catch (x) {
+        if (x instanceof d)
+          return;
+        throw x;
+      }
+      let c;
+      try {
+        c = await this.readTiffIFD(e);
+      } catch (x) {
+        if (x instanceof d)
+          return;
+        throw x;
+      }
+      return c ?? t;
+    }
+    if (i === 43)
+      return t;
+  }
+  /**
+  	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(e) {
+    if (this.check([255, 224], { offset: e, mask: [255, 224] })) {
+      if (this.check([16], { offset: e + 1, mask: [22] }))
+        return this.check([8], { offset: e + 1, mask: [8] }) ? {
+          ext: "aac",
+          mime: "audio/aac"
+        } : {
+          ext: "aac",
+          mime: "audio/aac"
+        };
+      if (this.check([2], { offset: e + 1, mask: [6] }))
+        return {
+          ext: "mp3",
+          mime: "audio/mpeg"
+        };
+      if (this.check([4], { offset: e + 1, mask: [6] }))
+        return {
+          ext: "mp2",
+          mime: "audio/mpeg"
+        };
+      if (this.check([6], { offset: e + 1, mask: [6] }))
+        return {
+          ext: "mp1",
+          mime: "audio/mpeg"
+        };
+    }
+  }
+}
+const ge = new Set(U), de = new Set(N);
+export {
+  y as FileTypeParser,
+  le as fileTypeFromStream,
+  J as normalizeSampleSize,
+  k as reasonableDetectionSizeInBytes,
+  ge as supportedExtensions,
+  de as supportedMimeTypes
+};