@remotion/media-parser 4.0.265 → 4.0.266

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iteratorOverTsFiles = void 0;
+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, }) => {
+    const playlist = (0, get_playlist_1.getPlaylist)(structure);
+    const chunks = (0, get_chunks_1.getChunks)(playlist);
+    const lastChunkProcessed = m3uState.getLastChunkProcessed();
+    const chunkIndex = lastChunkProcessed + 1;
+    // TODO: Be able to pause / resume / cancel / seek
+    const chunk = chunks[chunkIndex];
+    const isLastChunk = chunkIndex === chunks.length - 1;
+    const src = new URL(chunk.url, playlistUrl).toString();
+    await (0, parse_media_1.parseMedia)({
+        src,
+        acknowledgeRemotionLicense: true,
+        logLevel,
+        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();
+    }
+};
+exports.iteratorOverTsFiles = iteratorOverTsFiles;

package/dist/containers/flac/m3u/select-stream.d.ts

@@ -0,0 +1,10 @@
+import type { M3uStream } from './get-streams';
+export type StreamSelectionFnOptions = {
+    streams: M3uStream[];
+};
+export type StreamSelectionFn = (options: StreamSelectionFnOptions) => number | Promise<number>;
+export declare const selectStream: ({ streams, fn, }: {
+    streams: M3uStream[];
+    fn: StreamSelectionFn;
+}) => Promise<M3uStream>;
+export declare const defaultStreamSelectionFn: StreamSelectionFn;

package/dist/containers/flac/m3u/select-stream.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultStreamSelectionFn = exports.selectStream = void 0;
+const selectStream = async ({ streams, fn, }) => {
+    if (streams.length < 1) {
+        throw new Error('No streams found');
+    }
+    const selectedStream = await fn({ streams });
+    return Promise.resolve(streams[selectedStream]);
+};
+exports.selectStream = selectStream;
+const defaultStreamSelectionFn = ({ streams }) => {
+    return Promise.resolve(streams[0].id);
+};
+exports.defaultStreamSelectionFn = defaultStreamSelectionFn;

package/dist/containers/flac/m3u/types.d.ts

@@ -0,0 +1,48 @@
+export type M3uHeader = {
+    type: 'm3u-header';
+};
+export type M3uVersion = {
+    type: 'm3u-version';
+    version: string;
+};
+export type M3uIndependentSegments = {
+    type: 'm3u-independent-segments';
+};
+export type M3uTargetDuration = {
+    type: 'm3u-target-duration';
+    duration: number;
+};
+export type M3uPlaylistType = {
+    type: 'm3u-playlist-type';
+    playlistType: string;
+};
+export type M3uPlaylist = {
+    type: 'm3u-playlist';
+    boxes: M3uBox[];
+};
+export type M3uExtInf = {
+    type: 'm3u-extinf';
+    value: number;
+};
+export type M3uEndList = {
+    type: 'm3u-endlist';
+};
+export type M3uStreamInfo = {
+    type: 'm3u-stream-info';
+    bandwidth: number | null;
+    averageBandwidth: number | null;
+    codecs: string[] | null;
+    resolution: {
+        width: number;
+        height: number;
+    } | null;
+};
+export type M3uTextValue = {
+    type: 'm3u-text-value';
+    value: string;
+};
+export type M3uBox = M3uHeader | M3uPlaylist | M3uVersion | M3uIndependentSegments | M3uStreamInfo | M3uTargetDuration | M3uPlaylistType | M3uExtInf | M3uEndList | M3uTextValue;
+export type M3uStructure = {
+    type: 'm3u';
+    boxes: M3uBox[];
+};

package/dist/containers/flac/m3u/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/containers/flac/parse-streaminfo.js

@@ -31,7 +31,7 @@ const parseStreamInfo = async ({ iterator, state, }) => {
         totalSamples,
     };
     state.getFlacStructure().boxes.push(flacStreamInfo);
-    await (0, register_track_1.registerTrack)({
+    await (0, register_track_1.registerAudioTrack)({
         container: 'flac',
         state,
         track: {

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

@@ -22,13 +22,13 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
         },
         onAudioTrack: state.onAudioTrack
             ? async ({ track, container }) => {
-                await (0, register_track_1.registerTrack)({ state, track, container });
+                await (0, register_track_1.registerAudioTrack)({ state, track, container });
                 return null;
             }
             : null,
         onVideoTrack: state.onVideoTrack
             ? async ({ track, container }) => {
-                await (0, register_track_1.registerTrack)({ state, track, container });
+                await (0, register_track_1.registerVideoTrack)({ state, track, container });
                 return null;
             }
             : null,
@@ -38,6 +38,7 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
         readerInterface: state.readerInterface,
         src: state.src,
         onDiscardedData: null,
+        selectM3uStreamFn: state.selectM3uStreamFn,
     });
     while (true) {
         const result = await reader.reader.read();

package/dist/containers/iso-base-media/process-box.js

@@ -181,8 +181,15 @@ const processBox = async (state) => {
             state,
         });
         const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(box);
-        if (transformedTrack) {
-            await (0, register_track_1.registerTrack)({
+        if (transformedTrack && transformedTrack.type === 'video') {
+            await (0, register_track_1.registerVideoTrack)({
+                state,
+                track: transformedTrack,
+                container: 'mp4',
+            });
+        }
+        if (transformedTrack && transformedTrack.type === 'audio') {
+            await (0, register_track_1.registerAudioTrack)({
                 state,
                 track: transformedTrack,
                 container: 'mp4',

package/dist/containers/iso-base-media/trun.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTrun = void 0;
 const parseTrun = ({ iterator, offset, size, }) => {
     const version = iterator.getUint8();
-    if (version !== 0) {
+    if (version !== 0 && version !== 1) {
         throw new Error(`Unsupported TRUN version ${version}`);
     }
     const flags = iterator.getUint24();

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

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

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOverM3u = exports.afterManifestFetch = void 0;
+const register_track_1 = require("../../register-track");
+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 independentSegments = (0, get_streams_1.isIndependentSegments)(structure);
+    if (!independentSegments) {
+        if (!src) {
+            throw new Error('No src');
+        }
+        m3uState.setSelectedStream({
+            type: 'initial-url',
+            url: src,
+        });
+        return m3uState.setReadyToIterateOverM3u();
+    }
+    const streams = (0, get_streams_1.getM3uStreams)(structure, src);
+    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) {
+        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.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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+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);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch ${stream.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);
+    }
+    return boxes;
+};
+exports.fetchM3u8Stream = fetchM3u8Stream;

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

@@ -0,0 +1,6 @@
+import type { M3uPlaylist } from './types';
+export type M3uChunk = {
+    duration: number;
+    url: string;
+};
+export declare const getChunks: (playlist: M3uPlaylist) => M3uChunk[];

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChunks = void 0;
+const getChunks = (playlist) => {
+    const chunks = [];
+    for (let i = 0; i < playlist.boxes.length; i++) {
+        const box = playlist.boxes[i];
+        if (box.type === 'm3u-extinf') {
+            const nextBox = playlist.boxes[i + 1];
+            i++;
+            if (nextBox.type !== 'm3u-text-value') {
+                throw new Error('Expected m3u-text-value');
+            }
+            chunks.push({ duration: box.value, url: nextBox.value });
+        }
+        continue;
+    }
+    return chunks;
+};
+exports.getChunks = getChunks;

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

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

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

@@ -0,0 +1,9 @@
+"use strict";
+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);
+};
+exports.getDurationFromM3u = getDurationFromM3u;

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

@@ -0,0 +1,3 @@
+import type { M3uPlaylist, M3uStructure } from './types';
+export declare const getPlaylist: (structure: M3uStructure) => M3uPlaylist;
+export declare const getDurationFromPlaylist: (playlist: M3uPlaylist) => number;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDurationFromPlaylist = exports.getPlaylist = void 0;
+const get_streams_1 = require("./get-streams");
+const getPlaylist = (structure) => {
+    const isIndependent = (0, get_streams_1.isIndependentSegments)(structure);
+    if (!isIndependent) {
+        return {
+            type: 'm3u-playlist',
+            boxes: structure.boxes,
+        };
+    }
+    const playlists = structure.boxes.filter((box) => box.type === 'm3u-playlist');
+    if (playlists.length !== 1) {
+        throw new Error('Expected one playlist');
+    }
+    return playlists[0];
+};
+exports.getPlaylist = getPlaylist;
+const getDurationFromPlaylist = (playlist) => {
+    const duration = playlist.boxes.filter((box) => box.type === 'm3u-extinf');
+    if (duration.length === 0) {
+        throw new Error('Expected duration in m3u playlist');
+    }
+    return duration.reduce((acc, d) => acc + d.value, 0);
+};
+exports.getDurationFromPlaylist = getDurationFromPlaylist;

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

@@ -0,0 +1,14 @@
+import type { Dimensions } from '../../get-dimensions';
+import type { Structure } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export type M3uStream = {
+    url: string;
+    bandwidth: number | null;
+    averageBandwidth: number | null;
+    resolution: Dimensions | null;
+    codecs: string[] | null;
+    id: number;
+};
+export declare const isIndependentSegments: (structure: Structure | null) => boolean;
+export declare const getM3uStreams: (structure: Structure | null, originalSrc: string | null) => M3uStream[] | null;
+export declare const m3uHasStreams: (state: ParserState) => boolean;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.m3uHasStreams = exports.getM3uStreams = exports.isIndependentSegments = void 0;
+const isIndependentSegments = (structure) => {
+    if (structure === null || structure.type !== 'm3u') {
+        return false;
+    }
+    return structure.boxes.some((box) => box.type === 'm3u-independent-segments' || box.type === 'm3u-stream-info');
+};
+exports.isIndependentSegments = isIndependentSegments;
+const getM3uStreams = (structure, originalSrc) => {
+    if (structure === null || structure.type !== 'm3u') {
+        return null;
+    }
+    const boxes = [];
+    for (let i = 0; i < structure.boxes.length; i++) {
+        const str = structure.boxes[i];
+        if (str.type === 'm3u-stream-info') {
+            const next = structure.boxes[i + 1];
+            if (next.type !== 'm3u-text-value') {
+                throw new Error('Expected m3u-text-value');
+            }
+            boxes.push({
+                url: originalSrc && originalSrc.startsWith('http')
+                    ? new URL(next.value, originalSrc).href
+                    : next.value,
+                averageBandwidth: str.averageBandwidth,
+                bandwidth: str.bandwidth,
+                codecs: str.codecs,
+                resolution: str.resolution,
+            });
+        }
+    }
+    // Maybe this is already a playlist
+    if (boxes.length === 0) {
+        return null;
+    }
+    const sorted = boxes.slice().sort((a, b) => {
+        const aResolution = a.resolution
+            ? a.resolution.width * a.resolution.height
+            : 0;
+        const bResolution = b.resolution
+            ? b.resolution.width * b.resolution.height
+            : 0;
+        return bResolution - aResolution;
+    });
+    return sorted.map((box, index) => ({ ...box, id: index }));
+};
+exports.getM3uStreams = getM3uStreams;
+const m3uHasStreams = (state) => {
+    const structure = state.getStructureOrNull();
+    if (!structure) {
+        return false;
+    }
+    if (structure.type !== 'm3u') {
+        return true;
+    }
+    return state.m3u.hasFinishedManifest();
+};
+exports.m3uHasStreams = m3uHasStreams;

package/dist/containers/m3u/parse-directive.d.ts

@@ -0,0 +1,2 @@
+import type { M3uBox } from './types';
+export declare const parseM3uDirective: (str: string) => M3uBox;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseM3uDirective = void 0;
+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 value = firstColon === -1 ? null : str.slice(firstColon + 1);
+    if (directive === '#EXT-X-VERSION') {
+        if (!value) {
+            throw new Error('EXT-X-VERSION directive must have a value');
+        }
+        return {
+            type: 'm3u-version',
+            version: value,
+        };
+    }
+    if (directive === '#EXT-X-INDEPENDENT-SEGMENTS') {
+        return {
+            type: 'm3u-independent-segments',
+        };
+    }
+    if (directive === '#EXT-X-TARGETDURATION') {
+        if (!value) {
+            throw new Error('EXT-X-TARGETDURATION directive must have a value');
+        }
+        return {
+            type: 'm3u-target-duration',
+            duration: parseFloat(value),
+        };
+    }
+    if (directive === '#EXTINF') {
+        if (!value) {
+            throw new Error('EXTINF has no value');
+        }
+        return {
+            type: 'm3u-extinf',
+            value: parseFloat(value),
+        };
+    }
+    if (directive === '#EXT-X-ENDLIST') {
+        return {
+            type: 'm3u-endlist',
+        };
+    }
+    if (directive === '#EXT-X-PLAYLIST-TYPE') {
+        if (!value) {
+            throw new Error('#EXT-X-PLAYLIST-TYPE. directive must have a value');
+        }
+        return {
+            type: 'm3u-playlist-type',
+            playlistType: value,
+        };
+    }
+    if (directive === '#EXT-X-STREAM-INF') {
+        if (!value) {
+            throw new Error('EXT-X-STREAM-INF directive must have a value');
+        }
+        const res = (0, parse_stream_inf_1.parseStreamInf)(value);
+        return res;
+    }
+    throw new Error(`Unknown directive ${directive}. Value: ${value}`);
+};
+exports.parseM3uDirective = parseM3uDirective;

package/dist/containers/m3u/parse-m3u-manifest.d.ts

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParseResult } from '../../parse-result';
+import type { M3uStructure } from './types';
+export declare const parseM3uManifest: ({ iterator, structure, contentLength, }: {
+    iterator: BufferIterator;
+    structure: M3uStructure;
+    contentLength: number;
+}) => Promise<ParseResult>;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseM3uManifest = void 0;
+const parse_m3u8_text_1 = require("./parse-m3u8-text");
+const parseM3uManifest = ({ iterator, structure, contentLength, }) => {
+    const start = iterator.startCheckpoint();
+    const line = iterator.readUntilLineEnd();
+    if (iterator.counter.getOffset() > contentLength) {
+        throw new Error('Unexpected end of file');
+    }
+    if (line === null) {
+        start.returnToCheckpoint();
+        return Promise.resolve(null);
+    }
+    (0, parse_m3u8_text_1.parseM3u8Text)(line, structure.boxes);
+    return Promise.resolve(null);
+};
+exports.parseM3uManifest = parseM3uManifest;

package/dist/containers/m3u/parse-m3u.d.ts

@@ -0,0 +1,4 @@
+import type { ParserState } from '../../state/parser-state';
+export declare const parseM3u: ({ state }: {
+    state: ParserState;
+}) => Promise<import("../../parse-result").ParseResult>;

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

@@ -0,0 +1,35 @@
+"use strict";
+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 parseM3u = async ({ state }) => {
+    const structure = state.getM3uStructure();
+    if (state.m3u.isReadyToIterateOverM3u()) {
+        await (0, after_manifest_fetch_1.runOverM3u)({
+            state,
+            structure,
+        });
+        return null;
+    }
+    if (state.m3u.hasFinishedManifest()) {
+        await (0, after_manifest_fetch_1.afterManifestFetch)({
+            structure,
+            m3uState: state.m3u,
+            src: typeof state.src === 'string' ? state.src : null,
+            selectM3uStreamFn: state.selectM3uStreamFn,
+        });
+        return null;
+    }
+    const box = await (0, parse_m3u_manifest_1.parseM3uManifest)({
+        iterator: state.iterator,
+        structure,
+        contentLength: state.contentLength,
+    });
+    const isDoneNow = state.iterator.counter.getOffset() === state.contentLength;
+    if (isDoneNow) {
+        state.m3u.setHasFinishedManifest();
+    }
+    return box;
+};
+exports.parseM3u = parseM3u;

package/dist/containers/m3u/parse-m3u8-text.d.ts

@@ -0,0 +1,2 @@
+import type { M3uBox } from './types';
+export declare const parseM3u8Text: (line: string, boxes: M3uBox[]) => void;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseM3u8Text = void 0;
+const parse_directive_1 = require("./parse-directive");
+const parseM3u8Text = (line, boxes) => {
+    if (line === '#EXTM3U') {
+        boxes.push({
+            type: 'm3u-header',
+        });
+        return;
+    }
+    if (line.startsWith('#')) {
+        boxes.push((0, parse_directive_1.parseM3uDirective)(line));
+        return;
+    }
+    if (line.trim()) {
+        boxes.push({
+            type: 'm3u-text-value',
+            value: line,
+        });
+    }
+};
+exports.parseM3u8Text = parseM3u8Text;

package/dist/containers/m3u/parse-stream-inf.d.ts

@@ -0,0 +1,3 @@
+import type { M3uStreamInfo } from './types';
+export declare function splitRespectingQuotes(input: string): string[];
+export declare const parseStreamInf: (str: string) => M3uStreamInfo;