@remotion/media-parser 4.0.277 → 4.0.279

package/dist/containers/riff/traversal.js

@@ -1,23 +1,31 @@
-export const isRiffAvi = (structure) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStrhBox = exports.getStrlBoxes = exports.getAvihBox = exports.getHdlrBox = exports.isRiffAvi = void 0;
+const isRiffAvi = (structure) => {
     return structure.boxes.some((box) => box.type === 'riff-header' && box.fileType === 'AVI');
 };
-export const getHdlrBox = (structure) => {
+exports.isRiffAvi = isRiffAvi;
+const getHdlrBox = (structure) => {
     return structure.boxes.find((box) => box.type === 'list-box' && box.listType === 'hdrl');
 };
-export const getAvihBox = (structure) => {
-    const hdlrBox = getHdlrBox(structure);
+exports.getHdlrBox = getHdlrBox;
+const getAvihBox = (structure) => {
+    const hdlrBox = (0, exports.getHdlrBox)(structure);
     if (!hdlrBox) {
         return null;
     }
     return hdlrBox.children.find((box) => box.type === 'avih-box');
 };
-export const getStrlBoxes = (structure) => {
-    const hdlrBox = getHdlrBox(structure);
+exports.getAvihBox = getAvihBox;
+const getStrlBoxes = (structure) => {
+    const hdlrBox = (0, exports.getHdlrBox)(structure);
     if (!hdlrBox) {
         return [];
     }
     return hdlrBox.children.filter((box) => box.type === 'list-box' && box.listType === 'strl');
 };
-export const getStrhBox = (strlBoxChildren) => {
+exports.getStrlBoxes = getStrlBoxes;
+const getStrhBox = (strlBoxChildren) => {
     return strlBoxChildren.find((box) => box.type === 'strh-box');
 };
+exports.getStrhBox = getStrhBox;

package/dist/containers/transport-stream/adts-header.js

@@ -1,10 +1,13 @@
-import { createAacCodecPrivate, getSampleRateFromSampleFrequencyIndex, } from '../../aac-codecprivate';
-import { getArrayBufferIterator } from '../../buffer-iterator';
-export const readAdtsHeader = (buffer) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAdtsHeader = void 0;
+const aac_codecprivate_1 = require("../../aac-codecprivate");
+const buffer_iterator_1 = require("../../iterator/buffer-iterator");
+const readAdtsHeader = (buffer) => {
     if (buffer.byteLength < 9) {
         return null;
     }
-    const iterator = getArrayBufferIterator(buffer, buffer.byteLength);
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(buffer, buffer.byteLength);
     iterator.startReadingBits();
     const bits = iterator.getBits(12);
     if (bits !== 0xfff) {
@@ -22,10 +25,10 @@ export const readAdtsHeader = (buffer) => {
     const protectionAbsent = iterator.getBits(1); // protection absent
     const audioObjectType = iterator.getBits(2); // 1 = 'AAC-LC'
     const samplingFrequencyIndex = iterator.getBits(4);
-    const sampleRate = getSampleRateFromSampleFrequencyIndex(samplingFrequencyIndex);
+    const sampleRate = (0, aac_codecprivate_1.getSampleRateFromSampleFrequencyIndex)(samplingFrequencyIndex);
     iterator.getBits(1); // private bit
     const channelConfiguration = iterator.getBits(3);
-    const codecPrivate = createAacCodecPrivate({
+    const codecPrivate = (0, aac_codecprivate_1.createAacCodecPrivate)({
         audioObjectType,
         sampleRate,
         channelConfiguration,
@@ -51,3 +54,4 @@ export const readAdtsHeader = (buffer) => {
         audioObjectType,
     };
 };
+exports.readAdtsHeader = readAdtsHeader;

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

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

package/dist/containers/transport-stream/discard-rest-of-packet.d.ts

@@ -1,3 +1,3 @@
-import type { BufferIterator } from '../../buffer-iterator';
+import type { BufferIterator } from '../../iterator/buffer-iterator';
 export declare const discardRestOfPacket: (iterator: BufferIterator) => void;
 export declare const getRestOfPacket: (iterator: BufferIterator) => Uint8Array;

package/dist/containers/transport-stream/discard-rest-of-packet.js

@@ -1,8 +1,13 @@
-export const discardRestOfPacket = (iterator) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRestOfPacket = exports.discardRestOfPacket = void 0;
+const discardRestOfPacket = (iterator) => {
     const next188 = 188 - (iterator.counter.getOffset() % 188);
     iterator.discard(next188);
 };
-export const getRestOfPacket = (iterator) => {
+exports.discardRestOfPacket = discardRestOfPacket;
+const getRestOfPacket = (iterator) => {
     const next188 = 188 - (iterator.counter.getOffset() % 188);
     return iterator.getSlice(next188);
 };
+exports.getRestOfPacket = getRestOfPacket;

package/dist/containers/transport-stream/find-separator.js

@@ -1,4 +1,7 @@
-export function findNthSubarrayIndex(array, subarray, n) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNthSubarrayIndex = findNthSubarrayIndex;
+function findNthSubarrayIndex(array, subarray, n) {
     const subarrayLength = subarray.length;
     const arrayLength = array.length;
     let count = 0;

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,15 @@
-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 emit_audio_sample_1 = require("../../emit-audio-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 +23,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 +46,12 @@ 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 (0, emit_audio_sample_1.emitAudioSample)({
+        trackId: programId,
+        audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)(sample, handle_avc_packet_1.MPEG_TIMESCALE),
+        state,
+    });
 };
+exports.handleAacPacket = handleAacPacket;

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

@@ -1,30 +1,34 @@
-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 emit_audio_sample_1 = require("../../emit-audio-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 +43,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 +55,14 @@ 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 (0, emit_audio_sample_1.emitVideoSample)({
+        trackId: programId,
+        videoSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)(sample, exports.MPEG_TIMESCALE),
+        state,
+    });
 };
+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.d.ts

@@ -1,4 +1,4 @@
-import type { BufferIterator } from '../../buffer-iterator';
+import type { BufferIterator } from '../../iterator/buffer-iterator';
 import type { TransportStreamPATBox, TransportStreamSdtBox } from './boxes';
 export type TransportStreamProgramAssociationTableEntry = {
     type: 'transport-stream-program-association-table';

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.d.ts

@@ -1,4 +1,4 @@
-import type { BufferIterator } from '../../buffer-iterator';
+import type { BufferIterator } from '../../iterator/buffer-iterator';
 export type PacketPes = {
     streamId: number;
     dts: number | null;

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.d.ts

@@ -1,4 +1,4 @@
-import type { BufferIterator } from '../../buffer-iterator';
+import type { BufferIterator } from '../../iterator/buffer-iterator';
 import type { TransportStreamPMTBox } from './boxes';
 export type TransportStreamEntry = {
     streamType: number;

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;