@remotion/media-parser 4.0.240 → 4.0.241

package/dist/esm/index.mjs

@@ -83,6 +83,7 @@ var fetchReader = {
         }
       },
       contentLength,
+      contentType: res.headers.get("content-type"),
       name: name ?? fallbackName,
       supportsContentRange
     };
@@ -1366,7 +1367,7 @@ var createIsoBaseMediaFtyp = ({
 };
 
 // src/version.ts
-var VERSION = "4.0.240";
+var VERSION = "4.0.241";
 
 // src/create/iso-base-media/create-ilst.ts
 var createIlst = (items) => {
@@ -3529,6 +3530,120 @@ var createWav = async ({
   };
 };
 
+// src/errors.ts
+class IsAGifError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    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 IsAnUnsupportedAudioTypeError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  audioType;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName,
+    audioType
+  }) {
+    super(message);
+    this.name = "IsAnUnsupportedAudioTypeError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    this.audioType = audioType;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnUnsupportedAudioTypeError);
+    }
+  }
+}
 // src/boxes/iso-base-media/traversal.ts
 var getMoovBox = (segments) => {
   const moovBox = segments.find((s) => s.type === "moov-box");
@@ -4358,6 +4473,234 @@ var getPrimariesFromIndex = (index) => {
   return index === 1 ? "bt709" : index === 5 ? "bt470bg" : index === 6 ? "smpte170m" : index === 9 ? "bt2020" : null;
 };
 
+// src/file-types/detect-file-type.ts
+var matchesPattern = (pattern) => {
+  return (data) => {
+    return pattern.every((value, index) => data[index] === value);
+  };
+};
+var isRiffAvi2 = (data) => {
+  const riffPattern = new Uint8Array([82, 73, 70, 70]);
+  if (!matchesPattern(riffPattern)(data.subarray(0, 4))) {
+    return false;
+  }
+  const fileType = data.subarray(8, 12);
+  return new TextDecoder().decode(fileType) === "AVI ";
+};
+var isRiffWave = (data) => {
+  const riffPattern = new Uint8Array([82, 73, 70, 70]);
+  if (!matchesPattern(riffPattern)(data.subarray(0, 4))) {
+    return false;
+  }
+  const fileType = data.subarray(8, 12);
+  return new TextDecoder().decode(fileType) === "WAVE";
+};
+var isWebm = (data) => {
+  return matchesPattern(webmPattern)(data.subarray(0, 4));
+};
+var isIsoBaseMedia = (data) => {
+  const isoBaseMediaMp4Pattern = new TextEncoder().encode("ftyp");
+  return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+};
+var isTransportStream = (data) => {
+  return data[0] === 71 && data[188] === 71;
+};
+var isMp3 = (data) => {
+  const mpegPattern = new Uint8Array([255, 243, 228, 100]);
+  const id3Pattern = new Uint8Array([73, 68, 51, 3]);
+  const subarray = data.subarray(0, 4);
+  return matchesPattern(mpegPattern)(subarray) || matchesPattern(id3Pattern)(subarray);
+};
+var isGif = (data) => {
+  const gifPattern = new Uint8Array([71, 73, 70, 56]);
+  return matchesPattern(gifPattern)(data.subarray(0, 4));
+};
+var isAac = (data) => {
+  const aacPattern = new Uint8Array([255, 241]);
+  return matchesPattern(aacPattern)(data.subarray(0, 2));
+};
+
+// src/file-types/bmp.ts
+function getBmpDimensions(bmpData) {
+  if (bmpData.length < 26) {
+    return null;
+  }
+  const view = new DataView(bmpData.buffer, bmpData.byteOffset);
+  return {
+    width: view.getUint32(18, true),
+    height: Math.abs(view.getInt32(22, true))
+  };
+}
+var isBmp = (data) => {
+  const bmpPattern = new Uint8Array([66, 77]);
+  if (matchesPattern(bmpPattern)(data.subarray(0, 2))) {
+    const bmp = getBmpDimensions(data);
+    return { dimensions: bmp, type: "bmp" };
+  }
+  return null;
+};
+
+// src/file-types/jpeg.ts
+function getJpegDimensions(data) {
+  let offset = 0;
+  function readUint16BE(o) {
+    return data[o] << 8 | data[o + 1];
+  }
+  if (readUint16BE(offset) !== 65496) {
+    return null;
+  }
+  offset += 2;
+  while (offset < data.length) {
+    if (data[offset] === 255) {
+      const marker = data[offset + 1];
+      if (marker === 192 || marker === 194) {
+        const height = readUint16BE(offset + 5);
+        const width = readUint16BE(offset + 7);
+        return { width, height };
+      }
+      const length = readUint16BE(offset + 2);
+      offset += length + 2;
+    } else {
+      offset++;
+    }
+  }
+  return null;
+}
+var isJpeg = (data) => {
+  const jpegPattern = new Uint8Array([255, 216]);
+  const jpeg = matchesPattern(jpegPattern)(data.subarray(0, 2));
+  if (!jpeg) {
+    return null;
+  }
+  const dim = getJpegDimensions(data);
+  return { dimensions: dim, type: "jpeg" };
+};
+
+// src/file-types/pdf.ts
+var isPdf = (data) => {
+  if (data.length < 4) {
+    return null;
+  }
+  const pdfPattern = new Uint8Array([37, 80, 68, 70]);
+  return matchesPattern(pdfPattern)(data.subarray(0, 4)) ? { type: "pdf" } : null;
+};
+
+// src/file-types/png.ts
+function getPngDimensions(pngData) {
+  if (pngData.length < 24) {
+    return null;
+  }
+  const view = new DataView(pngData.buffer, pngData.byteOffset);
+  const pngSignature = [137, 80, 78, 71, 13, 10, 26, 10];
+  for (let i = 0;i < 8; i++) {
+    if (pngData[i] !== pngSignature[i]) {
+      return null;
+    }
+  }
+  return {
+    width: view.getUint32(16, false),
+    height: view.getUint32(20, false)
+  };
+}
+var isPng = (data) => {
+  const pngPattern = new Uint8Array([137, 80, 78, 71]);
+  if (matchesPattern(pngPattern)(data.subarray(0, 4))) {
+    const png = getPngDimensions(data);
+    return { dimensions: png, type: "png" };
+  }
+  return null;
+};
+
+// src/file-types/webp.ts
+function getWebPDimensions(bytes) {
+  if (bytes.length < 30) {
+    return null;
+  }
+  if (bytes[0] !== 82 || bytes[1] !== 73 || bytes[2] !== 70 || bytes[3] !== 70 || bytes[8] !== 87 || bytes[9] !== 69 || bytes[10] !== 66 || bytes[11] !== 80) {
+    return null;
+  }
+  if (bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56) {
+    if (bytes[15] === 32) {
+      return {
+        width: bytes[26] | bytes[27] << 8 & 16383,
+        height: bytes[28] | bytes[29] << 8 & 16383
+      };
+    }
+  }
+  if (bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56 && bytes[15] === 76) {
+    return {
+      width: 1 + (bytes[21] | (bytes[22] & 63) << 8),
+      height: 1 + ((bytes[22] & 192) >> 6 | bytes[23] << 2 | (bytes[24] & 15) << 10)
+    };
+  }
+  if (bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56 && bytes[15] === 88) {
+    return {
+      width: 1 + (bytes[24] | bytes[25] << 8 | bytes[26] << 16),
+      height: 1 + (bytes[27] | bytes[28] << 8 | bytes[29] << 16)
+    };
+  }
+  return null;
+}
+var isWebp = (data) => {
+  const webpPattern = new Uint8Array([82, 73, 70, 70]);
+  if (matchesPattern(webpPattern)(data.subarray(0, 4))) {
+    return {
+      type: "webp",
+      dimensions: getWebPDimensions(data)
+    };
+  }
+  return null;
+};
+
+// src/file-types/index.ts
+var detectFileType = (data) => {
+  if (isRiffWave(data)) {
+    return { type: "wav" };
+  }
+  if (isRiffAvi2(data)) {
+    return { type: "riff" };
+  }
+  if (isAac(data)) {
+    return { type: "aac" };
+  }
+  const webp = isWebp(data);
+  if (webp) {
+    return webp;
+  }
+  if (isWebm(data)) {
+    return { type: "webm" };
+  }
+  if (isIsoBaseMedia(data)) {
+    return { type: "iso-base-media" };
+  }
+  if (isTransportStream(data)) {
+    return { type: "transport-stream" };
+  }
+  if (isMp3(data)) {
+    return { type: "mp3" };
+  }
+  if (isGif(data)) {
+    return { type: "gif" };
+  }
+  const png = isPng(data);
+  if (png) {
+    return png;
+  }
+  const pdf = isPdf(data);
+  if (pdf) {
+    return pdf;
+  }
+  const bmp = isBmp(data);
+  if (bmp) {
+    return bmp;
+  }
+  const jpeg = isJpeg(data);
+  if (jpeg) {
+    return jpeg;
+  }
+  return { type: "unknown" };
+};
+
 // src/buffer-iterator.ts
 class OffsetCounter {
   #offset;
@@ -4394,14 +4737,6 @@ class OffsetCounter {
     this.#offset -= amount;
   }
 }
-var isoBaseMediaMp4Pattern = new TextEncoder().encode("ftyp");
-var mpegPattern = new Uint8Array([255, 243, 228, 100]);
-var riffPattern = new Uint8Array([82, 73, 70, 70]);
-var matchesPattern = (pattern) => {
-  return (data) => {
-    return pattern.every((value, index) => data[index] === value);
-  };
-};
 var makeOffsetCounter = () => {
   return new OffsetCounter(0);
 };
@@ -4542,21 +4877,6 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
   const bytesRemaining = () => {
     return data.byteLength - counter.getDiscardedOffset();
   };
-  const isIsoBaseMedia = () => {
-    return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
-  };
-  const isRiff = () => {
-    return matchesPattern(riffPattern)(data.subarray(0, 4));
-  };
-  const isWebm = () => {
-    return matchesPattern(webmPattern)(data.subarray(0, 4));
-  };
-  const isMp3 = () => {
-    return matchesPattern(mpegPattern)(data.subarray(0, 4));
-  };
-  const isTransportStream = () => {
-    return data[0] === 71;
-  };
   const removeBytesRead = () => {
     if (!discardAllowed) {
       return;
@@ -4671,10 +4991,8 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     getBits,
     byteLength,
     bytesRemaining,
-    isIsoBaseMedia,
     leb128,
     removeBytesRead,
-    isWebm,
     discard,
     getEightByteNumber,
     getFourByteNumber,
@@ -4683,7 +5001,9 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
       const atom = getSlice(4);
       return new TextDecoder().decode(atom);
     },
-    isRiff,
+    detectFileType: () => {
+      return detectFileType(data);
+    },
     getPaddedFourByteNumber,
     getMatroskaSegmentId: () => {
       if (bytesRemaining() === 0) {
@@ -4836,11 +5156,9 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     getInt32Le,
     getInt32,
     destroy,
-    isMp3,
     disallowDiscard,
     allowDiscard,
     startBox,
-    isTransportStream,
     readExpGolomb
   };
 };
@@ -6205,145 +6523,205 @@ var getLocation = (structure) => {
 var emitAvailableInfo = ({
   hasInfo,
   parseResult,
-  moreFields,
+  callbacks,
   state,
   returnValue,
   contentLength,
-  name
+  name,
+  mimeType,
+  fieldsInReturnValue,
+  emittedFields
 }) => {
   const keys = Object.keys(hasInfo);
   for (const key of keys) {
     if (key === "structure") {
-      if (parseResult && hasInfo.structure && returnValue.structure === undefined) {
-        moreFields.onStructure?.(parseResult.segments);
-        returnValue.structure = parseResult.segments;
+      if (parseResult && hasInfo.structure && !emittedFields.structure) {
+        callbacks.onStructure?.(parseResult.segments);
+        if (fieldsInReturnValue.structure) {
+          returnValue.structure = parseResult.segments;
+        }
+        emittedFields.structure = true;
       }
       continue;
     }
     if (key === "durationInSeconds") {
-      if (hasInfo.durationInSeconds && returnValue.durationInSeconds === undefined && parseResult) {
+      if (hasInfo.durationInSeconds && !emittedFields.durationInSeconds && parseResult) {
         const durationInSeconds = getDuration(parseResult.segments, state);
-        moreFields.onDurationInSeconds?.(durationInSeconds);
-        returnValue.durationInSeconds = durationInSeconds;
+        callbacks.onDurationInSeconds?.(durationInSeconds);
+        if (fieldsInReturnValue.durationInSeconds) {
+          returnValue.durationInSeconds = durationInSeconds;
+        }
+        emittedFields.durationInSeconds = true;
       }
       continue;
     }
     if (key === "dimensions") {
-      if (hasInfo.dimensions && returnValue.dimensions === undefined && parseResult) {
+      if (hasInfo.dimensions && !emittedFields.dimensions && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const dimensions = {
           height: dimensionsQueried.height,
           width: dimensionsQueried.width
         };
-        moreFields.onDimensions?.(dimensions);
-        returnValue.dimensions = dimensions;
+        callbacks.onDimensions?.(dimensions);
+        if (fieldsInReturnValue.dimensions) {
+          returnValue.dimensions = dimensions;
+        }
+        emittedFields.dimensions = true;
       }
       continue;
     }
     if (key === "unrotatedDimensions") {
-      if (returnValue.unrotatedDimensions === undefined && hasInfo.unrotatedDimensions && parseResult) {
+      if (hasInfo.unrotatedDimensions && !emittedFields.unrotatedDimensions && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const unrotatedDimensions = {
           height: dimensionsQueried.unrotatedHeight,
           width: dimensionsQueried.unrotatedWidth
         };
-        moreFields.onUnrotatedDimensions?.(unrotatedDimensions);
-        returnValue.unrotatedDimensions = unrotatedDimensions;
+        callbacks.onUnrotatedDimensions?.(unrotatedDimensions);
+        if (fieldsInReturnValue.unrotatedDimensions) {
+          returnValue.unrotatedDimensions = unrotatedDimensions;
+        }
+        emittedFields.unrotatedDimensions = true;
       }
       continue;
     }
     if (key === "rotation") {
-      if (returnValue.rotation === undefined && hasInfo.rotation && parseResult) {
+      if (hasInfo.rotation && !emittedFields.rotation && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const { rotation } = dimensionsQueried;
-        moreFields.onRotation?.(rotation);
-        returnValue.rotation = rotation;
+        callbacks.onRotation?.(rotation);
+        if (fieldsInReturnValue.rotation) {
+          returnValue.rotation = rotation;
+        }
+        emittedFields.rotation = true;
       }
       continue;
     }
     if (key === "fps") {
-      if (returnValue.fps === undefined && hasInfo.fps && parseResult) {
+      if (!emittedFields.fps && hasInfo.fps && parseResult) {
         const fps = getFps(parseResult.segments);
-        moreFields.onFps?.(fps);
-        returnValue.fps = fps;
+        callbacks.onFps?.(fps);
+        if (fieldsInReturnValue.fps) {
+          returnValue.fps = fps;
+        }
+        emittedFields.fps = true;
       }
       continue;
     }
     if (key === "videoCodec") {
-      if (returnValue.videoCodec === undefined && hasInfo.videoCodec && parseResult) {
+      if (!emittedFields.videoCodec && hasInfo.videoCodec && parseResult) {
         const videoCodec = getVideoCodec(parseResult.segments, state);
-        moreFields.onVideoCodec?.(videoCodec);
-        returnValue.videoCodec = videoCodec;
+        callbacks.onVideoCodec?.(videoCodec);
+        if (fieldsInReturnValue.videoCodec) {
+          returnValue.videoCodec = videoCodec;
+        }
+        emittedFields.videoCodec = true;
       }
       continue;
     }
     if (key === "audioCodec") {
-      if (returnValue.audioCodec === undefined && hasInfo.audioCodec && parseResult) {
+      if (!emittedFields.audioCodec && hasInfo.audioCodec && parseResult) {
         const audioCodec = getAudioCodec(parseResult.segments, state);
-        moreFields.onAudioCodec?.(audioCodec);
-        returnValue.audioCodec = audioCodec;
+        callbacks.onAudioCodec?.(audioCodec);
+        if (fieldsInReturnValue.audioCodec) {
+          returnValue.audioCodec = audioCodec;
+        }
+        emittedFields.audioCodec = true;
       }
       continue;
     }
     if (key === "tracks") {
-      if (hasInfo.tracks && returnValue.videoTracks === undefined && returnValue.audioTracks === undefined && parseResult) {
+      if (!emittedFields.tracks && hasInfo.tracks && parseResult) {
         const { videoTracks, audioTracks } = getTracks(parseResult.segments, state);
-        moreFields.onTracks?.({ videoTracks, audioTracks });
-        returnValue.videoTracks = videoTracks;
-        returnValue.audioTracks = audioTracks;
+        callbacks.onTracks?.({ videoTracks, audioTracks });
+        if (fieldsInReturnValue.tracks) {
+          returnValue.tracks = { videoTracks, audioTracks };
+        }
+        emittedFields.tracks = true;
       }
       continue;
     }
     if (key === "internalStats") {
       if (hasInfo.internalStats) {
         const internalStats = state.getInternalStats();
-        returnValue.internalStats = internalStats;
+        if (fieldsInReturnValue.internalStats) {
+          returnValue.internalStats = internalStats;
+        }
+        emittedFields.internalStats = true;
       }
       continue;
     }
     if (key === "size") {
-      if (returnValue.size === undefined && hasInfo.size) {
-        moreFields.onSize?.(contentLength);
-        returnValue.size = contentLength;
+      if (!emittedFields.size && hasInfo.size) {
+        callbacks.onSize?.(contentLength);
+        if (fieldsInReturnValue.size) {
+          returnValue.size = contentLength;
+        }
+        emittedFields.size = true;
+      }
+      continue;
+    }
+    if (key === "mimeType") {
+      if (!emittedFields.mimeType && hasInfo.mimeType) {
+        callbacks.onMimeType?.(mimeType);
+        if (fieldsInReturnValue.mimeType) {
+          returnValue.mimeType = mimeType;
+        }
+        emittedFields.mimeType = true;
       }
       continue;
     }
     if (key === "name") {
-      if (returnValue.name === undefined && hasInfo.name) {
-        moreFields.onName?.(name);
-        returnValue.name = name;
+      if (!emittedFields.name && hasInfo.name) {
+        callbacks.onName?.(name);
+        if (fieldsInReturnValue.name) {
+          returnValue.name = name;
+        }
+        emittedFields.name = true;
       }
       continue;
     }
     if (key === "isHdr") {
-      if (returnValue.isHdr === undefined && hasInfo.isHdr && parseResult) {
+      if (!returnValue.isHdr && hasInfo.isHdr && parseResult) {
         const isHdr = getIsHdr(parseResult.segments, state);
-        moreFields.onIsHdr?.(isHdr);
-        returnValue.isHdr = isHdr;
+        callbacks.onIsHdr?.(isHdr);
+        if (fieldsInReturnValue.isHdr) {
+          returnValue.isHdr = isHdr;
+        }
+        emittedFields.isHdr = true;
       }
       continue;
     }
     if (key === "container") {
-      if (returnValue.container === undefined && hasInfo.container && parseResult) {
+      if (!returnValue.container && hasInfo.container && parseResult) {
         const container = getContainer(parseResult.segments);
-        moreFields.onContainer?.(container);
-        returnValue.container = container;
+        callbacks.onContainer?.(container);
+        if (fieldsInReturnValue.container) {
+          returnValue.container = container;
+        }
+        emittedFields.container = true;
       }
       continue;
     }
     if (key === "metadata") {
-      if (returnValue.metadata === undefined && hasInfo.metadata && parseResult) {
+      if (!emittedFields.metadata && hasInfo.metadata && parseResult) {
         const metadata = getMetadata(parseResult.segments);
-        moreFields.onMetadata?.(metadata);
-        returnValue.metadata = metadata;
+        callbacks.onMetadata?.(metadata);
+        if (fieldsInReturnValue.metadata) {
+          returnValue.metadata = metadata;
+        }
+        emittedFields.metadata = true;
       }
       continue;
     }
     if (key === "location") {
-      if (returnValue.location === undefined && hasInfo.location && parseResult) {
+      if (!emittedFields.location && hasInfo.location && parseResult) {
         const location = getLocation(parseResult.segments);
-        moreFields.onLocation?.(location);
-        returnValue.location = location;
+        callbacks.onLocation?.(location);
+        if (fieldsInReturnValue.location) {
+          returnValue.location = location;
+        }
+        emittedFields.location = true;
       }
       continue;
     }
@@ -6351,9 +6729,41 @@ var emitAvailableInfo = ({
   }
 };
 
+// src/get-fields-from-callbacks.ts
+var getFieldsFromCallback = ({
+  fields,
+  callbacks
+}) => {
+  const newFields = {
+    audioCodec: Boolean(callbacks.onAudioCodec),
+    container: Boolean(callbacks.onContainer),
+    dimensions: Boolean(callbacks.onDimensions),
+    durationInSeconds: Boolean(callbacks.onDurationInSeconds),
+    fps: Boolean(callbacks.onFps),
+    internalStats: Boolean(callbacks.onInternalStats),
+    isHdr: Boolean(callbacks.onIsHdr),
+    location: Boolean(callbacks.onLocation),
+    metadata: Boolean(callbacks.onMetadata),
+    mimeType: Boolean(callbacks.onMimeType),
+    name: Boolean(callbacks.onName),
+    rotation: Boolean(callbacks.onRotation),
+    size: Boolean(callbacks.onSize),
+    structure: Boolean(callbacks.onStructure),
+    tracks: Boolean(callbacks.onTracks),
+    unrotatedDimensions: Boolean(callbacks.onUnrotatedDimensions),
+    videoCodec: Boolean(callbacks.onVideoCodec),
+    ...fields
+  };
+  return newFields;
+};
+
 // src/has-all-info.ts
-var getAvailableInfo = (options, structure, state) => {
-  const keys = Object.entries(options).filter(([, value]) => value);
+var getAvailableInfo = ({
+  fieldsToFetch,
+  structure,
+  state
+}) => {
+  const keys = Object.entries(fieldsToFetch).filter(([, value]) => value);
   const infos = keys.map(([_key]) => {
     const key = _key;
     if (key === "structure") {
@@ -6386,6 +6796,9 @@ var getAvailableInfo = (options, structure, state) => {
     if (key === "size") {
       return true;
     }
+    if (key === "mimeType") {
+      return true;
+    }
     if (key === "name") {
       return true;
     }
@@ -6409,7 +6822,11 @@ var hasAllInfo = ({
   state,
   structure
 }) => {
-  const availableInfo = getAvailableInfo(fields ?? {}, structure, state);
+  const availableInfo = getAvailableInfo({
+    fieldsToFetch: fields ?? {},
+    structure,
+    state
+  });
   return Object.values(availableInfo).every(Boolean) && (state.maySkipVideoData() || state.canSkipTracksState.canSkipTracks());
 };
 
@@ -10960,16 +11377,20 @@ var parseVideo = ({
   options,
   signal,
   logLevel,
-  fields
+  fields,
+  mimeType,
+  contentLength,
+  name
 }) => {
   if (iterator.bytesRemaining() === 0) {
     return Promise.reject(new Error("no bytes"));
   }
-  if (iterator.isRiff()) {
+  const fileType = iterator.detectFileType();
+  if (fileType.type === "riff") {
     Log.verbose(logLevel, "Detected RIFF container");
     return Promise.resolve(parseRiff({ iterator, options, fields }));
   }
-  if (iterator.isIsoBaseMedia()) {
+  if (fileType.type === "iso-base-media") {
     Log.verbose(logLevel, "Detected ISO Base Media container");
     return parseIsoBaseMediaBoxes({
       iterator,
@@ -10983,11 +11404,11 @@ var parseVideo = ({
       fields
     });
   }
-  if (iterator.isWebm()) {
+  if (fileType.type === "webm") {
     Log.verbose(logLevel, "Detected Matroska container");
     return parseWebm({ counter: iterator, parserContext: options, fields });
   }
-  if (iterator.isTransportStream()) {
+  if (fileType.type === "transport-stream") {
     return parseTransportStream({
       iterator,
       parserContext: options,
@@ -11000,10 +11421,68 @@ var parseVideo = ({
       nextPesHeaderStore: makeNextPesHeaderStore()
     });
   }
-  if (iterator.isMp3()) {
-    return Promise.reject(new Error("MP3 files are not yet supported"));
-  }
-  return Promise.reject(new Error("Unknown video format"));
+  if (fileType.type === "mp3") {
+    return Promise.reject(new IsAnUnsupportedAudioTypeError({
+      message: "MP3 files are not yet supported",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name,
+      audioType: "mp3"
+    }));
+  }
+  if (fileType.type === "wav") {
+    return Promise.reject(new IsAnUnsupportedAudioTypeError({
+      message: "WAV files are not yet supported",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name,
+      audioType: "wav"
+    }));
+  }
+  if (fileType.type === "aac") {
+    return Promise.reject(new IsAnUnsupportedAudioTypeError({
+      message: "AAC files are not yet supported",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name,
+      audioType: "aac"
+    }));
+  }
+  if (fileType.type === "gif") {
+    return Promise.reject(new IsAGifError({
+      message: "GIF files are not yet supported",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name
+    }));
+  }
+  if (fileType.type === "pdf") {
+    return Promise.reject(new IsAPdfError({
+      message: "GIF files are not supported",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name
+    }));
+  }
+  if (fileType.type === "bmp" || fileType.type === "jpeg" || fileType.type === "png" || fileType.type === "webp") {
+    return Promise.reject(new IsAnImageError({
+      message: "Image files are not supported",
+      imageType: fileType.type,
+      dimensions: fileType.dimensions,
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name
+    }));
+  }
+  if (fileType.type === "unknown") {
+    return Promise.reject(new IsAnUnsupportedFileTypeError({
+      message: "Unknown file format",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name
+    }));
+  }
+  return Promise.reject(new Error("Unknown video format " + fileType));
 };
 
 // src/state/can-skip-tracks.ts
@@ -11023,7 +11502,8 @@ var needsTracksField = {
   unrotatedDimensions: true,
   videoCodec: true,
   metadata: true,
-  location: true
+  location: true,
+  mimeType: false
 };
 var makeCanSkipTracksState = ({
   hasAudioTrackHandlers,
@@ -11225,9 +11705,9 @@ var makeParserState = ({
 };
 
 // src/parse-media.ts
-var parseMedia = async ({
+var parseMedia = async function({
   src,
-  fields,
+  fields: _fieldsInReturnValue,
   reader: readerInterface = fetchReader,
   onAudioTrack,
   onVideoTrack,
@@ -11235,23 +11715,48 @@ var parseMedia = async ({
   logLevel = "info",
   onParseProgress,
   ...more
-}) => {
+}) {
   let iterator = null;
   let parseResult = null;
+  const fieldsInReturnValue = _fieldsInReturnValue ?? {};
+  const fields = getFieldsFromCallback({
+    fields: fieldsInReturnValue,
+    callbacks: more
+  });
   const state = makeParserState({
     hasAudioTrackHandlers: Boolean(onAudioTrack),
     hasVideoTrackHandlers: Boolean(onVideoTrack),
     signal,
     getIterator: () => iterator,
-    fields: fields ?? {}
+    fields
   });
   const {
     reader,
     contentLength,
     name,
+    contentType,
     supportsContentRange: readerSupportsContentRange
   } = await readerInterface.read(src, null, signal);
   let currentReader = reader;
+  const emittedFields = {
+    audioCodec: false,
+    container: false,
+    dimensions: false,
+    durationInSeconds: false,
+    fps: false,
+    internalStats: false,
+    isHdr: false,
+    location: false,
+    metadata: false,
+    mimeType: false,
+    name: false,
+    rotation: false,
+    size: false,
+    structure: false,
+    tracks: false,
+    videoCodec: false,
+    unrotatedDimensions: false
+  };
   const supportsContentRange = readerSupportsContentRange && !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.DISABLE_CONTENT_RANGE === "true");
   const returnValue = {};
   const moreFields = more;
@@ -11264,15 +11769,22 @@ var parseMedia = async ({
     nextTrackIndex: 0
   };
   const triggerInfoEmit = () => {
-    const availableInfo = getAvailableInfo(fields ?? {}, parseResult?.segments ?? null, state);
+    const availableInfo = getAvailableInfo({
+      fieldsToFetch: fields,
+      structure: parseResult?.segments ?? null,
+      state
+    });
     emitAvailableInfo({
       hasInfo: availableInfo,
-      moreFields,
+      callbacks: moreFields,
+      fieldsInReturnValue,
       parseResult,
       state,
       returnValue,
       contentLength,
-      name
+      name,
+      mimeType: contentType,
+      emittedFields
     });
   };
   triggerInfoEmit();
@@ -11317,14 +11829,17 @@ var parseMedia = async ({
         options,
         signal: signal ?? null,
         logLevel,
-        fields: fields ?? {}
+        fields,
+        mimeType: contentType,
+        contentLength,
+        name
       });
     }
     if (parseResult.status === "incomplete" && parseResult.skipTo !== null) {
       state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
     }
     if (hasAllInfo({
-      fields: fields ?? {},
+      fields,
       structure: parseResult.segments,
       state
     })) {
@@ -11350,19 +11865,23 @@ var parseMedia = async ({
     }
   }
   Log.verbose(logLevel, "Finished parsing file");
+  const hasInfo = Object.keys(fields).reduce((acc, key) => {
+    if (fields?.[key]) {
+      acc[key] = true;
+    }
+    return acc;
+  }, {});
   emitAvailableInfo({
-    hasInfo: Object.keys(fields ?? {}).reduce((acc, key) => {
-      if (fields?.[key]) {
-        acc[key] = true;
-      }
-      return acc;
-    }, {}),
-    moreFields,
+    hasInfo,
+    callbacks: moreFields,
+    fieldsInReturnValue,
     parseResult,
     state,
     returnValue,
     contentLength,
-    name
+    mimeType: contentType,
+    name,
+    emittedFields
   });
   currentReader.abort();
   iterator?.destroy();
@@ -11384,5 +11903,10 @@ var MediaParserInternals = {
 export {
   parseMedia,
   VERSION,
-  MediaParserInternals
+  MediaParserInternals,
+  IsAnUnsupportedFileTypeError,
+  IsAnUnsupportedAudioTypeError,
+  IsAnImageError,
+  IsAPdfError,
+  IsAGifError
 };