dune-react 0.0.1

package/dist/node_modules/.pnpm/file-type@12.4.1/node_modules/file-type/index.js

@@ -0,0 +1,826 @@
+import { __module as fileType } from "../../../../../_virtual/index.js";
+import "./util.js";
+import { s as supported } from "./supported.js";
+import { __exports as util } from "../../../../../_virtual/util.js";
+(function(module) {
+  const {
+    multiByteIndexOf,
+    stringToBytes,
+    readUInt64LE,
+    tarHeaderChecksumMatches,
+    uint8ArrayUtf8ByteString
+  } = util;
+  const supported$1 = supported;
+  const xpiZipFilename = stringToBytes("META-INF/mozilla.rsa");
+  const oxmlContentTypes = stringToBytes("[Content_Types].xml");
+  const oxmlRels = stringToBytes("_rels/.rels");
+  const fileType = (input) => {
+    if (!(input instanceof Uint8Array || input instanceof ArrayBuffer || Buffer.isBuffer(input))) {
+      throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\` or \`ArrayBuffer\`, got \`${typeof input}\``);
+    }
+    const buffer = input instanceof Uint8Array ? input : new Uint8Array(input);
+    if (!(buffer && buffer.length > 1)) {
+      return;
+    }
+    const check = (header, options) => {
+      options = {
+        offset: 0,
+        ...options
+      };
+      for (let i = 0; i < header.length; i++) {
+        if (options.mask) {
+          if (header[i] !== (options.mask[i] & buffer[i + options.offset])) {
+            return false;
+          }
+        } else if (header[i] !== buffer[i + options.offset]) {
+          return false;
+        }
+      }
+      return true;
+    };
+    const checkString = (header, options) => check(stringToBytes(header), options);
+    if (check([255, 216, 255])) {
+      return {
+        ext: "jpg",
+        mime: "image/jpeg"
+      };
+    }
+    if (check([137, 80, 78, 71, 13, 10, 26, 10])) {
+      const startIndex = 33;
+      const firstImageDataChunkIndex = buffer.findIndex((el, i) => i >= startIndex && buffer[i] === 73 && buffer[i + 1] === 68 && buffer[i + 2] === 65 && buffer[i + 3] === 84);
+      const sliced = buffer.subarray(startIndex, firstImageDataChunkIndex);
+      if (sliced.findIndex((el, i) => sliced[i] === 97 && sliced[i + 1] === 99 && sliced[i + 2] === 84 && sliced[i + 3] === 76) >= 0) {
+        return {
+          ext: "apng",
+          mime: "image/apng"
+        };
+      }
+      return {
+        ext: "png",
+        mime: "image/png"
+      };
+    }
+    if (check([71, 73, 70])) {
+      return {
+        ext: "gif",
+        mime: "image/gif"
+      };
+    }
+    if (check([87, 69, 66, 80], { offset: 8 })) {
+      return {
+        ext: "webp",
+        mime: "image/webp"
+      };
+    }
+    if (check([70, 76, 73, 70])) {
+      return {
+        ext: "flif",
+        mime: "image/flif"
+      };
+    }
+    if ((check([73, 73, 42, 0]) || check([77, 77, 0, 42])) && check([67, 82], { offset: 8 })) {
+      return {
+        ext: "cr2",
+        mime: "image/x-canon-cr2"
+      };
+    }
+    if (check([73, 73, 82, 79, 8, 0, 0, 0, 24])) {
+      return {
+        ext: "orf",
+        mime: "image/x-olympus-orf"
+      };
+    }
+    if (check([73, 73, 42, 0]) && (check([16, 251, 134, 1], { offset: 4 }) || check([8, 0, 0, 0], { offset: 4 })) && // This pattern differentiates ARW from other TIFF-ish file types:
+    check([0, 254, 0, 4, 0, 1, 0, 0, 0, 1, 0, 0, 0, 3, 1], { offset: 9 })) {
+      return {
+        ext: "arw",
+        mime: "image/x-sony-arw"
+      };
+    }
+    if (check([73, 73, 42, 0, 8, 0, 0, 0]) && (check([45, 0, 254, 0], { offset: 8 }) || check([39, 0, 254, 0], { offset: 8 }))) {
+      return {
+        ext: "dng",
+        mime: "image/x-adobe-dng"
+      };
+    }
+    if (check([73, 73, 42, 0]) && check([28, 0, 254, 0], { offset: 8 })) {
+      return {
+        ext: "nef",
+        mime: "image/x-nikon-nef"
+      };
+    }
+    if (check([73, 73, 85, 0, 24, 0, 0, 0, 136, 231, 116, 216])) {
+      return {
+        ext: "rw2",
+        mime: "image/x-panasonic-rw2"
+      };
+    }
+    if (checkString("FUJIFILMCCD-RAW")) {
+      return {
+        ext: "raf",
+        mime: "image/x-fujifilm-raf"
+      };
+    }
+    if (check([73, 73, 42, 0]) || check([77, 77, 0, 42])) {
+      return {
+        ext: "tif",
+        mime: "image/tiff"
+      };
+    }
+    if (check([66, 77])) {
+      return {
+        ext: "bmp",
+        mime: "image/bmp"
+      };
+    }
+    if (check([73, 73, 188])) {
+      return {
+        ext: "jxr",
+        mime: "image/vnd.ms-photo"
+      };
+    }
+    if (check([56, 66, 80, 83])) {
+      return {
+        ext: "psd",
+        mime: "image/vnd.adobe.photoshop"
+      };
+    }
+    const zipHeader = [80, 75, 3, 4];
+    if (check(zipHeader)) {
+      if (check([109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 101, 112, 117, 98, 43, 122, 105, 112], { offset: 30 })) {
+        return {
+          ext: "epub",
+          mime: "application/epub+zip"
+        };
+      }
+      if (check(xpiZipFilename, { offset: 30 })) {
+        return {
+          ext: "xpi",
+          mime: "application/x-xpinstall"
+        };
+      }
+      if (checkString("mimetypeapplication/vnd.oasis.opendocument.text", { offset: 30 })) {
+        return {
+          ext: "odt",
+          mime: "application/vnd.oasis.opendocument.text"
+        };
+      }
+      if (checkString("mimetypeapplication/vnd.oasis.opendocument.spreadsheet", { offset: 30 })) {
+        return {
+          ext: "ods",
+          mime: "application/vnd.oasis.opendocument.spreadsheet"
+        };
+      }
+      if (checkString("mimetypeapplication/vnd.oasis.opendocument.presentation", { offset: 30 })) {
+        return {
+          ext: "odp",
+          mime: "application/vnd.oasis.opendocument.presentation"
+        };
+      }
+      let zipHeaderIndex = 0;
+      let oxmlFound = false;
+      let type;
+      do {
+        const offset = zipHeaderIndex + 30;
+        if (!oxmlFound) {
+          oxmlFound = check(oxmlContentTypes, { offset }) || check(oxmlRels, { offset });
+        }
+        if (!type) {
+          if (checkString("word/", { offset })) {
+            type = {
+              ext: "docx",
+              mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+            };
+          } else if (checkString("ppt/", { offset })) {
+            type = {
+              ext: "pptx",
+              mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+            };
+          } else if (checkString("xl/", { offset })) {
+            type = {
+              ext: "xlsx",
+              mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            };
+          }
+        }
+        if (oxmlFound && type) {
+          return type;
+        }
+        zipHeaderIndex = multiByteIndexOf(buffer, zipHeader, offset);
+      } while (zipHeaderIndex >= 0);
+      if (type) {
+        return type;
+      }
+    }
+    if (check([80, 75]) && (buffer[2] === 3 || buffer[2] === 5 || buffer[2] === 7) && (buffer[3] === 4 || buffer[3] === 6 || buffer[3] === 8)) {
+      return {
+        ext: "zip",
+        mime: "application/zip"
+      };
+    }
+    if (check([48, 48, 48, 48, 48, 48], { offset: 148, mask: [248, 248, 248, 248, 248, 248] }) && // Valid tar checksum
+    tarHeaderChecksumMatches(buffer)) {
+      return {
+        ext: "tar",
+        mime: "application/x-tar"
+      };
+    }
+    if (check([82, 97, 114, 33, 26, 7]) && (buffer[6] === 0 || buffer[6] === 1)) {
+      return {
+        ext: "rar",
+        mime: "application/x-rar-compressed"
+      };
+    }
+    if (check([31, 139, 8])) {
+      return {
+        ext: "gz",
+        mime: "application/gzip"
+      };
+    }
+    if (check([66, 90, 104])) {
+      return {
+        ext: "bz2",
+        mime: "application/x-bzip2"
+      };
+    }
+    if (check([55, 122, 188, 175, 39, 28])) {
+      return {
+        ext: "7z",
+        mime: "application/x-7z-compressed"
+      };
+    }
+    if (check([120, 1])) {
+      return {
+        ext: "dmg",
+        mime: "application/x-apple-diskimage"
+      };
+    }
+    if (check([102, 114, 101, 101], { offset: 4 }) || // `free`
+    check([109, 100, 97, 116], { offset: 4 }) || // `mdat` MJPEG
+    check([109, 111, 111, 118], { offset: 4 }) || // `moov`
+    check([119, 105, 100, 101], { offset: 4 })) {
+      return {
+        ext: "mov",
+        mime: "video/quicktime"
+      };
+    }
+    if (check([102, 116, 121, 112], { offset: 4 }) && // `ftyp`
+    (buffer[8] & 96) !== 0 && (buffer[9] & 96) !== 0 && (buffer[10] & 96) !== 0 && (buffer[11] & 96) !== 0) {
+      const brandMajor = uint8ArrayUtf8ByteString(buffer, 8, 12);
+      switch (brandMajor) {
+        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" };
+        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 (check([77, 84, 104, 100])) {
+      return {
+        ext: "mid",
+        mime: "audio/midi"
+      };
+    }
+    if (check([26, 69, 223, 163])) {
+      const sliced = buffer.subarray(4, 4 + 4096);
+      const idPos = sliced.findIndex((el, i, arr) => arr[i] === 66 && arr[i + 1] === 130);
+      if (idPos !== -1) {
+        const docTypePos = idPos + 3;
+        const findDocType = (type) => [...type].every((c, i) => sliced[docTypePos + i] === c.charCodeAt(0));
+        if (findDocType("matroska")) {
+          return {
+            ext: "mkv",
+            mime: "video/x-matroska"
+          };
+        }
+        if (findDocType("webm")) {
+          return {
+            ext: "webm",
+            mime: "video/webm"
+          };
+        }
+      }
+    }
+    if (check([82, 73, 70, 70])) {
+      if (check([65, 86, 73], { offset: 8 })) {
+        return {
+          ext: "avi",
+          mime: "video/vnd.avi"
+        };
+      }
+      if (check([87, 65, 86, 69], { offset: 8 })) {
+        return {
+          ext: "wav",
+          mime: "audio/vnd.wave"
+        };
+      }
+      if (check([81, 76, 67, 77], { offset: 8 })) {
+        return {
+          ext: "qcp",
+          mime: "audio/qcelp"
+        };
+      }
+    }
+    if (check([48, 38, 178, 117, 142, 102, 207, 17, 166, 217])) {
+      let offset = 30;
+      do {
+        const objectSize = readUInt64LE(buffer, offset + 16);
+        if (check([145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101], { offset })) {
+          if (check([64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43], { offset: offset + 24 })) {
+            return {
+              ext: "wma",
+              mime: "audio/x-ms-wma"
+            };
+          }
+          if (check([192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43], { offset: offset + 24 })) {
+            return {
+              ext: "wmv",
+              mime: "video/x-ms-asf"
+            };
+          }
+          break;
+        }
+        offset += objectSize;
+      } while (offset + 24 <= buffer.length);
+      return {
+        ext: "asf",
+        mime: "application/vnd.ms-asf"
+      };
+    }
+    if (check([0, 0, 1, 186]) || check([0, 0, 1, 179])) {
+      return {
+        ext: "mpg",
+        mime: "video/mpeg"
+      };
+    }
+    for (let start = 0; start < 2 && start < buffer.length - 16; start++) {
+      if (check([73, 68, 51], { offset: start }) || // ID3 header
+      check([255, 226], { offset: start, mask: [255, 230] })) {
+        return {
+          ext: "mp3",
+          mime: "audio/mpeg"
+        };
+      }
+      if (check([255, 228], { offset: start, mask: [255, 230] })) {
+        return {
+          ext: "mp2",
+          mime: "audio/mpeg"
+        };
+      }
+      if (check([255, 248], { offset: start, mask: [255, 252] })) {
+        return {
+          ext: "mp2",
+          mime: "audio/mpeg"
+        };
+      }
+      if (check([255, 240], { offset: start, mask: [255, 252] })) {
+        return {
+          ext: "mp4",
+          mime: "audio/mpeg"
+        };
+      }
+    }
+    if (check([79, 112, 117, 115, 72, 101, 97, 100], { offset: 28 })) {
+      return {
+        ext: "opus",
+        mime: "audio/opus"
+      };
+    }
+    if (check([79, 103, 103, 83])) {
+      if (check([128, 116, 104, 101, 111, 114, 97], { offset: 28 })) {
+        return {
+          ext: "ogv",
+          mime: "video/ogg"
+        };
+      }
+      if (check([1, 118, 105, 100, 101, 111, 0], { offset: 28 })) {
+        return {
+          ext: "ogm",
+          mime: "video/ogg"
+        };
+      }
+      if (check([127, 70, 76, 65, 67], { offset: 28 })) {
+        return {
+          ext: "oga",
+          mime: "audio/ogg"
+        };
+      }
+      if (check([83, 112, 101, 101, 120, 32, 32], { offset: 28 })) {
+        return {
+          ext: "spx",
+          mime: "audio/ogg"
+        };
+      }
+      if (check([1, 118, 111, 114, 98, 105, 115], { offset: 28 })) {
+        return {
+          ext: "ogg",
+          mime: "audio/ogg"
+        };
+      }
+      return {
+        ext: "ogx",
+        mime: "application/ogg"
+      };
+    }
+    if (check([102, 76, 97, 67])) {
+      return {
+        ext: "flac",
+        mime: "audio/x-flac"
+      };
+    }
+    if (check([77, 65, 67, 32])) {
+      return {
+        ext: "ape",
+        mime: "audio/ape"
+      };
+    }
+    if (check([119, 118, 112, 107])) {
+      return {
+        ext: "wv",
+        mime: "audio/wavpack"
+      };
+    }
+    if (check([35, 33, 65, 77, 82, 10])) {
+      return {
+        ext: "amr",
+        mime: "audio/amr"
+      };
+    }
+    if (check([37, 80, 68, 70])) {
+      return {
+        ext: "pdf",
+        mime: "application/pdf"
+      };
+    }
+    if (check([77, 90])) {
+      return {
+        ext: "exe",
+        mime: "application/x-msdownload"
+      };
+    }
+    if ((buffer[0] === 67 || buffer[0] === 70) && check([87, 83], { offset: 1 })) {
+      return {
+        ext: "swf",
+        mime: "application/x-shockwave-flash"
+      };
+    }
+    if (check([123, 92, 114, 116, 102])) {
+      return {
+        ext: "rtf",
+        mime: "application/rtf"
+      };
+    }
+    if (check([0, 97, 115, 109])) {
+      return {
+        ext: "wasm",
+        mime: "application/wasm"
+      };
+    }
+    if (check([119, 79, 70, 70]) && (check([0, 1, 0, 0], { offset: 4 }) || check([79, 84, 84, 79], { offset: 4 }))) {
+      return {
+        ext: "woff",
+        mime: "font/woff"
+      };
+    }
+    if (check([119, 79, 70, 50]) && (check([0, 1, 0, 0], { offset: 4 }) || check([79, 84, 84, 79], { offset: 4 }))) {
+      return {
+        ext: "woff2",
+        mime: "font/woff2"
+      };
+    }
+    if (check([76, 80], { offset: 34 }) && (check([0, 0, 1], { offset: 8 }) || check([1, 0, 2], { offset: 8 }) || check([2, 0, 2], { offset: 8 }))) {
+      return {
+        ext: "eot",
+        mime: "application/vnd.ms-fontobject"
+      };
+    }
+    if (check([0, 1, 0, 0, 0])) {
+      return {
+        ext: "ttf",
+        mime: "font/ttf"
+      };
+    }
+    if (check([79, 84, 84, 79, 0])) {
+      return {
+        ext: "otf",
+        mime: "font/otf"
+      };
+    }
+    if (check([0, 0, 1, 0])) {
+      return {
+        ext: "ico",
+        mime: "image/x-icon"
+      };
+    }
+    if (check([0, 0, 2, 0])) {
+      return {
+        ext: "cur",
+        mime: "image/x-icon"
+      };
+    }
+    if (check([70, 76, 86, 1])) {
+      return {
+        ext: "flv",
+        mime: "video/x-flv"
+      };
+    }
+    if (check([37, 33])) {
+      return {
+        ext: "ps",
+        mime: "application/postscript"
+      };
+    }
+    if (check([253, 55, 122, 88, 90, 0])) {
+      return {
+        ext: "xz",
+        mime: "application/x-xz"
+      };
+    }
+    if (check([83, 81, 76, 105])) {
+      return {
+        ext: "sqlite",
+        mime: "application/x-sqlite3"
+      };
+    }
+    if (check([78, 69, 83, 26])) {
+      return {
+        ext: "nes",
+        mime: "application/x-nintendo-nes-rom"
+      };
+    }
+    if (check([67, 114, 50, 52])) {
+      return {
+        ext: "crx",
+        mime: "application/x-google-chrome-extension"
+      };
+    }
+    if (check([77, 83, 67, 70]) || check([73, 83, 99, 40])) {
+      return {
+        ext: "cab",
+        mime: "application/vnd.ms-cab-compressed"
+      };
+    }
+    if (check([33, 60, 97, 114, 99, 104, 62, 10, 100, 101, 98, 105, 97, 110, 45, 98, 105, 110, 97, 114, 121])) {
+      return {
+        ext: "deb",
+        mime: "application/x-deb"
+      };
+    }
+    if (check([33, 60, 97, 114, 99, 104, 62])) {
+      return {
+        ext: "ar",
+        mime: "application/x-unix-archive"
+      };
+    }
+    if (check([237, 171, 238, 219])) {
+      return {
+        ext: "rpm",
+        mime: "application/x-rpm"
+      };
+    }
+    if (check([31, 160]) || check([31, 157])) {
+      return {
+        ext: "Z",
+        mime: "application/x-compress"
+      };
+    }
+    if (check([76, 90, 73, 80])) {
+      return {
+        ext: "lz",
+        mime: "application/x-lzip"
+      };
+    }
+    if (check([208, 207, 17, 224, 161, 177, 26, 225, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62])) {
+      return {
+        ext: "msi",
+        mime: "application/x-msi"
+      };
+    }
+    if (check([6, 14, 43, 52, 2, 5, 1, 1, 13, 1, 2, 1, 1, 2])) {
+      return {
+        ext: "mxf",
+        mime: "application/mxf"
+      };
+    }
+    if (check([71], { offset: 4 }) && (check([71], { offset: 192 }) || check([71], { offset: 196 }))) {
+      return {
+        ext: "mts",
+        mime: "video/mp2t"
+      };
+    }
+    if (check([66, 76, 69, 78, 68, 69, 82])) {
+      return {
+        ext: "blend",
+        mime: "application/x-blender"
+      };
+    }
+    if (check([66, 80, 71, 251])) {
+      return {
+        ext: "bpg",
+        mime: "image/bpg"
+      };
+    }
+    if (check([0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10])) {
+      if (check([106, 112, 50, 32], { offset: 20 })) {
+        return {
+          ext: "jp2",
+          mime: "image/jp2"
+        };
+      }
+      if (check([106, 112, 120, 32], { offset: 20 })) {
+        return {
+          ext: "jpx",
+          mime: "image/jpx"
+        };
+      }
+      if (check([106, 112, 109, 32], { offset: 20 })) {
+        return {
+          ext: "jpm",
+          mime: "image/jpm"
+        };
+      }
+      if (check([109, 106, 112, 50], { offset: 20 })) {
+        return {
+          ext: "mj2",
+          mime: "image/mj2"
+        };
+      }
+    }
+    if (check([70, 79, 82, 77])) {
+      return {
+        ext: "aif",
+        mime: "audio/aiff"
+      };
+    }
+    if (checkString("<?xml ")) {
+      return {
+        ext: "xml",
+        mime: "application/xml"
+      };
+    }
+    if (check([66, 79, 79, 75, 77, 79, 66, 73], { offset: 60 })) {
+      return {
+        ext: "mobi",
+        mime: "application/x-mobipocket-ebook"
+      };
+    }
+    if (check([171, 75, 84, 88, 32, 49, 49, 187, 13, 10, 26, 10])) {
+      return {
+        ext: "ktx",
+        mime: "image/ktx"
+      };
+    }
+    if (check([68, 73, 67, 77], { offset: 128 })) {
+      return {
+        ext: "dcm",
+        mime: "application/dicom"
+      };
+    }
+    if (check([77, 80, 43])) {
+      return {
+        ext: "mpc",
+        mime: "audio/x-musepack"
+      };
+    }
+    if (check([77, 80, 67, 75])) {
+      return {
+        ext: "mpc",
+        mime: "audio/x-musepack"
+      };
+    }
+    if (check([66, 69, 71, 73, 78, 58])) {
+      return {
+        ext: "ics",
+        mime: "text/calendar"
+      };
+    }
+    if (check([103, 108, 84, 70, 2, 0, 0, 0])) {
+      return {
+        ext: "glb",
+        mime: "model/gltf-binary"
+      };
+    }
+    if (check([212, 195, 178, 161]) || check([161, 178, 195, 212])) {
+      return {
+        ext: "pcap",
+        mime: "application/vnd.tcpdump.pcap"
+      };
+    }
+    if (check([68, 83, 68, 32])) {
+      return {
+        ext: "dsf",
+        mime: "audio/x-dsf"
+        // Non-standard
+      };
+    }
+    if (check([76, 0, 0, 0, 1, 20, 2, 0, 0, 0, 0, 0, 192, 0, 0, 0, 0, 0, 0, 70])) {
+      return {
+        ext: "lnk",
+        mime: "application/x.ms.shortcut"
+        // Invented by us
+      };
+    }
+    if (check([98, 111, 111, 107, 0, 0, 0, 0, 109, 97, 114, 107, 0, 0, 0, 0])) {
+      return {
+        ext: "alias",
+        mime: "application/x.apple.alias"
+        // Invented by us
+      };
+    }
+    if (checkString("Creative Voice File")) {
+      return {
+        ext: "voc",
+        mime: "audio/x-voc"
+      };
+    }
+    if (check([11, 119])) {
+      return {
+        ext: "ac3",
+        mime: "audio/vnd.dolby.dd-raw"
+      };
+    }
+    if ((check([126, 16, 4]) || check([126, 24, 4])) && check([48, 77, 73, 69], { offset: 4 })) {
+      return {
+        ext: "mie",
+        mime: "application/x-mie"
+      };
+    }
+    if (check([65, 82, 82, 79, 87, 49, 0, 0])) {
+      return {
+        ext: "arrow",
+        mime: "application/x-apache-arrow"
+      };
+    }
+    if (check([39, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], { offset: 2 })) {
+      return {
+        ext: "shp",
+        mime: "application/x-esri-shape"
+      };
+    }
+  };
+  module.exports = fileType;
+  Object.defineProperty(fileType, "minimumBytes", { value: 4100 });
+  fileType.stream = (readableStream) => new Promise((resolve, reject) => {
+    const stream = eval("require")("stream");
+    readableStream.on("error", reject);
+    readableStream.once("readable", () => {
+      const pass = new stream.PassThrough();
+      const chunk = readableStream.read(module.exports.minimumBytes) || readableStream.read();
+      try {
+        pass.fileType = fileType(chunk);
+      } catch (error) {
+        reject(error);
+      }
+      readableStream.unshift(chunk);
+      if (stream.pipeline) {
+        resolve(stream.pipeline(readableStream, pass, () => {
+        }));
+      } else {
+        resolve(readableStream.pipe(pass));
+      }
+    });
+  });
+  Object.defineProperty(fileType, "extensions", {
+    get() {
+      return new Set(supported$1.extensions);
+    }
+  });
+  Object.defineProperty(fileType, "mimeTypes", {
+    get() {
+      return new Set(supported$1.mimeTypes);
+    }
+  });
+})(fileType);