@remotion/media-parser 4.0.277 → 4.0.278

package/dist/containers/transport-stream/get-tracks.js

@@ -1,19 +1,23 @@
-import { truthy } from '../../truthy';
-import { findProgramMapTableOrThrow } from './traversal';
-export const filterStreamsBySupportedTypes = (streams) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAllTracksFromTransportStream = exports.getTracksFromTransportStream = exports.filterStreamsBySupportedTypes = void 0;
+const truthy_1 = require("../../truthy");
+const traversal_1 = require("./traversal");
+const filterStreamsBySupportedTypes = (streams) => {
     return streams.filter((stream) => stream.streamType === 27 || stream.streamType === 15);
 };
-export const getTracksFromTransportStream = (parserState) => {
+exports.filterStreamsBySupportedTypes = filterStreamsBySupportedTypes;
+const getTracksFromTransportStream = (parserState) => {
     const structure = parserState.getTsStructure();
-    const programMapTable = findProgramMapTableOrThrow(structure);
+    const programMapTable = (0, traversal_1.findProgramMapTableOrThrow)(structure);
     const parserTracks = parserState.callbacks.tracks.getTracks();
-    const mapped = filterStreamsBySupportedTypes(programMapTable.streams)
+    const mapped = (0, exports.filterStreamsBySupportedTypes)(programMapTable.streams)
         .map((stream) => {
         return parserTracks.find((track) => track.trackId === stream.pid);
     })
-        .filter(truthy);
+        .filter(truthy_1.truthy);
     if (mapped.length !==
-        filterStreamsBySupportedTypes(programMapTable.streams).length) {
+        (0, exports.filterStreamsBySupportedTypes)(programMapTable.streams).length) {
         throw new Error('Not all tracks found');
     }
     return {
@@ -22,12 +26,14 @@ export const getTracksFromTransportStream = (parserState) => {
         otherTracks: [],
     };
 };
-export const hasAllTracksFromTransportStream = (parserState) => {
+exports.getTracksFromTransportStream = getTracksFromTransportStream;
+const hasAllTracksFromTransportStream = (parserState) => {
     try {
-        getTracksFromTransportStream(parserState);
+        (0, exports.getTracksFromTransportStream)(parserState);
         return true;
     }
     catch (_a) {
         return false;
     }
 };
+exports.hasAllTracksFromTransportStream = hasAllTracksFromTransportStream;

package/dist/containers/transport-stream/handle-aac-packet.js

@@ -1,11 +1,14 @@
-import { mapAudioObjectTypeToCodecString } from '../../aac-codecprivate';
-import { convertAudioOrVideoSampleToWebCodecsTimestamps } from '../../convert-audio-or-video-sample';
-import { registerAudioTrack } from '../../register-track';
-import { readAdtsHeader } from './adts-header';
-import { MPEG_TIMESCALE } from './handle-avc-packet';
-export const handleAacPacket = async ({ streamBuffer, state, programId, offset, }) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAacPacket = void 0;
+const aac_codecprivate_1 = require("../../aac-codecprivate");
+const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
+const register_track_1 = require("../../register-track");
+const adts_header_1 = require("./adts-header");
+const handle_avc_packet_1 = require("./handle-avc-packet");
+const handleAacPacket = async ({ streamBuffer, state, programId, offset, }) => {
     var _a;
-    const adtsHeader = readAdtsHeader(streamBuffer.buffer);
+    const adtsHeader = (0, adts_header_1.readAdtsHeader)(streamBuffer.buffer);
     if (!adtsHeader) {
         throw new Error('Invalid ADTS header - too short');
     }
@@ -19,15 +22,15 @@ export const handleAacPacket = async ({ streamBuffer, state, programId, offset,
             codecPrivate,
             trackId: programId,
             trakBox: null,
-            timescale: MPEG_TIMESCALE,
+            timescale: handle_avc_packet_1.MPEG_TIMESCALE,
             codecWithoutConfig: 'aac',
-            codec: mapAudioObjectTypeToCodecString(audioObjectType),
+            codec: (0, aac_codecprivate_1.mapAudioObjectTypeToCodecString)(audioObjectType),
             // https://www.w3.org/TR/webcodecs-aac-codec-registration/
             description: undefined,
             numberOfChannels: channelConfiguration,
             sampleRate,
         };
-        await registerAudioTrack({
+        await (0, register_track_1.registerAudioTrack)({
             track,
             state,
             container: 'transport-stream',
@@ -42,7 +45,8 @@ export const handleAacPacket = async ({ streamBuffer, state, programId, offset,
         trackId: programId,
         type: 'key',
         offset,
-        timescale: MPEG_TIMESCALE,
+        timescale: handle_avc_packet_1.MPEG_TIMESCALE,
     };
-    await state.callbacks.onAudioSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
+    await state.callbacks.onAudioSample(programId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)(sample, handle_avc_packet_1.MPEG_TIMESCALE));
 };
+exports.handleAacPacket = handleAacPacket;

package/dist/containers/transport-stream/handle-avc-packet.js

@@ -1,30 +1,33 @@
-import { convertAudioOrVideoSampleToWebCodecsTimestamps } from '../../convert-audio-or-video-sample';
-import { registerVideoTrack } from '../../register-track';
-import { getCodecStringFromSpsAndPps } from '../avc/codec-string';
-import { createSpsPpsData } from '../avc/create-sps-pps-data';
-import { getDimensionsFromSps, getSampleAspectRatioFromSps, getVideoColorFromSps, } from '../avc/interpret-sps';
-import { getKeyFrameOrDeltaFromAvcInfo } from '../avc/key';
-import { parseAvc } from '../avc/parse-avc';
-import { getSpsAndPps } from '../avc/sps-and-pps';
-export const MPEG_TIMESCALE = 90000;
-export const handleAvcPacket = async ({ streamBuffer, programId, state, offset, }) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAvcPacket = exports.MPEG_TIMESCALE = void 0;
+const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
+const register_track_1 = require("../../register-track");
+const codec_string_1 = require("../avc/codec-string");
+const create_sps_pps_data_1 = require("../avc/create-sps-pps-data");
+const interpret_sps_1 = require("../avc/interpret-sps");
+const key_1 = require("../avc/key");
+const parse_avc_1 = require("../avc/parse-avc");
+const sps_and_pps_1 = require("../avc/sps-and-pps");
+exports.MPEG_TIMESCALE = 90000;
+const handleAvcPacket = async ({ streamBuffer, programId, state, offset, }) => {
     var _a;
-    const avc = parseAvc(streamBuffer.buffer);
+    const avc = (0, parse_avc_1.parseAvc)(streamBuffer.buffer);
     const isTrackRegistered = state.callbacks.tracks.getTracks().find((t) => {
         return t.trackId === programId;
     });
     if (!isTrackRegistered) {
-        const spsAndPps = getSpsAndPps(avc);
-        const dimensions = getDimensionsFromSps(spsAndPps.sps.spsData);
-        const sampleAspectRatio = getSampleAspectRatioFromSps(spsAndPps.sps.spsData);
+        const spsAndPps = (0, sps_and_pps_1.getSpsAndPps)(avc);
+        const dimensions = (0, interpret_sps_1.getDimensionsFromSps)(spsAndPps.sps.spsData);
+        const sampleAspectRatio = (0, interpret_sps_1.getSampleAspectRatioFromSps)(spsAndPps.sps.spsData);
         const track = {
             m3uStreamFormat: null,
             rotation: 0,
             trackId: programId,
             type: 'video',
-            timescale: MPEG_TIMESCALE,
-            codec: getCodecStringFromSpsAndPps(spsAndPps.sps),
-            codecPrivate: createSpsPpsData(spsAndPps),
+            timescale: exports.MPEG_TIMESCALE,
+            codec: (0, codec_string_1.getCodecStringFromSpsAndPps)(spsAndPps.sps),
+            codecPrivate: (0, create_sps_pps_data_1.createSpsPpsData)(spsAndPps),
             fps: null,
             codedWidth: dimensions.width,
             codedHeight: dimensions.height,
@@ -39,9 +42,9 @@ export const handleAvcPacket = async ({ streamBuffer, programId, state, offset,
                 denominator: sampleAspectRatio.height,
                 numerator: sampleAspectRatio.width,
             },
-            color: getVideoColorFromSps(spsAndPps.sps.spsData),
+            color: (0, interpret_sps_1.getVideoColorFromSps)(spsAndPps.sps.spsData),
         };
-        await registerVideoTrack({ track, state, container: 'transport-stream' });
+        await (0, register_track_1.registerVideoTrack)({ track, state, container: 'transport-stream' });
     }
     // sample for webcodecs needs to be in nano seconds
     const sample = {
@@ -51,9 +54,10 @@ export const handleAvcPacket = async ({ streamBuffer, programId, state, offset,
         duration: undefined,
         data: new Uint8Array(streamBuffer.buffer),
         trackId: programId,
-        type: getKeyFrameOrDeltaFromAvcInfo(avc),
+        type: (0, key_1.getKeyFrameOrDeltaFromAvcInfo)(avc),
         offset,
-        timescale: MPEG_TIMESCALE,
+        timescale: exports.MPEG_TIMESCALE,
     };
-    await state.callbacks.onVideoSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
+    await state.callbacks.onVideoSample(programId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)(sample, exports.MPEG_TIMESCALE));
 };
+exports.handleAvcPacket = handleAvcPacket;

package/dist/containers/transport-stream/next-pes-header-store.js

@@ -1,4 +1,7 @@
-export const makeNextPesHeaderStore = () => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNextPesHeaderStore = void 0;
+const makeNextPesHeaderStore = () => {
     let nextPesHeader = null;
     return {
         setNextPesHeader: (pesHeader) => {
@@ -12,3 +15,4 @@ export const makeNextPesHeaderStore = () => {
         },
     };
 };
+exports.makeNextPesHeaderStore = makeNextPesHeaderStore;

package/dist/containers/transport-stream/parse-packet.js

@@ -1,9 +1,12 @@
-import { parsePat, parseSdt } from './parse-pat';
-import { parsePes } from './parse-pes';
-import { parsePmt } from './parse-pmt';
-import { parseStream } from './parse-stream-packet';
-import { getProgramForId, getStreamForId } from './traversal';
-export const parsePacket = async ({ parserState, }) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePacket = void 0;
+const parse_pat_1 = require("./parse-pat");
+const parse_pes_1 = require("./parse-pes");
+const parse_pmt_1 = require("./parse-pmt");
+const parse_stream_packet_1 = require("./parse-stream-packet");
+const traversal_1 = require("./traversal");
+const parsePacket = async ({ parserState, }) => {
     const { iterator } = parserState;
     const offset = iterator.counter.getOffset();
     const syncByte = iterator.getUint8();
@@ -47,29 +50,29 @@ export const parsePacket = async ({ parserState, }) => {
     const pat = structure.boxes.find((b) => b.type === 'transport-stream-pmt-box');
     const isPes = payloadUnitStartIndicator && (pat === null || pat === void 0 ? void 0 : pat.streams.find((e) => e.pid === programId));
     if (isPes) {
-        const packetPes = parsePes(iterator);
+        const packetPes = (0, parse_pes_1.parsePes)(iterator);
         parserState.transportStream.nextPesHeaderStore.setNextPesHeader(packetPes);
     }
     else if (payloadUnitStartIndicator === 1) {
         iterator.getUint8(); // pointerField
     }
     if (programId === 0) {
-        return Promise.resolve(parsePat(iterator));
+        return Promise.resolve((0, parse_pat_1.parsePat)(iterator));
     }
     if (programId === 17) {
-        return Promise.resolve(parseSdt(iterator));
+        return Promise.resolve((0, parse_pat_1.parseSdt)(iterator));
     }
     // PID 17 is SDT
     // https://de.wikipedia.org/wiki/MPEG-Transportstrom
     // Die Service Description Table nennt den Programmnamen (z. B. „ZDF“) und gibt weitere Informationen der einzelnen Programme (Services); sie wird auf PID 17 übertragen.
-    const program = programId === 17 ? null : getProgramForId(structure, programId);
+    const program = programId === 17 ? null : (0, traversal_1.getProgramForId)(structure, programId);
     if (program) {
-        const pmt = parsePmt(iterator);
+        const pmt = (0, parse_pmt_1.parsePmt)(iterator);
         return Promise.resolve(pmt);
     }
-    const stream = getStreamForId(structure, programId);
+    const stream = (0, traversal_1.getStreamForId)(structure, programId);
     if (stream) {
-        await parseStream({
+        await (0, parse_stream_packet_1.parseStream)({
             transportStreamEntry: stream,
             state: parserState,
             programId,
@@ -79,3 +82,4 @@ export const parsePacket = async ({ parserState, }) => {
     }
     throw new Error('Unknown packet identifier');
 };
+exports.parsePacket = parsePacket;

package/dist/containers/transport-stream/parse-pat.js

@@ -1,5 +1,8 @@
+"use strict";
 // https://en.wikipedia.org/wiki/Program-specific_information
-import { discardRestOfPacket } from './discard-rest-of-packet';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSdt = exports.parsePat = void 0;
+const discard_rest_of_packet_1 = require("./discard-rest-of-packet");
 const parsePatTable = (iterator, tableId) => {
     iterator.getUint16(); // table ID extension
     iterator.startReadingBits();
@@ -28,7 +31,7 @@ const parsePatTable = (iterator, tableId) => {
         pat: tables,
     };
 };
-export const parsePat = (iterator) => {
+const parsePat = (iterator) => {
     iterator.startReadingBits();
     const tableId = iterator.getBits(8);
     iterator.getBits(1); // syntax indicator
@@ -40,10 +43,11 @@ export const parsePat = (iterator) => {
     }
     iterator.stopReadingBits();
     const tables = parsePatTable(iterator, tableId);
-    discardRestOfPacket(iterator);
+    (0, discard_rest_of_packet_1.discardRestOfPacket)(iterator);
     return tables;
 };
-export const parseSdt = (iterator) => {
+exports.parsePat = parsePat;
+const parseSdt = (iterator) => {
     iterator.startReadingBits();
     iterator.getBits(8); // table ID
     iterator.getBits(1); // section syntax indicator
@@ -52,8 +56,9 @@ export const parseSdt = (iterator) => {
     const sectionLength = iterator.getBits(12);
     iterator.stopReadingBits();
     iterator.discard(sectionLength);
-    discardRestOfPacket(iterator);
+    (0, discard_rest_of_packet_1.discardRestOfPacket)(iterator);
     return {
         type: 'transport-stream-sdt-box',
     };
 };
+exports.parseSdt = parseSdt;

package/dist/containers/transport-stream/parse-pes.js

@@ -1,4 +1,7 @@
-export const parsePes = (iterator) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePes = void 0;
+const parsePes = (iterator) => {
     const ident = iterator.getUint24();
     if (ident !== 0x000001) {
         throw new Error(`Unexpected PES packet start code: ${ident.toString(16)}`);
@@ -70,3 +73,4 @@ export const parsePes = (iterator) => {
     };
     return packet;
 };
+exports.parsePes = parsePes;

package/dist/containers/transport-stream/parse-pmt.js

@@ -1,4 +1,7 @@
-import { discardRestOfPacket } from './discard-rest-of-packet';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePmt = void 0;
+const discard_rest_of_packet_1 = require("./discard-rest-of-packet");
 const parsePmtTable = ({ iterator, tableId, sectionLength, }) => {
     const start = iterator.counter.getOffset();
     iterator.getUint16(); // table ID extension
@@ -43,7 +46,7 @@ const parsePmtTable = ({ iterator, tableId, sectionLength, }) => {
         streams: tables[0].streams,
     };
 };
-export const parsePmt = (iterator) => {
+const parsePmt = (iterator) => {
     iterator.startReadingBits();
     const tableId = iterator.getBits(8);
     iterator.getBits(1); // syntax indicator
@@ -55,6 +58,7 @@ export const parsePmt = (iterator) => {
     }
     iterator.stopReadingBits();
     const tables = parsePmtTable({ iterator, tableId, sectionLength });
-    discardRestOfPacket(iterator);
+    (0, discard_rest_of_packet_1.discardRestOfPacket)(iterator);
     return tables;
 };
+exports.parsePmt = parsePmt;

package/dist/containers/transport-stream/parse-stream-packet.js

@@ -1,8 +1,11 @@
-import { combineUint8Arrays } from '../../combine-uint8-arrays';
-import { readAdtsHeader } from './adts-header';
-import { getRestOfPacket } from './discard-rest-of-packet';
-import { findNthSubarrayIndex } from './find-separator';
-import { processStreamBuffer } from './process-stream-buffers';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStream = void 0;
+const combine_uint8_arrays_1 = require("../../combine-uint8-arrays");
+const adts_header_1 = require("./adts-header");
+const discard_rest_of_packet_1 = require("./discard-rest-of-packet");
+const find_separator_1 = require("./find-separator");
+const process_stream_buffers_1 = require("./process-stream-buffers");
 const parseAdtsStream = async ({ transportStreamEntry, state, structure, offset, }) => {
     var _a, _b;
     const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
@@ -11,14 +14,14 @@ const parseAdtsStream = async ({ transportStreamEntry, state, structure, offset,
         if (!streamBuffer) {
             throw new Error('Stream buffer not found');
         }
-        const expectedLength = (_b = (_a = readAdtsHeader(streamBuffer.buffer)) === null || _a === void 0 ? void 0 : _a.frameLength) !== null && _b !== void 0 ? _b : null;
+        const expectedLength = (_b = (_a = (0, adts_header_1.readAdtsHeader)(streamBuffer.buffer)) === null || _a === void 0 ? void 0 : _a.frameLength) !== null && _b !== void 0 ? _b : null;
         if (expectedLength === null) {
             break;
         }
         if (expectedLength > streamBuffer.buffer.length) {
             break;
         }
-        await processStreamBuffer({
+        await (0, process_stream_buffers_1.processStreamBuffer)({
             streamBuffer: {
                 buffer: streamBuffer.buffer.slice(0, expectedLength),
                 offset,
@@ -37,13 +40,13 @@ const parseAdtsStream = async ({ transportStreamEntry, state, structure, offset,
     }
 };
 const parseAvcStream = async ({ programId, state, structure, streamBuffer, }) => {
-    const indexOfSeparator = findNthSubarrayIndex(streamBuffer.buffer, new Uint8Array([0, 0, 1, 9]), 2);
+    const indexOfSeparator = (0, find_separator_1.findNthSubarrayIndex)(streamBuffer.buffer, new Uint8Array([0, 0, 1, 9]), 2);
     if (indexOfSeparator === -1 || indexOfSeparator === 0) {
         return null;
     }
     const packet = streamBuffer.buffer.slice(0, indexOfSeparator);
     const rest = streamBuffer.buffer.slice(indexOfSeparator);
-    await processStreamBuffer({
+    await (0, process_stream_buffers_1.processStreamBuffer)({
         state,
         streamBuffer: {
             offset: streamBuffer.offset,
@@ -56,9 +59,9 @@ const parseAvcStream = async ({ programId, state, structure, streamBuffer, }) =>
     });
     return rest;
 };
-export const parseStream = async ({ transportStreamEntry, state, programId, structure, }) => {
+const parseStream = async ({ transportStreamEntry, state, programId, structure, }) => {
     const { iterator } = state;
-    let restOfPacket = getRestOfPacket(iterator);
+    let restOfPacket = (0, discard_rest_of_packet_1.getRestOfPacket)(iterator);
     const offset = iterator.counter.getOffset();
     if (transportStreamEntry.streamType === 27) {
         const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
@@ -71,7 +74,7 @@ export const parseStream = async ({ transportStreamEntry, state, programId, stru
                 });
             }
             const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-            streamBuffer.buffer = combineUint8Arrays([
+            streamBuffer.buffer = (0, combine_uint8_arrays_1.combineUint8Arrays)([
                 streamBuffer.buffer,
                 restOfPacket,
             ]);
@@ -105,7 +108,7 @@ export const parseStream = async ({ transportStreamEntry, state, programId, stru
             });
         }
         else {
-            streamBuffer.buffer = combineUint8Arrays([
+            streamBuffer.buffer = (0, combine_uint8_arrays_1.combineUint8Arrays)([
                 streamBuffer.buffer,
                 restOfPacket,
             ]);
@@ -119,3 +122,4 @@ export const parseStream = async ({ transportStreamEntry, state, programId, stru
     }
     throw new Error(`Unsupported stream type ${transportStreamEntry.streamType}`);
 };
+exports.parseStream = parseStream;

package/dist/containers/transport-stream/parse-transport-stream.js

@@ -1,22 +1,26 @@
-import { parsePacket } from './parse-packet';
-import { processFinalStreamBuffers } from './process-stream-buffers';
-export const parseTransportStream = async (state) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTransportStream = void 0;
+const parse_packet_1 = require("./parse-packet");
+const process_stream_buffers_1 = require("./process-stream-buffers");
+const parseTransportStream = async (state) => {
     const structure = state.getTsStructure();
     const { iterator } = state;
     if (iterator.bytesRemaining() < 188) {
         return Promise.resolve(null);
     }
-    const packet = await parsePacket({
+    const packet = await (0, parse_packet_1.parsePacket)({
         parserState: state,
     });
     if (packet) {
         structure.boxes.push(packet);
     }
     if (iterator.bytesRemaining() === 0) {
-        await processFinalStreamBuffers({
+        await (0, process_stream_buffers_1.processFinalStreamBuffers)({
             state,
             structure,
         });
     }
     return Promise.resolve(null);
 };
+exports.parseTransportStream = parseTransportStream;

package/dist/containers/transport-stream/process-stream-buffers.js

@@ -1,15 +1,18 @@
-import { filterStreamsBySupportedTypes } from './get-tracks';
-import { handleAacPacket } from './handle-aac-packet';
-import { handleAvcPacket } from './handle-avc-packet';
-import { findProgramMapTableOrThrow, getStreamForId } from './traversal';
-export const processStreamBuffer = async ({ streamBuffer, state, programId, structure, }) => {
-    const stream = getStreamForId(structure, programId);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFinalStreamBuffers = exports.processStreamBuffer = void 0;
+const get_tracks_1 = require("./get-tracks");
+const handle_aac_packet_1 = require("./handle-aac-packet");
+const handle_avc_packet_1 = require("./handle-avc-packet");
+const traversal_1 = require("./traversal");
+const processStreamBuffer = async ({ streamBuffer, state, programId, structure, }) => {
+    const stream = (0, traversal_1.getStreamForId)(structure, programId);
     if (!stream) {
         throw new Error('No stream found');
     }
     // 27 = AVC / H.264 Video
     if (stream.streamType === 27) {
-        await handleAvcPacket({
+        await (0, handle_avc_packet_1.handleAvcPacket)({
             programId,
             streamBuffer,
             state,
@@ -18,7 +21,7 @@ export const processStreamBuffer = async ({ streamBuffer, state, programId, stru
     }
     // 15 = AAC / ADTS
     else if (stream.streamType === 15) {
-        await handleAacPacket({
+        await (0, handle_aac_packet_1.handleAacPacket)({
             streamBuffer,
             state,
             programId,
@@ -27,16 +30,17 @@ export const processStreamBuffer = async ({ streamBuffer, state, programId, stru
     }
     if (!state.callbacks.tracks.hasAllTracks()) {
         const tracksRegistered = state.callbacks.tracks.getTracks().length;
-        const { streams } = findProgramMapTableOrThrow(structure);
-        if (filterStreamsBySupportedTypes(streams).length === tracksRegistered) {
+        const { streams } = (0, traversal_1.findProgramMapTableOrThrow)(structure);
+        if ((0, get_tracks_1.filterStreamsBySupportedTypes)(streams).length === tracksRegistered) {
             state.callbacks.tracks.setIsDone(state.logLevel);
         }
     }
 };
-export const processFinalStreamBuffers = async ({ state, structure, }) => {
+exports.processStreamBuffer = processStreamBuffer;
+const processFinalStreamBuffers = async ({ state, structure, }) => {
     for (const [programId, buffer] of state.transportStream.streamBuffers) {
         if (buffer.buffer.byteLength > 0) {
-            await processStreamBuffer({
+            await (0, exports.processStreamBuffer)({
                 streamBuffer: buffer,
                 state,
                 programId,
@@ -46,3 +50,4 @@ export const processFinalStreamBuffers = async ({ state, structure, }) => {
         }
     }
 };
+exports.processFinalStreamBuffers = processFinalStreamBuffers;

package/dist/containers/transport-stream/traversal.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStreamForId = exports.getProgramForId = exports.findProgramMapTableOrThrow = void 0;
 const findProgramAssociationTableOrThrow = (structure) => {
     const box = structure.boxes.find((b) => b.type === 'transport-stream-pat-box');
     if (!box) {
@@ -5,20 +8,23 @@ const findProgramAssociationTableOrThrow = (structure) => {
     }
     return box;
 };
-export const findProgramMapTableOrThrow = (structure) => {
+const findProgramMapTableOrThrow = (structure) => {
     const box = structure.boxes.find((b) => b.type === 'transport-stream-pmt-box');
     if (!box) {
         throw new Error('No PMT box found');
     }
     return box;
 };
-export const getProgramForId = (structure, packetIdentifier) => {
+exports.findProgramMapTableOrThrow = findProgramMapTableOrThrow;
+const getProgramForId = (structure, packetIdentifier) => {
     const box = findProgramAssociationTableOrThrow(structure);
     const entry = box.pat.find((e) => e.programMapIdentifier === packetIdentifier);
     return entry !== null && entry !== void 0 ? entry : null;
 };
-export const getStreamForId = (structure, packetIdentifier) => {
-    const box = findProgramMapTableOrThrow(structure);
+exports.getProgramForId = getProgramForId;
+const getStreamForId = (structure, packetIdentifier) => {
+    const box = (0, exports.findProgramMapTableOrThrow)(structure);
     const entry = box.streams.find((e) => e.pid === packetIdentifier);
     return entry !== null && entry !== void 0 ? entry : null;
 };
+exports.getStreamForId = getStreamForId;

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

@@ -1,4 +1,7 @@
-export const getDurationFromWav = (state) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDurationFromWav = exports.getDurationFromWav = void 0;
+const getDurationFromWav = (state) => {
     const structure = state.getWavStructure();
     const fmt = structure.boxes.find((b) => b.type === 'wav-fmt');
     if (!fmt) {
@@ -11,11 +14,13 @@ export const getDurationFromWav = (state) => {
     const durationInSeconds = dataBox.dataSize / (fmt.sampleRate * fmt.blockAlign);
     return durationInSeconds;
 };
-export const hasDurationFromWav = (state) => {
+exports.getDurationFromWav = getDurationFromWav;
+const hasDurationFromWav = (state) => {
     try {
-        return getDurationFromWav(state);
+        return (0, exports.getDurationFromWav)(state);
     }
     catch (_a) {
         return false;
     }
 };
+exports.hasDurationFromWav = hasDurationFromWav;

package/dist/containers/wav/get-metadata-from-wav.js

@@ -1,7 +1,11 @@
-export const getMetadataFromWav = (structure) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataFromWav = void 0;
+const getMetadataFromWav = (structure) => {
     const list = structure.boxes.find((b) => b.type === 'wav-list');
     if (!list) {
         return null;
     }
     return list.metadata;
 };
+exports.getMetadataFromWav = getMetadataFromWav;

package/dist/containers/wav/parse-data.js

@@ -1,6 +1,9 @@
-import { makeSkip } from '../../skip';
-import { maySkipVideoData } from '../../state/may-skip-video-data';
-export const parseData = ({ state, }) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseData = void 0;
+const skip_1 = require("../../skip");
+const may_skip_video_data_1 = require("../../state/may-skip-video-data");
+const parseData = ({ state, }) => {
     const { iterator } = state;
     const ckSize = iterator.getUint32Le(); // chunkSize
     const box = {
@@ -13,9 +16,10 @@ export const parseData = ({ state, }) => {
         size: ckSize,
         start: iterator.counter.getOffset(),
     });
-    if (maySkipVideoData({ state })) {
+    if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
         // Skipping only in query mode
-        return Promise.resolve(makeSkip(iterator.counter.getOffset() + ckSize));
+        return Promise.resolve((0, skip_1.makeSkip)(iterator.counter.getOffset() + ckSize));
     }
     return Promise.resolve(null);
 };
+exports.parseData = parseData;

package/dist/containers/wav/parse-fmt.js

@@ -1,5 +1,8 @@
-import { registerAudioTrack } from '../../register-track';
-export const parseFmt = async ({ state, }) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFmt = void 0;
+const register_track_1 = require("../../register-track");
+const parseFmt = async ({ state, }) => {
     const { iterator } = state;
     const ckSize = iterator.getUint32Le(); // chunkSize
     const box = iterator.startBox(ckSize);
@@ -31,7 +34,7 @@ export const parseFmt = async ({ state, }) => {
         type: 'wav-fmt',
     };
     state.getWavStructure().boxes.push(wavHeader);
-    await registerAudioTrack({
+    await (0, register_track_1.registerAudioTrack)({
         state,
         track: {
             type: 'audio',
@@ -50,3 +53,4 @@ export const parseFmt = async ({ state, }) => {
     box.expectNoMoreBytes();
     return Promise.resolve(null);
 };
+exports.parseFmt = parseFmt;