@remotion/media-parser 4.0.270 → 4.0.271

package/dist/esm/index.mjs

@@ -1996,17 +1996,25 @@ var parseEsds = ({
 };
 
 // src/containers/iso-base-media/traversal.ts
-var getMoovBox = (state) => {
-  if (state.iso.moov.getMoovBox()) {
-    return state.iso.moov.getMoovBox();
-  }
-  const structure = state.getIsoStructure();
+var getMoovFromFromIsoStructure = (structure) => {
   const moovBox = structure.boxes.find((s) => s.type === "moov-box");
   if (!moovBox || moovBox.type !== "moov-box") {
     return null;
   }
   return moovBox;
 };
+var getMoovBoxFromState = (state) => {
+  const got = state.iso.moov.getMoovBox();
+  if (got) {
+    return got;
+  }
+  const a = state.mp4HeaderSegment;
+  if (a) {
+    return getMoovFromFromIsoStructure(a);
+  }
+  const structure = state.getIsoStructure();
+  return getMoovFromFromIsoStructure(structure);
+};
 var getMoofBoxes = (main) => {
   const moofBoxes = main.filter((s) => s.type === "regular-box" && s.boxType === "moof");
   return moofBoxes;
@@ -2270,7 +2278,7 @@ var getFpsFromMp4TrakBox = (trakBox) => {
   });
 };
 var getFpsFromIsoMaseMedia = (state) => {
-  const moovBox = getMoovBox(state);
+  const moovBox = getMoovBoxFromState(state);
   if (!moovBox) {
     return null;
   }
@@ -3189,7 +3197,7 @@ var matroskaHasTracks = (state) => {
 
 // src/get-tracks.ts
 var isoBaseMediaHasTracks = (state) => {
-  return Boolean(getMoovBox(state));
+  return Boolean(getMoovBoxFromState(state));
 };
 var getHasTracks = (state) => {
   const structure = state.getStructure();
@@ -3244,18 +3252,10 @@ var getCategorizedTracksFromMatroska = (state) => {
     otherTracks
   };
 };
-var getTracksFromIsoBaseMedia = (state) => {
+var getTracksFromMoovBox = (moovBox) => {
   const videoTracks = [];
   const audioTracks = [];
   const otherTracks = [];
-  const moovBox = getMoovBox(state);
-  if (!moovBox) {
-    return {
-      videoTracks,
-      audioTracks,
-      otherTracks
-    };
-  }
   const tracks2 = getTraks(moovBox);
   for (const trakBox of tracks2) {
     const track = makeBaseMediaTrack(trakBox);
@@ -3276,6 +3276,17 @@ var getTracksFromIsoBaseMedia = (state) => {
     otherTracks
   };
 };
+var getTracksFromIsoBaseMedia = (state) => {
+  const moovBox = getMoovBoxFromState(state);
+  if (!moovBox) {
+    return {
+      videoTracks: [],
+      audioTracks: [],
+      otherTracks: []
+    };
+  }
+  return getTracksFromMoovBox(moovBox);
+};
 var defaultGetTracks = (parserState) => {
   const tracks2 = parserState.callbacks.tracks.getTracks();
   if (tracks2.length === 0) {
@@ -4727,7 +4738,7 @@ var parseTrun = ({
     const sampleDuration = flags & 256 ? iterator.getUint32() : null;
     const sampleSize = flags & 512 ? iterator.getUint32() : null;
     const sampleFlags = flags & 1024 ? iterator.getUint32() : null;
-    const sampleCompositionTimeOffset = flags & 2048 ? version === 0 ? iterator.getUint32() : iterator.getInt32Le() : null;
+    const sampleCompositionTimeOffset = flags & 2048 ? version === 0 ? iterator.getUint32() : iterator.getInt32() : null;
     samples.push({
       sampleDuration,
       sampleSize,
@@ -5812,7 +5823,11 @@ var isIndependentSegments = (structure) => {
   }
   return structure.boxes.some((box) => box.type === "m3u-independent-segments" || box.type === "m3u-stream-info");
 };
-var getM3uStreams = (structure, originalSrc) => {
+var getM3uStreams = ({
+  structure,
+  originalSrc,
+  readerInterface
+}) => {
   if (structure === null || structure.type !== "m3u") {
     return null;
   }
@@ -5837,13 +5852,13 @@ var getM3uStreams = (structure, originalSrc) => {
             groupId: audioTrack.groupId,
             language: audioTrack.language,
             name: audioTrack.name,
-            url: originalSrc && originalSrc.startsWith("http") ? new URL(audioTrack.uri, originalSrc).href : audioTrack.uri,
+            src: readerInterface.createAdjacentFileSource(audioTrack.uri, originalSrc),
             id: associatedPlaylists.length
           });
         }
       }
       boxes.push({
-        url: originalSrc && originalSrc.startsWith("http") ? new URL(next.value, originalSrc).href : next.value,
+        src: readerInterface.createAdjacentFileSource(next.value, originalSrc),
         averageBandwidth: str.averageBandwidth,
         bandwidth: str.bandwidth,
         codecs: str.codecs,
@@ -6097,7 +6112,7 @@ var getSamplesFromTraf = (trafSegment, moofOffset) => {
       const samplePosition = {
         offset: offset + (moofOffset ?? 0) + (dataOffset ?? 0),
         dts,
-        cts: dts,
+        cts: dts + (sample.sampleCompositionTimeOffset ?? 0),
         duration: duration2,
         isKeyframe: keyframe,
         size,
@@ -6376,7 +6391,7 @@ var getDurationFromMatroska = (segments) => {
 };
 var isoHasDuration = (parserState) => {
   const structure = parserState.getIsoStructure();
-  const moovBox = getMoovBox(parserState);
+  const moovBox = getMoovBoxFromState(parserState);
   if (!moovBox) {
     return false;
   }
@@ -6397,7 +6412,7 @@ var isoHasDuration = (parserState) => {
 };
 var getDurationFromIsoBaseMedia = (parserState) => {
   const structure = parserState.getIsoStructure();
-  const moovBox = getMoovBox(parserState);
+  const moovBox = getMoovBoxFromState(parserState);
   if (!moovBox) {
     return null;
   }
@@ -6639,7 +6654,7 @@ var parseIsoMetaBox = (meta, trackId) => {
   return entries;
 };
 var getMetadataFromIsoBase = (state) => {
-  const moov = getMoovBox(state);
+  const moov = getMoovBoxFromState(state);
   if (!moov) {
     return [];
   }
@@ -7173,7 +7188,11 @@ var emitAvailableInfo = async ({
     }
     if (key === "m3uStreams") {
       if (!emittedFields.m3uStreams && hasInfo.m3uStreams) {
-        const streams = getM3uStreams(state.getStructureOrNull(), typeof state.src === "string" ? state.src : null);
+        const streams = getM3uStreams({
+          structure: state.getStructureOrNull(),
+          originalSrc: state.src,
+          readerInterface: state.readerInterface
+        });
         await callbacks.onM3uStreams?.(streams);
         if (fieldsInReturnValue.m3uStreams) {
           returnValue.m3uStreams = streams;
@@ -7418,6 +7437,7 @@ class IsAGifError extends Error {
     fileName
   }) {
     super(message);
+    this.name = "IsAGifError";
     this.fileName = "IsAGifError";
     this.mimeType = mimeType;
     this.sizeInBytes = sizeInBytes;
@@ -7497,30 +7517,6 @@ class IsAnUnsupportedFileTypeError extends Error {
   }
 }
 
-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);
-    }
-  }
-}
-
 class MediaParserAbortError extends Error {
   constructor(message) {
     super(message);
@@ -7529,7 +7525,7 @@ class MediaParserAbortError extends Error {
   }
 }
 var hasBeenAborted = (error) => {
-  return error instanceof MediaParserAbortError;
+  return error instanceof MediaParserAbortError || error.name === "MediaParserAbortError";
 };
 
 // src/pause-signal.ts
@@ -8307,21 +8303,6 @@ var keyframesState = () => {
   };
 };
 
-// src/state/last-eventloop-break.ts
-var eventLoopState = (logLevel) => {
-  let lastEventLoopBreak = Date.now();
-  const eventLoopBreakIfNeeded = async () => {
-    if (Date.now() - lastEventLoopBreak > 2000) {
-      await new Promise((resolve) => {
-        setTimeout(() => resolve(), 50);
-      });
-      Log.verbose(logLevel, "10ms event loop break");
-      lastEventLoopBreak = Date.now();
-    }
-  };
-  return { eventLoopBreakIfNeeded };
-};
-
 // src/containers/m3u/sample-sorter.ts
 var sampleSorter = ({
   logLevel,
@@ -8400,16 +8381,23 @@ var m3uState = (logLevel) => {
     if (!selectedMainPlaylist) {
       throw new Error("No main playlist selected");
     }
-    const playlistUrl = selectedMainPlaylist.type === "initial-url" ? selectedMainPlaylist.url : selectedMainPlaylist.stream.url;
+    const playlistUrl = selectedMainPlaylist.type === "initial-url" ? selectedMainPlaylist.url : selectedMainPlaylist.stream.src;
     return playlistUrl;
   };
   const getSelectedPlaylists = () => {
     return [
       getMainPlaylistUrl(),
-      ...(associatedPlaylists ?? []).map((p) => p.url)
+      ...(associatedPlaylists ?? []).map((p) => p.src)
     ];
   };
   const getAllChunksProcessedForPlaylist = (src) => allChunksProcessed[src];
+  const mp4HeaderSegments = {};
+  const setMp4HeaderSegment = (playlistUrl, structure) => {
+    mp4HeaderSegments[playlistUrl] = structure;
+  };
+  const getMp4HeaderSegment = (playlistUrl) => {
+    return mp4HeaderSegments[playlistUrl];
+  };
   return {
     setSelectedMainPlaylist: (stream) => {
       selectedMainPlaylist = stream;
@@ -8486,7 +8474,9 @@ var m3uState = (logLevel) => {
     },
     getAssociatedPlaylists: () => associatedPlaylists,
     getSelectedPlaylists,
-    sampleSorter: sampleSorter({ logLevel, getAllChunksProcessedForPlaylist })
+    sampleSorter: sampleSorter({ logLevel, getAllChunksProcessedForPlaylist }),
+    setMp4HeaderSegment,
+    getMp4HeaderSegment
   };
 };
 
@@ -9035,7 +9025,8 @@ var makeParserState = ({
   readerInterface,
   onDiscardedData,
   selectM3uStreamFn,
-  selectM3uAssociatedPlaylistsFn
+  selectM3uAssociatedPlaylistsFn,
+  mp4HeaderSegment
 }) => {
   let skippedBytes = 0;
   const iterator = getArrayBufferIterator(new Uint8Array([]), contentLength);
@@ -9096,12 +9087,12 @@ var makeParserState = ({
     iterator,
     controller,
     mode,
-    eventLoop: eventLoopState(logLevel),
     src,
     readerInterface,
     discardReadBytes,
     selectM3uStreamFn,
-    selectM3uAssociatedPlaylistsFn
+    selectM3uAssociatedPlaylistsFn,
+    mp4HeaderSegment
   };
 };
 
@@ -9110,6 +9101,14 @@ var getMoovAtom = async ({
   endOfMdat,
   state
 }) => {
+  const headerSegment = state.mp4HeaderSegment;
+  if (headerSegment) {
+    const segment = getMoovFromFromIsoStructure(headerSegment);
+    if (!segment) {
+      throw new Error("No moov box found in header segment");
+    }
+    return segment;
+  }
   const start = Date.now();
   Log.verbose(state.logLevel, "Starting second fetch to get moov atom");
   const { reader } = await state.readerInterface.read({
@@ -9139,7 +9138,8 @@ var getMoovAtom = async ({
     src: state.src,
     onDiscardedData: null,
     selectM3uStreamFn: state.selectM3uStreamFn,
-    selectM3uAssociatedPlaylistsFn: state.selectM3uAssociatedPlaylistsFn
+    selectM3uAssociatedPlaylistsFn: state.selectM3uAssociatedPlaylistsFn,
+    mp4HeaderSegment: state.mp4HeaderSegment
   });
   while (true) {
     const result = await reader.reader.read();
@@ -9308,7 +9308,7 @@ var parseStreamInf = (str) => {
 };
 
 // src/containers/m3u/parse-m3u-media-directive.ts
-var parseM3uMediaDirective = (str) => {
+var parseM3uKeyValue = (str) => {
   const quotes = splitRespectingQuotes(str);
   const map = {};
   for (const quote of quotes) {
@@ -9321,6 +9321,10 @@ var parseM3uMediaDirective = (str) => {
     const actualValue = value?.startsWith('"') && value?.endsWith('"') ? value.slice(1, -1) : value;
     map[key] = actualValue;
   }
+  return map;
+};
+var parseM3uMediaDirective = (str) => {
+  const map = parseM3uKeyValue(str);
   return {
     type: "m3u-media-info",
     autoselect: map.AUTOSELECT === "YES",
@@ -9420,9 +9424,13 @@ var parseM3uDirective = (str) => {
     if (!value) {
       throw new Error("#EXT-X-MAP directive must have a value");
     }
+    const p = parseM3uKeyValue(value);
+    if (!p.URI) {
+      throw new Error("EXT-X-MAP directive must have a URI");
+    }
     return {
       type: "m3u-map",
-      value: Number(value)
+      value: p.URI
     };
   }
   throw new Error(`Unknown directive ${directive}. Value: ${value}`);
@@ -9449,12 +9457,11 @@ var parseM3u8Text = (line, boxes) => {
 };
 
 // src/containers/m3u/fetch-m3u8-stream.ts
-var fetchM3u8Stream = async (url) => {
-  const res = await fetch(url);
-  if (!res.ok) {
-    throw new Error(`Failed to fetch ${url} (HTTP code: ${res.status})`);
-  }
-  const text = await res.text();
+var fetchM3u8Stream = async ({
+  url,
+  readerInterface
+}) => {
+  const text = await readerInterface.readWholeAsText(url);
   const lines = text.split(`
 `);
   const boxes = [];
@@ -9477,14 +9484,17 @@ var selectAssociatedPlaylists = async ({
     throw new Error("Expected an array of associated playlists");
   }
   for (const stream of streams) {
-    if (!playlists.find((playlist) => playlist.url === stream.url)) {
+    if (!playlists.find((playlist) => playlist.src === stream.src)) {
       throw new Error(`The associated playlist ${JSON.stringify(streams)} cannot be selected because it was not in the list of selectable playlists`);
     }
   }
   return streams;
 };
 var defaultSelectM3uAssociatedPlaylists = ({ associatedPlaylists }) => {
-  return Promise.resolve(associatedPlaylists.filter((playlist) => playlist.default));
+  if (associatedPlaylists.length === 1) {
+    return associatedPlaylists;
+  }
+  return associatedPlaylists.filter((playlist) => playlist.default);
 };
 var selectStream = async ({
   streams,
@@ -9511,7 +9521,8 @@ var afterManifestFetch = async ({
   src,
   selectM3uStreamFn,
   logLevel,
-  selectAssociatedPlaylists: selectAssociatedPlaylistsFn
+  selectAssociatedPlaylistsFn,
+  readerInterface
 }) => {
   const independentSegments = isIndependentSegments(structure);
   if (!independentSegments) {
@@ -9524,7 +9535,7 @@ var afterManifestFetch = async ({
     });
     return m3uState2.setReadyToIterateOverM3u();
   }
-  const streams = getM3uStreams(structure, src);
+  const streams = getM3uStreams({ structure, originalSrc: src, readerInterface });
   if (streams === null) {
     throw new Error("No streams found");
   }
@@ -9542,12 +9553,12 @@ var afterManifestFetch = async ({
   });
   m3uState2.setAssociatedPlaylists(associatedPlaylists);
   const playlistUrls = [
-    selectedPlaylist.url,
-    ...associatedPlaylists.map((p) => p.url)
+    selectedPlaylist.src,
+    ...associatedPlaylists.map((p) => p.src)
   ];
   const struc = await Promise.all(playlistUrls.map(async (url) => {
     Log.verbose(logLevel, `Fetching playlist ${url}`);
-    const boxes = await fetchM3u8Stream(url);
+    const boxes = await fetchM3u8Stream({ url, readerInterface });
     return {
       type: "m3u-playlist",
       boxes,
@@ -9676,89 +9687,178 @@ function parseContentRange(input) {
   return range2;
 }
 var validateContentRangeAndDetectIfSupported = ({
-  actualRange,
+  requestedRange,
   parsedContentRange,
   statusCode
 }) => {
   if (statusCode === 206) {
     return { supportsContentRange: true };
   }
-  if (typeof actualRange === "number" && parsedContentRange?.start !== actualRange) {
-    if (actualRange === 0) {
+  if (typeof requestedRange === "number" && parsedContentRange?.start !== requestedRange) {
+    if (requestedRange === 0) {
       return { supportsContentRange: false };
     }
-    throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange?.start})`);
+    throw new Error(`Range header (${requestedRange}) does not match content-range header (${parsedContentRange?.start})`);
   }
-  if (actualRange !== null && typeof actualRange !== "number" && (parsedContentRange?.start !== actualRange[0] || parsedContentRange?.end !== actualRange[1])) {
-    throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange?.start})`);
+  if (requestedRange !== null && typeof requestedRange !== "number" && (parsedContentRange?.start !== requestedRange[0] || parsedContentRange?.end !== requestedRange[1])) {
+    throw new Error(`Range header (${requestedRange}) does not match content-range header (${parsedContentRange?.start})`);
   }
   return { supportsContentRange: true };
 };
-var fetchReader = {
-  read: async ({ src, range: range2, controller }) => {
-    if (typeof src !== "string") {
-      throw new Error("src must be a string when using `fetchReader`");
-    }
-    const resolvedUrl = resolveUrl(src);
-    const resolvedUrlString = resolvedUrl.toString();
-    if (!resolvedUrlString.startsWith("https://") && !resolvedUrlString.startsWith("blob:") && !resolvedUrlString.startsWith("http://")) {
-      return Promise.reject(new Error(`${resolvedUrlString} is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass \`reader: nodeReader\` to parseMedia().`));
-    }
-    const ownController = new AbortController;
-    const cache = typeof navigator !== "undefined" && navigator.userAgent.includes("Cloudflare-Workers") ? undefined : "no-store";
-    const actualRange = range2 === null ? 0 : range2;
-    const asString = typeof resolvedUrl === "string" ? resolvedUrl : resolvedUrl.pathname;
-    const requestWithoutRange = asString.endsWith(".m3u8");
-    const canLiveWithoutContentLength = asString.endsWith(".m3u8") || asString.endsWith(".ts");
-    const headers = actualRange === 0 && requestWithoutRange ? {} : typeof actualRange === "number" ? {
-      Range: `bytes=${actualRange}-`
-    } : {
-      Range: `bytes=${`${actualRange[0]}-${actualRange[1]}`}`
-    };
-    const res = await fetch(resolvedUrl, {
-      headers,
-      signal: ownController.signal,
-      cache
-    });
-    const contentRange = res.headers.get("content-range");
-    const parsedContentRange = contentRange ? parseContentRange(contentRange) : null;
-    const { supportsContentRange } = validateContentRangeAndDetectIfSupported({
-      actualRange,
-      parsedContentRange,
-      statusCode: res.status
-    });
+var fetchReadContent = async ({
+  src,
+  range: range2,
+  controller
+}) => {
+  if (typeof src !== "string" && src instanceof URL === false) {
+    throw new Error("src must be a string when using `fetchReader`");
+  }
+  const resolvedUrl = resolveUrl(src);
+  const resolvedUrlString = resolvedUrl.toString();
+  if (!resolvedUrlString.startsWith("https://") && !resolvedUrlString.startsWith("blob:") && !resolvedUrlString.startsWith("http://")) {
+    return Promise.reject(new Error(`${resolvedUrlString} is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass \`reader: nodeReader\` to parseMedia().`));
+  }
+  const ownController = new AbortController;
+  const cache = typeof navigator !== "undefined" && navigator.userAgent.includes("Cloudflare-Workers") ? undefined : "no-store";
+  const requestedRange = range2 === null ? 0 : range2;
+  const asString = typeof resolvedUrl === "string" ? resolvedUrl : resolvedUrl.pathname;
+  const requestWithoutRange = asString.endsWith(".m3u8");
+  const canLiveWithoutContentLength = asString.endsWith(".m3u8") || asString.endsWith(".ts");
+  const headers = requestedRange === 0 && requestWithoutRange ? {} : typeof requestedRange === "number" ? {
+    Range: `bytes=${requestedRange}-`
+  } : {
+    Range: `bytes=${`${requestedRange[0]}-${requestedRange[1]}`}`
+  };
+  const res = await fetch(resolvedUrl, {
+    headers,
+    signal: ownController.signal,
+    cache
+  });
+  const contentRange = res.headers.get("content-range");
+  const parsedContentRange = contentRange ? parseContentRange(contentRange) : null;
+  const { supportsContentRange } = validateContentRangeAndDetectIfSupported({
+    requestedRange,
+    parsedContentRange,
+    statusCode: res.status
+  });
+  controller._internals.signal.addEventListener("abort", () => {
+    ownController.abort(new MediaParserAbortError("Aborted by user"));
+  }, { once: true });
+  if (res.status.toString().startsWith("4") || res.status.toString().startsWith("5")) {
+    throw new Error(`Server returned status code ${res.status} for ${src} and range ${requestedRange}`);
+  }
+  const contentDisposition = res.headers.get("content-disposition");
+  const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
+  const fallbackName = src.toString().split("/").pop();
+  const { contentLength, needsContentRange, reader } = await getLengthAndReader({
+    canLiveWithoutContentLength,
+    res,
+    ownController,
+    requestedWithoutRange: requestWithoutRange
+  });
+  if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
-      ownController.abort(new MediaParserAbortError("Aborted by user"));
+      reader.reader.cancel().catch(() => {
+      });
+    }, { once: true });
+  }
+  return {
+    reader,
+    contentLength,
+    contentType: res.headers.get("content-type"),
+    name: name ?? fallbackName,
+    supportsContentRange,
+    needsContentRange
+  };
+};
+var fetchReadWholeAsText = async (src) => {
+  if (typeof src !== "string" && src instanceof URL === false) {
+    throw new Error("src must be a string when using `fetchReader`");
+  }
+  const res = await fetch(src);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch ${src} (HTTP code: ${res.status})`);
+  }
+  return res.text();
+};
+var fetchCreateAdjacentFileSource = (relativePath, src) => {
+  if (typeof src !== "string" && src instanceof URL === false) {
+    throw new Error("src must be a string or URL when using `fetchReader`");
+  }
+  return new URL(relativePath, src).toString();
+};
+
+// src/readers/from-web-file.ts
+var webFileReadContent = ({ src, range: range2, controller }) => {
+  if (typeof src === "string" || src instanceof URL) {
+    throw new Error("`inputTypeFileReader` only supports `File` objects");
+  }
+  const part = range2 === null ? src : typeof range2 === "number" ? src.slice(range2) : src.slice(range2[0], range2[1]);
+  const reader = new FileReader;
+  reader.readAsArrayBuffer(src);
+  const ownController = new AbortController;
+  if (ownController) {
+    ownController.signal.addEventListener("abort", () => {
+      reader.abort();
+    }, { once: true });
+  }
+  if (controller) {
+    controller._internals.signal.addEventListener("abort", () => {
+      ownController.abort();
     }, { once: true });
-    if (res.status.toString().startsWith("4") || res.status.toString().startsWith("5")) {
-      throw new Error(`Server returned status code ${res.status} for ${src} and range ${actualRange}`);
-    }
-    const contentDisposition = res.headers.get("content-disposition");
-    const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
-    const fallbackName = src.split("/").pop();
-    const { contentLength, needsContentRange, reader } = await getLengthAndReader({
-      canLiveWithoutContentLength,
-      res,
-      ownController,
-      requestedWithoutRange: requestWithoutRange
-    });
-    if (controller) {
-      controller._internals.signal.addEventListener("abort", () => {
-        reader.reader.cancel().catch(() => {
-        });
-      }, { once: true });
-    }
-    return {
-      reader,
-      contentLength,
-      contentType: res.headers.get("content-type"),
-      name: name ?? fallbackName,
-      supportsContentRange,
-      needsContentRange
-    };
   }
+  return new Promise((resolve, reject) => {
+    reader.onload = () => {
+      const stream = part.stream();
+      const streamReader = stream.getReader();
+      resolve({
+        reader: {
+          reader: streamReader,
+          abort() {
+            streamReader.cancel();
+            ownController.abort();
+          }
+        },
+        contentLength: src.size,
+        name: src.name,
+        supportsContentRange: true,
+        contentType: src.type,
+        needsContentRange: true
+      });
+    };
+    reader.onerror = () => {
+      reject(reader.error);
+    };
+  });
+};
+var webFileReadWholeAsText = () => {
+  throw new Error("`webFileReader` cannot read auxiliary files.");
+};
+var webFileCreateAdjacentFileSource = () => {
+  throw new Error("`webFileReader` cannot create adjacent file sources.");
 };
 
+// src/readers/web.ts
+var webReader = {
+  read: (params) => {
+    if (params.src instanceof Blob) {
+      return webFileReadContent(params);
+    }
+    return fetchReadContent(params);
+  },
+  createAdjacentFileSource: (relativePath, src) => {
+    if (src instanceof Blob) {
+      return webFileCreateAdjacentFileSource(relativePath, src);
+    }
+    return fetchCreateAdjacentFileSource(relativePath, src);
+  },
+  readWholeAsText: (src) => {
+    if (src instanceof Blob) {
+      return webFileReadWholeAsText(src);
+    }
+    return fetchReadWholeAsText(src);
+  }
+};
 // src/parse-media.ts
 var parseMedia = (options) => {
   return internalParseMedia({
@@ -9796,10 +9896,11 @@ var parseMedia = (options) => {
     onVideoCodec: options.onVideoCodec ?? null,
     onVideoTrack: options.onVideoTrack ?? null,
     progressIntervalInMs: options.progressIntervalInMs ?? null,
-    reader: options.reader ?? fetchReader,
+    reader: options.reader ?? webReader,
     controller: options.controller ?? undefined,
     selectM3uStream: options.selectM3uStream ?? defaultSelectM3uStreamFn,
     selectM3uAssociatedPlaylists: options.selectM3uAssociatedPlaylists ?? defaultSelectM3uAssociatedPlaylists,
+    mp4HeaderSegment: options.mp4HeaderSegment ?? null,
     src: options.src,
     mode: "query",
     onDiscardedData: null,
@@ -9814,21 +9915,25 @@ var getChunks = (playlist) => {
   const chunks = [];
   for (let i = 0;i < playlist.boxes.length; i++) {
     const box = playlist.boxes[i];
+    if (box.type === "m3u-map") {
+      chunks.push({ duration: 0, url: box.value, isHeader: true });
+      continue;
+    }
     if (box.type === "m3u-extinf") {
       const nextBox = playlist.boxes[i + 1];
       i++;
       if (nextBox.type !== "m3u-text-value") {
         throw new Error("Expected m3u-text-value");
       }
-      chunks.push({ duration: box.value, url: nextBox.value });
+      chunks.push({ duration: box.value, url: nextBox.value, isHeader: false });
     }
     continue;
   }
   return chunks;
 };
 
-// src/containers/m3u/return-packets.ts
-var iteratorOverTsFiles = async ({
+// src/containers/m3u/iterate-over-segment-files.ts
+var iteratorOverSegmentFiles = async ({
   structure,
   onVideoTrack,
   m3uState: m3uState2,
@@ -9837,7 +9942,8 @@ var iteratorOverTsFiles = async ({
   playlistUrl,
   logLevel,
   parentController,
-  onInitialProgress
+  onInitialProgress,
+  readerInterface
 }) => {
   const playlist = getPlaylist(structure, playlistUrl);
   const chunks = getChunks(playlist);
@@ -9866,9 +9972,10 @@ var iteratorOverTsFiles = async ({
   for (const chunk of chunks) {
     const isLastChunk = chunk === chunks[chunks.length - 1];
     await childController._internals.checkForAbortAndPause();
-    const src = new URL(chunk.url, playlistUrl).toString();
+    const src = readerInterface.createAdjacentFileSource(chunk.url, playlistUrl);
     try {
-      await parseMedia({
+      const mp4HeaderSegment = m3uState2.getMp4HeaderSegment(playlistUrl);
+      const data = await parseMedia({
         src,
         acknowledgeRemotionLicense: true,
         logLevel,
@@ -9878,6 +9985,7 @@ var iteratorOverTsFiles = async ({
           childController.pause();
           resolver(makeContinuationFn());
         },
+        fields: chunk.isHeader ? { structure: true } : undefined,
         onTracks: () => {
           if (!m3uState2.hasEmittedDoneWithTracks(playlistUrl)) {
             m3uState2.setHasEmittedDoneWithTracks(playlistUrl);
@@ -9914,8 +10022,16 @@ var iteratorOverTsFiles = async ({
             };
           }
           return callbackOrFalse;
-        }
+        },
+        reader: readerInterface,
+        mp4HeaderSegment
       });
+      if (chunk.isHeader) {
+        if (data.structure.type !== "iso-base-media") {
+          throw new Error("Expected an mp4 file");
+        }
+        m3uState2.setMp4HeaderSegment(playlistUrl, data.structure);
+      }
     } catch (e) {
       rejector(e);
       throw e;
@@ -9948,7 +10064,7 @@ var runOverM3u = async ({
   }
   Log.trace(logLevel, "Starting new M3U parsing process for", playlistUrl);
   return new Promise((resolve, reject) => {
-    const run = iteratorOverTsFiles({
+    const run = iteratorOverSegmentFiles({
       playlistUrl,
       structure,
       onInitialProgress: (newRun) => {
@@ -10009,7 +10125,8 @@ var runOverM3u = async ({
         };
       },
       m3uState: state.m3u,
-      parentController: state.controller
+      parentController: state.controller,
+      readerInterface: state.readerInterface
     });
     run.catch((err) => {
       reject(err);
@@ -10032,13 +10149,17 @@ var parseM3u = async ({ state }) => {
     return null;
   }
   if (state.m3u.hasFinishedManifest()) {
+    if (typeof state.src !== "string" && !(state.src instanceof URL)) {
+      throw new Error("Expected src to be a string");
+    }
     await afterManifestFetch({
       structure,
       m3uState: state.m3u,
-      src: typeof state.src === "string" ? state.src : null,
+      src: state.src.toString(),
       selectM3uStreamFn: state.selectM3uStreamFn,
       logLevel: state.logLevel,
-      selectAssociatedPlaylists: state.selectM3uAssociatedPlaylistsFn
+      selectAssociatedPlaylistsFn: state.selectM3uAssociatedPlaylistsFn,
+      readerInterface: state.readerInterface
     });
     return null;
   }
@@ -11924,7 +12045,7 @@ var parseWebm = async (state) => {
 };
 
 // src/init-video.ts
-var initVideo = ({
+var initVideo = async ({
   state,
   mimeType,
   name,
@@ -11939,6 +12060,34 @@ var initVideo = ({
     });
     return;
   }
+  if (state.mp4HeaderSegment) {
+    Log.verbose(state.logLevel, "Detected ISO Base Media segment");
+    const moovAtom = getMoovFromFromIsoStructure(state.mp4HeaderSegment);
+    if (!moovAtom) {
+      throw new Error("No moov box found");
+    }
+    const tracks2 = getTracksFromMoovBox(moovAtom);
+    for (const track of tracks2.videoTracks) {
+      await registerVideoTrack({
+        state,
+        track,
+        container: "mp4"
+      });
+    }
+    for (const track of tracks2.audioTracks) {
+      await registerAudioTrack({
+        state,
+        track,
+        container: "mp4"
+      });
+    }
+    state.callbacks.tracks.setIsDone(state.logLevel);
+    state.setStructure({
+      type: "iso-base-media",
+      boxes: []
+    });
+    return;
+  }
   if (fileType.type === "iso-base-media") {
     Log.verbose(state.logLevel, "Detected ISO Base Media container");
     state.setStructure({
@@ -12058,7 +12207,12 @@ var runParseIteration = async ({
     return Promise.reject(new Error("no bytes"));
   }
   if (structure === null) {
-    await initVideo({ state, mimeType, name, contentLength });
+    await initVideo({
+      state,
+      mimeType,
+      name,
+      contentLength
+    });
     return null;
   }
   if (structure.type === "riff") {
@@ -12165,6 +12319,7 @@ var internalParseMedia = async function({
   apiName,
   selectM3uStream: selectM3uStreamFn,
   selectM3uAssociatedPlaylists: selectM3uAssociatedPlaylistsFn,
+  mp4HeaderSegment,
   ...more
 }) {
   warnIfRemotionLicenseNotAcknowledged({
@@ -12177,7 +12332,7 @@ var internalParseMedia = async function({
     fields: fieldsInReturnValue,
     callbacks: more
   });
-  Log.verbose(logLevel, `Reading ${typeof src === "string" ? src : src.name}`);
+  Log.verbose(logLevel, `Reading ${typeof src === "string" ? src : src instanceof URL ? src.toString() : src.name}`);
   const {
     reader: readerInstance,
     contentLength,
@@ -12217,7 +12372,8 @@ var internalParseMedia = async function({
     src,
     onDiscardedData,
     selectM3uStreamFn,
-    selectM3uAssociatedPlaylistsFn
+    selectM3uAssociatedPlaylistsFn,
+    mp4HeaderSegment
   });
   const { iterator } = state;
   let currentReader = readerInstance;
@@ -12294,7 +12450,6 @@ var internalParseMedia = async function({
     if (iterationWithThisOffset > 0 || !hasBigBuffer) {
       await fetchMoreData();
     }
-    await state.eventLoop.eventLoopBreakIfNeeded();
     timeReadingData += Date.now() - readStart;
     throttledState.update?.(() => ({
       bytes: iterator.counter.getOffset(),
@@ -12386,6 +12541,353 @@ var internalParseMedia = async function({
   }
   return returnValue;
 };
+// 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/parse-media-on-worker-entry.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,
+    src,
+    ...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),
+    src
+  };
+};
+var post = (worker, payload) => {
+  worker.postMessage(payload);
+};
+var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params }, workerUrlEntry, apiName) => {
+  if (typeof Worker === "undefined") {
+    throw new Error('"Worker" is not available. Cannot call workerClient()');
+  }
+  if (reader) {
+    throw new Error(`\`reader\` should not be provided to \`${apiName}\`. If you want to use it in the browser, use parseMediaOnWorker(). If you also want to read files from the file system, use parseMediaOnServerWorker().`);
+  }
+  const worker = new Worker(workerUrlEntry);
+  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;
+};
+
+// src/parse-media-on-server-worker.ts
+var parseMediaOnServerWorker = (params) => {
+  return parseMediaOnWorkerImplementation(params, new URL("./worker-server-entry", import.meta.url), "parseMediaOnServerWorker");
+};
+// src/parse-media-on-web-worker.ts
+var parseMediaOnWebWorker = (params) => {
+  return parseMediaOnWorkerImplementation(params, new URL("./worker-web-entry", import.meta.url), "parseMediaOnWebWorker");
+};
 // src/download-and-parse-media.ts
 var downloadAndParseMedia = async (options) => {
   const logLevel = options.logLevel ?? "info";
@@ -12399,11 +12901,12 @@ var downloadAndParseMedia = async (options) => {
     logLevel,
     mode: "download",
     onAudioCodec: options.onAudioCodec ?? null,
-    onAudioTrack: null,
+    onAudioTrack: options.onAudioTrack ?? null,
     onContainer: options.onContainer ?? null,
     onDimensions: options.onDimensions ?? null,
     selectM3uStream: options.selectM3uStream ?? defaultSelectM3uStreamFn,
     selectM3uAssociatedPlaylists: options.selectM3uAssociatedPlaylists ?? defaultSelectM3uAssociatedPlaylists,
+    mp4HeaderSegment: options.mp4HeaderSegment ?? null,
     onDiscardedData: async (data) => {
       await content.write(data);
     },
@@ -12433,9 +12936,9 @@ var downloadAndParseMedia = async (options) => {
     onTracks: options.onTracks ?? null,
     onUnrotatedDimensions: options.onUnrotatedDimensions ?? null,
     onVideoCodec: options.onVideoCodec ?? null,
-    onVideoTrack: null,
+    onVideoTrack: options.onVideoTrack ?? null,
     progressIntervalInMs: options.progressIntervalInMs ?? null,
-    reader: options.reader ?? fetchReader,
+    reader: options.reader ?? webReader,
     controller: options.controller ?? undefined,
     src: options.src,
     onError: async (err) => {
@@ -12454,7 +12957,7 @@ var downloadAndParseMedia = async (options) => {
   return returnValue;
 };
 // src/version.ts
-var VERSION = "4.0.270";
+var VERSION = "4.0.271";
 
 // src/index.ts
 var MediaParserInternals = {
@@ -12473,6 +12976,8 @@ var MediaParserInternals = {
   internalParseMedia
 };
 export {
+  parseMediaOnWebWorker,
+  parseMediaOnServerWorker,
   parseMedia,
   mediaParserController,
   hasBeenAborted,
@@ -12483,7 +12988,6 @@ export {
   MediaParserInternals,
   MediaParserAbortError,
   IsAnUnsupportedFileTypeError,
-  IsAnUnsupportedAudioTypeError,
   IsAnImageError,
   IsAPdfError,
   IsAGifError