@remotion/media-parser 4.0.290 → 4.0.292

package/dist/parse-loop.js

@@ -45,19 +45,34 @@ const parseLoop = async ({ state, throttledState, onError, }) => {
             try {
                 await (0, emit_all_info_1.triggerInfoEmit)(state);
                 await state.controller._internals.checkForAbortAndPause();
-                const skip = await (0, run_parse_iteration_1.runParseIteration)({
+                const result = await (0, run_parse_iteration_1.runParseIteration)({
                     state,
                 });
-                if (skip !== null) {
-                    state.increaseSkippedBytes(skip.skipTo - state.iterator.counter.getOffset());
-                    if (skip.skipTo === state.contentLength) {
-                        state.iterator.discard(skip.skipTo - state.iterator.counter.getOffset());
+                if (result !== null && result.action === 'fetch-more-data') {
+                    log_1.Log.verbose(state.logLevel, `Need to fetch ${result.bytesNeeded} more bytes before we can continue`);
+                    const startBytesRemaining = state.iterator.bytesRemaining();
+                    while (true) {
+                        const done = await fetchMoreData(state);
+                        if (done) {
+                            break;
+                        }
+                        if (state.iterator.bytesRemaining() - startBytesRemaining >=
+                            result.bytesNeeded) {
+                            break;
+                        }
+                    }
+                    continue;
+                }
+                if (result !== null && result.action === 'skip') {
+                    state.increaseSkippedBytes(result.skipTo - state.iterator.counter.getOffset());
+                    if (result.skipTo === state.contentLength) {
+                        state.iterator.discard(result.skipTo - state.iterator.counter.getOffset());
                         log_1.Log.verbose(state.logLevel, 'Skipped to end of file, not fetching.');
                         break;
                     }
                     const seekStart = Date.now();
                     await (0, perform_seek_1.performSeek)({
-                        seekTo: skip.skipTo,
+                        seekTo: result.skipTo,
                         userInitiated: false,
                         controller: state.controller,
                         mediaSection: state.mediaSection,
@@ -71,6 +86,7 @@ const parseLoop = async ({ state, throttledState, onError, }) => {
                         fields: state.fields,
                         src: state.src,
                         discardReadBytes: state.discardReadBytes,
+                        prefetchCache: state.prefetchCache,
                     });
                     state.timings.timeSeeking += Date.now() - seekStart;
                 }

package/dist/parse-media-on-worker-entry.js

@@ -101,6 +101,7 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
             cleanup();
             // Reject main loop
             const error = (0, serialize_error_1.deserializeError)(data);
+            error.stack = data.errorStack;
             reject(error);
             // If aborted, we send the seeking hints we got,
             // otherwise we reject all .getSeekingHints() promises

package/dist/parse-media.js

@@ -45,7 +45,7 @@ const parseMedia = (options) => {
         controller: (_11 = options.controller) !== null && _11 !== void 0 ? _11 : undefined,
         selectM3uStream: (_12 = options.selectM3uStream) !== null && _12 !== void 0 ? _12 : select_stream_1.defaultSelectM3uStreamFn,
         selectM3uAssociatedPlaylists: (_13 = options.selectM3uAssociatedPlaylists) !== null && _13 !== void 0 ? _13 : select_stream_1.defaultSelectM3uAssociatedPlaylists,
-        mp4HeaderSegment: (_14 = options.mp4HeaderSegment) !== null && _14 !== void 0 ? _14 : null,
+        m3uPlaylistContext: (_14 = options.m3uPlaylistContext) !== null && _14 !== void 0 ? _14 : null,
         src: options.src,
         mode: 'query',
         onDiscardedData: null,

package/dist/parse-result.d.ts

@@ -7,7 +7,7 @@ import type { TransportStreamBox } from './containers/transport-stream/boxes';
 import type { WavStructure } from './containers/wav/types';
 import type { MatroskaSegment } from './containers/webm/segments';
 import type { MediaParserMetadataEntry } from './metadata/get-metadata';
-import type { Skip } from './skip';
+import type { FetchMoreData, Skip } from './skip';
 type Mp3Id3Header = {
     type: 'id3-header';
     versionMajor: number;
@@ -35,5 +35,5 @@ export type Mp3Structure = {
     boxes: Mp3Box[];
 };
 export type MediaParserStructureUnstable = IsoBaseMediaStructure | RiffStructure | MatroskaStructure | TransportStreamStructure | Mp3Structure | AacStructure | WavStructure | M3uStructure | FlacStructure;
-export type ParseResult = Skip | null;
+export type ParseResult = Skip | FetchMoreData | null;
 export {};

package/dist/perform-seek.d.ts

@@ -1,4 +1,5 @@
 import type { MediaParserController } from './controller/media-parser-controller';
+import type { PrefetchCache } from './fetch';
 import type { AllOptions, ParseMediaFields } from './fields';
 import type { BufferIterator } from './iterator/buffer-iterator';
 import type { LogLevel } from './log';
@@ -7,7 +8,7 @@ import type { ReaderInterface } from './readers/reader';
 import type { CurrentReader } from './state/current-reader';
 import type { SeekInfiniteLoop } from './state/seek-infinite-loop';
 import type { MediaSectionState } from './state/video-section';
-export declare const performSeek: ({ seekTo, userInitiated, controller, mediaSection, iterator, seekInfiniteLoop, logLevel, mode, contentLength, currentReader, readerInterface, src, discardReadBytes, fields, }: {
+export declare const performSeek: ({ seekTo, userInitiated, controller, mediaSection, iterator, seekInfiniteLoop, logLevel, mode, contentLength, currentReader, readerInterface, src, discardReadBytes, fields, prefetchCache, }: {
     seekTo: number;
     userInitiated: boolean;
     controller: MediaParserController;
@@ -22,4 +23,5 @@ export declare const performSeek: ({ seekTo, userInitiated, controller, mediaSec
     fields: Partial<AllOptions<ParseMediaFields>>;
     src: ParseMediaSrc;
     discardReadBytes: (force: boolean) => Promise<void>;
+    prefetchCache: PrefetchCache;
 }) => Promise<void>;

package/dist/perform-seek.js

@@ -5,7 +5,7 @@ const log_1 = require("./log");
 const seek_backwards_1 = require("./seek-backwards");
 const seek_forwards_1 = require("./seek-forwards");
 const video_section_1 = require("./state/video-section");
-const performSeek = async ({ seekTo, userInitiated, controller, mediaSection, iterator, seekInfiniteLoop, logLevel, mode, contentLength, currentReader, readerInterface, src, discardReadBytes, fields, }) => {
+const performSeek = async ({ seekTo, userInitiated, controller, mediaSection, iterator, seekInfiniteLoop, logLevel, mode, contentLength, currentReader, readerInterface, src, discardReadBytes, fields, prefetchCache, }) => {
     const byteInMediaSection = (0, video_section_1.isByteInMediaSection)({
         position: seekTo,
         mediaSections: mediaSection.getMediaSections(),
@@ -54,6 +54,7 @@ const performSeek = async ({ seekTo, userInitiated, controller, mediaSection, it
             src,
             controller,
             discardReadBytes,
+            prefetchCache,
         });
     }
     else {
@@ -65,6 +66,7 @@ const performSeek = async ({ seekTo, userInitiated, controller, mediaSection, it
             currentReader,
             readerInterface,
             src,
+            prefetchCache,
         });
     }
     await controller._internals.checkForAbortAndPause();

package/dist/readers/fetch/get-body-and-reader.js

@@ -8,10 +8,25 @@ const getLengthAndReader = async ({ canLiveWithoutContentLength, res, ownControl
         (canLiveWithoutContentLength && contentLength === null)) {
         const buffer = await res.arrayBuffer();
         const encoded = new Uint8Array(buffer);
+        let streamCancelled = false;
         const stream = new ReadableStream({
             start(controller) {
-                controller.enqueue(encoded);
-                controller.close();
+                if (ownController.signal.aborted) {
+                    return;
+                }
+                if (streamCancelled) {
+                    return;
+                }
+                try {
+                    controller.enqueue(encoded);
+                    controller.close();
+                }
+                catch (_a) {
+                    // sometimes on windows after aborting on node 16		: Invalid state: ReadableStreamDefaultController is not in a state where chunk can be enqueued
+                }
+            },
+            cancel() {
+                streamCancelled = true;
             },
         });
         return {

package/dist/readers/from-fetch.d.ts

@@ -1,4 +1,6 @@
-import type { CreateAdjacentFileSource, ReadContent, ReaderInterface, ReadWholeAsText } from './reader';
+import type { MediaParserController } from '../controller/media-parser-controller';
+import type { ParseMediaRange } from '../options';
+import type { CreateAdjacentFileSource, PreloadContent, ReadContent, ReaderInterface, ReadWholeAsText } from './reader';
 interface ParsedContentRange {
     unit: string;
     start?: number | null;
@@ -10,7 +12,21 @@ interface ParsedContentRange {
  * From: https://github.com/gregberge/content-range/blob/main/src/index.ts
  */
 export declare function parseContentRange(input: string): ParsedContentRange | null;
+export declare const makeFetchRequest: ({ range, src, controller, }: {
+    range: ParseMediaRange;
+    src: string | URL;
+    controller: MediaParserController | null;
+}) => Promise<{
+    contentLength: number | null;
+    needsContentRange: boolean;
+    reader: import("./reader").Reader;
+    name: string | undefined;
+    contentType: string | null;
+    supportsContentRange: boolean;
+}>;
+export type PrefetchCache = Map<string, ReturnType<typeof makeFetchRequest>>;
 export declare const fetchReadContent: ReadContent;
+export declare const fetchPreload: PreloadContent;
 export declare const fetchReadWholeAsText: ReadWholeAsText;
 export declare const fetchCreateAdjacentFileSource: CreateAdjacentFileSource;
 export declare const fetchReader: ReaderInterface;

package/dist/readers/from-fetch.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchReader = exports.fetchCreateAdjacentFileSource = exports.fetchReadWholeAsText = exports.fetchReadContent = void 0;
+exports.fetchReader = exports.fetchCreateAdjacentFileSource = exports.fetchReadWholeAsText = exports.fetchPreload = exports.fetchReadContent = exports.makeFetchRequest = void 0;
 exports.parseContentRange = parseContentRange;
-/* eslint-disable eqeqeq */
-/* eslint-disable no-eq-null */
 const errors_1 = require("../errors");
+const log_1 = require("../log");
 const get_body_and_reader_1 = require("./fetch/get-body-and-reader");
 const resolve_url_1 = require("./fetch/resolve-url");
 /**
@@ -46,11 +45,8 @@ const validateContentRangeAndDetectIfSupported = ({ requestedRange, parsedConten
     }
     return { supportsContentRange: true };
 };
-const fetchReadContent = async ({ src, range, controller, }) => {
+const makeFetchRequest = async ({ range, src, controller, }) => {
     var _a;
-    if (typeof src !== 'string' && src instanceof URL === false) {
-        throw new Error('src must be a string when using `fetchReader`');
-    }
     const resolvedUrl = (0, resolve_url_1.resolveUrl)(src);
     const resolvedUrlString = resolvedUrl.toString();
     if (!resolvedUrlString.startsWith('https://') &&
@@ -91,22 +87,63 @@ const fetchReadContent = async ({ src, range, controller, }) => {
         parsedContentRange,
         statusCode: res.status,
     });
-    controller._internals.signal.addEventListener('abort', () => {
-        ownController.abort(new errors_1.MediaParserAbortError('Aborted by user'));
-    }, { once: true });
+    if (controller) {
+        controller._internals.signal.addEventListener('abort', () => {
+            ownController.abort(new errors_1.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}`);
+        throw new Error(`Server returned status code ${res.status} for ${resolvedUrl} and range ${requestedRange}`);
     }
     const contentDisposition = res.headers.get('content-disposition');
     const name = (_a = contentDisposition === null || contentDisposition === void 0 ? void 0 : contentDisposition.match(/filename="([^"]+)"/)) === null || _a === void 0 ? void 0 : _a[1];
-    const fallbackName = src.toString().split('/').pop();
     const { contentLength, needsContentRange, reader } = await (0, get_body_and_reader_1.getLengthAndReader)({
         canLiveWithoutContentLength,
         res,
         ownController,
         requestedWithoutRange: requestWithoutRange,
     });
+    const contentType = res.headers.get('content-type');
+    return {
+        contentLength,
+        needsContentRange,
+        reader,
+        name,
+        contentType,
+        supportsContentRange,
+    };
+};
+exports.makeFetchRequest = makeFetchRequest;
+const cacheKey = ({ src, range, }) => {
+    return `${src}-${JSON.stringify(range)}`;
+};
+const makeFetchRequestOrGetCached = ({ range, src, controller, logLevel, prefetchCache, }) => {
+    const key = cacheKey({ src, range });
+    const cached = prefetchCache.get(key);
+    if (cached) {
+        log_1.Log.verbose(logLevel, `Reading from preload cache for ${key}`);
+        return cached;
+    }
+    log_1.Log.verbose(logLevel, `Fetching ${key}`);
+    const result = (0, exports.makeFetchRequest)({ range, src, controller });
+    prefetchCache.set(key, result);
+    return result;
+};
+const fetchReadContent = async ({ src, range, controller, logLevel, prefetchCache, }) => {
+    if (typeof src !== 'string' && src instanceof URL === false) {
+        throw new Error('src must be a string when using `fetchReader`');
+    }
+    const fallbackName = src.toString().split('/').pop();
+    const { reader, contentLength, needsContentRange, name, supportsContentRange, contentType, } = await makeFetchRequestOrGetCached({
+        range,
+        src,
+        controller,
+        logLevel,
+        prefetchCache,
+    });
+    const key = cacheKey({ src, range });
+    prefetchCache.delete(key);
     if (controller) {
         controller._internals.signal.addEventListener('abort', () => {
             reader.reader.cancel().catch(() => {
@@ -117,13 +154,30 @@ const fetchReadContent = async ({ src, range, controller, }) => {
     return {
         reader,
         contentLength,
-        contentType: res.headers.get('content-type'),
+        contentType,
         name: name !== null && name !== void 0 ? name : fallbackName,
         supportsContentRange,
         needsContentRange,
     };
 };
 exports.fetchReadContent = fetchReadContent;
+const fetchPreload = ({ src, range, logLevel, prefetchCache, }) => {
+    if (typeof src !== 'string' && src instanceof URL === false) {
+        throw new Error('src must be a string when using `fetchReader`');
+    }
+    const key = cacheKey({ src, range });
+    if (prefetchCache.has(key)) {
+        return prefetchCache.get(key);
+    }
+    makeFetchRequestOrGetCached({
+        range,
+        src,
+        controller: null,
+        logLevel,
+        prefetchCache,
+    });
+};
+exports.fetchPreload = fetchPreload;
 const fetchReadWholeAsText = async (src) => {
     if (typeof src !== 'string' && src instanceof URL === false) {
         throw new Error('src must be a string when using `fetchReader`');
@@ -146,4 +200,5 @@ exports.fetchReader = {
     read: exports.fetchReadContent,
     readWholeAsText: exports.fetchReadWholeAsText,
     createAdjacentFileSource: exports.fetchCreateAdjacentFileSource,
+    preload: exports.fetchPreload,
 };

package/dist/readers/from-node.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeReader = exports.nodeCreateAdjacentFileSource = exports.nodeReadWholeAsText = exports.nodeReadContent = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const stream_1 = require("stream");
 const nodeReadContent = ({ src, range, controller }) => {
     if (typeof src !== 'string') {
         throw new Error('src must be a string when using `nodeReader`');
@@ -22,7 +21,27 @@ const nodeReadContent = ({ src, range, controller }) => {
         ownController.abort();
     }, { once: true });
     const stats = (0, fs_1.statSync)(src);
-    const reader = stream_1.Readable.toWeb(stream).getReader();
+    let readerCancelled = false;
+    const reader = new ReadableStream({
+        start(c) {
+            if (readerCancelled) {
+                return;
+            }
+            stream.on('data', (chunk) => {
+                c.enqueue(chunk);
+            });
+            stream.on('end', () => {
+                c.close();
+            });
+            stream.on('error', (err) => {
+                c.error(err);
+            });
+        },
+        cancel() {
+            readerCancelled = true;
+            stream.destroy();
+        },
+    }).getReader();
     if (controller) {
         controller._internals.signal.addEventListener('abort', () => {
             reader.cancel().catch(() => { });
@@ -66,4 +85,7 @@ exports.nodeReader = {
     read: exports.nodeReadContent,
     readWholeAsText: exports.nodeReadWholeAsText,
     createAdjacentFileSource: exports.nodeCreateAdjacentFileSource,
+    preload: () => {
+        // doing nothing, it's just for when fetching over the network
+    },
 };

package/dist/readers/from-web-file.js

@@ -60,4 +60,7 @@ exports.webFileReader = {
     read: exports.webFileReadContent,
     readWholeAsText: exports.webFileReadWholeAsText,
     createAdjacentFileSource: exports.webFileCreateAdjacentFileSource,
+    preload: () => {
+        // doing nothing, it's just for when fetching over the network
+    },
 };

package/dist/readers/reader.d.ts

@@ -1,5 +1,7 @@
 import type { MediaParserController } from '../controller/media-parser-controller';
-import type { ParseMediaSrc } from '../options';
+import type { LogLevel } from '../log';
+import type { ParseMediaRange, ParseMediaSrc } from '../options';
+import type { PrefetchCache } from './from-fetch';
 export type Reader = {
     reader: ReadableStreamDefaultReader<Uint8Array>;
     abort: () => void;
@@ -14,14 +16,29 @@ type ReadResult = {
 };
 export type ReadContent = (options: {
     src: ParseMediaSrc;
-    range: [number, number] | number | null;
+    range: ParseMediaRange;
     controller: MediaParserController;
+    logLevel: LogLevel;
+    prefetchCache: PrefetchCache;
 }) => Promise<ReadResult>;
 export type ReadWholeAsText = (src: ParseMediaSrc) => Promise<string>;
+export type PreloadContent = (options: {
+    src: ParseMediaSrc;
+    range: ParseMediaRange;
+    logLevel: LogLevel;
+    prefetchCache: PrefetchCache;
+}) => void;
+export type ClearPreloadCache = (options: {
+    src: ParseMediaSrc;
+    range: ParseMediaRange;
+    logLevel: LogLevel;
+    prefetchCache: PrefetchCache;
+}) => void;
 export type CreateAdjacentFileSource = (relativePath: string, src: ParseMediaSrc) => string;
 export type ReaderInterface = {
     read: ReadContent;
     readWholeAsText: ReadWholeAsText;
     createAdjacentFileSource: CreateAdjacentFileSource;
+    preload: PreloadContent;
 };
 export {};

package/dist/readers/universal.js

@@ -35,4 +35,13 @@ exports.universalReader = {
         }
         return (0, from_node_1.nodeCreateAdjacentFileSource)(relativePath, src);
     },
+    preload: ({ src, range, logLevel, prefetchCache }) => {
+        if (src instanceof Blob) {
+            return;
+        }
+        if (src.toString().startsWith('http') ||
+            src.toString().startsWith('blob:')) {
+            return (0, from_fetch_1.fetchPreload)({ range, src, logLevel, prefetchCache });
+        }
+    },
 };

package/dist/readers/web.js

@@ -22,4 +22,10 @@ exports.webReader = {
         }
         return (0, from_fetch_1.fetchReadWholeAsText)(src);
     },
+    preload: ({ range, src, logLevel, prefetchCache }) => {
+        if (src instanceof Blob) {
+            return;
+        }
+        return (0, from_fetch_1.fetchPreload)({ range, src, logLevel, prefetchCache });
+    },
 };

package/dist/register-track.d.ts

@@ -3,14 +3,14 @@ import type { LogLevel } from './log';
 import type { MediaParserContainer } from './options';
 import type { TracksState } from './state/has-tracks-section';
 import type { ParserState } from './state/parser-state';
-import type { SampleCallbacks } from './state/sample-callbacks';
+import type { CallbacksState } from './state/sample-callbacks';
 import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
 export declare const registerVideoTrack: ({ track, container, logLevel, onVideoTrack, registerVideoSampleCallback, tracks, }: {
     track: Track;
     container: MediaParserContainer;
     logLevel: LogLevel;
     onVideoTrack: OnVideoTrack | null;
-    registerVideoSampleCallback: SampleCallbacks["registerVideoSampleCallback"];
+    registerVideoSampleCallback: CallbacksState["registerVideoSampleCallback"];
     tracks: TracksState;
 }) => Promise<import("./webcodec-sample-types").OnVideoSample | null>;
 export declare const registerAudioTrack: ({ track, container, tracks, logLevel, onAudioTrack, registerAudioSampleCallback, }: {
@@ -19,7 +19,7 @@ export declare const registerAudioTrack: ({ track, container, tracks, logLevel,
     tracks: TracksState;
     logLevel: LogLevel;
     onAudioTrack: OnAudioTrack | null;
-    registerAudioSampleCallback: SampleCallbacks["registerAudioSampleCallback"];
+    registerAudioSampleCallback: CallbacksState["registerAudioSampleCallback"];
 }) => Promise<import("./webcodec-sample-types").OnAudioSample | null>;
 export declare const registerVideoTrackWhenProfileIsAvailable: ({ state, track, container, }: {
     state: ParserState;

package/dist/seek-backwards.d.ts

@@ -1,10 +1,11 @@
 import type { MediaParserController } from './controller/media-parser-controller';
+import type { PrefetchCache } from './fetch';
 import type { BufferIterator } from './iterator/buffer-iterator';
 import type { LogLevel } from './log';
 import type { ParseMediaSrc } from './options';
 import type { ReaderInterface } from './readers/reader';
 import type { CurrentReader } from './state/current-reader';
-export declare const seekBackwards: ({ iterator, seekTo, readerInterface, src, controller, logLevel, currentReader, }: {
+export declare const seekBackwards: ({ iterator, seekTo, readerInterface, src, controller, logLevel, currentReader, prefetchCache, }: {
     iterator: BufferIterator;
     seekTo: number;
     readerInterface: ReaderInterface;
@@ -12,4 +13,5 @@ export declare const seekBackwards: ({ iterator, seekTo, readerInterface, src, c
     controller: MediaParserController;
     logLevel: LogLevel;
     currentReader: CurrentReader;
+    prefetchCache: PrefetchCache;
 }) => Promise<void>;

package/dist/seek-backwards.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.seekBackwards = void 0;
 const log_1 = require("./log");
-const seekBackwards = async ({ iterator, seekTo, readerInterface, src, controller, logLevel, currentReader, }) => {
+const seekBackwards = async ({ iterator, seekTo, readerInterface, src, controller, logLevel, currentReader, prefetchCache, }) => {
     // (a) data has not been discarded yet
     const howManyBytesWeCanGoBack = iterator.counter.getDiscardedOffset();
     if (iterator.counter.getOffset() - howManyBytesWeCanGoBack <= seekTo) {
+        log_1.Log.verbose(logLevel, `Seeking back to ${seekTo}`);
         iterator.skipTo(seekTo);
         return;
     }
@@ -16,6 +17,8 @@ const seekBackwards = async ({ iterator, seekTo, readerInterface, src, controlle
         src,
         range: seekTo,
         controller,
+        logLevel,
+        prefetchCache,
     });
     iterator.replaceData(new Uint8Array([]), seekTo);
     log_1.Log.verbose(logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);

package/dist/seek-forwards.d.ts

@@ -1,11 +1,12 @@
 import type { MediaParserController } from './controller/media-parser-controller';
+import type { PrefetchCache } from './fetch';
 import type { AllOptions, ParseMediaFields } from './fields';
 import type { BufferIterator } from './iterator/buffer-iterator';
 import type { LogLevel } from './log';
 import type { ParseMediaSrc } from './options';
 import type { ReaderInterface } from './readers/reader';
 import type { CurrentReader } from './state/current-reader';
-export declare const seekForward: ({ seekTo, userInitiated, iterator, fields, logLevel, currentReader, readerInterface, src, controller, discardReadBytes, }: {
+export declare const seekForward: ({ seekTo, userInitiated, iterator, fields, logLevel, currentReader, readerInterface, src, controller, discardReadBytes, prefetchCache, }: {
     seekTo: number;
     userInitiated: boolean;
     iterator: BufferIterator;
@@ -16,4 +17,5 @@ export declare const seekForward: ({ seekTo, userInitiated, iterator, fields, lo
     src: ParseMediaSrc;
     controller: MediaParserController;
     discardReadBytes: (force: boolean) => Promise<void>;
+    prefetchCache: PrefetchCache;
 }) => Promise<void>;

package/dist/seek-forwards.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.seekForward = void 0;
 const disallow_forward_seek_if_samples_are_needed_1 = require("./disallow-forward-seek-if-samples-are-needed");
 const log_1 = require("./log");
-const seekForward = async ({ seekTo, userInitiated, iterator, fields, logLevel, currentReader, readerInterface, src, controller, discardReadBytes, }) => {
+const seekForward = async ({ seekTo, userInitiated, iterator, fields, logLevel, currentReader, readerInterface, src, controller, discardReadBytes, prefetchCache, }) => {
     if (userInitiated) {
         (0, disallow_forward_seek_if_samples_are_needed_1.disallowForwardSeekIfSamplesAreNeeded)({
             fields,
@@ -26,6 +26,8 @@ const seekForward = async ({ seekTo, userInitiated, iterator, fields, logLevel,
         src,
         range: seekTo,
         controller,
+        logLevel,
+        prefetchCache,
     });
     iterator.skipTo(seekTo);
     await discardReadBytes(true);

package/dist/seeking-hints.d.ts

@@ -40,4 +40,7 @@ export type WebmSeekingHints = {
     loadedCues: LazyCuesLoadedOrNull;
     timestampMap: Map<number, number>;
 };
-export type SeekingHints = IsoBaseMediaSeekingHints | WavSeekingHints | TransportStreamSeekingHints | WebmSeekingHints | FlacSeekingHints | RiffSeekingHints | Mp3SeekingHints | AacSeekingHints;
+export type M3u8SeekingHints = {
+    type: 'm3u8-seeking-hints';
+};
+export type SeekingHints = IsoBaseMediaSeekingHints | WavSeekingHints | TransportStreamSeekingHints | WebmSeekingHints | FlacSeekingHints | RiffSeekingHints | Mp3SeekingHints | AacSeekingHints | M3u8SeekingHints;

package/dist/set-seeking-hints.js

@@ -42,6 +42,10 @@ const setSeekingHints = ({ hints, state, }) => {
         (0, seeking_hints_1.setSeekingHintsForAac)();
         return;
     }
+    if (hints.type === 'm3u8-seeking-hints') {
+        // TODO: Implement
+        return;
+    }
     throw new Error(`Unknown seeking hints type: ${hints}`);
 };
 exports.setSeekingHints = setSeekingHints;

package/dist/skip.d.ts

@@ -3,3 +3,8 @@ export type Skip = {
     skipTo: number;
 };
 export declare const makeSkip: (skipTo: number) => Skip;
+export type FetchMoreData = {
+    action: 'fetch-more-data';
+    bytesNeeded: number;
+};
+export declare const makeFetchMoreData: (bytesNeeded: number) => FetchMoreData;

package/dist/skip.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSkip = void 0;
+exports.makeFetchMoreData = exports.makeSkip = void 0;
 const makeSkip = (skipTo) => ({
     action: 'skip',
     skipTo,
 });
 exports.makeSkip = makeSkip;
+const makeFetchMoreData = (bytesNeeded) => ({
+    action: 'fetch-more-data',
+    bytesNeeded,
+});
+exports.makeFetchMoreData = makeFetchMoreData;

package/dist/state/can-skip-tracks.d.ts

@@ -11,6 +11,7 @@ export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, h
     fields: Options<ParseMediaFields>;
     structure: StructureState;
 }) => {
+    doFieldsNeedTracks: () => boolean;
     canSkipTracks: () => boolean;
 };
 export type CanSkipTracksState = ReturnType<typeof makeCanSkipTracksState>;

package/dist/state/can-skip-tracks.js

@@ -43,17 +43,21 @@ const needsTracksForField = ({ field, structure, }) => {
 };
 exports.needsTracksForField = needsTracksForField;
 const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }) => {
+    const doFieldsNeedTracks = () => {
+        const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});
+        const selectedKeys = keys.filter((k) => fields[k]);
+        return selectedKeys.some((k) => (0, exports.needsTracksForField)({
+            field: k,
+            structure: structure.getStructureOrNull(),
+        }));
+    };
     return {
+        doFieldsNeedTracks,
         canSkipTracks: () => {
             if (hasAudioTrackHandlers || hasVideoTrackHandlers) {
                 return false;
             }
-            const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});
-            const selectedKeys = keys.filter((k) => fields[k]);
-            return !selectedKeys.some((k) => (0, exports.needsTracksForField)({
-                field: k,
-                structure: structure.getStructureOrNull(),
-            }));
+            return !doFieldsNeedTracks();
         },
     };
 };