@remotion/media-parser 4.0.249 → 4.0.251

package/dist/file-types/detect-file-type.d.ts

@@ -12,6 +12,7 @@ export declare const isTransportStream: (data: Uint8Array) => boolean;
 export declare const isMp3: (data: Uint8Array) => boolean;
 export declare const isGif: (data: Uint8Array) => boolean;
 export declare const isAac: (data: Uint8Array) => boolean;
+export declare const isFlac: (data: Uint8Array) => boolean;
 export type RiffType = {
     type: 'riff';
 };
@@ -36,7 +37,10 @@ export type WavType = {
 export type GifType = {
     type: 'gif';
 };
+export type FlacType = {
+    type: 'flac';
+};
 export type UnknownType = {
     type: 'unknown';
 };
-export type FileType = JpegType | WebpType | RiffType | WebmType | WavType | PdfType | AacType | IsoBaseMediaType | TransportStreamType | Mp3Type | GifType | PngType | BmpType | AacType | UnknownType;
+export type FileType = JpegType | WebpType | RiffType | WebmType | WavType | PdfType | AacType | IsoBaseMediaType | TransportStreamType | Mp3Type | GifType | PngType | BmpType | AacType | FlacType | UnknownType;

package/dist/file-types/detect-file-type.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAac = exports.isGif = exports.isMp3 = exports.isTransportStream = exports.isIsoBaseMedia = exports.isWebm = exports.isRiffWave = exports.isRiffAvi = exports.matchesPattern = void 0;
+exports.isFlac = exports.isAac = exports.isGif = exports.isMp3 = exports.isTransportStream = exports.isIsoBaseMedia = exports.isWebm = exports.isRiffWave = exports.isRiffAvi = exports.matchesPattern = void 0;
 const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
 const matchesPattern = (pattern) => {
     return (data) => {
@@ -43,10 +43,12 @@ const isTransportStream = (data) => {
 exports.isTransportStream = isTransportStream;
 const isMp3 = (data) => {
     const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
-    const id3v3Pattern = new Uint8Array([73, 68, 51, 3]);
-    const id3v2Pattern = new Uint8Array([73, 68, 51, 2]);
+    const id3v4Pattern = new Uint8Array([0x49, 0x44, 0x33, 4]);
+    const id3v3Pattern = new Uint8Array([0x49, 0x44, 0x33, 3]);
+    const id3v2Pattern = new Uint8Array([0x49, 0x44, 0x33, 2]);
     const subarray = data.subarray(0, 4);
     return ((0, exports.matchesPattern)(mpegPattern)(subarray) ||
+        (0, exports.matchesPattern)(id3v4Pattern)(subarray) ||
         (0, exports.matchesPattern)(id3v3Pattern)(subarray) ||
         (0, exports.matchesPattern)(id3v2Pattern)(subarray));
 };
@@ -61,3 +63,8 @@ const isAac = (data) => {
     return (0, exports.matchesPattern)(aacPattern)(data.subarray(0, 2));
 };
 exports.isAac = isAac;
+const isFlac = (data) => {
+    const flacPattern = new Uint8Array([0x66, 0x4c, 0x61, 0x43]);
+    return (0, exports.matchesPattern)(flacPattern)(data.subarray(0, 4));
+};
+exports.isFlac = isFlac;

package/dist/file-types/index.js

@@ -17,6 +17,9 @@ const detectFileType = (data) => {
     if ((0, detect_file_type_1.isAac)(data)) {
         return { type: 'aac' };
     }
+    if ((0, detect_file_type_1.isFlac)(data)) {
+        return { type: 'flac' };
+    }
     const webp = (0, webp_1.isWebp)(data);
     if (webp) {
         return webp;

package/dist/get-audio-codec.d.ts

@@ -1,10 +1,9 @@
-import type { MoovBox } from './boxes/iso-base-media/moov/moov';
-import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { MoovBox } from './containers/iso-base-media/moov/moov';
+import type { TrakBox } from './containers/iso-base-media/trak/trak';
 import { type MediaParserAudioCodec } from './get-tracks';
-import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const getAudioCodec: (boxes: Structure, parserState: ParserState) => MediaParserAudioCodec | null;
-export declare const hasAudioCodec: (boxes: Structure, state: ParserState) => boolean;
+export declare const getAudioCodec: (parserState: ParserState) => MediaParserAudioCodec | null;
+export declare const hasAudioCodec: (state: ParserState) => boolean;
 type AudioCodecInfo = {
     format: string;
     primarySpecificator: number | null;

package/dist/get-audio-codec.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioCodecFromTrack = exports.getAudioCodecStringFromTrak = exports.getAudioCodecFromIso = exports.isLpcmAudioCodec = exports.getAudioCodecFromTrak = exports.getSampleRate = exports.getNumberOfChannelsFromTrak = exports.getCodecPrivateFromTrak = exports.hasAudioCodec = exports.getAudioCodec = void 0;
-const traversal_1 = require("./boxes/iso-base-media/traversal");
+const traversal_1 = require("./containers/iso-base-media/traversal");
 const get_fps_1 = require("./get-fps");
 const get_tracks_1 = require("./get-tracks");
-const getAudioCodec = (boxes, parserState) => {
-    const tracks = (0, get_tracks_1.getTracks)(boxes, parserState);
+const getAudioCodec = (parserState) => {
+    const tracks = (0, get_tracks_1.getTracks)(parserState);
     const allTracks = tracks.audioTracks.length +
         tracks.otherTracks.length +
         tracks.videoTracks.length;
@@ -22,8 +22,8 @@ const getAudioCodec = (boxes, parserState) => {
     return null;
 };
 exports.getAudioCodec = getAudioCodec;
-const hasAudioCodec = (boxes, state) => {
-    return (0, get_tracks_1.getHasTracks)(boxes, state);
+const hasAudioCodec = (state) => {
+    return (0, get_tracks_1.getHasTracks)(state);
 };
 exports.hasAudioCodec = hasAudioCodec;
 const getCodecSpecificatorFromEsdsBox = ({ child, }) => {

package/dist/get-container.d.ts

@@ -1,4 +1,4 @@
-import type { ParseMediaContainer } from './options';
+import type { MediaParserContainer } from './options';
 import type { Structure } from './parse-result';
-export declare const getContainer: (segments: Structure) => ParseMediaContainer;
+export declare const getContainer: (segments: Structure) => MediaParserContainer;
 export declare const hasContainer: (boxes: Structure) => boolean;

package/dist/get-container.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasContainer = exports.getContainer = void 0;
-const traversal_1 = require("./boxes/riff/traversal");
+const traversal_1 = require("./containers/riff/traversal");
 const getContainer = (segments) => {
     if (segments.type === 'iso-base-media') {
         return 'mp4';
@@ -15,12 +15,21 @@ const getContainer = (segments) => {
     if (segments.type === 'mp3') {
         return 'mp3';
     }
+    if (segments.type === 'wav') {
+        return 'wav';
+    }
+    if (segments.type === 'flac') {
+        return 'flac';
+    }
     if (segments.type === 'riff') {
         if ((0, traversal_1.isRiffAvi)(segments)) {
             return 'avi';
         }
         throw new Error('Unknown RIFF container ' + segments.type);
     }
+    if (segments.type === 'aac') {
+        return 'aac';
+    }
     throw new Error('Unknown container ' + segments);
 };
 exports.getContainer = getContainer;

package/dist/get-dimensions.d.ts

@@ -1,4 +1,3 @@
-import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
 export type Dimensions = {
     width: number;
@@ -9,5 +8,5 @@ export type ExpandedDimensions = Dimensions & {
     unrotatedWidth: number;
     unrotatedHeight: number;
 };
-export declare const getDimensions: (boxes: Structure, state: ParserState) => ExpandedDimensions | null;
-export declare const hasDimensions: (boxes: Structure, state: ParserState) => boolean;
+export declare const getDimensions: (state: ParserState) => ExpandedDimensions | null;
+export declare const hasDimensions: (state: ParserState) => boolean;

package/dist/get-dimensions.js

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasDimensions = exports.getDimensions = void 0;
 const get_tracks_1 = require("./get-tracks");
-const getDimensions = (boxes, state) => {
-    const { videoTracks } = (0, get_tracks_1.getTracks)(boxes, state);
+const is_audio_structure_1 = require("./is-audio-structure");
+const getDimensions = (state) => {
+    const structure = state.structure.getStructureOrNull();
+    if (structure && (0, is_audio_structure_1.isAudioStructure)(structure)) {
+        return null;
+    }
+    const { videoTracks } = (0, get_tracks_1.getTracks)(state);
     if (!videoTracks.length) {
-        if (boxes.type === 'mp3') {
-            return null;
-        }
-        throw new Error('Expected video track');
+        return null;
     }
     const firstVideoTrack = videoTracks[0];
     return {
@@ -20,11 +22,13 @@ const getDimensions = (boxes, state) => {
     };
 };
 exports.getDimensions = getDimensions;
-// TODO: An audio track should return 'hasDimensions' = true on an audio file
-// and stop parsing
-const hasDimensions = (boxes, state) => {
+const hasDimensions = (state) => {
+    const structure = state.structure.getStructureOrNull();
+    if (structure && (0, is_audio_structure_1.isAudioStructure)(structure)) {
+        return true;
+    }
     try {
-        return (0, exports.getDimensions)(boxes, state) !== null;
+        return (0, exports.getDimensions)(state) !== null;
     }
     catch (_a) {
         return false;

package/dist/get-duration.d.ts

@@ -1,10 +1,10 @@
-import type { AnySegment, Structure } from './parse-result';
+import type { AnySegment } from './parse-result';
 import type { ParserState } from './state/parser-state';
 export declare const isMatroska: (boxes: AnySegment[]) => {
     type: "Segment";
-    value: import("./boxes/webm/segments/all-segments").PossibleEbml[];
+    value: import("./containers/webm/segments/all-segments").PossibleEbml[];
     minVintWidth: number | null;
 } | undefined;
-export declare const getDuration: (structure: Structure, parserState: ParserState) => number | null;
-export declare const hasDuration: (structure: Structure, parserState: ParserState) => boolean;
-export declare const hasSlowDuration: (structure: Structure, parserState: ParserState) => boolean;
+export declare const getDuration: (parserState: ParserState) => number | null;
+export declare const hasDuration: (parserState: ParserState) => boolean;
+export declare const hasSlowDuration: (parserState: ParserState) => boolean;

package/dist/get-duration.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasSlowDuration = exports.hasDuration = exports.getDuration = exports.isMatroska = void 0;
-const get_sample_positions_from_track_1 = require("./boxes/iso-base-media/get-sample-positions-from-track");
-const traversal_1 = require("./boxes/iso-base-media/traversal");
-const get_duration_1 = require("./boxes/mp3/get-duration");
-const traversal_2 = require("./boxes/riff/traversal");
+const get_duration_from_flac_1 = require("./containers/flac/get-duration-from-flac");
+const get_sample_positions_from_track_1 = require("./containers/iso-base-media/get-sample-positions-from-track");
+const traversal_1 = require("./containers/iso-base-media/traversal");
+const get_duration_1 = require("./containers/mp3/get-duration");
+const get_duration_2 = require("./containers/riff/get-duration");
+const get_duration_from_wav_1 = require("./containers/wav/get-duration-from-wav");
 const get_tracks_1 = require("./get-tracks");
 const getDurationFromMatroska = (segments) => {
     const mainSegment = segments.find((s) => s.type === 'Segment');
@@ -35,7 +37,11 @@ const isMatroska = (boxes) => {
     return matroskaBox;
 };
 exports.isMatroska = isMatroska;
-const getDurationFromIsoBaseMedia = (structure, parserState) => {
+const getDurationFromIsoBaseMedia = (parserState) => {
+    const structure = parserState.structure.getStructure();
+    if (structure.type !== 'iso-base-media') {
+        throw new Error('Expected iso-base-media');
+    }
     const moovBox = (0, traversal_1.getMoovBox)(structure.boxes);
     if (!moovBox) {
         return null;
@@ -51,7 +57,7 @@ const getDurationFromIsoBaseMedia = (structure, parserState) => {
     if (mvhdBox.durationInSeconds > 0) {
         return mvhdBox.durationInSeconds;
     }
-    const tracks = (0, get_tracks_1.getTracks)(structure, parserState);
+    const tracks = (0, get_tracks_1.getTracks)(parserState);
     const allTracks = [
         ...tracks.videoTracks,
         ...tracks.audioTracks,
@@ -66,29 +72,16 @@ const getDurationFromIsoBaseMedia = (structure, parserState) => {
     const highestTimestamp = Math.max(...allSamples);
     return highestTimestamp;
 };
-const getDurationFromAvi = (structure) => {
-    const strl = (0, traversal_2.getStrlBoxes)(structure);
-    const lengths = [];
-    for (const s of strl) {
-        const strh = (0, traversal_2.getStrhBox)(s.children);
-        if (!strh) {
-            throw new Error('No strh box');
-        }
-        const samplesPerSecond = strh.rate / strh.scale;
-        const streamLength = strh.length / samplesPerSecond;
-        lengths.push(streamLength);
-    }
-    return Math.max(...lengths);
-};
-const getDuration = (structure, parserState) => {
+const getDuration = (parserState) => {
+    const structure = parserState.structure.getStructure();
     if (structure.type === 'matroska') {
         return getDurationFromMatroska(structure.boxes);
     }
     if (structure.type === 'iso-base-media') {
-        return getDurationFromIsoBaseMedia(structure, parserState);
+        return getDurationFromIsoBaseMedia(parserState);
     }
     if (structure.type === 'riff') {
-        return getDurationFromAvi(structure);
+        return (0, get_duration_2.getDurationFromAvi)(structure);
     }
     if (structure.type === 'transport-stream') {
         return null;
@@ -96,20 +89,29 @@ const getDuration = (structure, parserState) => {
     if (structure.type === 'mp3') {
         return (0, get_duration_1.getDurationFromMp3)(parserState);
     }
+    if (structure.type === 'wav') {
+        return (0, get_duration_from_wav_1.getDurationFromWav)(parserState);
+    }
+    if (structure.type === 'aac') {
+        return null;
+    }
+    if (structure.type === 'flac') {
+        return (0, get_duration_from_flac_1.getDurationFromFlac)(parserState);
+    }
     throw new Error('Has no duration ' + structure);
 };
 exports.getDuration = getDuration;
 // `duration` just grabs from metadata, and otherwise returns null
 // Therefore just checking if we have tracks
-const hasDuration = (structure, parserState) => {
-    return (0, get_tracks_1.getHasTracks)(structure, parserState);
+const hasDuration = (parserState) => {
+    return (0, get_tracks_1.getHasTracks)(parserState);
 };
 exports.hasDuration = hasDuration;
 // `slowDuration` does through everything, and therefore is false
 // Unless it it somewhere in the metadata and is non-null
-const hasSlowDuration = (structure, parserState) => {
+const hasSlowDuration = (parserState) => {
     try {
-        return (0, exports.getDuration)(structure, parserState) !== null;
+        return (0, exports.getDuration)(parserState) !== null;
     }
     catch (_a) {
         return false;

package/dist/get-fields-from-callbacks.js

@@ -26,6 +26,10 @@ const getFieldsFromCallback = ({ fields, callbacks, }) => {
         slowNumberOfFrames: Boolean(callbacks.onSlowNumberOfFrames),
         keyframes: Boolean(callbacks.onKeyframes),
         images: Boolean(callbacks.onImages),
+        numberOfAudioChannels: Boolean(callbacks.onNumberOfAudioChannels),
+        sampleRate: Boolean(callbacks.onSampleRate),
+        slowAudioBitrate: Boolean(callbacks.onSlowAudioBitrate),
+        slowVideoBitrate: Boolean(callbacks.onSlowVideoBitrate),
         ...fields,
     };
     return newFields;

package/dist/get-fps.d.ts

@@ -1,4 +1,4 @@
-import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { TrakBox } from './containers/iso-base-media/trak/trak';
 import type { Structure } from './parse-result';
 type TimescaleAndDuration = {
     timescale: number;

package/dist/get-fps.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasFps = exports.hasFpsSuitedForSlowFps = exports.getFps = exports.getFpsFromMp4TrakBox = exports.getTimescaleAndDuration = exports.trakBoxContainsVideo = exports.trakBoxContainsAudio = void 0;
-const traversal_1 = require("./boxes/iso-base-media/traversal");
-const traversal_2 = require("./boxes/riff/traversal");
+const traversal_1 = require("./containers/iso-base-media/traversal");
+const traversal_2 = require("./containers/riff/traversal");
+const is_audio_structure_1 = require("./is-audio-structure");
 const calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
     let totalSamples = 0;
     for (const sample of sttsBox.sampleDistribution) {
@@ -101,10 +102,13 @@ const getFps = (segments) => {
     if (segments.type === 'transport-stream') {
         return null;
     }
-    if (segments.type === 'mp3') {
+    if (segments.type === 'mp3' ||
+        segments.type === 'wav' ||
+        segments.type === 'flac' ||
+        segments.type === 'aac') {
         return null;
     }
-    throw new Error('Cannot get fps, not implemented');
+    throw new Error('Cannot get fps, not implemented: ' + segments);
 };
 exports.getFps = getFps;
 const hasFpsSuitedForSlowFps = (boxes) => {
@@ -120,6 +124,10 @@ const hasFps = (boxes) => {
     // Matroska and Transport stream has no FPS metadata
     // Not bothering to parse
     // Users should use `slowFps` field
+    // same goes for audio
+    if ((0, is_audio_structure_1.isAudioStructure)(boxes)) {
+        return true;
+    }
     if (boxes.type === 'matroska') {
         return true;
     }

package/dist/get-is-hdr.d.ts

@@ -1,4 +1,3 @@
-import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const getIsHdr: (boxes: Structure, state: ParserState) => boolean;
-export declare const hasHdr: (boxes: Structure, state: ParserState) => boolean;
+export declare const getIsHdr: (state: ParserState) => boolean;
+export declare const hasHdr: (state: ParserState) => boolean;

package/dist/get-is-hdr.js

@@ -7,12 +7,12 @@ const isVideoTrackHdr = (track) => {
         track.color.transferCharacteristics === 'arib-std-b67' &&
         track.color.primaries === 'bt2020');
 };
-const getIsHdr = (boxes, state) => {
-    const { videoTracks } = (0, get_tracks_1.getTracks)(boxes, state);
+const getIsHdr = (state) => {
+    const { videoTracks } = (0, get_tracks_1.getTracks)(state);
     return videoTracks.some((track) => isVideoTrackHdr(track));
 };
 exports.getIsHdr = getIsHdr;
-const hasHdr = (boxes, state) => {
-    return (0, get_tracks_1.getHasTracks)(boxes, state);
+const hasHdr = (state) => {
+    return (0, get_tracks_1.getHasTracks)(state);
 };
 exports.hasHdr = hasHdr;

package/dist/get-keyframes.d.ts

@@ -2,4 +2,4 @@ import type { MediaParserKeyframe } from './options';
 import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
 export declare const getKeyframes: (structure: Structure) => MediaParserKeyframe[] | null;
-export declare const hasKeyframes: (structure: Structure, parserState: ParserState) => boolean;
+export declare const hasKeyframes: (parserState: ParserState) => boolean;

package/dist/get-keyframes.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasKeyframes = exports.getKeyframes = void 0;
-const get_keyframes_1 = require("./boxes/iso-base-media/get-keyframes");
+const get_keyframes_1 = require("./containers/iso-base-media/get-keyframes");
 const get_tracks_1 = require("./get-tracks");
 const getKeyframes = (structure) => {
     if (structure.type === 'iso-base-media') {
@@ -10,9 +10,10 @@ const getKeyframes = (structure) => {
     return null;
 };
 exports.getKeyframes = getKeyframes;
-const hasKeyframes = (structure, parserState) => {
+const hasKeyframes = (parserState) => {
+    const structure = parserState.structure.getStructure();
     if (structure.type === 'iso-base-media') {
-        return (0, get_tracks_1.getHasTracks)(structure, parserState);
+        return (0, get_tracks_1.getHasTracks)(parserState);
     }
     // Has, but will be null
     return true;

package/dist/get-number-of-audio-channels.d.ts

@@ -0,0 +1,3 @@
+import type { ParserState } from './state/parser-state';
+export declare const getNumberOfAudioChannels: (state: ParserState) => number | null;
+export declare const hasNumberOfAudioChannels: (state: ParserState) => boolean;

package/dist/get-number-of-audio-channels.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNumberOfAudioChannels = exports.getNumberOfAudioChannels = void 0;
+const getNumberOfAudioChannels = (state) => {
+    var _a, _b;
+    return ((_b = (_a = state.callbacks.tracks.getTracks().find((track) => {
+        return track.type === 'audio';
+    })) === null || _a === void 0 ? void 0 : _a.numberOfChannels) !== null && _b !== void 0 ? _b : null);
+};
+exports.getNumberOfAudioChannels = getNumberOfAudioChannels;
+const hasNumberOfAudioChannels = (state) => {
+    return state.callbacks.tracks.hasAllTracks();
+};
+exports.hasNumberOfAudioChannels = hasNumberOfAudioChannels;

package/dist/get-sample-aspect-ratio.d.ts

@@ -1,11 +1,11 @@
-import type { Av1CBox } from './boxes/iso-base-media/stsd/av1c';
-import type { AvccBox } from './boxes/iso-base-media/stsd/avcc';
-import type { ColorParameterBox } from './boxes/iso-base-media/stsd/colr';
-import type { HvccBox } from './boxes/iso-base-media/stsd/hvcc';
-import type { PaspBox } from './boxes/iso-base-media/stsd/pasp';
-import type { VideoSample } from './boxes/iso-base-media/stsd/samples';
-import type { TkhdBox } from './boxes/iso-base-media/tkhd';
-import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { Av1CBox } from './containers/iso-base-media/stsd/av1c';
+import type { AvccBox } from './containers/iso-base-media/stsd/avcc';
+import type { ColorParameterBox } from './containers/iso-base-media/stsd/colr';
+import type { HvccBox } from './containers/iso-base-media/stsd/hvcc';
+import type { PaspBox } from './containers/iso-base-media/stsd/pasp';
+import type { VideoSample } from './containers/iso-base-media/stsd/samples';
+import type { TkhdBox } from './containers/iso-base-media/tkhd';
+import type { TrakBox } from './containers/iso-base-media/trak/trak';
 import type { Dimensions } from './get-dimensions';
 type AspectRatio = {
     numerator: number;

package/dist/get-sample-aspect-ratio.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDisplayAspectRatio = exports.applyAspectRatios = exports.applyTkhdBox = exports.getColrBox = exports.getSampleAspectRatio = exports.getHvccBox = exports.getPaspBox = exports.getAv1CBox = exports.getAvccBox = exports.getStsdVideoConfig = void 0;
-const traversal_1 = require("./boxes/iso-base-media/traversal");
+const traversal_1 = require("./containers/iso-base-media/traversal");
 const getStsdVideoConfig = (trakBox) => {
     const stsdBox = (0, traversal_1.getStsdBox)(trakBox);
     if (!stsdBox) {

package/dist/get-sample-positions-from-lpcm.d.ts

@@ -1,3 +1,3 @@
-import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { TrakBox } from './containers/iso-base-media/trak/trak';
 import type { SamplePosition } from './get-sample-positions';
 export declare const getSamplePositionsFromLpcm: (trakBox: TrakBox) => SamplePosition[];

package/dist/get-sample-positions-from-lpcm.js

@@ -3,7 +3,7 @@
 // We need to handle this case differently and treat each chunk as a sample instead
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSamplePositionsFromLpcm = void 0;
-const traversal_1 = require("./boxes/iso-base-media/traversal");
+const traversal_1 = require("./containers/iso-base-media/traversal");
 // example video: mehmet.mov
 const getSamplePositionsFromLpcm = (trakBox) => {
     const stscBox = (0, traversal_1.getStscBox)(trakBox);

package/dist/get-sample-positions.d.ts

@@ -1,9 +1,9 @@
-import type { CttsBox } from './boxes/iso-base-media/stsd/ctts';
-import type { StcoBox } from './boxes/iso-base-media/stsd/stco';
-import type { StscBox } from './boxes/iso-base-media/stsd/stsc';
-import type { StssBox } from './boxes/iso-base-media/stsd/stss';
-import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
-import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
+import type { CttsBox } from './containers/iso-base-media/stsd/ctts';
+import type { StcoBox } from './containers/iso-base-media/stsd/stco';
+import type { StscBox } from './containers/iso-base-media/stsd/stsc';
+import type { StssBox } from './containers/iso-base-media/stsd/stss';
+import type { StszBox } from './containers/iso-base-media/stsd/stsz';
+import type { SttsBox } from './containers/iso-base-media/stsd/stts';
 export type SamplePosition = {
     offset: number;
     size: number;

package/dist/get-sample-rate.d.ts

@@ -0,0 +1,3 @@
+import type { ParserState } from './state/parser-state';
+export declare const getSampleRate: (state: ParserState) => number | null;
+export declare const hasSampleRate: (state: ParserState) => boolean;

package/dist/get-sample-rate.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasSampleRate = exports.getSampleRate = void 0;
+const getSampleRate = (state) => {
+    var _a, _b;
+    return ((_b = (_a = state.callbacks.tracks.getTracks().find((track) => {
+        return track.type === 'audio';
+    })) === null || _a === void 0 ? void 0 : _a.sampleRate) !== null && _b !== void 0 ? _b : null);
+};
+exports.getSampleRate = getSampleRate;
+const hasSampleRate = (state) => {
+    return state.callbacks.tracks.hasAllTracks();
+};
+exports.hasSampleRate = hasSampleRate;

package/dist/get-tracks.d.ts

@@ -1,8 +1,9 @@
-import type { MatrixCoefficients, Primaries, TransferCharacteristics } from './boxes/avc/color';
-import type { MoovBox } from './boxes/iso-base-media/moov/moov';
-import type { TrakBox } from './boxes/iso-base-media/trak/trak';
-import type { AllTracks } from './boxes/riff/get-tracks-from-avi';
-import type { IsoBaseMediaBox, IsoBaseMediaStructure, Structure } from './parse-result';
+import type { MatrixCoefficients, Primaries, TransferCharacteristics } from './containers/avc/color';
+import type { IsoBaseMediaBox } from './containers/iso-base-media/base-media-box';
+import type { MoovBox } from './containers/iso-base-media/moov/moov';
+import type { TrakBox } from './containers/iso-base-media/trak/trak';
+import type { AllTracks } from './containers/riff/get-tracks-from-avi';
+import type { IsoBaseMediaStructure } from './parse-result';
 import type { ParserState } from './state/parser-state';
 type SampleAspectRatio = {
     numerator: number;
@@ -15,7 +16,7 @@ export type VideoTrackColorParams = {
     fullRange: boolean | null;
 };
 export type MediaParserVideoCodec = 'vp8' | 'vp9' | 'h264' | 'av1' | 'h265' | 'prores';
-export type MediaParserAudioCodec = 'opus' | 'aac' | 'mp3' | 'vorbis' | 'pcm-u8' | 'pcm-s16' | 'pcm-s24' | 'pcm-s32' | 'pcm-f32' | 'aiff';
+export type MediaParserAudioCodec = 'opus' | 'aac' | 'mp3' | 'vorbis' | 'pcm-u8' | 'pcm-s16' | 'pcm-s24' | 'pcm-s32' | 'pcm-f32' | 'flac' | 'aiff';
 export type VideoTrack = {
     type: 'video';
     trackId: number;
@@ -57,11 +58,11 @@ export type OtherTrack = {
 export type Track = VideoTrack | AudioTrack | OtherTrack;
 export declare const getNumberOfTracks: (moovBox: MoovBox) => number;
 export declare const isoBaseMediaHasTracks: (structure: IsoBaseMediaStructure) => boolean;
-export declare const getHasTracks: (structure: Structure, state: ParserState) => boolean;
+export declare const getHasTracks: (state: ParserState) => boolean;
 export declare const getTracksFromIsoBaseMedia: (segments: IsoBaseMediaBox[]) => {
     videoTracks: VideoTrack[];
     audioTracks: AudioTrack[];
     otherTracks: OtherTrack[];
 };
-export declare const getTracks: (segments: Structure, state: ParserState) => AllTracks;
+export declare const getTracks: (state: ParserState) => AllTracks;
 export {};