@remotion/media-parser 4.0.311 → 4.0.312

package/dist/esm/worker-web-entry.mjs

@@ -647,24 +647,38 @@ var mediaParserController = () => {
     await pauseSignal.waitUntilResume();
   };
   let seekingHintResolution = null;
+  let simulateSeekResolution = null;
   const getSeekingHints = () => {
     if (!seekingHintResolution) {
       throw new Error("The mediaParserController() was not yet used in a parseMedia() call");
     }
     return seekingHintResolution();
   };
+  const simulateSeek = (seekInSeconds) => {
+    if (!simulateSeekResolution) {
+      throw new Error("The mediaParserController() was not yet used in a parseMedia() call");
+    }
+    return simulateSeekResolution(seekInSeconds);
+  };
   const attachSeekingHintResolution = (callback) => {
     if (seekingHintResolution) {
       throw new Error("The mediaParserController() was used in multiple parseMedia() calls. Create a separate controller for each call.");
     }
     seekingHintResolution = callback;
   };
+  const attachSimulateSeekResolution = (callback) => {
+    if (simulateSeekResolution) {
+      throw new Error("The mediaParserController() was used in multiple parseMedia() calls. Create a separate controller for each call.");
+    }
+    simulateSeekResolution = callback;
+  };
   return {
     abort: (reason) => {
       abortController.abort(reason);
       emitter.dispatchAbort(reason);
     },
     seek: seekSignal.seek,
+    simulateSeek,
     pause: pauseSignal.pause,
     resume: pauseSignal.resume,
     addEventListener: emitter.addEventListener,
@@ -676,7 +690,8 @@ var mediaParserController = () => {
       seekSignal,
       markAsReadyToEmitEvents: emitter.markAsReady,
       performedSeeksSignal,
-      attachSeekingHintResolution
+      attachSeekingHintResolution,
+      attachSimulateSeekResolution
     }
   };
 };
@@ -5741,7 +5756,11 @@ var getSeekingByteForAac = ({
     }
   }
   if (bestAudioSample) {
-    return { type: "do-seek", byte: bestAudioSample.offset };
+    return {
+      type: "do-seek",
+      byte: bestAudioSample.offset,
+      timeInSeconds: bestAudioSample.timeInSeconds
+    };
   }
   return { type: "valid-but-must-wait" };
 };
@@ -5768,7 +5787,7 @@ var getSeekingByteForFlac = ({
     }
   }
   if (bestAudioSample) {
-    return bestAudioSample.offset;
+    return bestAudioSample;
   }
   return null;
 };
@@ -5806,7 +5825,7 @@ var findKeyframeBeforeTime = ({
     Log.trace(logLevel, "Found a sample, but the offset has not yet been marked as a video section yet. Not yet able to seek, but probably once we have started reading the next box.", videoSample);
     return null;
   }
-  return videoSample.offset;
+  return videoSample;
 };
 
 // src/containers/iso-base-media/find-track-to-seek.ts
@@ -6037,7 +6056,8 @@ var getSeekingByteFromFragmentedMp4 = async ({
       if (kf) {
         return {
           type: "do-seek",
-          byte: kf
+          byte: kf.offset,
+          timeInSeconds: Math.min(kf.decodingTimestamp, kf.timestamp) / firstTrack.originalTimescale
         };
       }
     }
@@ -6140,7 +6160,8 @@ var getSeekingByteFromIsoBaseMedia = ({
   if (keyframe) {
     return Promise.resolve({
       type: "do-seek",
-      byte: keyframe
+      byte: keyframe.offset,
+      timeInSeconds: Math.min(keyframe.decodingTimestamp, keyframe.timestamp) / track.originalTimescale
     });
   }
   return Promise.resolve({
@@ -6180,7 +6201,8 @@ var getSeekingByteForM3u8 = ({
   }
   return {
     type: "do-seek",
-    byte: currentPosition
+    byte: currentPosition,
+    timeInSeconds: time
   };
 };
 
@@ -6414,9 +6436,12 @@ var getSeekingByteForMp3 = ({
       type: "valid-but-must-wait"
     };
   }
+  const byte = Math.max(...candidates);
+  const timeInSeconds = byte === bestAudioSample?.offset ? bestAudioSample.timeInSeconds : time;
   return {
     type: "do-seek",
-    byte: Math.max(...candidates)
+    byte,
+    timeInSeconds
   };
 };
 
@@ -6460,7 +6485,8 @@ var getSeekingByteForRiff = async ({
     avcState.clear();
     return {
       type: "do-seek",
-      byte: lastKeyframe.positionInBytes
+      byte: lastKeyframe.positionInBytes,
+      timeInSeconds: Math.min(lastKeyframe.decodingTimeInSeconds, lastKeyframe.presentationTimeInSeconds)
     };
   }
   if (idx1Entries.videoTrackIndex === null) {
@@ -6491,121 +6517,8 @@ var getSeekingByteForRiff = async ({
   avcState.clear();
   return {
     type: "do-seek",
-    byte: bestEntry.offset + info.moviOffset - 4
-  };
-};
-
-// src/containers/wav/get-seeking-byte.ts
-var WAVE_SAMPLES_PER_SECOND = 25;
-var getSeekingByteFromWav = ({
-  info,
-  time
-}) => {
-  const bytesPerSecond = info.sampleRate * info.blockAlign;
-  const durationInSeconds = info.mediaSection.size / bytesPerSecond;
-  const timeRoundedDown = Math.floor(Math.min(time, durationInSeconds - 0.0000001) * WAVE_SAMPLES_PER_SECOND) / WAVE_SAMPLES_PER_SECOND;
-  const byteOffset = bytesPerSecond * timeRoundedDown;
-  return Promise.resolve({
-    type: "do-seek",
-    byte: byteOffset + info.mediaSection.start
-  });
-};
-
-// src/containers/webm/seek/get-seeking-byte.ts
-var toSeconds = (timeInTimescale, track) => {
-  return timeInTimescale / track.timescale * 1000;
-};
-var findBiggestCueBeforeTime = ({
-  cues,
-  time,
-  track
-}) => {
-  let biggestCueBeforeTime;
-  for (const cue of cues) {
-    const cueTimeInSeconds = toSeconds(cue.timeInTimescale, track);
-    if (cueTimeInSeconds < time && (!biggestCueBeforeTime || cueTimeInSeconds > toSeconds(biggestCueBeforeTime.timeInTimescale, track))) {
-      biggestCueBeforeTime = cue;
-    }
-  }
-  return biggestCueBeforeTime;
-};
-var findKeyframeBeforeTime2 = ({
-  keyframes,
-  time
-}) => {
-  let keyframeBeforeTime;
-  for (const keyframe of keyframes) {
-    if (keyframe.decodingTimeInSeconds < time && (!keyframeBeforeTime || keyframe.decodingTimeInSeconds > keyframeBeforeTime.decodingTimeInSeconds)) {
-      keyframeBeforeTime = keyframe;
-    }
-  }
-  return keyframeBeforeTime?.positionInBytes ?? null;
-};
-var getByteFromCues = ({
-  cuesResponse,
-  time,
-  info,
-  logLevel
-}) => {
-  if (!cuesResponse) {
-    Log.trace(logLevel, "Has no Matroska cues at the moment, cannot use them");
-    return null;
-  }
-  const { cues, segmentOffset } = cuesResponse;
-  Log.trace(logLevel, "Has Matroska cues. Will use them to perform a seek.");
-  const biggestCueBeforeTime = findBiggestCueBeforeTime({
-    cues,
-    time,
-    track: info.track
-  });
-  if (!biggestCueBeforeTime) {
-    return null;
-  }
-  return biggestCueBeforeTime.clusterPositionInSegment + segmentOffset;
-};
-var getSeekingByteFromMatroska = async ({
-  time,
-  webmState,
-  info,
-  logLevel,
-  mediaSection
-}) => {
-  if (!info.track) {
-    Log.trace(logLevel, "No video track found, cannot seek yet");
-    return {
-      type: "valid-but-must-wait"
-    };
-  }
-  const cuesResponse = info.loadedCues ?? await webmState.cues.getLoadedCues();
-  const byteFromObservedKeyframe = findKeyframeBeforeTime2({
-    keyframes: info.keyframes,
-    time
-  });
-  const byteFromCues = getByteFromCues({
-    cuesResponse,
-    time,
-    info,
-    logLevel
-  });
-  const byteFromFirstMediaSection = webmState.getFirstCluster()?.start ?? null;
-  const seekPossibilities = [
-    byteFromCues,
-    byteFromObservedKeyframe,
-    byteFromFirstMediaSection
-  ].filter((n) => n !== null);
-  const byteToSeekTo = seekPossibilities.length === 0 ? null : Math.max(...seekPossibilities);
-  if (byteToSeekTo === null) {
-    return {
-      type: "invalid"
-    };
-  }
-  mediaSection.addMediaSection({
-    start: byteToSeekTo,
-    size: 1
-  });
-  return {
-    type: "do-seek",
-    byte: byteToSeekTo
+    byte: bestEntry.offset + info.moviOffset - 4,
+    timeInSeconds: bestEntry.sampleCounts[idx1Entries.videoTrackIndex] / info.samplesPerSecond
   };
 };
 
@@ -7147,6 +7060,137 @@ var handleAvcPacket = async ({
   transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 
+// src/containers/wav/get-seeking-byte.ts
+var WAVE_SAMPLES_PER_SECOND = 25;
+var getSeekingByteFromWav = ({
+  info,
+  time
+}) => {
+  const bytesPerSecond = info.sampleRate * info.blockAlign;
+  const durationInSeconds = info.mediaSection.size / bytesPerSecond;
+  const timeRoundedDown = Math.floor(Math.min(time, durationInSeconds - 0.0000001) * WAVE_SAMPLES_PER_SECOND) / WAVE_SAMPLES_PER_SECOND;
+  const byteOffset = bytesPerSecond * timeRoundedDown;
+  return Promise.resolve({
+    type: "do-seek",
+    byte: byteOffset + info.mediaSection.start,
+    timeInSeconds: timeRoundedDown
+  });
+};
+
+// src/containers/webm/seek/get-seeking-byte.ts
+var toSeconds = (timeInTimescale, track) => {
+  return timeInTimescale / track.timescale * 1000;
+};
+var findBiggestCueBeforeTime = ({
+  cues,
+  time,
+  track
+}) => {
+  let biggestCueBeforeTime;
+  for (const cue of cues) {
+    const cueTimeInSeconds = toSeconds(cue.timeInTimescale, track);
+    if (cueTimeInSeconds < time && (!biggestCueBeforeTime || cueTimeInSeconds > toSeconds(biggestCueBeforeTime.timeInTimescale, track))) {
+      biggestCueBeforeTime = cue;
+    }
+  }
+  return biggestCueBeforeTime;
+};
+var findKeyframeBeforeTime2 = ({
+  keyframes,
+  time
+}) => {
+  let keyframeBeforeTime;
+  for (const keyframe of keyframes) {
+    if (keyframe.decodingTimeInSeconds < time && (!keyframeBeforeTime || keyframe.decodingTimeInSeconds > keyframeBeforeTime.decodingTimeInSeconds)) {
+      keyframeBeforeTime = keyframe;
+    }
+  }
+  return keyframeBeforeTime ?? null;
+};
+var getByteFromCues = ({
+  cuesResponse,
+  time,
+  info,
+  logLevel
+}) => {
+  if (!cuesResponse) {
+    Log.trace(logLevel, "Has no Matroska cues at the moment, cannot use them");
+    return null;
+  }
+  const { cues, segmentOffset } = cuesResponse;
+  Log.trace(logLevel, "Has Matroska cues. Will use them to perform a seek.");
+  const biggestCueBeforeTime = findBiggestCueBeforeTime({
+    cues,
+    time,
+    track: info.track
+  });
+  if (!biggestCueBeforeTime) {
+    return null;
+  }
+  return {
+    byte: biggestCueBeforeTime.clusterPositionInSegment + segmentOffset,
+    timeInSeconds: toSeconds(biggestCueBeforeTime.timeInTimescale, info.track)
+  };
+};
+var getSeekingByteFromMatroska = async ({
+  time,
+  webmState,
+  info,
+  logLevel,
+  mediaSection
+}) => {
+  if (!info.track) {
+    Log.trace(logLevel, "No video track found, cannot seek yet");
+    return {
+      type: "valid-but-must-wait"
+    };
+  }
+  const cuesResponse = info.loadedCues ?? await webmState.cues.getLoadedCues();
+  const byteFromObservedKeyframe = findKeyframeBeforeTime2({
+    keyframes: info.keyframes,
+    time
+  });
+  const byteFromCues = getByteFromCues({
+    cuesResponse,
+    time,
+    info,
+    logLevel
+  });
+  const byteFromFirstMediaSection = webmState.getFirstCluster()?.start ?? null;
+  const seekPossibilities = [
+    byteFromCues?.byte ?? null,
+    byteFromObservedKeyframe?.positionInBytes ?? null,
+    byteFromFirstMediaSection
+  ].filter((n) => n !== null);
+  const byteToSeekTo = seekPossibilities.length === 0 ? null : Math.max(...seekPossibilities);
+  if (byteToSeekTo === null) {
+    return {
+      type: "invalid"
+    };
+  }
+  mediaSection.addMediaSection({
+    start: byteToSeekTo,
+    size: 1
+  });
+  const timeInSeconds = (() => {
+    if (byteToSeekTo === byteFromObservedKeyframe?.positionInBytes) {
+      return Math.min(byteFromObservedKeyframe.decodingTimeInSeconds, byteFromObservedKeyframe.presentationTimeInSeconds);
+    }
+    if (byteToSeekTo === byteFromCues?.byte) {
+      return byteFromCues.timeInSeconds;
+    }
+    if (byteToSeekTo === byteFromFirstMediaSection) {
+      return 0;
+    }
+    throw new Error("Should not happen");
+  })();
+  return {
+    type: "do-seek",
+    byte: byteToSeekTo,
+    timeInSeconds
+  };
+};
+
 // src/state/transport-stream/observed-pes-header.ts
 var makeObservedPesHeader = () => {
   const pesHeaders = [];
@@ -7236,7 +7280,8 @@ var getSeekingByte = ({
     if (byte) {
       return Promise.resolve({
         type: "do-seek",
-        byte
+        byte: byte.offset,
+        timeInSeconds: byte.timeInSeconds
       });
     }
     return Promise.resolve({
@@ -7249,11 +7294,20 @@ var getSeekingByte = ({
       timeInSeconds: time,
       ptsStartOffset: info.ptsStartOffset
     });
-    const byte = lastKeyframeBeforeTimeInSeconds?.offset ?? 0;
+    if (!lastKeyframeBeforeTimeInSeconds) {
+      transportStream.resetBeforeSeek();
+      return Promise.resolve({
+        type: "do-seek",
+        byte: 0,
+        timeInSeconds: 0
+      });
+    }
+    const byte = lastKeyframeBeforeTimeInSeconds.offset;
     transportStream.resetBeforeSeek();
     return Promise.resolve({
       type: "do-seek",
-      byte
+      byte,
+      timeInSeconds: Math.min(lastKeyframeBeforeTimeInSeconds.pts, lastKeyframeBeforeTimeInSeconds.dts ?? Infinity) / MPEG_TIMESCALE
     });
   }
   if (info.type === "riff-seeking-hints") {
@@ -14647,10 +14701,11 @@ var parseList = ({
   const metadata = [];
   const remainingBytes = () => ckSize - (iterator.counter.getOffset() - startOffset);
   while (remainingBytes() > 0) {
-    if (remainingBytes() < 4) {
-      iterator.discard(remainingBytes());
-      break;
+    const byte = iterator.getUint8();
+    if (byte === 0) {
+      continue;
     }
+    iterator.counter.decrement(1);
     const key = iterator.getByteString(4, false);
     const size = iterator.getUint32Le();
     const value = iterator.getByteString(size, true);
@@ -17595,6 +17650,46 @@ var internalParseMedia = async function({
     contentLength: state.contentLength,
     aacState: state.aac
   })));
+  controller._internals.attachSimulateSeekResolution((seek2) => {
+    const {
+      aacState: aacState2,
+      avcState: avcState2,
+      flacState: flacState2,
+      isoState,
+      iterator,
+      keyframes,
+      m3uState: m3uState2,
+      mediaSection,
+      mp3State,
+      riffState,
+      samplesObserved,
+      structureState: structureState2,
+      tracksState,
+      transportStream,
+      webmState: webmState2
+    } = getWorkOnSeekRequestOptions(state);
+    return turnSeekIntoByte({
+      aacState: aacState2,
+      seek: seek2,
+      avcState: avcState2,
+      contentLength,
+      flacState: flacState2,
+      isoState,
+      iterator,
+      keyframes,
+      logLevel,
+      m3uPlaylistContext,
+      m3uState: m3uState2,
+      mediaSectionState: mediaSection,
+      mp3State,
+      riffState,
+      samplesObserved,
+      structureState: structureState2,
+      tracksState,
+      transportStream,
+      webmState: webmState2
+    });
+  });
   if (!hasAudioTrackHandlers && !hasVideoTrackHandlers && Object.values(state.fields).every((v) => !v) && mode === "query") {
     Log.warn(logLevel, new Error("Warning - No `fields` and no `on*` callbacks were passed to `parseMedia()`. Specify the data you would like to retrieve."));
   }
@@ -17648,6 +17743,21 @@ var forwardMediaParserControllerToWorker = (controller) => {
       });
       return;
     }
+    if (message.type === "request-simulate-seek") {
+      controller.simulateSeek(message.payload).then((resolution) => {
+        postMessage({
+          type: "response-simulate-seek",
+          nonce: message.nonce,
+          payload: resolution
+        });
+      }).catch((err) => {
+        postMessage({
+          type: "response-error",
+          payload: err
+        });
+      });
+      return;
+    }
     if (message.type === "request-resume") {
       controller.resume();
       return;

package/dist/esm/worker.mjs

@@ -243,6 +243,14 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     seekingHintPromises.push(prom);
     return prom.promise;
   });
+  const simulateSeekPromises = {};
+  controller?._internals.attachSimulateSeekResolution((seek) => {
+    const prom = withResolvers();
+    const nonce = String(Math.random());
+    post(worker, { type: "request-simulate-seek", payload: seek, nonce });
+    simulateSeekPromises[nonce] = prom;
+    return prom.promise;
+  });
   const callbacks = {};
   function onMessage(message) {
     const data = message.data;
@@ -462,6 +470,15 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
       firstPromise.resolve(data.payload);
       return;
     }
+    if (data.type === "response-simulate-seek") {
+      const prom = simulateSeekPromises[data.nonce];
+      if (!prom) {
+        throw new Error("No simulate seek promise found");
+      }
+      prom.resolve(data.payload);
+      delete simulateSeekPromises[data.nonce];
+      return;
+    }
     throw new Error(`Unknown response type: ${JSON.stringify(data)}`);
   }
   worker.addEventListener("message", onMessage);
@@ -489,6 +506,17 @@ var parseMediaOnWebWorker = (params) => {
   if (typeof Worker === "undefined") {
     throw new Error('"Worker" is not available. Cannot call parseMediaOnWebWorker()');
   }
+  if (import.meta.url.includes(".vite/deps")) {
+    const err = [
+      "Detected Vite pre-bundling, which will break the worker.",
+      "Please add the following to your vite.config.js:",
+      "  optimizeDeps: {",
+      '    exclude: ["@remotion/media-parser/worker"]',
+      "  }"
+    ].join(`
+`);
+    throw new Error(err);
+  }
   const worker = new Worker(new URL("./worker-web-entry.mjs", import.meta.url));
   return parseMediaOnWorkerImplementation(params, worker, "parseMediaOnWebWorker");
 };

package/dist/get-seeking-byte.js

@@ -7,6 +7,7 @@ const get_seeking_byte_3 = require("./containers/iso-base-media/get-seeking-byte
 const get_seeking_byte_4 = require("./containers/m3u/get-seeking-byte");
 const get_seeking_byte_5 = require("./containers/mp3/get-seeking-byte");
 const get_seeking_byte_6 = require("./containers/riff/get-seeking-byte");
+const handle_avc_packet_1 = require("./containers/transport-stream/handle-avc-packet");
 const get_seeking_byte_7 = require("./containers/wav/get-seeking-byte");
 const get_seeking_byte_8 = require("./containers/webm/seek/get-seeking-byte");
 const observed_pes_header_1 = require("./state/transport-stream/observed-pes-header");
@@ -46,7 +47,8 @@ const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, trans
         if (byte) {
             return Promise.resolve({
                 type: 'do-seek',
-                byte,
+                byte: byte.offset,
+                timeInSeconds: byte.timeInSeconds,
             });
         }
         return Promise.resolve({
@@ -59,11 +61,20 @@ const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, trans
             timeInSeconds: time,
             ptsStartOffset: info.ptsStartOffset,
         });
-        const byte = (_a = lastKeyframeBeforeTimeInSeconds === null || lastKeyframeBeforeTimeInSeconds === void 0 ? void 0 : lastKeyframeBeforeTimeInSeconds.offset) !== null && _a !== void 0 ? _a : 0;
+        if (!lastKeyframeBeforeTimeInSeconds) {
+            transportStream.resetBeforeSeek();
+            return Promise.resolve({
+                type: 'do-seek',
+                byte: 0,
+                timeInSeconds: 0,
+            });
+        }
+        const byte = lastKeyframeBeforeTimeInSeconds.offset;
         transportStream.resetBeforeSeek();
         return Promise.resolve({
             type: 'do-seek',
             byte,
+            timeInSeconds: Math.min(lastKeyframeBeforeTimeInSeconds.pts, (_a = lastKeyframeBeforeTimeInSeconds.dts) !== null && _a !== void 0 ? _a : Infinity) / handle_avc_packet_1.MPEG_TIMESCALE,
         });
     }
     if (info.type === 'riff-seeking-hints') {

package/dist/index.cjs

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBCODECS_TIMESCALE = exports.VERSION = exports.mediaParserController = exports.defaultSelectM3uStreamFn = exports.defaultSelectM3uAssociatedPlaylists = exports.MediaParserInternals = exports.downloadAndParseMedia = exports.MediaParserAbortError = exports.IsAPdfError = exports.IsAnUnsupportedFileTypeError = exports.IsAnImageError = exports.hasBeenAborted = exports.parseMedia = void 0;
+const aac_codecprivate_1 = require("./aac-codecprivate");
+const ftyp_1 = require("./containers/iso-base-media/ftyp");
+const mvhd_1 = require("./containers/iso-base-media/mvhd");
+const samples_1 = require("./containers/iso-base-media/stsd/samples");
+const stsd_1 = require("./containers/iso-base-media/stsd/stsd");
+const tkhd_1 = require("./containers/iso-base-media/tkhd");
+const parse_ebml_1 = require("./containers/webm/parse-ebml");
+const all_segments_1 = require("./containers/webm/segments/all-segments");
+const internal_parse_media_1 = require("./internal-parse-media");
+const buffer_iterator_1 = require("./iterator/buffer-iterator");
+const log_1 = require("./log");
+const need_samples_for_fields_1 = require("./state/need-samples-for-fields");
+const parser_state_1 = require("./state/parser-state");
+var parse_media_1 = require("./parse-media");
+Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "hasBeenAborted", { enumerable: true, get: function () { return errors_1.hasBeenAborted; } });
+Object.defineProperty(exports, "IsAnImageError", { enumerable: true, get: function () { return errors_1.IsAnImageError; } });
+Object.defineProperty(exports, "IsAnUnsupportedFileTypeError", { enumerable: true, get: function () { return errors_1.IsAnUnsupportedFileTypeError; } });
+Object.defineProperty(exports, "IsAPdfError", { enumerable: true, get: function () { return errors_1.IsAPdfError; } });
+Object.defineProperty(exports, "MediaParserAbortError", { enumerable: true, get: function () { return errors_1.MediaParserAbortError; } });
+var download_and_parse_media_1 = require("./download-and-parse-media");
+Object.defineProperty(exports, "downloadAndParseMedia", { enumerable: true, get: function () { return download_and_parse_media_1.downloadAndParseMedia; } });
+/**
+ * @deprecated Dont use these yet.
+ */
+exports.MediaParserInternals = {
+    Log: log_1.Log,
+    createAacCodecPrivate: aac_codecprivate_1.createAacCodecPrivate,
+    matroskaElements: all_segments_1.matroskaElements,
+    ebmlMap: all_segments_1.ebmlMap,
+    parseTkhd: tkhd_1.parseTkhd,
+    getArrayBufferIterator: buffer_iterator_1.getArrayBufferIterator,
+    parseStsd: stsd_1.parseStsd,
+    makeParserState: parser_state_1.makeParserState,
+    processSample: samples_1.processIsoFormatBox,
+    parseFtyp: ftyp_1.parseFtyp,
+    parseEbml: parse_ebml_1.parseEbml,
+    parseMvhd: mvhd_1.parseMvhd,
+    internalParseMedia: internal_parse_media_1.internalParseMedia,
+    fieldsNeedSamplesMap: need_samples_for_fields_1.fieldsNeedSamplesMap,
+};
+var select_stream_1 = require("./containers/m3u/select-stream");
+Object.defineProperty(exports, "defaultSelectM3uAssociatedPlaylists", { enumerable: true, get: function () { return select_stream_1.defaultSelectM3uAssociatedPlaylists; } });
+Object.defineProperty(exports, "defaultSelectM3uStreamFn", { enumerable: true, get: function () { return select_stream_1.defaultSelectM3uStreamFn; } });
+var media_parser_controller_1 = require("./controller/media-parser-controller");
+Object.defineProperty(exports, "mediaParserController", { enumerable: true, get: function () { return media_parser_controller_1.mediaParserController; } });
+var version_1 = require("./version");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
+var webcodecs_timescale_1 = require("./webcodecs-timescale");
+Object.defineProperty(exports, "WEBCODECS_TIMESCALE", { enumerable: true, get: function () { return webcodecs_timescale_1.WEBCODECS_TIMESCALE; } });

package/dist/index.d.ts

@@ -1275,6 +1275,7 @@ export { defaultSelectM3uAssociatedPlaylists, defaultSelectM3uStreamFn, SelectM3
 export { mediaParserController, MediaParserController, } from './controller/media-parser-controller';
 export { VERSION } from './version';
 export { WEBCODECS_TIMESCALE } from './webcodecs-timescale';
+export type { SeekResolution } from './work-on-seek-request';
 export type { MediaParserSampleAspectRatio } from './get-tracks';
 /**
  * @deprecated Dont use these yet.