@remotion/media-parser 4.0.265 → 4.0.266

package/dist/buffer-iterator.d.ts

@@ -70,6 +70,7 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
         returnToCheckpoint: () => void;
     };
     getFlacCodecNumber: () => number;
+    readUntilLineEnd: () => string | null;
     getSyncSafeInt32: () => number;
 };
 export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/buffer-iterator.js

@@ -94,6 +94,22 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         counter.decrement(1);
         return new TextDecoder().decode(new Uint8Array(bytes));
     };
+    const readUntilLineEnd = () => {
+        const bytes = [];
+        // 10 is "\n"
+        while (true) {
+            if (bytesRemaining() === 0) {
+                return null;
+            }
+            const byte = getUint8();
+            bytes.push(byte);
+            if (byte === 10) {
+                break;
+            }
+        }
+        const str = new TextDecoder().decode(new Uint8Array(bytes)).trim();
+        return str;
+    };
     const getUint8 = () => {
         const val = view.getUint8(counter.getDiscardedOffset());
         counter.increment(1);
@@ -565,6 +581,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         readExpGolomb,
         startCheckpoint,
         getFlacCodecNumber,
+        readUntilLineEnd,
         getSyncSafeInt32,
     };
 };

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

@@ -46,7 +46,7 @@ const parseAac = async (state) => {
     iterator.counter.decrement(iterator.counter.getOffset() - startOffset);
     const data = iterator.getSlice(frameLength);
     if (state.callbacks.tracks.getTracks().length === 0) {
-        await (0, register_track_1.registerTrack)({
+        await (0, register_track_1.registerAudioTrack)({
             state,
             container: 'aac',
             track: {

package/dist/containers/avc/create-sps-pps-data.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSpsPpsData = void 0;
 const combine_uint8_arrays_1 = require("../../combine-uint8-arrays");
+const truthy_1 = require("../../truthy");
 function serializeUint16(value) {
     const buffer = new ArrayBuffer(2);
     const view = new DataView(buffer);
@@ -29,6 +30,19 @@ const createSpsPpsData = (avc1Profile) => {
         serializeUint16(avc1Profile.pps.pps.length),
         // PPS
         avc1Profile.pps.pps,
-    ]);
+        // if AVCProfileIndication != 66 && AVCProfileIndication != 77 && AVCProfileIndication != 88
+        [66, 77, 88].some((b) => avc1Profile.sps.spsData.profile === b)
+            ? null
+            : /**
+             *  reserved	63 (0x3F)
+                    chroma_format	1, '4:2:0'
+                    reserved	31 (0x1F)
+                    bit_depth_luma_minus8	0
+                    reserved	31 (0x1F)
+                    bit_depth_chroma_minus8	0
+                    numOfSequenceParameterSetExt	0
+             */
+                new Uint8Array([0xfd, 0xf8, 0xf8, 0]),
+    ].filter(truthy_1.truthy));
 };
 exports.createSpsPpsData = createSpsPpsData;

package/dist/containers/avc/interpret-sps.js

@@ -3,11 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVideoColorFromSps = exports.getSampleAspectRatioFromSps = exports.getDimensionsFromSps = void 0;
 const color_1 = require("./color");
 const getDimensionsFromSps = (sps) => {
+    var _a, _b, _c, _d;
     const height = sps.pic_height_in_map_units_minus1;
     const width = sps.pic_width_in_mbs_minus1;
+    // https://stackoverflow.com/questions/12018535/get-the-width-height-of-the-video-from-h-264-nalu
     return {
-        height: (height + 1) * 16,
-        width: (width + 1) * 16,
+        height: (height + 1) * 16 -
+            ((_a = sps.frame_crop_bottom_offset) !== null && _a !== void 0 ? _a : 0) * 2 -
+            ((_b = sps.frame_crop_top_offset) !== null && _b !== void 0 ? _b : 0) * 2,
+        width: (width + 1) * 16 -
+            ((_c = sps.frame_crop_right_offset) !== null && _c !== void 0 ? _c : 0) * 2 -
+            ((_d = sps.frame_crop_left_offset) !== null && _d !== void 0 ? _d : 0) * 2,
     };
 };
 exports.getDimensionsFromSps = getDimensionsFromSps;

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

@@ -79,7 +79,7 @@ const readSps = (iterator) => {
     let frame_crop_bottom_offset = null;
     let vui_parameters = null;
     // Page 71
-    if (!(profile === 100 ||
+    if (profile === 100 ||
         profile === 110 ||
         profile === 122 ||
         profile === 244 ||
@@ -91,29 +91,28 @@ const readSps = (iterator) => {
         profile === 138 ||
         profile === 139 ||
         profile === 134 ||
-        profile === 135)) {
-        throw new Error('Invalid profile');
-    }
-    const chromaFormat = iterator.readExpGolomb();
-    if (chromaFormat === 3) {
-        separate_colour_plane_flag = iterator.getBits(1);
-    }
-    bit_depth_luma_minus8 = iterator.readExpGolomb();
-    bit_depth_chroma_minus8 = iterator.readExpGolomb();
-    qpprime_y_zero_transform_bypass_flag = iterator.getBits(1);
-    const seq_scaling_matrix_present_flag = iterator.getBits(1);
-    const seq_scaling_list_present_flag = [];
-    if (seq_scaling_matrix_present_flag) {
-        for (let i = 0; i < (chromaFormat !== 3 ? 8 : 12); i++) {
-            seq_scaling_list_present_flag[i] = iterator.getBits(1);
-            if (seq_scaling_list_present_flag[i]) {
-                if (i < 6) {
-                    // scaling_list not implemented
-                    throw new Error('Not implemented');
-                }
-                else {
-                    // scaling_list not implemented
-                    throw new Error('Not implemented');
+        profile === 135) {
+        const chromaFormat = iterator.readExpGolomb();
+        if (chromaFormat === 3) {
+            separate_colour_plane_flag = iterator.getBits(1);
+        }
+        bit_depth_luma_minus8 = iterator.readExpGolomb();
+        bit_depth_chroma_minus8 = iterator.readExpGolomb();
+        qpprime_y_zero_transform_bypass_flag = iterator.getBits(1);
+        const seq_scaling_matrix_present_flag = iterator.getBits(1);
+        const seq_scaling_list_present_flag = [];
+        if (seq_scaling_matrix_present_flag) {
+            for (let i = 0; i < (chromaFormat !== 3 ? 8 : 12); i++) {
+                seq_scaling_list_present_flag[i] = iterator.getBits(1);
+                if (seq_scaling_list_present_flag[i]) {
+                    if (i < 6) {
+                        // scaling_list not implemented
+                        throw new Error('Not implemented');
+                    }
+                    else {
+                        // scaling_list not implemented
+                        throw new Error('Not implemented');
+                    }
                 }
             }
         }

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 | 1 | 8 | 7 | 3 | 6 | 5 | 4;

package/dist/containers/flac/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 { StreamSelectionFn } from './select-stream';
+import type { M3uStructure } from './types';
+export declare const afterManifestFetch: ({ structure, m3uState, src, streamSelectionFn, }: {
+    structure: M3uStructure;
+    m3uState: M3uState;
+    src: string | null;
+    streamSelectionFn: StreamSelectionFn;
+}) => Promise<void>;
+export declare const runOverM3u: ({ state, structure, }: {
+    state: ParserState;
+    structure: M3uStructure;
+}) => Promise<void>;

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

@@ -0,0 +1,53 @@
+"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, streamSelectionFn, }) => {
+    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: streamSelectionFn });
+    m3uState.setSelectedStream(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.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,
+    });
+};
+exports.runOverM3u = runOverM3u;

package/dist/containers/flac/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/flac/m3u/fetch-m3u8-stream.js

@@ -0,0 +1,15 @@
+"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);
+    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/flac/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/flac/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/flac/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/flac/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/flac/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/flac/m3u/get-playlist.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDurationFromPlaylist = exports.getPlaylist = void 0;
+const getPlaylist = (structure) => {
+    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/flac/m3u/get-streams.d.ts

@@ -0,0 +1,13 @@
+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 getM3uStreams: (structure: Structure | null, originalSrc: string | null) => M3uStream[] | null;
+export declare const m3uHasStreams: (state: ParserState) => boolean;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.m3uHasStreams = exports.getM3uStreams = void 0;
+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,
+                id: i,
+            });
+        }
+    }
+    return boxes;
+};
+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/flac/m3u/parse-directive.d.ts

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

package/dist/containers/flac/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/flac/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/flac/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/flac/m3u/parse-m3u.d.ts

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

package/dist/containers/flac/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,
+            streamSelectionFn: state.streamSelectionFn,
+        });
+        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/flac/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/flac/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/flac/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;

package/dist/containers/flac/m3u/parse-stream-inf.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStreamInf = void 0;
+exports.splitRespectingQuotes = splitRespectingQuotes;
+function splitRespectingQuotes(input) {
+    const result = [];
+    let currentPart = '';
+    let insideQuote = false;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        // Toggle flag when encountering a quote character.
+        if (char === '"') {
+            insideQuote = !insideQuote;
+            currentPart += char;
+        }
+        // If we encounter a comma and we are NOT inside a quoted substring
+        else if (char === ',' && !insideQuote) {
+            result.push(currentPart);
+            currentPart = '';
+        }
+        else {
+            currentPart += char;
+        }
+    }
+    // Push the last token, if any.
+    if (currentPart) {
+        result.push(currentPart);
+    }
+    return result;
+}
+const parseStreamInf = (str) => {
+    const quotes = splitRespectingQuotes(str);
+    const map = {};
+    for (const quote of quotes) {
+        const firstColon = quote.indexOf('=');
+        const key = firstColon === -1 ? quote : quote.slice(0, firstColon);
+        const value = firstColon === -1 ? null : quote.slice(firstColon + 1);
+        if (value === null) {
+            throw new Error('Value is null');
+        }
+        const actualValue = (value === null || value === void 0 ? void 0 : value.startsWith('"')) && (value === null || value === void 0 ? void 0 : value.endsWith('"'))
+            ? value.slice(1, -1)
+            : value;
+        map[key] = actualValue;
+    }
+    return {
+        type: 'm3u-stream-info',
+        averageBandwidth: map['AVERAGE-BANDWIDTH']
+            ? parseInt(map['AVERAGE-BANDWIDTH'], 10)
+            : null,
+        bandwidth: map.BANDWIDTH ? parseInt(map.BANDWIDTH, 10) : null,
+        codecs: map.CODECS ? map.CODECS.split(',') : null,
+        resolution: map.RESOLUTION
+            ? {
+                width: parseInt(map.RESOLUTION.split('x')[0], 10),
+                height: parseInt(map.RESOLUTION.split('x')[1], 10),
+            }
+            : null,
+    };
+};
+exports.parseStreamInf = parseStreamInf;

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

@@ -0,0 +1,14 @@
+import type { AudioTrack, VideoTrack } from '../../get-tracks';
+import type { LogLevel } from '../../log';
+import type { 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, }: {
+    structure: M3uStructure;
+    onVideoTrack: (track: VideoTrack) => Promise<OnVideoSample | null>;
+    onAudioTrack: (track: AudioTrack) => Promise<OnAudioSample | null>;
+    onDoneWithTracks: () => void;
+    m3uState: M3uState;
+    playlistUrl: string;
+    logLevel: LogLevel;
+}) => Promise<void>;