@remotion/media-parser 4.0.270 → 4.0.271

package/dist/esm/worker.mjs

@@ -0,0 +1,439 @@
+// src/errors.ts
+class IsAGifError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAGifError";
+    this.fileName = "IsAGifError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAGifError);
+    }
+  }
+}
+
+class IsAnImageError extends Error {
+  imageType;
+  dimensions;
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    dimensions,
+    imageType,
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAnImageError";
+    this.imageType = imageType;
+    this.dimensions = dimensions;
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnImageError);
+    }
+  }
+}
+
+class IsAPdfError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAPdfError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAPdfError);
+    }
+  }
+}
+
+class IsAnUnsupportedFileTypeError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAnUnsupportedFileTypeError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnUnsupportedFileTypeError);
+    }
+  }
+}
+
+class MediaParserAbortError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MediaParserAbortError";
+    this.cause = undefined;
+  }
+}
+
+// src/worker/serialize-error.ts
+var deserializeError = (error) => {
+  switch (error.errorName) {
+    case "IsAGifError":
+      return new IsAGifError({
+        fileName: error.fileName,
+        mimeType: error.mimeType,
+        sizeInBytes: error.sizeInBytes,
+        message: error.errorMessage
+      });
+    case "IsAnImageError":
+      return new IsAnImageError({
+        dimensions: error.dimensions,
+        fileName: error.fileName,
+        imageType: error.imageType,
+        mimeType: error.mimeType,
+        sizeInBytes: error.sizeInBytes,
+        message: error.errorMessage
+      });
+    case "IsAPdfError":
+      return new IsAPdfError({
+        fileName: error.fileName,
+        mimeType: error.mimeType,
+        sizeInBytes: error.sizeInBytes,
+        message: error.errorMessage
+      });
+    case "IsAnUnsupportedFileTypeError":
+      return new IsAnUnsupportedFileTypeError({
+        fileName: error.fileName,
+        mimeType: error.mimeType,
+        sizeInBytes: error.sizeInBytes,
+        message: error.errorMessage
+      });
+    case "MediaParserAbortError":
+      return new MediaParserAbortError(error.errorMessage);
+    default:
+      return new Error(error.errorMessage);
+  }
+};
+
+// src/worker.ts
+var convertToWorkerPayload = (payload) => {
+  const {
+    onAudioCodec,
+    onContainer,
+    onDimensions,
+    onUnrotatedDimensions,
+    onVideoCodec,
+    onFps,
+    onAudioTrack,
+    onDurationInSeconds,
+    onImages,
+    onInternalStats,
+    onIsHdr,
+    onKeyframes,
+    onLocation,
+    onM3uStreams,
+    onMetadata,
+    onMimeType,
+    onName,
+    onNumberOfAudioChannels,
+    onParseProgress,
+    onRotation,
+    onSampleRate,
+    onSlowAudioBitrate,
+    onSize,
+    onSlowDurationInSeconds,
+    onSlowFps,
+    onSlowKeyframes,
+    onSlowNumberOfFrames,
+    onSlowVideoBitrate,
+    onStructure,
+    onTracks,
+    onVideoTrack,
+    selectM3uStream,
+    selectM3uAssociatedPlaylists,
+    ...others
+  } = payload;
+  return {
+    type: "request-worker",
+    payload: others,
+    postAudioCodec: Boolean(onAudioCodec),
+    postContainer: Boolean(onContainer),
+    postDimensions: Boolean(onDimensions),
+    postDurationInSeconds: Boolean(onDurationInSeconds),
+    postFps: Boolean(onFps),
+    postImages: Boolean(onImages),
+    postInternalStats: Boolean(onInternalStats),
+    postIsHdr: Boolean(onIsHdr),
+    postKeyframes: Boolean(onKeyframes),
+    postLocation: Boolean(onLocation),
+    postM3uStreams: Boolean(onM3uStreams),
+    postMetadata: Boolean(onMetadata),
+    postMimeType: Boolean(onMimeType),
+    postName: Boolean(onName),
+    postNumberOfAudioChannels: Boolean(onNumberOfAudioChannels),
+    postRotation: Boolean(onRotation),
+    postSampleRate: Boolean(onSampleRate),
+    postSlowAudioBitrate: Boolean(onSlowAudioBitrate),
+    postSlowDurationInSeconds: Boolean(onSlowDurationInSeconds),
+    postSlowFps: Boolean(onSlowFps),
+    postSlowKeyframes: Boolean(onSlowKeyframes),
+    postSlowNumberOfFrames: Boolean(onSlowNumberOfFrames),
+    postSlowVideoBitrate: Boolean(onSlowVideoBitrate),
+    postStructure: Boolean(onStructure),
+    postTracks: Boolean(onTracks),
+    postUnrotatedDimensions: Boolean(onUnrotatedDimensions),
+    postVideoCodec: Boolean(onVideoCodec),
+    postSize: Boolean(onSize),
+    postParseProgress: Boolean(onParseProgress),
+    postM3uStreamSelection: Boolean(selectM3uStream),
+    postM3uAssociatedPlaylistsSelection: Boolean(selectM3uAssociatedPlaylists),
+    postOnAudioTrack: Boolean(onAudioTrack),
+    postOnVideoTrack: Boolean(onVideoTrack)
+  };
+};
+var post = (worker, payload) => {
+  worker.postMessage(payload);
+};
+var parseMediaOnWorker = async ({
+  controller,
+  ...params
+}) => {
+  if (typeof Worker === "undefined") {
+    throw new Error('"Worker" is not available. Cannot call workerClient()');
+  }
+  const worker = new Worker(new URL("./worker-server", import.meta.url));
+  post(worker, convertToWorkerPayload(params));
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const onAbort = () => {
+    post(worker, { type: "request-abort" });
+  };
+  const onResume = () => {
+    post(worker, { type: "request-resume" });
+  };
+  const onPause = () => {
+    post(worker, { type: "request-pause" });
+  };
+  const callbacks = {};
+  function onMessage(message) {
+    const data = message.data;
+    if (data.type === "response-done") {
+      resolve(data.payload);
+    }
+    if (data.type === "response-error") {
+      cleanup();
+      reject(deserializeError(data));
+    }
+    if (data.type === "response-on-callback-request") {
+      Promise.resolve().then(async () => {
+        if (data.payload.callbackType === "audio-codec") {
+          await params.onAudioCodec?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "container") {
+          await params.onContainer?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "dimensions") {
+          await params.onDimensions?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "unrotated-dimensions") {
+          await params.onUnrotatedDimensions?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "video-codec") {
+          await params.onVideoCodec?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "tracks") {
+          await params.onTracks?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "rotation") {
+          await params.onRotation?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "sample-rate") {
+          await params.onSampleRate?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "slow-audio-bitrate") {
+          await params.onSlowAudioBitrate?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "slow-duration-in-seconds") {
+          await params.onSlowDurationInSeconds?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "slow-fps") {
+          await params.onSlowFps?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "slow-keyframes") {
+          await params.onSlowKeyframes?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "slow-number-of-frames") {
+          await params.onSlowNumberOfFrames?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "slow-video-bitrate") {
+          await params.onSlowVideoBitrate?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "structure") {
+          await params.onStructure?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "fps") {
+          await params.onFps?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "images") {
+          await params.onImages?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "internal-stats") {
+          await params.onInternalStats?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "is-hdr") {
+          await params.onIsHdr?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "keyframes") {
+          await params.onKeyframes?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "location") {
+          await params.onLocation?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "m3u-streams") {
+          await params.onM3uStreams?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "metadata") {
+          await params.onMetadata?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "mime-type") {
+          await params.onMimeType?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "name") {
+          await params.onName?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "number-of-audio-channels") {
+          await params.onNumberOfAudioChannels?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "size") {
+          await params.onSize?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "duration-in-seconds") {
+          await params.onDurationInSeconds?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "parse-progress") {
+          await params.onParseProgress?.(data.payload.value);
+          return { payloadType: "void" };
+        }
+        if (data.payload.callbackType === "m3u-stream-selection") {
+          const selection = await params.selectM3uStream(data.payload.value);
+          return { payloadType: "m3u-stream-selection", value: selection };
+        }
+        if (data.payload.callbackType === "m3u-associated-playlists-selection") {
+          const selection = await params.selectM3uAssociatedPlaylists(data.payload.value);
+          return {
+            payloadType: "m3u-associated-playlists-selection",
+            value: selection
+          };
+        }
+        if (data.payload.callbackType === "on-audio-track") {
+          const possibleCallback = await params.onAudioTrack?.(data.payload.value);
+          if (possibleCallback) {
+            callbacks[data.payload.value.track.trackId] = possibleCallback;
+          }
+          return {
+            payloadType: "on-audio-track-response",
+            registeredCallback: Boolean(possibleCallback)
+          };
+        }
+        if (data.payload.callbackType === "on-video-track") {
+          const possibleCallback = await params.onVideoTrack?.(data.payload.value);
+          if (possibleCallback) {
+            callbacks[data.payload.value.track.trackId] = possibleCallback;
+          }
+          return {
+            payloadType: "on-video-track-response",
+            registeredCallback: Boolean(possibleCallback)
+          };
+        }
+        if (data.payload.callbackType === "on-audio-video-sample") {
+          const callback = callbacks[data.payload.trackId];
+          if (!callback) {
+            throw new Error(`No callback registered for track ${data.payload.trackId}`);
+          }
+          await callback(data.payload.value);
+          return { payloadType: "void" };
+        }
+        throw new Error(`Unknown callback type: ${data.payload}`);
+      }).then((payload) => {
+        post(worker, {
+          type: "acknowledge-callback",
+          nonce: data.nonce,
+          ...payload
+        });
+      }).catch((err) => {
+        reject(err);
+        post(worker, {
+          type: "signal-error-in-callback",
+          nonce: data.nonce
+        });
+      });
+    }
+  }
+  worker.addEventListener("message", onMessage);
+  controller?.addEventListener("abort", onAbort);
+  controller?.addEventListener("resume", onResume);
+  controller?.addEventListener("pause", onPause);
+  function cleanup() {
+    worker.removeEventListener("message", onMessage);
+    controller?.removeEventListener("abort", onAbort);
+    controller?.removeEventListener("resume", onResume);
+    controller?.removeEventListener("pause", onPause);
+    worker.terminate();
+  }
+  const val = await promise;
+  cleanup();
+  return val;
+};
+export {
+  parseMediaOnWorker
+};

package/dist/fetch.js

@@ -1,17 +1 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./readers/from-fetch"), exports);
+export * from './readers/from-fetch';

package/dist/file-types/bmp.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBmp = void 0;
-const detect_file_type_1 = require("./detect-file-type");
+import { matchesPattern } from './detect-file-type';
 function getBmpDimensions(bmpData) {
     if (bmpData.length < 26) {
         return null;
@@ -12,12 +9,11 @@ function getBmpDimensions(bmpData) {
         height: Math.abs(view.getInt32(22, true)),
     };
 }
-const isBmp = (data) => {
+export const isBmp = (data) => {
     const bmpPattern = new Uint8Array([0x42, 0x4d]);
-    if ((0, detect_file_type_1.matchesPattern)(bmpPattern)(data.subarray(0, 2))) {
+    if (matchesPattern(bmpPattern)(data.subarray(0, 2))) {
         const bmp = getBmpDimensions(data);
         return { dimensions: bmp, type: 'bmp' };
     }
     return null;
 };
-exports.isBmp = isBmp;

package/dist/file-types/detect-file-type.js

@@ -1,74 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isM3u = exports.isFlac = exports.isAac = exports.isGif = exports.isMp3 = exports.isTransportStream = exports.isIsoBaseMedia = exports.isWebm = exports.isRiffWave = exports.isRiffAvi = exports.matchesPattern = void 0;
 const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
-const matchesPattern = (pattern) => {
+export const matchesPattern = (pattern) => {
     return (data) => {
         return pattern.every((value, index) => data[index] === value);
     };
 };
-exports.matchesPattern = matchesPattern;
-const isRiffAvi = (data) => {
+export const isRiffAvi = (data) => {
     const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
-    if (!(0, exports.matchesPattern)(riffPattern)(data.subarray(0, 4))) {
+    if (!matchesPattern(riffPattern)(data.subarray(0, 4))) {
         return false;
     }
     const fileType = data.subarray(8, 12);
     const aviPattern = new Uint8Array([0x41, 0x56, 0x49, 0x20]);
-    return (0, exports.matchesPattern)(aviPattern)(fileType);
+    return matchesPattern(aviPattern)(fileType);
 };
-exports.isRiffAvi = isRiffAvi;
-const isRiffWave = (data) => {
+export const isRiffWave = (data) => {
     const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
-    if (!(0, exports.matchesPattern)(riffPattern)(data.subarray(0, 4))) {
+    if (!matchesPattern(riffPattern)(data.subarray(0, 4))) {
         return false;
     }
     const fileType = data.subarray(8, 12);
     const wavePattern = new Uint8Array([0x57, 0x41, 0x56, 0x45]);
-    return (0, exports.matchesPattern)(wavePattern)(fileType);
+    return matchesPattern(wavePattern)(fileType);
 };
-exports.isRiffWave = isRiffWave;
-const isWebm = (data) => {
-    return (0, exports.matchesPattern)(webmPattern)(data.subarray(0, 4));
+export const isWebm = (data) => {
+    return matchesPattern(webmPattern)(data.subarray(0, 4));
 };
-exports.isWebm = isWebm;
-const isIsoBaseMedia = (data) => {
+export const isIsoBaseMedia = (data) => {
     const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
-    return (0, exports.matchesPattern)(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+    return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
 };
-exports.isIsoBaseMedia = isIsoBaseMedia;
-const isTransportStream = (data) => {
+export const isTransportStream = (data) => {
     return data[0] === 0x47 && data[188] === 0x47;
 };
-exports.isTransportStream = isTransportStream;
-const isMp3 = (data) => {
+export const isMp3 = (data) => {
     const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
     const id3v4Pattern = new Uint8Array([0x49, 0x44, 0x33, 4]);
     const id3v3Pattern = new Uint8Array([0x49, 0x44, 0x33, 3]);
     const id3v2Pattern = new Uint8Array([0x49, 0x44, 0x33, 2]);
     const subarray = data.subarray(0, 4);
-    return ((0, exports.matchesPattern)(mpegPattern)(subarray) ||
-        (0, exports.matchesPattern)(id3v4Pattern)(subarray) ||
-        (0, exports.matchesPattern)(id3v3Pattern)(subarray) ||
-        (0, exports.matchesPattern)(id3v2Pattern)(subarray));
+    return (matchesPattern(mpegPattern)(subarray) ||
+        matchesPattern(id3v4Pattern)(subarray) ||
+        matchesPattern(id3v3Pattern)(subarray) ||
+        matchesPattern(id3v2Pattern)(subarray));
 };
-exports.isMp3 = isMp3;
-const isGif = (data) => {
+export const isGif = (data) => {
     const gifPattern = new Uint8Array([0x47, 0x49, 0x46, 0x38]);
-    return (0, exports.matchesPattern)(gifPattern)(data.subarray(0, 4));
+    return matchesPattern(gifPattern)(data.subarray(0, 4));
 };
-exports.isGif = isGif;
-const isAac = (data) => {
+export const isAac = (data) => {
     const aacPattern = new Uint8Array([0xff, 0xf1]);
-    return (0, exports.matchesPattern)(aacPattern)(data.subarray(0, 2));
+    return matchesPattern(aacPattern)(data.subarray(0, 2));
 };
-exports.isAac = isAac;
-const isFlac = (data) => {
+export const isFlac = (data) => {
     const flacPattern = new Uint8Array([0x66, 0x4c, 0x61, 0x43]);
-    return (0, exports.matchesPattern)(flacPattern)(data.subarray(0, 4));
+    return matchesPattern(flacPattern)(data.subarray(0, 4));
 };
-exports.isFlac = isFlac;
-const isM3u = (data) => {
+export const isM3u = (data) => {
     return new TextDecoder('utf-8').decode(data.slice(0, 7)) === '#EXTM3U';
 };
-exports.isM3u = isM3u;

package/dist/file-types/index.js

@@ -1,63 +1,59 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectFileType = void 0;
-const bmp_1 = require("./bmp");
-const detect_file_type_1 = require("./detect-file-type");
-const jpeg_1 = require("./jpeg");
-const pdf_1 = require("./pdf");
-const png_1 = require("./png");
-const webp_1 = require("./webp");
-const detectFileType = (data) => {
-    if ((0, detect_file_type_1.isRiffWave)(data)) {
+import { isBmp } from './bmp';
+import { isAac, isFlac, isGif, isIsoBaseMedia, isM3u, isMp3, isRiffAvi, isRiffWave, isTransportStream, isWebm, } from './detect-file-type';
+import { isJpeg } from './jpeg';
+import { isPdf } from './pdf';
+import { isPng } from './png';
+import { isWebp } from './webp';
+export const detectFileType = (data) => {
+    if (isRiffWave(data)) {
         return { type: 'wav' };
     }
-    if ((0, detect_file_type_1.isRiffAvi)(data)) {
+    if (isRiffAvi(data)) {
         return { type: 'riff' };
     }
-    if ((0, detect_file_type_1.isAac)(data)) {
+    if (isAac(data)) {
         return { type: 'aac' };
     }
-    if ((0, detect_file_type_1.isFlac)(data)) {
+    if (isFlac(data)) {
         return { type: 'flac' };
     }
-    if ((0, detect_file_type_1.isM3u)(data)) {
+    if (isM3u(data)) {
         return { type: 'm3u' };
     }
-    const webp = (0, webp_1.isWebp)(data);
+    const webp = isWebp(data);
     if (webp) {
         return webp;
     }
-    if ((0, detect_file_type_1.isWebm)(data)) {
+    if (isWebm(data)) {
         return { type: 'webm' };
     }
-    if ((0, detect_file_type_1.isIsoBaseMedia)(data)) {
+    if (isIsoBaseMedia(data)) {
         return { type: 'iso-base-media' };
     }
-    if ((0, detect_file_type_1.isTransportStream)(data)) {
+    if (isTransportStream(data)) {
         return { type: 'transport-stream' };
     }
-    if ((0, detect_file_type_1.isMp3)(data)) {
+    if (isMp3(data)) {
         return { type: 'mp3' };
     }
-    if ((0, detect_file_type_1.isGif)(data)) {
+    if (isGif(data)) {
         return { type: 'gif' };
     }
-    const png = (0, png_1.isPng)(data);
+    const png = isPng(data);
     if (png) {
         return png;
     }
-    const pdf = (0, pdf_1.isPdf)(data);
+    const pdf = isPdf(data);
     if (pdf) {
         return pdf;
     }
-    const bmp = (0, bmp_1.isBmp)(data);
+    const bmp = isBmp(data);
     if (bmp) {
         return bmp;
     }
-    const jpeg = (0, jpeg_1.isJpeg)(data);
+    const jpeg = isJpeg(data);
     if (jpeg) {
         return jpeg;
     }
     return { type: 'unknown' };
 };
-exports.detectFileType = detectFileType;