@remotion/media-parser 4.0.230 → 4.0.232

package/dist/esm/web-fs.mjs

@@ -1,7 +1,7 @@
 // src/writers/web-fs.ts
-var createContent = async () => {
+var createContent = async ({ filename }) => {
   const directoryHandle = await navigator.storage.getDirectory();
-  const filename = `media-parser-${Math.random().toString().replace("0.", "")}.webm`;
+  directoryHandle.removeEntry(filename);
   const fileHandle = await directoryHandle.getFileHandle(filename, {
     create: true
   });

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

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

package/dist/get-audio-codec.js

@@ -23,12 +23,7 @@ const getAudioCodec = (boxes, parserState) => {
 };
 exports.getAudioCodec = getAudioCodec;
 const hasAudioCodec = (boxes, state) => {
-    try {
-        return (0, exports.getAudioCodec)(boxes, state) !== null;
-    }
-    catch (_a) {
-        return false;
-    }
+    return (0, get_tracks_1.hasTracks)(boxes, state);
 };
 exports.hasAudioCodec = hasAudioCodec;
 const getCodecSpecificatorFromEsdsBox = ({ child, }) => {

package/dist/get-container.d.ts

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

package/dist/get-container.js

@@ -1,18 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasContainer = exports.getContainer = void 0;
-const traversal_1 = require("./boxes/iso-base-media/traversal");
-const traversal_2 = require("./boxes/webm/traversal");
+const traversal_1 = require("./boxes/riff/traversal");
 const getContainer = (segments) => {
-    const moovBox = (0, traversal_1.getMoovBox)(segments);
-    if (moovBox) {
+    if (segments.type === 'iso-base-media') {
         return 'mp4';
     }
-    const mainSegment = (0, traversal_2.getMainSegment)(segments);
-    if (mainSegment) {
+    if (segments.type === 'matroska') {
         return 'webm';
     }
-    return null;
+    if (segments.type === 'riff') {
+        if ((0, traversal_1.isRiffAvi)(segments)) {
+            return 'avi';
+        }
+    }
+    throw new Error('Unknown container');
 };
 exports.getContainer = getContainer;
 const hasContainer = (boxes) => {

package/dist/get-dimensions.d.ts

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

package/dist/get-duration.d.ts

@@ -1,4 +1,9 @@
-import type { AnySegment } from './parse-result';
+import type { AnySegment, Structure } from './parse-result';
 import type { ParserState } from './parser-state';
-export declare const getDuration: (boxes: AnySegment[], parserState: ParserState) => number | null;
-export declare const hasDuration: (boxes: AnySegment[], parserState: ParserState) => boolean;
+export declare const isMatroska: (boxes: AnySegment[]) => {
+    type: "Segment";
+    value: import("./boxes/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;

package/dist/get-duration.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasDuration = exports.getDuration = void 0;
+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 traversal_2 = require("./boxes/riff/traversal");
 const get_tracks_1 = require("./get-tracks");
 const getDurationFromMatroska = (segments) => {
     const mainSegment = segments.find((s) => s.type === 'Segment');
@@ -28,16 +29,17 @@ const getDurationFromMatroska = (segments) => {
     }
     return (duration.value.value / timestampScale.value.value) * 1000;
 };
-const getDuration = (boxes, parserState) => {
+const isMatroska = (boxes) => {
     const matroskaBox = boxes.find((b) => b.type === 'Segment');
-    if (matroskaBox) {
-        return getDurationFromMatroska(boxes);
-    }
-    const moovBox = (0, traversal_1.getMoovBox)(boxes);
+    return matroskaBox;
+};
+exports.isMatroska = isMatroska;
+const getDurationFromIsoBaseMedia = (structure, parserState) => {
+    const moovBox = (0, traversal_1.getMoovBox)(structure.boxes);
     if (!moovBox) {
         return null;
     }
-    const moofBox = (0, traversal_1.getMoofBox)(boxes);
+    const moofBox = (0, traversal_1.getMoofBox)(structure.boxes);
     const mvhdBox = (0, traversal_1.getMvhdBox)(moovBox);
     if (!mvhdBox) {
         return null;
@@ -48,7 +50,7 @@ const getDuration = (boxes, parserState) => {
     if (mvhdBox.durationInSeconds > 0) {
         return mvhdBox.durationInSeconds;
     }
-    const tracks = (0, get_tracks_1.getTracks)(boxes, parserState);
+    const tracks = (0, get_tracks_1.getTracks)(structure, parserState);
     const allTracks = [
         ...tracks.videoTracks,
         ...tracks.audioTracks,
@@ -63,14 +65,34 @@ const getDuration = (boxes, parserState) => {
     const highestTimestamp = Math.max(...allSamples);
     return highestTimestamp;
 };
-exports.getDuration = getDuration;
-const hasDuration = (boxes, parserState) => {
-    try {
-        const duration = (0, exports.getDuration)(boxes, parserState);
-        return (0, exports.getDuration)(boxes, parserState) !== null && duration !== 0;
+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) => {
+    if (structure.type === 'matroska') {
+        return getDurationFromMatroska(structure.boxes);
+    }
+    if (structure.type === 'iso-base-media') {
+        return getDurationFromIsoBaseMedia(structure, parserState);
     }
-    catch (_a) {
-        return false;
+    if (structure.type === 'riff') {
+        return getDurationFromAvi(structure);
     }
+    throw new Error('Has no duration');
+};
+exports.getDuration = getDuration;
+const hasDuration = (structure, parserState) => {
+    return (0, get_tracks_1.hasTracks)(structure, parserState);
 };
 exports.hasDuration = hasDuration;

package/dist/get-fps.d.ts

@@ -1,5 +1,5 @@
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
-import type { AnySegment } from './parse-result';
+import type { Structure } from './parse-result';
 type TimescaleAndDuration = {
     timescale: number;
     duration: number;
@@ -8,6 +8,6 @@ export declare const trakBoxContainsAudio: (trakBox: TrakBox) => boolean;
 export declare const trakBoxContainsVideo: (trakBox: TrakBox) => boolean;
 export declare const getTimescaleAndDuration: (trakBox: TrakBox) => TimescaleAndDuration | null;
 export declare const getFpsFromMp4TrakBox: (trakBox: TrakBox) => number | null;
-export declare const getFps: (segments: AnySegment[]) => number | null;
-export declare const hasFps: (boxes: AnySegment[]) => boolean;
+export declare const getFps: (segments: Structure) => number | null;
+export declare const hasFps: (boxes: Structure) => boolean;
 export {};

package/dist/get-fps.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasFps = 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 calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
     let totalSamples = 0;
     for (const sample of sttsBox.sampleDistribution) {
@@ -59,8 +60,8 @@ const getFpsFromMp4TrakBox = (trakBox) => {
     });
 };
 exports.getFpsFromMp4TrakBox = getFpsFromMp4TrakBox;
-const getFps = (segments) => {
-    const moovBox = (0, traversal_1.getMoovBox)(segments);
+const getFpsFromIsoMaseMedia = (structure) => {
+    const moovBox = (0, traversal_1.getMoovBox)(structure.boxes);
     if (!moovBox) {
         return null;
     }
@@ -71,9 +72,42 @@ const getFps = (segments) => {
     }
     return (0, exports.getFpsFromMp4TrakBox)(trackBox);
 };
+const getFpsFromAvi = (structure) => {
+    const strl = (0, traversal_2.getStrlBoxes)(structure);
+    for (const s of strl) {
+        const strh = (0, traversal_2.getStrhBox)(s.children);
+        if (!strh) {
+            throw new Error('No strh box');
+        }
+        if (strh.fccType === 'auds') {
+            continue;
+        }
+        return strh.rate;
+    }
+    return null;
+};
+const getFps = (segments) => {
+    if (segments.type === 'iso-base-media') {
+        return getFpsFromIsoMaseMedia(segments);
+    }
+    if (segments.type === 'riff') {
+        return getFpsFromAvi(segments);
+    }
+    // TODO: Matroska doesn't have Matroska
+    if (segments.type === 'matroska') {
+        return null;
+    }
+    throw new Error('Cannot get fps, not implemented');
+};
 exports.getFps = getFps;
 const hasFps = (boxes) => {
     try {
+        // Matroska has no FPS metadata
+        // Not bothering to parse
+        // Idea: `guaranteedFps` field
+        if (boxes.type === 'matroska') {
+            return true;
+        }
         return (0, exports.getFps)(boxes) !== null;
     }
     catch (_a) {

package/dist/get-tracks.d.ts

@@ -1,6 +1,7 @@
 import type { MoovBox } from './boxes/iso-base-media/moov/moov';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
-import type { AnySegment } from './parse-result';
+import type { AllTracks } from './boxes/riff/get-tracks-from-avi';
+import type { Structure } from './parse-result';
 import type { ParserState } from './parser-state';
 type SampleAspectRatio = {
     numerator: number;
@@ -54,10 +55,6 @@ export type OtherTrack = {
 };
 export type Track = VideoTrack | AudioTrack | OtherTrack;
 export declare const getNumberOfTracks: (moovBox: MoovBox) => number;
-export declare const hasTracks: (segments: AnySegment[]) => boolean;
-export declare const getTracks: (segments: AnySegment[], state: ParserState) => {
-    videoTracks: VideoTrack[];
-    audioTracks: AudioTrack[];
-    otherTracks: OtherTrack[];
-};
+export declare const hasTracks: (structure: Structure, state: ParserState) => boolean;
+export declare const getTracks: (segments: Structure, state: ParserState) => AllTracks;
 export {};

package/dist/get-tracks.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTracks = exports.hasTracks = exports.getNumberOfTracks = void 0;
 const make_track_1 = require("./boxes/iso-base-media/make-track");
 const traversal_1 = require("./boxes/iso-base-media/traversal");
+const get_tracks_from_avi_1 = require("./boxes/riff/get-tracks-from-avi");
 const get_ready_tracks_1 = require("./boxes/webm/get-ready-tracks");
 const traversal_2 = require("./boxes/webm/traversal");
 const getNumberOfTracks = (moovBox) => {
@@ -13,44 +14,59 @@ const getNumberOfTracks = (moovBox) => {
     return mvHdBox.nextTrackId - 1;
 };
 exports.getNumberOfTracks = getNumberOfTracks;
-const hasTracks = (segments) => {
-    const mainSegment = (0, traversal_2.getMainSegment)(segments);
-    if (mainSegment) {
+const hasTracks = (structure, state) => {
+    if (structure.type === 'matroska') {
+        const mainSegment = (0, traversal_2.getMainSegment)(structure.boxes);
+        if (!mainSegment) {
+            throw new Error('No main segment found');
+        }
         return (0, traversal_2.getTracksSegment)(mainSegment) !== null;
     }
-    const moovBox = (0, traversal_1.getMoovBox)(segments);
-    if (!moovBox) {
-        return false;
+    if (structure.type === 'iso-base-media') {
+        const moovBox = (0, traversal_1.getMoovBox)(structure.boxes);
+        if (!moovBox) {
+            return false;
+        }
+        const numberOfTracks = (0, exports.getNumberOfTracks)(moovBox);
+        const tracks = (0, traversal_1.getTraks)(moovBox);
+        return tracks.length === numberOfTracks;
     }
-    const numberOfTracks = (0, exports.getNumberOfTracks)(moovBox);
-    const tracks = (0, traversal_1.getTraks)(moovBox);
-    return tracks.length === numberOfTracks;
+    if (structure.type === 'riff') {
+        return (0, get_tracks_from_avi_1.hasAllTracksFromAvi)(structure, state);
+    }
+    throw new Error('Unknown container');
 };
 exports.hasTracks = hasTracks;
-const getTracks = (segments, state) => {
+const getTracksFromMa = (segments, state) => {
     const videoTracks = [];
     const audioTracks = [];
     const otherTracks = [];
     const mainSegment = segments.find((s) => s.type === 'Segment');
-    if (mainSegment && mainSegment.type === 'Segment') {
-        const matroskaTracks = (0, get_ready_tracks_1.getTracksFromMatroska)(mainSegment, state.getTimescale());
-        for (const track of matroskaTracks) {
-            if (track.type === 'video') {
-                videoTracks.push(track);
-            }
-            else if (track.type === 'audio') {
-                audioTracks.push(track);
-            }
-            else if (track.type === 'other') {
-                otherTracks.push(track);
-            }
+    if (!mainSegment) {
+        throw new Error('No main segment found');
+    }
+    const matroskaTracks = (0, get_ready_tracks_1.getTracksFromMatroska)(mainSegment, state.getTimescale());
+    for (const track of matroskaTracks) {
+        if (track.type === 'video') {
+            videoTracks.push(track);
+        }
+        else if (track.type === 'audio') {
+            audioTracks.push(track);
+        }
+        else if (track.type === 'other') {
+            otherTracks.push(track);
         }
-        return {
-            videoTracks,
-            audioTracks,
-            otherTracks,
-        };
     }
+    return {
+        videoTracks,
+        audioTracks,
+        otherTracks,
+    };
+};
+const getTracksFromIsoBaseMedia = (segments) => {
+    const videoTracks = [];
+    const audioTracks = [];
+    const otherTracks = [];
     const moovBox = (0, traversal_1.getMoovBox)(segments);
     if (!moovBox) {
         return {
@@ -81,4 +97,16 @@ const getTracks = (segments, state) => {
         otherTracks,
     };
 };
+const getTracks = (segments, state) => {
+    if (segments.type === 'matroska') {
+        return getTracksFromMa(segments.boxes, state);
+    }
+    if (segments.type === 'iso-base-media') {
+        return getTracksFromIsoBaseMedia(segments.boxes);
+    }
+    if (segments.type === 'riff') {
+        return (0, get_tracks_from_avi_1.getTracksFromAvi)(segments, state);
+    }
+    throw new Error('Unknown container');
+};
 exports.getTracks = getTracks;

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

@@ -1,9 +1,10 @@
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
-import type { MediaParserVideoCodec, VideoTrackColorParams } from './get-tracks';
-import type { AnySegment } from './parse-result';
+import { type MediaParserVideoCodec, type VideoTrackColorParams } from './get-tracks';
+import type { Structure } from './parse-result';
+import type { ParserState } from './parser-state';
 export declare const getVideoCodecFromIsoTrak: (trakBox: TrakBox) => "h264" | "av1" | "h265" | "prores";
-export declare const getVideoCodec: (boxes: AnySegment[]) => MediaParserVideoCodec | null;
-export declare const hasVideoCodec: (boxes: AnySegment[]) => boolean;
+export declare const getVideoCodec: (boxes: Structure) => MediaParserVideoCodec | null;
+export declare const hasVideoCodec: (boxes: Structure, state: ParserState) => boolean;
 export declare const getVideoPrivateData: (trakBox: TrakBox) => Uint8Array | null;
 export declare const getIsoBmColrConfig: (trakBox: TrakBox) => VideoTrackColorParams | null;
 export declare const getVideoCodecString: (trakBox: TrakBox) => string | null;

package/dist/get-video-codec.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVideoCodecString = exports.getIsoBmColrConfig = exports.getVideoPrivateData = exports.hasVideoCodec = exports.getVideoCodec = exports.getVideoCodecFromIsoTrak = void 0;
 const traversal_1 = require("./boxes/iso-base-media/traversal");
+const traversal_2 = require("./boxes/riff/traversal");
 const av1_codec_private_1 = require("./boxes/webm/av1-codec-private");
 const get_fps_1 = require("./get-fps");
 const get_sample_aspect_ratio_1 = require("./get-sample-aspect-ratio");
+const get_tracks_1 = require("./get-tracks");
 const getVideoCodecFromIsoTrak = (trakBox) => {
     const stsdBox = (0, traversal_1.getStsdBox)(trakBox);
     if (stsdBox && stsdBox.type === 'stsd-box') {
@@ -56,14 +58,7 @@ const getVideoCodecFromIsoTrak = (trakBox) => {
     throw new Error('Could not find video codec');
 };
 exports.getVideoCodecFromIsoTrak = getVideoCodecFromIsoTrak;
-const getVideoCodec = (boxes) => {
-    const moovBox = (0, traversal_1.getMoovBox)(boxes);
-    if (moovBox) {
-        const trakBox = (0, traversal_1.getTraks)(moovBox).filter((t) => (0, get_fps_1.trakBoxContainsVideo)(t))[0];
-        if (trakBox) {
-            return (0, exports.getVideoCodecFromIsoTrak)(trakBox);
-        }
-    }
+const getVideoCodecFromMatroska = (boxes) => {
     const mainSegment = boxes.find((b) => b.type === 'Segment');
     if (!mainSegment || mainSegment.type !== 'Segment') {
         return null;
@@ -94,16 +89,45 @@ const getVideoCodec = (boxes) => {
             }
         }
     }
-    return null;
+    throw new Error('Could not find video codec');
 };
-exports.getVideoCodec = getVideoCodec;
-const hasVideoCodec = (boxes) => {
-    try {
-        return (0, exports.getVideoCodec)(boxes) !== null;
+const getVideoCodecFromAvi = (structure) => {
+    const strl = (0, traversal_2.getStrlBoxes)(structure);
+    for (const s of strl) {
+        const strh = (0, traversal_2.getStrhBox)(s.children);
+        if (!strh) {
+            throw new Error('No strh box');
+        }
+        if (strh.fccType === 'auds') {
+            continue;
+        }
+        if (strh.handler === 'H264') {
+            return 'h264';
+        }
     }
-    catch (_a) {
-        return false;
+    throw new Error('Unsupported codec');
+};
+const getVideoCodec = (boxes) => {
+    if (boxes.type === 'iso-base-media') {
+        const moovBox = (0, traversal_1.getMoovBox)(boxes.boxes);
+        if (moovBox) {
+            const trakBox = (0, traversal_1.getTraks)(moovBox).filter((t) => (0, get_fps_1.trakBoxContainsVideo)(t))[0];
+            if (trakBox) {
+                return (0, exports.getVideoCodecFromIsoTrak)(trakBox);
+            }
+        }
+    }
+    if (boxes.type === 'riff') {
+        return getVideoCodecFromAvi(boxes);
     }
+    if (boxes.type === 'matroska') {
+        return getVideoCodecFromMatroska(boxes.boxes);
+    }
+    return null;
+};
+exports.getVideoCodec = getVideoCodec;
+const hasVideoCodec = (boxes, state) => {
+    return (0, get_tracks_1.hasTracks)(boxes, state);
 };
 exports.hasVideoCodec = hasVideoCodec;
 const getVideoPrivateData = (trakBox) => {

package/dist/has-all-info.d.ts

@@ -1,4 +1,4 @@
 import type { Options, ParseMediaFields } from './options';
-import type { ParseResult } from './parse-result';
+import type { ParseResult, Structure } from './parse-result';
 import type { ParserState } from './parser-state';
-export declare const getAvailableInfo: (options: Options<ParseMediaFields>, parseResult: ParseResult, state: ParserState) => Record<keyof Options<ParseMediaFields>, boolean>;
+export declare const getAvailableInfo: (options: Options<ParseMediaFields>, parseResult: ParseResult<Structure> | null, state: ParserState) => Record<keyof Options<ParseMediaFields>, boolean>;

package/dist/has-all-info.js

@@ -11,28 +11,28 @@ const get_video_codec_1 = require("./get-video-codec");
 const getAvailableInfo = (options, parseResult, state) => {
     const keys = Object.entries(options).filter(([, value]) => value);
     const infos = keys.map(([key]) => {
-        if (key === 'boxes') {
-            return parseResult.status === 'done';
+        if (key === 'structure') {
+            return Boolean(parseResult && parseResult.status === 'done');
         }
         if (key === 'durationInSeconds') {
-            return (0, get_duration_1.hasDuration)(parseResult.segments, state);
+            return Boolean(parseResult && (0, get_duration_1.hasDuration)(parseResult.segments, state));
         }
         if (key === 'dimensions' ||
             key === 'rotation' ||
             key === 'unrotatedDimensions') {
-            return (0, get_dimensions_1.hasDimensions)(parseResult.segments, state);
+            return Boolean(parseResult && (0, get_dimensions_1.hasDimensions)(parseResult.segments, state));
         }
         if (key === 'fps') {
-            return (0, get_fps_1.hasFps)(parseResult.segments);
+            return Boolean(parseResult && (0, get_fps_1.hasFps)(parseResult.segments));
         }
         if (key === 'videoCodec') {
-            return (0, get_video_codec_1.hasVideoCodec)(parseResult.segments);
+            return Boolean(parseResult && (0, get_video_codec_1.hasVideoCodec)(parseResult.segments, state));
         }
         if (key === 'audioCodec') {
-            return (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments, state);
+            return Boolean(parseResult && (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments, state));
         }
         if (key === 'tracks') {
-            return (0, get_tracks_1.hasTracks)(parseResult.segments);
+            return Boolean(parseResult && (0, get_tracks_1.hasTracks)(parseResult.segments, state));
         }
         if (key === 'internalStats') {
             return false;
@@ -44,7 +44,7 @@ const getAvailableInfo = (options, parseResult, state) => {
             return true;
         }
         if (key === 'container') {
-            return (0, get_container_1.hasContainer)(parseResult.segments);
+            return Boolean(parseResult && (0, get_container_1.hasContainer)(parseResult.segments));
         }
         throw new Error(`Unknown key: ${key}`);
     });

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import type { LogLevel } from './log';
 export { WriterInterface } from './writers/writer';
 export { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
-export type { Options, ParseMediaContainer, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOptions, ParseMediaResult, TracksField, } from './options';
+export type { Options, ParseMediaContainer, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, TracksField, } from './options';
 export { parseMedia } from './parse-media';
 export { AudioOrVideoSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, } from './webcodec-sample-types';
 export type { MediaFn } from './create/media-fn';
@@ -9,8 +9,9 @@ export { Dimensions } from './get-dimensions';
 export type { ReaderInterface } from './readers/reader';
 export type { LogLevel };
 export declare const MediaParserInternals: {
-    createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
-    createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
+    createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
+    createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
+    createWav: ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
     Log: {
         trace: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
         verbose: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
@@ -19,3 +20,4 @@ export declare const MediaParserInternals: {
         error: (...args: Parameters<typeof console.log>) => void;
     };
 };
+export { VERSION } from './version';

package/dist/index.js

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MediaParserInternals = exports.parseMedia = void 0;
+exports.VERSION = exports.MediaParserInternals = exports.parseMedia = void 0;
 const create_iso_base_media_1 = require("./create/iso-base-media/create-iso-base-media");
 const create_matroska_media_1 = require("./create/matroska/create-matroska-media");
+const create_wav_1 = require("./create/wav/create-wav");
 const log_1 = require("./log");
 var parse_media_1 = require("./parse-media");
 Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
 exports.MediaParserInternals = {
     createMatroskaMedia: create_matroska_media_1.createMatroskaMedia,
     createIsoBaseMedia: create_iso_base_media_1.createIsoBaseMedia,
+    createWav: create_wav_1.createWav,
     Log: log_1.Log,
 };
+var version_1 = require("./version");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });