@remotion/media-parser 4.0.268 → 4.0.270

package/dist/containers/flac/get-channel-count.d.ts

@@ -1,2 +1,2 @@
 import type { BufferIterator } from '../../buffer-iterator';
-export declare const getChannelCount: (iterator: BufferIterator) => 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export declare const getChannelCount: (iterator: BufferIterator) => 2 | 8 | 1 | 7 | 3 | 4 | 5 | 6;

package/dist/containers/iso-base-media/get-moov-atom.js

@@ -39,6 +39,7 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
         src: state.src,
         onDiscardedData: null,
         selectM3uStreamFn: state.selectM3uStreamFn,
+        selectM3uAssociatedPlaylistsFn: state.selectM3uAssociatedPlaylistsFn,
     });
     while (true) {
         const result = await reader.reader.read();

package/dist/containers/m3u/after-manifest-fetch.d.ts

@@ -1,14 +1,12 @@
+import type { LogLevel } from '../../log';
 import type { M3uState } from '../../state/m3u-state';
-import type { ParserState } from '../../state/parser-state';
-import type { SelectM3uStreamFn } from './select-stream';
+import type { SelectM3uAssociatedPlaylistsFn, SelectM3uStreamFn } from './select-stream';
 import type { M3uStructure } from './types';
-export declare const afterManifestFetch: ({ structure, m3uState, src, selectM3uStreamFn, }: {
+export declare const afterManifestFetch: ({ structure, m3uState, src, selectM3uStreamFn, logLevel, selectAssociatedPlaylists: selectAssociatedPlaylistsFn, }: {
     structure: M3uStructure;
     m3uState: M3uState;
     src: string | null;
     selectM3uStreamFn: SelectM3uStreamFn;
-}) => Promise<void>;
-export declare const runOverM3u: ({ state, structure, }: {
-    state: ParserState;
-    structure: M3uStructure;
+    selectAssociatedPlaylists: SelectM3uAssociatedPlaylistsFn;
+    logLevel: LogLevel;
 }) => Promise<void>;

package/dist/containers/m3u/after-manifest-fetch.js

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runOverM3u = exports.afterManifestFetch = void 0;
-const register_track_1 = require("../../register-track");
+exports.afterManifestFetch = void 0;
+const log_1 = require("../../log");
 const fetch_m3u8_stream_1 = require("./fetch-m3u8-stream");
 const get_streams_1 = require("./get-streams");
-const return_packets_1 = require("./return-packets");
 const select_stream_1 = require("./select-stream");
-const afterManifestFetch = async ({ structure, m3uState, src, selectM3uStreamFn, }) => {
+const afterManifestFetch = async ({ structure, m3uState, src, selectM3uStreamFn, logLevel, selectAssociatedPlaylists: selectAssociatedPlaylistsFn, }) => {
     const independentSegments = (0, get_streams_1.isIndependentSegments)(structure);
     if (!independentSegments) {
         if (!src) {
             throw new Error('No src');
         }
-        m3uState.setSelectedStream({
+        m3uState.setSelectedMainPlaylist({
             type: 'initial-url',
             url: src,
         });
@@ -22,46 +21,33 @@ const afterManifestFetch = async ({ structure, m3uState, src, selectM3uStreamFn,
     if (streams === null) {
         throw new Error('No streams found');
     }
-    const selectedStream = await (0, select_stream_1.selectStream)({ streams, fn: selectM3uStreamFn });
-    m3uState.setSelectedStream({ type: 'selected-stream', stream: selectedStream });
-    if (!selectedStream.resolution) {
+    const selectedPlaylist = await (0, select_stream_1.selectStream)({ streams, fn: selectM3uStreamFn });
+    if (!selectedPlaylist.resolution) {
         throw new Error('Stream does not have a resolution');
     }
-    const boxes = await (0, fetch_m3u8_stream_1.fetchM3u8Stream)(selectedStream);
-    structure.boxes.push({ type: 'm3u-playlist', boxes });
+    m3uState.setSelectedMainPlaylist({
+        type: 'selected-stream',
+        stream: selectedPlaylist,
+    });
+    const associatedPlaylists = await (0, select_stream_1.selectAssociatedPlaylists)({
+        playlists: selectedPlaylist.associatedPlaylists,
+        fn: selectAssociatedPlaylistsFn,
+    });
+    m3uState.setAssociatedPlaylists(associatedPlaylists);
+    const playlistUrls = [
+        selectedPlaylist.url,
+        ...associatedPlaylists.map((p) => p.url),
+    ];
+    const struc = await Promise.all(playlistUrls.map(async (url) => {
+        log_1.Log.verbose(logLevel, `Fetching playlist ${url}`);
+        const boxes = await (0, fetch_m3u8_stream_1.fetchM3u8Stream)(url);
+        return {
+            type: 'm3u-playlist',
+            boxes,
+            src: url,
+        };
+    }));
+    structure.boxes.push(...struc);
     m3uState.setReadyToIterateOverM3u();
 };
 exports.afterManifestFetch = afterManifestFetch;
-const runOverM3u = async ({ state, structure, }) => {
-    const selectedStream = state.m3u.getSelectedStream();
-    if (!selectedStream) {
-        throw new Error('No stream selected');
-    }
-    await (0, return_packets_1.iteratorOverTsFiles)({
-        playlistUrl: selectedStream.type === 'initial-url'
-            ? selectedStream.url
-            : selectedStream.stream.url,
-        structure,
-        logLevel: state.logLevel,
-        onDoneWithTracks() {
-            state.callbacks.tracks.setIsDone(state.logLevel);
-        },
-        onAudioTrack: (track) => {
-            return (0, register_track_1.registerAudioTrack)({
-                container: 'm3u8',
-                state,
-                track,
-            });
-        },
-        onVideoTrack: (track) => {
-            return (0, register_track_1.registerVideoTrack)({
-                container: 'm3u8',
-                state,
-                track,
-            });
-        },
-        m3uState: state.m3u,
-        parentController: state.controller,
-    });
-};
-exports.runOverM3u = runOverM3u;

package/dist/containers/m3u/fetch-m3u8-stream.d.ts

@@ -1,3 +1,2 @@
-import type { M3uStream } from './get-streams';
 import type { M3uBox } from './types';
-export declare const fetchM3u8Stream: (stream: M3uStream) => Promise<M3uBox[]>;
+export declare const fetchM3u8Stream: (url: string) => Promise<M3uBox[]>;

package/dist/containers/m3u/fetch-m3u8-stream.js

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchM3u8Stream = void 0;
 const parse_m3u8_text_1 = require("./parse-m3u8-text");
-const fetchM3u8Stream = async (stream) => {
-    const res = await fetch(stream.url);
+const fetchM3u8Stream = async (url) => {
+    const res = await fetch(url);
     if (!res.ok) {
-        throw new Error(`Failed to fetch ${stream.url} (HTTP code: ${res.status})`);
+        throw new Error(`Failed to fetch ${url} (HTTP code: ${res.status})`);
     }
     const text = await res.text();
     const lines = text.split('\n');
     const boxes = [];
     for (const line of lines) {
-        (0, parse_m3u8_text_1.parseM3u8Text)(line, boxes);
+        (0, parse_m3u8_text_1.parseM3u8Text)(line.trim(), boxes);
     }
     return boxes;
 };

package/dist/containers/m3u/get-duration-from-m3u.d.ts

@@ -1,2 +1,2 @@
-import type { M3uStructure } from './types';
-export declare const getDurationFromM3u: (structure: M3uStructure) => number | null;
+import type { ParserState } from '../../state/parser-state';
+export declare const getDurationFromM3u: (state: ParserState) => number | null;

package/dist/containers/m3u/get-duration-from-m3u.js

@@ -2,8 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDurationFromM3u = void 0;
 const get_playlist_1 = require("./get-playlist");
-const getDurationFromM3u = (structure) => {
-    const playlist = (0, get_playlist_1.getPlaylist)(structure);
-    return (0, get_playlist_1.getDurationFromPlaylist)(playlist);
+const getDurationFromM3u = (state) => {
+    const playlists = (0, get_playlist_1.getAllPlaylists)({
+        structure: state.getM3uStructure(),
+        src: state.src,
+    });
+    return Math.max(...playlists.map((p) => {
+        return (0, get_playlist_1.getDurationFromPlaylist)(p);
+    }));
 };
 exports.getDurationFromM3u = getDurationFromM3u;

package/dist/containers/m3u/get-playlist.d.ts

@@ -1,3 +1,8 @@
+import type { ParseMediaSrc } from '../../options';
 import type { M3uPlaylist, M3uStructure } from './types';
-export declare const getPlaylist: (structure: M3uStructure) => M3uPlaylist;
+export declare const getAllPlaylists: ({ structure, src, }: {
+    structure: M3uStructure;
+    src: ParseMediaSrc;
+}) => M3uPlaylist[];
+export declare const getPlaylist: (structure: M3uStructure, src: string) => M3uPlaylist;
 export declare const getDurationFromPlaylist: (playlist: M3uPlaylist) => number;

package/dist/containers/m3u/get-playlist.js

@@ -1,20 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDurationFromPlaylist = exports.getPlaylist = void 0;
+exports.getDurationFromPlaylist = exports.getPlaylist = exports.getAllPlaylists = void 0;
 const get_streams_1 = require("./get-streams");
-const getPlaylist = (structure) => {
+const getAllPlaylists = ({ structure, src, }) => {
     const isIndependent = (0, get_streams_1.isIndependentSegments)(structure);
     if (!isIndependent) {
-        return {
-            type: 'm3u-playlist',
-            boxes: structure.boxes,
-        };
+        return [
+            {
+                type: 'm3u-playlist',
+                boxes: structure.boxes,
+                src,
+            },
+        ];
     }
     const playlists = structure.boxes.filter((box) => box.type === 'm3u-playlist');
-    if (playlists.length !== 1) {
-        throw new Error('Expected one playlist');
+    return playlists;
+};
+exports.getAllPlaylists = getAllPlaylists;
+const getPlaylist = (structure, src) => {
+    const allPlaylists = (0, exports.getAllPlaylists)({ structure, src });
+    const playlists = allPlaylists.find((box) => box.src === src);
+    if (!playlists) {
+        throw new Error(`Expected m3u-playlist with src ${src}`);
     }
-    return playlists[0];
+    return playlists;
 };
 exports.getPlaylist = getPlaylist;
 const getDurationFromPlaylist = (playlist) => {

package/dist/containers/m3u/get-streams.d.ts

@@ -1,7 +1,7 @@
 import type { Dimensions } from '../../get-dimensions';
 import type { Structure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
-export type M3uStreamAudioTrack = {
+export type M3uAssociatedPlaylist = {
     groupId: string;
     language: string | null;
     name: string | null;
@@ -9,6 +9,7 @@ export type M3uStreamAudioTrack = {
     default: boolean;
     channels: number | null;
     url: string;
+    id: number;
 };
 export type M3uStream = {
     url: string;
@@ -17,7 +18,7 @@ export type M3uStream = {
     resolution: Dimensions | null;
     codecs: string[] | null;
     id: number;
-    dedicatedAudioTracks: M3uStreamAudioTrack[];
+    associatedPlaylists: M3uAssociatedPlaylist[];
 };
 export declare const isIndependentSegments: (structure: Structure | null) => boolean;
 export declare const getM3uStreams: (structure: Structure | null, originalSrc: string | null) => M3uStream[] | null;

package/dist/containers/m3u/get-streams.js

@@ -20,13 +20,13 @@ const getM3uStreams = (structure, originalSrc) => {
             if (next.type !== 'm3u-text-value') {
                 throw new Error('Expected m3u-text-value');
             }
-            const dedicatedAudioTracks = [];
+            const associatedPlaylists = [];
             if (str.audio) {
                 const match = structure.boxes.filter((box) => {
                     return box.type === 'm3u-media-info' && box.groupId === str.audio;
                 });
                 for (const audioTrack of match) {
-                    dedicatedAudioTracks.push({
+                    associatedPlaylists.push({
                         autoselect: audioTrack.autoselect,
                         channels: audioTrack.channels,
                         default: audioTrack.default,
@@ -36,6 +36,7 @@ const getM3uStreams = (structure, originalSrc) => {
                         url: originalSrc && originalSrc.startsWith('http')
                             ? new URL(audioTrack.uri, originalSrc).href
                             : audioTrack.uri,
+                        id: associatedPlaylists.length,
                     });
                 }
             }
@@ -47,7 +48,7 @@ const getM3uStreams = (structure, originalSrc) => {
                 bandwidth: str.bandwidth,
                 codecs: str.codecs,
                 resolution: str.resolution,
-                dedicatedAudioTracks,
+                associatedPlaylists,
             });
         }
     }
@@ -56,12 +57,18 @@ const getM3uStreams = (structure, originalSrc) => {
         return null;
     }
     const sorted = boxes.slice().sort((a, b) => {
+        var _a, _b, _c, _d;
         const aResolution = a.resolution
             ? a.resolution.width * a.resolution.height
             : 0;
         const bResolution = b.resolution
             ? b.resolution.width * b.resolution.height
             : 0;
+        if (aResolution === bResolution) {
+            const bandwidthA = (_b = (_a = a.averageBandwidth) !== null && _a !== void 0 ? _a : a.bandwidth) !== null && _b !== void 0 ? _b : 0;
+            const bandwidthB = (_d = (_c = b.averageBandwidth) !== null && _c !== void 0 ? _c : b.bandwidth) !== null && _d !== void 0 ? _d : 0;
+            return bandwidthB - bandwidthA;
+        }
         return bResolution - aResolution;
     });
     return sorted.map((box, index) => ({ ...box, id: index }));

package/dist/containers/m3u/m3u-child-stream.js

@@ -0,0 +1 @@
+"use strict";

package/dist/containers/m3u/parse-directive.js

@@ -5,7 +5,7 @@ const parse_m3u_media_directive_1 = require("./parse-m3u-media-directive");
 const parse_stream_inf_1 = require("./parse-stream-inf");
 const parseM3uDirective = (str) => {
     const firstColon = str.indexOf(':');
-    const directive = firstColon === -1 ? str : str.slice(0, firstColon);
+    const directive = (firstColon === -1 ? str : str.slice(0, firstColon)).trim();
     const value = firstColon === -1 ? null : str.slice(firstColon + 1);
     if (directive === '#EXT-X-VERSION') {
         if (!value) {
@@ -60,6 +60,24 @@ const parseM3uDirective = (str) => {
             playlistType: value,
         };
     }
+    if (directive === '#EXT-X-MEDIA-SEQUENCE') {
+        if (!value) {
+            throw new Error('#EXT-X-MEDIA-SEQUENCE directive must have a value');
+        }
+        return {
+            type: 'm3u-media-sequence',
+            value: Number(value),
+        };
+    }
+    if (directive === '#EXT-X-DISCONTINUITY-SEQUENCE') {
+        if (!value) {
+            throw new Error('#EXT-X-DISCONTINUITY-SEQUENCE directive must have a value');
+        }
+        return {
+            type: 'm3u-discontinuity-sequence',
+            value: Number(value),
+        };
+    }
     if (directive === '#EXT-X-STREAM-INF') {
         if (!value) {
             throw new Error('EXT-X-STREAM-INF directive must have a value');
@@ -67,6 +85,15 @@ const parseM3uDirective = (str) => {
         const res = (0, parse_stream_inf_1.parseStreamInf)(value);
         return res;
     }
+    if (directive === '#EXT-X-MAP') {
+        if (!value) {
+            throw new Error('#EXT-X-MAP directive must have a value');
+        }
+        return {
+            type: 'm3u-map',
+            value: Number(value),
+        };
+    }
     throw new Error(`Unknown directive ${directive}. Value: ${value}`);
 };
 exports.parseM3uDirective = parseM3uDirective;

package/dist/containers/m3u/parse-m3u-manifest.js

@@ -12,7 +12,7 @@ const parseM3uManifest = ({ iterator, structure, contentLength, }) => {
         start.returnToCheckpoint();
         return Promise.resolve(null);
     }
-    (0, parse_m3u8_text_1.parseM3u8Text)(line, structure.boxes);
+    (0, parse_m3u8_text_1.parseM3u8Text)(line.trim(), structure.boxes);
     return Promise.resolve(null);
 };
 exports.parseM3uManifest = parseM3uManifest;

package/dist/containers/m3u/parse-m3u.js

@@ -3,12 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseM3u = void 0;
 const after_manifest_fetch_1 = require("./after-manifest-fetch");
 const parse_m3u_manifest_1 = require("./parse-m3u-manifest");
+const run_over_m3u_1 = require("./run-over-m3u");
 const parseM3u = async ({ state }) => {
     const structure = state.getM3uStructure();
     if (state.m3u.isReadyToIterateOverM3u()) {
-        await (0, after_manifest_fetch_1.runOverM3u)({
+        const selectedPlaylists = state.m3u.getSelectedPlaylists();
+        const whichPlaylistToRunOver = state.m3u.sampleSorter.getNextStreamToRun(selectedPlaylists);
+        await (0, run_over_m3u_1.runOverM3u)({
             state,
             structure,
+            playlistUrl: whichPlaylistToRunOver,
+            logLevel: state.logLevel,
         });
         return null;
     }
@@ -18,6 +23,8 @@ const parseM3u = async ({ state }) => {
             m3uState: state.m3u,
             src: typeof state.src === 'string' ? state.src : null,
             selectM3uStreamFn: state.selectM3uStreamFn,
+            logLevel: state.logLevel,
+            selectAssociatedPlaylists: state.selectM3uAssociatedPlaylistsFn,
         });
         return null;
     }

package/dist/containers/m3u/return-packets.d.ts

@@ -1,10 +1,10 @@
 import type { AudioTrack, VideoTrack } from '../../get-tracks';
 import type { LogLevel } from '../../log';
 import type { MediaParserController } from '../../media-parser-controller';
-import type { M3uState } from '../../state/m3u-state';
+import type { ExistingM3uRun, M3uState } from '../../state/m3u-state';
 import type { OnAudioSample, OnVideoSample } from '../../webcodec-sample-types';
 import type { M3uStructure } from './types';
-export declare const iteratorOverTsFiles: ({ structure, onVideoTrack, m3uState, onAudioTrack, onDoneWithTracks, playlistUrl, logLevel, parentController, }: {
+export declare const iteratorOverTsFiles: ({ structure, onVideoTrack, m3uState, onAudioTrack, onDoneWithTracks, playlistUrl, logLevel, parentController, onInitialProgress, }: {
     structure: M3uStructure;
     onVideoTrack: (track: VideoTrack) => Promise<OnVideoSample | null>;
     onAudioTrack: (track: AudioTrack) => Promise<OnAudioSample | null>;
@@ -13,4 +13,5 @@ export declare const iteratorOverTsFiles: ({ structure, onVideoTrack, m3uState,
     playlistUrl: string;
     logLevel: LogLevel;
     parentController: MediaParserController;
+    onInitialProgress: (run: ExistingM3uRun | null) => void;
 }) => Promise<void>;

package/dist/containers/m3u/return-packets.js

@@ -6,66 +6,95 @@ const media_parser_controller_1 = require("../../media-parser-controller");
 const parse_media_1 = require("../../parse-media");
 const get_chunks_1 = require("./get-chunks");
 const get_playlist_1 = require("./get-playlist");
-const iteratorOverTsFiles = async ({ structure, onVideoTrack, m3uState, onAudioTrack, onDoneWithTracks, playlistUrl, logLevel, parentController, }) => {
-    const playlist = (0, get_playlist_1.getPlaylist)(structure);
+const iteratorOverTsFiles = async ({ structure, onVideoTrack, m3uState, onAudioTrack, onDoneWithTracks, playlistUrl, logLevel, parentController, onInitialProgress, }) => {
+    const playlist = (0, get_playlist_1.getPlaylist)(structure, playlistUrl);
     const chunks = (0, get_chunks_1.getChunks)(playlist);
-    const lastChunkProcessed = m3uState.getLastChunkProcessed();
-    const chunkIndex = lastChunkProcessed + 1;
-    const chunk = chunks[chunkIndex];
-    const isLastChunk = chunkIndex === chunks.length - 1;
-    const src = new URL(chunk.url, playlistUrl).toString();
+    let resolver = onInitialProgress;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    let rejector = (_e) => { };
     const childController = (0, media_parser_controller_1.mediaParserController)();
     const forwarded = (0, forward_controller_1.forwardMediaParserController)({
         childController,
         parentController,
     });
-    await (0, parse_media_1.parseMedia)({
-        src,
-        acknowledgeRemotionLicense: true,
-        logLevel,
-        controller: childController,
-        onTracks: () => {
-            if (!m3uState.hasEmittedDoneWithTracks()) {
-                m3uState.setHasEmittedDoneWithTracks();
-                onDoneWithTracks();
-                return null;
-            }
-        },
-        onAudioTrack: async ({ track }) => {
-            const callbackOrFalse = m3uState.hasEmittedAudioTrack();
-            if (callbackOrFalse === false) {
-                const callback = await onAudioTrack(track);
-                if (!callback) {
-                    m3uState.setHasEmittedAudioTrack(null);
-                    return null;
-                }
-                m3uState.setHasEmittedAudioTrack(callback);
-                return (sample) => {
-                    return callback(sample);
-                };
-            }
-            return callbackOrFalse;
-        },
-        onVideoTrack: async ({ track }) => {
-            const callbackOrFalse = m3uState.hasEmittedVideoTrack();
-            if (callbackOrFalse === false) {
-                const callback = await onVideoTrack(track);
-                if (!callback) {
-                    m3uState.setHasEmittedVideoTrack(null);
-                    return null;
-                }
-                m3uState.setHasEmittedVideoTrack(callback);
-                return (sample) => {
-                    return callback(sample);
-                };
-            }
-            return callbackOrFalse;
-        },
-    });
-    m3uState.setLastChunkProcessed(chunkIndex);
-    if (isLastChunk) {
-        m3uState.setAllChunksProcessed();
+    const makeContinuationFn = () => {
+        return {
+            continue() {
+                const { promise, reject, resolve } = Promise.withResolvers();
+                resolver = resolve;
+                rejector = reject;
+                childController.resume();
+                return promise;
+            },
+            abort() {
+                childController.abort();
+            },
+        };
+    };
+    for (const chunk of chunks) {
+        const isLastChunk = chunk === chunks[chunks.length - 1];
+        await childController._internals.checkForAbortAndPause();
+        const src = new URL(chunk.url, playlistUrl).toString();
+        try {
+            await (0, parse_media_1.parseMedia)({
+                src,
+                acknowledgeRemotionLicense: true,
+                logLevel,
+                controller: childController,
+                progressIntervalInMs: 0,
+                onParseProgress: () => {
+                    childController.pause();
+                    resolver(makeContinuationFn());
+                },
+                onTracks: () => {
+                    if (!m3uState.hasEmittedDoneWithTracks(playlistUrl)) {
+                        m3uState.setHasEmittedDoneWithTracks(playlistUrl);
+                        onDoneWithTracks();
+                        return null;
+                    }
+                },
+                onAudioTrack: async ({ track }) => {
+                    const callbackOrFalse = m3uState.hasEmittedAudioTrack(playlistUrl);
+                    if (callbackOrFalse === false) {
+                        const callback = await onAudioTrack(track);
+                        if (!callback) {
+                            m3uState.setHasEmittedAudioTrack(playlistUrl, null);
+                            return null;
+                        }
+                        m3uState.setHasEmittedAudioTrack(playlistUrl, callback);
+                        return (sample) => {
+                            return callback(sample);
+                        };
+                    }
+                    return callbackOrFalse;
+                },
+                onVideoTrack: async ({ track }) => {
+                    const callbackOrFalse = m3uState.hasEmittedVideoTrack(playlistUrl);
+                    if (callbackOrFalse === false) {
+                        const callback = await onVideoTrack(track);
+                        if (!callback) {
+                            m3uState.setHasEmittedVideoTrack(playlistUrl, null);
+                            return null;
+                        }
+                        m3uState.setHasEmittedVideoTrack(playlistUrl, callback);
+                        return (sample) => {
+                            return callback(sample);
+                        };
+                    }
+                    return callbackOrFalse;
+                },
+            });
+        }
+        catch (e) {
+            rejector(e);
+            throw e;
+        }
+        forwarded.cleanup();
+        if (!isLastChunk) {
+            childController.pause();
+            resolver(makeContinuationFn());
+        }
     }
-    forwarded.cleanup();
+    resolver(null);
 };
 exports.iteratorOverTsFiles = iteratorOverTsFiles;

package/dist/containers/m3u/run-over-m3u.d.ts

@@ -0,0 +1,9 @@
+import type { LogLevel } from '../../log';
+import type { ParserState } from '../../state/parser-state';
+import type { M3uStructure } from './types';
+export declare const runOverM3u: ({ state, structure, playlistUrl, logLevel, }: {
+    state: ParserState;
+    structure: M3uStructure;
+    playlistUrl: string;
+    logLevel: LogLevel;
+}) => Promise<void>;