@remotion/media-parser 4.0.265 → 4.0.266

package/dist/parse-media.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMedia = void 0;
+const select_stream_1 = require("./containers/m3u/select-stream");
 const internal_parse_media_1 = require("./internal-parse-media");
 const from_fetch_1 = require("./readers/from-fetch");
 const parseMedia = (options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12;
     return (0, internal_parse_media_1.internalParseMedia)({
         fields: (_a = options.fields) !== null && _a !== void 0 ? _a : null,
         logLevel: (_b = options.logLevel) !== null && _b !== void 0 ? _b : 'info',
@@ -34,13 +35,15 @@ const parseMedia = (options) => {
         onSlowNumberOfFrames: (_1 = options.onSlowNumberOfFrames) !== null && _1 !== void 0 ? _1 : null,
         onSlowVideoBitrate: (_2 = options.onSlowVideoBitrate) !== null && _2 !== void 0 ? _2 : null,
         onStructure: (_3 = options.onStructure) !== null && _3 !== void 0 ? _3 : null,
-        onTracks: (_4 = options.onTracks) !== null && _4 !== void 0 ? _4 : null,
-        onUnrotatedDimensions: (_5 = options.onUnrotatedDimensions) !== null && _5 !== void 0 ? _5 : null,
-        onVideoCodec: (_6 = options.onVideoCodec) !== null && _6 !== void 0 ? _6 : null,
-        onVideoTrack: (_7 = options.onVideoTrack) !== null && _7 !== void 0 ? _7 : null,
-        progressIntervalInMs: (_8 = options.progressIntervalInMs) !== null && _8 !== void 0 ? _8 : null,
-        reader: (_9 = options.reader) !== null && _9 !== void 0 ? _9 : from_fetch_1.fetchReader,
-        controller: (_10 = options.controller) !== null && _10 !== void 0 ? _10 : undefined,
+        onM3uStreams: (_4 = options.onM3uStreams) !== null && _4 !== void 0 ? _4 : null,
+        onTracks: (_5 = options.onTracks) !== null && _5 !== void 0 ? _5 : null,
+        onUnrotatedDimensions: (_6 = options.onUnrotatedDimensions) !== null && _6 !== void 0 ? _6 : null,
+        onVideoCodec: (_7 = options.onVideoCodec) !== null && _7 !== void 0 ? _7 : null,
+        onVideoTrack: (_8 = options.onVideoTrack) !== null && _8 !== void 0 ? _8 : null,
+        progressIntervalInMs: (_9 = options.progressIntervalInMs) !== null && _9 !== void 0 ? _9 : null,
+        reader: (_10 = options.reader) !== null && _10 !== void 0 ? _10 : from_fetch_1.fetchReader,
+        controller: (_11 = options.controller) !== null && _11 !== void 0 ? _11 : undefined,
+        selectM3uStream: (_12 = options.selectM3uStream) !== null && _12 !== void 0 ? _12 : select_stream_1.defaultSelectM3uStreamFn,
         src: options.src,
         mode: 'query',
         onDiscardedData: null,

package/dist/parse-result.d.ts

@@ -1,6 +1,7 @@
 import type { AacStructure } from './containers/aac/types';
 import type { FlacStructure } from './containers/flac/types';
 import type { IsoBaseMediaBox } from './containers/iso-base-media/base-media-box';
+import type { M3uStructure } from './containers/m3u/types';
 import type { RiffBox, RiffStructure } from './containers/riff/riff-box';
 import type { TransportStreamBox } from './containers/transport-stream/boxes';
 import type { WavStructure } from './containers/wav/types';
@@ -33,6 +34,6 @@ export type Mp3Structure = {
     type: 'mp3';
     boxes: Mp3Box[];
 };
-export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure | TransportStreamStructure | Mp3Structure | AacStructure | WavStructure | FlacStructure;
+export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure | TransportStreamStructure | Mp3Structure | AacStructure | WavStructure | M3uStructure | FlacStructure;
 export type ParseResult = Skip | null;
 export {};

package/dist/readers/fetch/get-body-and-reader.d.ts

@@ -0,0 +1,8 @@
+import type { Reader } from '../reader';
+type ReturnType = {
+    reader: Reader;
+    contentLength: number | null;
+    needsContentRange: boolean;
+};
+export declare const getLengthAndReader: (endsWithM3u8: boolean, res: Response, ownController: AbortController) => Promise<ReturnType>;
+export {};

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLengthAndReader = void 0;
+const getLengthAndReader = async (endsWithM3u8, res, ownController) => {
+    if (endsWithM3u8) {
+        const text = await res.text();
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(new TextEncoder().encode(text));
+                controller.close();
+            },
+        });
+        return {
+            contentLength: text.length,
+            reader: {
+                reader: stream.getReader(),
+                abort() {
+                    ownController.abort();
+                },
+            },
+            needsContentRange: false,
+        };
+    }
+    const length = res.headers.get('content-length');
+    const contentLength = length === null ? null : parseInt(length, 10);
+    if (!res.body) {
+        throw new Error('No body');
+    }
+    const reader = res.body.getReader();
+    return {
+        reader: {
+            reader,
+            abort: () => {
+                ownController.abort();
+            },
+        },
+        contentLength,
+        needsContentRange: true,
+    };
+};
+exports.getLengthAndReader = getLengthAndReader;

package/dist/readers/fetch/resolve-url.d.ts

@@ -0,0 +1 @@
+export declare const resolveUrl: (src: string) => string | URL;

package/dist/readers/fetch/resolve-url.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUrl = void 0;
+const resolveUrl = (src) => {
+    try {
+        const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
+            ? new URL(src, window.location.origin)
+            : new URL(src);
+        return resolvedUrl;
+    }
+    catch (_a) {
+        return src;
+    }
+};
+exports.resolveUrl = resolveUrl;

package/dist/readers/from-fetch.js

@@ -5,6 +5,8 @@ exports.parseContentRange = parseContentRange;
 /* eslint-disable eqeqeq */
 /* eslint-disable no-eq-null */
 const errors_1 = require("../errors");
+const get_body_and_reader_1 = require("./fetch/get-body-and-reader");
+const resolve_url_1 = require("./fetch/resolve-url");
 /**
  * Parse Content-Range header.
  * From: https://github.com/gregberge/content-range/blob/main/src/index.ts
@@ -50,14 +52,12 @@ exports.fetchReader = {
         if (typeof src !== 'string') {
             throw new Error('src must be a string when using `fetchReader`');
         }
-        const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
-            ? new URL(src, window.location.origin).toString()
-            : src;
-        if (!resolvedUrl.startsWith('https://') &&
-            !resolvedUrl.startsWith('blob:') &&
-            !resolvedUrl.startsWith('http://')) {
-            return Promise.reject(new Error(resolvedUrl +
-                ' 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 resolvedUrl = (0, resolve_url_1.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' &&
@@ -66,14 +66,18 @@ exports.fetchReader = {
             : // Disable Next.js caching
                 'no-store';
         const actualRange = range === null ? 0 : range;
-        const res = await fetch(resolvedUrl, {
-            headers: typeof actualRange === 'number'
+        const endsWithM3u8 = (typeof resolvedUrl === 'string' ? resolvedUrl : resolvedUrl.pathname).endsWith('.m3u8');
+        const headers = actualRange === 0 && endsWithM3u8
+            ? {}
+            : typeof actualRange === 'number'
                 ? {
                     Range: `bytes=${actualRange}-`,
                 }
                 : {
                     Range: `bytes=${`${actualRange[0]}-${actualRange[1]}`}`,
-                },
+                };
+        const res = await fetch(resolvedUrl, {
+            headers,
             signal: ownController.signal,
             cache,
         });
@@ -89,49 +93,24 @@ exports.fetchReader = {
             res.status.toString().startsWith('5')) {
             throw new Error(`Server returned status code ${res.status} for ${src} and range ${actualRange}`);
         }
-        if (!res.body) {
-            throw new Error('No body');
-        }
-        const length = res.headers.get('content-length');
-        const contentLength = length === null ? null : parseInt(length, 10);
         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.split('/').pop();
-        const reader = res.body.getReader();
+        const { contentLength, needsContentRange, reader } = await (0, get_body_and_reader_1.getLengthAndReader)(endsWithM3u8, res, ownController);
         if (controller) {
             controller._internals.signal.addEventListener('abort', () => {
-                reader.cancel().catch(() => {
+                reader.reader.cancel().catch(() => {
                     // Prevent unhandled rejection in Firefox
                 });
             }, { once: true });
         }
         return {
-            reader: {
-                reader,
-                abort: () => {
-                    ownController.abort();
-                },
-            },
+            reader,
             contentLength,
             contentType: res.headers.get('content-type'),
             name: name !== null && name !== void 0 ? name : fallbackName,
             supportsContentRange,
+            needsContentRange,
         };
     },
-    getLength: async (src) => {
-        if (typeof src !== 'string') {
-            throw new Error('src must be a string when using `fetchReader`');
-        }
-        const res = await fetch(src, {
-            method: 'HEAD',
-        });
-        if (!res.body) {
-            throw new Error('No body');
-        }
-        const length = res.headers.get('content-length');
-        if (!length) {
-            throw new Error('No content-length');
-        }
-        return parseInt(length, 10);
-    },
 };

package/dist/readers/from-node.js

@@ -40,13 +40,7 @@ exports.nodeReader = {
             contentType: null,
             name: src.split(path_1.sep).pop(),
             supportsContentRange: true,
+            needsContentRange: true,
         });
     },
-    getLength: (src) => {
-        if (typeof src !== 'string') {
-            throw new Error('src must be a string when using `nodeReader`');
-        }
-        const stats = (0, fs_1.statSync)(src);
-        return Promise.resolve(stats.size);
-    },
 };

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

@@ -0,0 +1,2 @@
+import { ReaderInterface } from "./reader";
+export declare const uintArrayReader: ReaderInterface;

package/dist/readers/from-uintarray.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uintArrayReader = void 0;
+exports.uintArrayReader = {
+    read: ({ src, range, controller }) => {
+        if (!(src instanceof Uint8Array)) {
+            throw new Error('`uintArrayReader` only supports `Uint8Array` objects');
+        }
+        const part = range === null
+            ? src
+            : typeof range === 'number'
+                ? src.slice(range)
+                : src.slice(range[0], range[1]);
+        return Promise.resolve({
+            reader: {
+                reader: part.(),
+                abort() {
+                    // no-op
+                },
+            },
+            contentLength: src.length,
+            contentType: 'application/octet-stream',
+            name: 'uintArray',
+            supportsContentRange: true,
+        });
+    }
+};

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

@@ -40,6 +40,7 @@ exports.webFileReader = {
                     name: src.name,
                     supportsContentRange: true,
                     contentType: src.type,
+                    needsContentRange: true,
                 });
             };
             reader.onerror = (error) => {
@@ -47,10 +48,4 @@ exports.webFileReader = {
             };
         });
     },
-    getLength: (src) => {
-        if (typeof src === 'string') {
-            throw new Error('`inputTypeFileReader` only supports `File` objects');
-        }
-        return Promise.resolve(src.size);
-    },
 };

package/dist/readers/reader.d.ts

@@ -10,15 +10,14 @@ type ReadResult = {
     contentType: string | null;
     name: string;
     supportsContentRange: boolean;
+    needsContentRange: boolean;
 };
 type ReadContent = (options: {
     src: ParseMediaSrc;
     range: [number, number] | number | null;
     controller: MediaParserController;
 }) => Promise<ReadResult>;
-type GetLength = (src: ParseMediaSrc) => Promise<number>;
 export type ReaderInterface = {
     read: ReadContent;
-    getLength: GetLength;
 };
 export {};

package/dist/register-track.d.ts

@@ -1,11 +1,16 @@
-import type { Track, VideoTrack } from './get-tracks';
+import type { AudioTrack, Track, VideoTrack } from './get-tracks';
 import type { MediaParserContainer } from './options';
 import type { ParserState } from './state/parser-state';
-export declare const registerTrack: ({ state, track, container, }: {
+export declare const registerVideoTrack: ({ state, track, container, }: {
     state: ParserState;
     track: Track;
     container: MediaParserContainer;
-}) => Promise<void>;
+}) => Promise<import("./webcodec-sample-types").OnVideoSample | null>;
+export declare const registerAudioTrack: ({ state, track, container, }: {
+    state: ParserState;
+    track: AudioTrack;
+    container: MediaParserContainer;
+}) => Promise<import("./webcodec-sample-types").OnAudioSample | null>;
 export declare const registerVideoTrackWhenProfileIsAvailable: ({ state, track, container, }: {
     state: ParserState;
     track: VideoTrack;

package/dist/register-track.js

@@ -1,32 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerVideoTrackWhenProfileIsAvailable = exports.registerTrack = void 0;
+exports.registerVideoTrackWhenProfileIsAvailable = exports.registerAudioTrack = exports.registerVideoTrack = void 0;
 const add_avc_profile_to_track_1 = require("./add-avc-profile-to-track");
 const log_1 = require("./log");
-const registerTrack = async ({ state, track, container, }) => {
+const registerVideoTrack = async ({ state, track, container, }) => {
     if (state.callbacks.tracks.getTracks().find((t) => t.trackId === track.trackId)) {
         log_1.Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
-        return;
+        return null;
     }
-    if (track.type === 'video') {
-        state.callbacks.tracks.addTrack(track);
-        if (state.onVideoTrack) {
-            const callback = await state.onVideoTrack({ track, container });
-            await state.callbacks.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
-        }
+    if (track.type !== 'video') {
+        throw new Error('Expected video track');
     }
-    if (track.type === 'audio') {
-        state.callbacks.tracks.addTrack(track);
-        if (state.onAudioTrack) {
-            const callback = await state.onAudioTrack({ track, container });
-            await state.callbacks.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
-        }
+    state.callbacks.tracks.addTrack(track);
+    if (!state.onVideoTrack) {
+        return null;
     }
+    const callback = await state.onVideoTrack({ track, container });
+    await state.callbacks.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    return callback;
 };
-exports.registerTrack = registerTrack;
+exports.registerVideoTrack = registerVideoTrack;
+const registerAudioTrack = async ({ state, track, container, }) => {
+    if (state.callbacks.tracks.getTracks().find((t) => t.trackId === track.trackId)) {
+        log_1.Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
+        return null;
+    }
+    if (track.type !== 'audio') {
+        throw new Error('Expected audio track');
+    }
+    state.callbacks.tracks.addTrack(track);
+    if (!state.onAudioTrack) {
+        return null;
+    }
+    const callback = await state.onAudioTrack({ track, container });
+    await state.callbacks.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    return callback;
+};
+exports.registerAudioTrack = registerAudioTrack;
 const registerVideoTrackWhenProfileIsAvailable = ({ state, track, container, }) => {
     state.riff.registerOnAvcProfileCallback(async (profile) => {
-        await (0, exports.registerTrack)({
+        await (0, exports.registerVideoTrack)({
             state,
             track: (0, add_avc_profile_to_track_1.addAvcProfileToTrack)(track, profile),
             container,

package/dist/run-parse-iteration.js

@@ -4,6 +4,7 @@ exports.runParseIteration = void 0;
 const parse_aac_1 = require("./containers/aac/parse-aac");
 const parse_flac_1 = require("./containers/flac/parse-flac");
 const parse_boxes_1 = require("./containers/iso-base-media/parse-boxes");
+const parse_m3u_1 = require("./containers/m3u/parse-m3u");
 const parse_mp3_1 = require("./containers/mp3/parse-mp3");
 const parse_riff_1 = require("./containers/riff/parse-riff");
 const parse_transport_stream_1 = require("./containers/transport-stream/parse-transport-stream");
@@ -11,10 +12,14 @@ const parse_wav_1 = require("./containers/wav/parse-wav");
 const parse_webm_header_1 = require("./containers/webm/parse-webm-header");
 const init_video_1 = require("./init-video");
 const runParseIteration = async ({ state, mimeType, contentLength, name, }) => {
+    const structure = state.getStructureOrNull();
+    // m3u8 is busy parsing the chunks once the manifest has been read
+    if (structure && structure.type === 'm3u') {
+        return (0, parse_m3u_1.parseM3u)({ state });
+    }
     if (state.iterator.bytesRemaining() === 0) {
         return Promise.reject(new Error('no bytes'));
     }
-    const structure = state.getStructureOrNull();
     if (structure === null) {
         await (0, init_video_1.initVideo)({ state, mimeType, name, contentLength });
         return null;

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

@@ -28,7 +28,8 @@ const needsTracksForField = ({ field, structure, }) => {
         field === 'sampleRate' ||
         field === 'numberOfAudioChannels' ||
         field === 'slowAudioBitrate' ||
-        field === 'slowVideoBitrate') {
+        field === 'slowVideoBitrate' ||
+        field === 'm3uStreams') {
         return true;
     }
     if (field === 'container' ||

package/dist/state/emitted-fields.js

@@ -30,6 +30,7 @@ const emittedState = () => {
         sampleRate: false,
         slowAudioBitrate: false,
         slowVideoBitrate: false,
+        m3uStreams: false,
     };
     return emittedFields;
 };

package/dist/state/m3u-state.d.ts

@@ -0,0 +1,29 @@
+import type { M3uStream } from '../containers/m3u/get-streams';
+import type { OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
+type M3uStreamOrInitialUrl = {
+    type: 'selected-stream';
+    stream: M3uStream;
+} | {
+    type: 'initial-url';
+    url: string;
+};
+export declare const m3uState: () => {
+    setSelectedStream: (stream: M3uStreamOrInitialUrl) => void;
+    getSelectedStream: () => M3uStreamOrInitialUrl | null;
+    setHasEmittedVideoTrack: (callback: OnVideoSample | null) => void;
+    hasEmittedVideoTrack: () => false | OnVideoSample | null;
+    setHasEmittedAudioTrack: (callback: OnAudioSample | null) => void;
+    hasEmittedAudioTrack: () => false | OnAudioSample | null;
+    setHasEmittedDoneWithTracks: () => void;
+    hasEmittedDoneWithTracks: () => boolean;
+    setReadyToIterateOverM3u: () => void;
+    isReadyToIterateOverM3u: () => boolean;
+    setLastChunkProcessed: (chunk: number) => void;
+    getLastChunkProcessed: () => number;
+    getAllChunksProcessed: () => boolean;
+    setAllChunksProcessed: () => void;
+    setHasFinishedManifest: () => void;
+    hasFinishedManifest: () => boolean;
+};
+export type M3uState = ReturnType<typeof m3uState>;
+export {};

package/dist/state/m3u-state.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.m3uState = void 0;
+const m3uState = () => {
+    let selectedStream = null;
+    let hasEmittedVideoTrack = false;
+    let hasEmittedAudioTrack = false;
+    let hasEmittedDoneWithTracks = false;
+    let hasFinishedManifest = false;
+    let readyToIterateOverM3u = false;
+    let lastChunkProcessed = -1;
+    let allChunksProcessed = false;
+    return {
+        setSelectedStream: (stream) => {
+            selectedStream = stream;
+        },
+        getSelectedStream: () => selectedStream,
+        setHasEmittedVideoTrack: (callback) => {
+            hasEmittedVideoTrack = callback;
+        },
+        hasEmittedVideoTrack: () => hasEmittedVideoTrack,
+        setHasEmittedAudioTrack: (callback) => {
+            hasEmittedAudioTrack = callback;
+        },
+        hasEmittedAudioTrack: () => hasEmittedAudioTrack,
+        setHasEmittedDoneWithTracks: () => {
+            hasEmittedDoneWithTracks = true;
+        },
+        hasEmittedDoneWithTracks: () => hasEmittedDoneWithTracks,
+        setReadyToIterateOverM3u: () => {
+            readyToIterateOverM3u = true;
+        },
+        isReadyToIterateOverM3u: () => readyToIterateOverM3u,
+        setLastChunkProcessed: (chunk) => {
+            lastChunkProcessed = chunk;
+        },
+        getLastChunkProcessed: () => lastChunkProcessed,
+        getAllChunksProcessed: () => allChunksProcessed,
+        setAllChunksProcessed: () => {
+            allChunksProcessed = true;
+        },
+        setHasFinishedManifest: () => {
+            hasFinishedManifest = true;
+        },
+        hasFinishedManifest: () => hasFinishedManifest,
+    };
+};
+exports.m3uState = m3uState;

package/dist/state/need-samples-for-fields.js

@@ -29,6 +29,7 @@ const needsSamples = {
     sampleRate: false,
     slowAudioBitrate: true,
     slowVideoBitrate: true,
+    m3uStreams: false,
 };
 const needsToIterateOverSamples = ({ fields, emittedFields, }) => {
     const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});

package/dist/state/parser-state.d.ts

@@ -1,5 +1,6 @@
 import { type BufferIterator } from '../buffer-iterator';
 import type { AvcPPs, AvcProfileInfo } from '../containers/avc/parse-avc';
+import type { SelectM3uStreamFn } from '../containers/m3u/select-stream';
 import { type LogLevel } from '../log';
 import type { MediaParserController } from '../media-parser-controller';
 import type { OnDiscardedData, Options, ParseMediaFields, ParseMediaMode, ParseMediaSrc } from '../options';
@@ -13,7 +14,7 @@ export type SpsAndPps = {
     sps: AvcProfileInfo;
     pps: AvcPPs;
 };
-export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, }: {
+export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     controller: MediaParserController;
@@ -26,6 +27,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     src: ParseMediaSrc;
     readerInterface: ReaderInterface;
     onDiscardedData: OnDiscardedData | null;
+    selectM3uStreamFn: SelectM3uStreamFn;
 }) => {
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
@@ -117,6 +119,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
             returnToCheckpoint: () => void;
         };
         getFlacCodecNumber: () => number;
+        readUntilLineEnd: () => string | null;
         getSyncSafeInt32: () => number;
     };
     controller: MediaParserController;
@@ -127,12 +130,14 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     src: ParseMediaSrc;
     readerInterface: ReaderInterface;
     discardReadBytes: (force: boolean) => Promise<void>;
+    selectM3uStreamFn: SelectM3uStreamFn;
     getStructureOrNull: () => import("../parse-result").Structure | null;
     getStructure: () => import("../parse-result").Structure;
     setStructure: (value: import("../parse-result").Structure) => void;
     getFlacStructure: () => import("../containers/flac/types").FlacStructure;
     getIsoStructure: () => import("../parse-result").IsoBaseMediaStructure;
     getMp3Structure: () => import("../parse-result").Mp3Structure;
+    getM3uStructure: () => import("../containers/m3u/types").M3uStructure;
     getRiffStructure: () => import("../containers/riff/riff-box").RiffStructure;
     getTsStructure: () => import("../parse-result").TransportStreamStructure;
     getWavStructure: () => import("../containers/wav/types").WavStructure;
@@ -197,6 +202,36 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         setBlockingBitStrategy: (strategy: number) => void;
         getBlockingBitStrategy: () => number | undefined;
     };
+    m3u: {
+        setSelectedStream: (stream: {
+            type: "selected-stream";
+            stream: import("../containers/m3u/get-streams").M3uStream;
+        } | {
+            type: "initial-url";
+            url: string;
+        }) => void;
+        getSelectedStream: () => ({
+            type: "selected-stream";
+            stream: import("../containers/m3u/get-streams").M3uStream;
+        } | {
+            type: "initial-url";
+            url: string;
+        }) | null;
+        setHasEmittedVideoTrack: (callback: import("../webcodec-sample-types").OnVideoSample | null) => void;
+        hasEmittedVideoTrack: () => false | import("../webcodec-sample-types").OnVideoSample | null;
+        setHasEmittedAudioTrack: (callback: import("../webcodec-sample-types").OnAudioSample | null) => void;
+        hasEmittedAudioTrack: () => false | import("../webcodec-sample-types").OnAudioSample | null;
+        setHasEmittedDoneWithTracks: () => void;
+        hasEmittedDoneWithTracks: () => boolean;
+        setReadyToIterateOverM3u: () => void;
+        isReadyToIterateOverM3u: () => boolean;
+        setLastChunkProcessed: (chunk: number) => void;
+        getLastChunkProcessed: () => number;
+        getAllChunksProcessed: () => boolean;
+        setAllChunksProcessed: () => void;
+        setHasFinishedManifest: () => void;
+        hasFinishedManifest: () => boolean;
+    };
     callbacks: {
         registerVideoSampleCallback: (id: number, callback: import("../webcodec-sample-types").OnVideoSample | null) => Promise<void>;
         onAudioSample: (trackId: number, audioSample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;

package/dist/state/parser-state.js

@@ -10,6 +10,7 @@ const images_1 = require("./images");
 const iso_state_1 = require("./iso-base-media/iso-state");
 const keyframes_1 = require("./keyframes");
 const last_eventloop_break_1 = require("./last-eventloop-break");
+const m3u_state_1 = require("./m3u-state");
 const mp3_1 = require("./mp3");
 const riff_1 = require("./riff");
 const sample_callbacks_1 = require("./sample-callbacks");
@@ -18,7 +19,7 @@ const structure_1 = require("./structure");
 const transport_stream_1 = require("./transport-stream");
 const video_section_1 = require("./video-section");
 const webm_1 = require("./webm");
-const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, }) => {
+const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, }) => {
     let skippedBytes = 0;
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), contentLength);
     const increaseSkippedBytes = (bytes) => {
@@ -47,6 +48,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         mp3Info,
         aac: (0, aac_state_1.aacState)(),
         flac: (0, flac_state_1.flacState)(),
+        m3u: (0, m3u_state_1.m3uState)(),
         callbacks: (0, sample_callbacks_1.sampleCallback)({
             controller,
             hasAudioTrackHandlers,
@@ -84,6 +86,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         src,
         readerInterface,
         discardReadBytes,
+        selectM3uStreamFn,
     };
 };
 exports.makeParserState = makeParserState;