@remotion/media-parser 4.0.230 → 4.0.231

package/dist/boxes/webm/parse-webm-header.js

@@ -2,14 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWebm = void 0;
 const parse_children_1 = require("./segments/parse-children");
+const continueAfterMatroskaResult = (result, children) => {
+    if (result.status === 'done') {
+        return {
+            status: 'done',
+            segments: children,
+        };
+    }
+    return {
+        status: 'incomplete',
+        segments: children,
+        continueParsing: async () => {
+            const newResult = await result.continueParsing();
+            return continueAfterMatroskaResult(newResult, children);
+        },
+        skipTo: null,
+    };
+};
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
-const parseWebm = (counter, parserContext) => {
-    return (0, parse_children_1.expectChildren)({
+const parseWebm = async (counter, parserContext) => {
+    const children = [];
+    const results = await (0, parse_children_1.expectChildren)({
         iterator: counter,
         length: Infinity,
-        initialChildren: [],
-        wrap: null,
+        children,
         parserContext,
+        startOffset: counter.counter.getOffset(),
     });
+    return continueAfterMatroskaResult(results, children);
 };
 exports.parseWebm = parseWebm;

package/dist/boxes/webm/segments/parse-children.d.ts

@@ -1,13 +1,18 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { ParseResult } from '../../../parse-result';
+import type { ExpectSegmentParseResult, MatroskaParseResult } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 import type { MatroskaSegment } from '../segments';
-type WrapChildren = (segments: MatroskaSegment[]) => MatroskaSegment;
-export declare const expectChildren: ({ iterator, length, initialChildren, wrap, parserContext, }: {
+import type { PossibleEbml } from './all-segments';
+export declare const expectAndProcessSegment: ({ iterator, parserContext, offset, children, }: {
+    iterator: BufferIterator;
+    parserContext: ParserContext;
+    offset: number;
+    children: PossibleEbml[];
+}) => Promise<ExpectSegmentParseResult>;
+export declare const expectChildren: ({ iterator, length, children, parserContext, startOffset, }: {
     iterator: BufferIterator;
     length: number;
-    initialChildren: MatroskaSegment[];
-    wrap: WrapChildren | null;
+    children: MatroskaSegment[];
     parserContext: ParserContext;
-}) => Promise<ParseResult>;
-export {};
+    startOffset: number;
+}) => Promise<MatroskaParseResult>;

package/dist/boxes/webm/segments/parse-children.js

@@ -1,100 +1,110 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectChildren = void 0;
+exports.expectChildren = exports.expectAndProcessSegment = void 0;
 const segments_1 = require("../segments");
-const processParseResult = ({ parseResult, children, wrap, }) => {
+const processParseResult = ({ parseResult, children, }) => {
+    if (parseResult.segment && !children.includes(parseResult.segment)) {
+        children.push(parseResult.segment);
+    }
     if (parseResult.status === 'incomplete') {
         // No need to decrement because expectSegment already does it
         return {
             status: 'incomplete',
-            segments: [],
+            segment: parseResult.segment,
             continueParsing: async () => {
                 const newParseResult = await parseResult.continueParsing();
                 return processParseResult({
                     children,
                     parseResult: newParseResult,
-                    wrap,
                 });
             },
-            skipTo: null,
         };
     }
-    for (const segment of parseResult.segments) {
-        children.push(segment);
-    }
     return {
         status: 'done',
-        segments: wrap ? [wrap(children)] : children,
+        segment: parseResult.segment,
     };
 };
-const continueParsingfunction = ({ result, iterator, children, wrap, parserContext, length, }) => async () => {
-    if (result.status !== 'incomplete') {
-        throw new Error('expected incomplete');
+const expectAndProcessSegment = async ({ iterator, parserContext, offset, children, }) => {
+    const segment = await (0, segments_1.expectSegment)({
+        iterator,
+        parserContext,
+        offset,
+        children,
+    });
+    return processParseResult({
+        children,
+        parseResult: segment,
+    });
+};
+exports.expectAndProcessSegment = expectAndProcessSegment;
+const continueAfterSegmentResult = async ({ result, length, children, parserContext, iterator, startOffset, }) => {
+    if (result.status === 'done') {
+        throw new Error('Should not continue after done');
     }
-    const offset = iterator.counter.getOffset();
-    const continued = await result.continueParsing();
-    if (continued.status === 'incomplete') {
-        if (!parserContext.supportsContentRange) {
-            throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
-        }
+    const segmentResult = await result.continueParsing();
+    if (segmentResult.status === 'done') {
         return {
             status: 'incomplete',
-            continueParsing: continueParsingfunction({
-                result: continued,
-                iterator,
-                children,
-                wrap,
-                parserContext,
-                length: length - (iterator.counter.getOffset() - offset),
-            }),
-            skipTo: continued.skipTo,
-            segments: wrap ? [wrap(children)] : children,
+            continueParsing: () => {
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                return (0, exports.expectChildren)({
+                    children,
+                    iterator,
+                    length,
+                    parserContext,
+                    startOffset,
+                });
+            },
+            skipTo: null,
         };
     }
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    return (0, exports.expectChildren)({
-        iterator,
-        length: length - (iterator.counter.getOffset() - offset),
-        initialChildren: children,
-        wrap,
-        parserContext,
-    });
+    return {
+        status: 'incomplete',
+        continueParsing: () => {
+            return continueAfterSegmentResult({
+                result: segmentResult,
+                children,
+                iterator,
+                length,
+                parserContext,
+                startOffset,
+            });
+        },
+        skipTo: null,
+    };
 };
-const expectChildren = async ({ iterator, length, initialChildren, wrap, parserContext, }) => {
-    const children = [...initialChildren];
-    const startOffset = iterator.counter.getOffset();
+const expectChildren = async ({ iterator, length, children, parserContext, startOffset, }) => {
     while (iterator.counter.getOffset() < startOffset + length) {
         if (iterator.bytesRemaining() === 0) {
             break;
         }
-        const parseResult = await (0, segments_1.expectSegment)(iterator, parserContext);
-        const child = processParseResult({
+        const currentOffset = iterator.counter.getOffset();
+        const child = await (0, exports.expectAndProcessSegment)({
+            iterator,
+            parserContext,
+            offset: currentOffset,
             children,
-            parseResult,
-            wrap,
         });
         if (child.status === 'incomplete') {
-            if (!parserContext.supportsContentRange) {
-                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
-            }
             return {
                 status: 'incomplete',
-                continueParsing: continueParsingfunction({
-                    result: child,
-                    iterator,
-                    children,
-                    wrap,
-                    parserContext,
-                    length: length - (iterator.counter.getOffset() - startOffset),
-                }),
-                skipTo: child.skipTo,
-                segments: wrap ? [wrap(children)] : children,
+                continueParsing: () => {
+                    return continueAfterSegmentResult({
+                        result: child,
+                        children,
+                        iterator,
+                        length: length - (currentOffset - startOffset),
+                        parserContext,
+                        startOffset: currentOffset,
+                    });
+                },
+                skipTo: null,
             };
         }
     }
     return {
         status: 'done',
-        segments: wrap ? [wrap(children)] : children,
     };
 };
 exports.expectChildren = expectChildren;

package/dist/boxes/webm/segments.d.ts

@@ -1,7 +1,12 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { ParseResult } from '../../parse-result';
+import type { ExpectSegmentParseResult } from '../../parse-result';
 import type { ParserContext } from '../../parser-context';
-import type { PossibleEbml, TrackEntry } from './segments/all-segments';
+import { type PossibleEbml, type TrackEntry } from './segments/all-segments';
 export type MatroskaSegment = PossibleEbml;
 export type OnTrackEntrySegment = (trackEntry: TrackEntry) => void;
-export declare const expectSegment: (iterator: BufferIterator, parserContext: ParserContext) => Promise<ParseResult>;
+export declare const expectSegment: ({ iterator, parserContext, offset, children, }: {
+    iterator: BufferIterator;
+    parserContext: ParserContext;
+    offset: number;
+    children: PossibleEbml[];
+}) => Promise<ExpectSegmentParseResult>;

package/dist/boxes/webm/segments.js

@@ -3,26 +3,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectSegment = void 0;
 const parse_ebml_1 = require("./parse-ebml");
 const parse_children_1 = require("./segments/parse-children");
-const parseSegment = async ({ segmentId, iterator, length, parserContext, headerReadSoFar, }) => {
-    if (length < 0) {
-        throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+const continueAfterMatroskaParseResult = async ({ result, iterator, parserContext, segment, }) => {
+    if (result.status === 'done') {
+        throw new Error('Should not continue after done');
     }
-    iterator.counter.decrement(headerReadSoFar);
-    const offset = iterator.counter.getOffset();
-    const ebml = await (0, parse_ebml_1.parseEbml)(iterator, parserContext);
-    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, parserContext });
-    return remapped;
+    const proceeded = await result.continueParsing();
+    if (proceeded.status === 'done') {
+        return {
+            status: 'done',
+            segment,
+        };
+    }
+    return {
+        continueParsing() {
+            return continueAfterMatroskaParseResult({
+                result: proceeded,
+                iterator,
+                parserContext,
+                segment,
+            });
+        },
+        segment: null,
+        status: 'incomplete',
+    };
 };
-const expectSegment = async (iterator, parserContext) => {
-    const offset = iterator.counter.getOffset();
+const expectSegment = async ({ iterator, parserContext, offset, children, }) => {
+    iterator.counter.decrement(iterator.counter.getOffset() - offset);
     if (iterator.bytesRemaining() === 0) {
         return {
             status: 'incomplete',
-            segments: [],
             continueParsing: () => {
-                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+                return (0, parse_children_1.expectAndProcessSegment)({
+                    iterator,
+                    parserContext,
+                    offset,
+                    children,
+                });
             },
-            skipTo: null,
+            segment: null,
         };
     }
     const segmentId = iterator.getMatroskaSegmentId();
@@ -30,11 +48,15 @@ const expectSegment = async (iterator, parserContext) => {
         iterator.counter.decrement(iterator.counter.getOffset() - offset);
         return {
             status: 'incomplete',
-            segments: [],
             continueParsing: () => {
-                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+                return (0, parse_children_1.expectAndProcessSegment)({
+                    iterator,
+                    parserContext,
+                    offset,
+                    children,
+                });
             },
-            skipTo: null,
+            segment: null,
         };
     }
     const offsetBeforeVInt = iterator.counter.getOffset();
@@ -44,43 +66,43 @@ const expectSegment = async (iterator, parserContext) => {
         iterator.counter.decrement(iterator.counter.getOffset() - offset);
         return {
             status: 'incomplete',
-            segments: [],
             continueParsing: () => {
-                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+                return (0, exports.expectSegment)({ iterator, parserContext, offset, children });
             },
-            skipTo: null,
+            segment: null,
         };
     }
     const bytesRemainingNow = iterator.byteLength() - iterator.counter.getOffset();
     if (segmentId === '0x18538067' || segmentId === '0x1f43b675') {
+        const newSegment = {
+            type: segmentId === '0x18538067' ? 'Segment' : 'Cluster',
+            minVintWidth: offsetAfterVInt - offsetBeforeVInt,
+            value: [],
+        };
         const main = await (0, parse_children_1.expectChildren)({
             iterator,
             length,
-            initialChildren: [],
-            wrap: segmentId === '0x18538067'
-                ? (s) => ({
-                    type: 'Segment',
-                    value: s,
-                    minVintWidth: offsetAfterVInt - offsetBeforeVInt,
-                })
-                : (s) => ({
-                    type: 'Cluster',
-                    value: s,
-                    minVintWidth: offsetAfterVInt - offsetBeforeVInt,
-                }),
+            children: newSegment.value,
             parserContext,
+            startOffset: iterator.counter.getOffset(),
         });
         if (main.status === 'incomplete') {
             return {
                 status: 'incomplete',
-                segments: main.segments,
-                skipTo: null,
-                continueParsing: main.continueParsing,
+                continueParsing: () => {
+                    return continueAfterMatroskaParseResult({
+                        iterator,
+                        parserContext,
+                        result: main,
+                        segment: newSegment,
+                    });
+                },
+                segment: newSegment,
             };
         }
         return {
             status: 'done',
-            segments: main.segments,
+            segment: newSegment,
         };
     }
     if (bytesRemainingNow < length) {
@@ -88,11 +110,10 @@ const expectSegment = async (iterator, parserContext) => {
         iterator.counter.decrement(bytesRead);
         return {
             status: 'incomplete',
-            segments: [],
+            segment: null,
             continueParsing: () => {
-                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+                return (0, exports.expectSegment)({ iterator, parserContext, offset, children });
             },
-            skipTo: null,
         };
     }
     const segment = await parseSegment({
@@ -104,7 +125,17 @@ const expectSegment = async (iterator, parserContext) => {
     });
     return {
         status: 'done',
-        segments: [segment],
+        segment,
     };
 };
 exports.expectSegment = expectSegment;
+const parseSegment = async ({ segmentId, iterator, length, parserContext, headerReadSoFar, }) => {
+    if (length < 0) {
+        throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+    }
+    iterator.counter.decrement(headerReadSoFar);
+    const offset = iterator.counter.getOffset();
+    const ebml = await (0, parse_ebml_1.parseEbml)(iterator, parserContext);
+    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, parserContext });
+    return remapped;
+};

package/dist/create/iso-base-media/create-iso-base-media.d.ts

@@ -1,2 +1,2 @@
 import type { MediaFn, MediaFnGeneratorInput } from '../media-fn';
-export declare const createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, }: MediaFnGeneratorInput) => Promise<MediaFn>;
+export declare const createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, }: MediaFnGeneratorInput) => Promise<MediaFn>;

package/dist/create/iso-base-media/create-iso-base-media.js

@@ -6,13 +6,13 @@ const log_1 = require("../../log");
 const create_ftyp_1 = require("./create-ftyp");
 const mp4_header_1 = require("./mp4-header");
 const primitives_1 = require("./primitives");
-const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, }) => {
+const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, }) => {
     const header = (0, create_ftyp_1.createIsoBaseMediaFtyp)({
         compatibleBrands: ['isom', 'iso2', 'avc1', 'mp42'],
         majorBrand: 'isom',
         minorBrand: 512,
     });
-    const w = await writer.createContent();
+    const w = await writer.createContent({ filename, mimeType: 'video/mp4' });
     await w.write(header);
     let durationInUnits = 0;
     const currentTracks = [];
@@ -113,9 +113,8 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
     };
     const waitForFinishPromises = [];
     return {
-        save: async () => {
-            const file = await w.save();
-            return file;
+        save: () => {
+            return w.save();
         },
         remove: async () => {
             await w.remove();

package/dist/create/matroska/cluster.d.ts

@@ -1,3 +1,4 @@
+import type { LogLevel } from '../../log';
 import type { AudioOrVideoSample } from '../../webcodec-sample-types';
 import type { Writer } from '../../writers/writer';
 export declare const timestampToClusterTimestamp: (timestamp: number, timescale: number) => number;
@@ -6,7 +7,12 @@ export declare const canFitInCluster: ({ clusterStartTimestamp, chunk, timescale
     chunk: AudioOrVideoSample;
     timescale: number;
 }) => boolean;
-export declare const makeCluster: (w: Writer, clusterStartTimestamp: number, timescale: number) => Promise<{
+export declare const makeCluster: ({ writer, clusterStartTimestamp, timescale, logLevel, }: {
+    writer: Writer;
+    clusterStartTimestamp: number;
+    timescale: number;
+    logLevel: LogLevel;
+}) => Promise<{
     addSample: (chunk: AudioOrVideoSample, trackNumber: number) => Promise<{
         timecodeRelativeToCluster: number;
     }>;

package/dist/create/matroska/cluster.js

@@ -4,6 +4,7 @@ exports.makeCluster = exports.canFitInCluster = exports.timestampToClusterTimest
 const ebml_1 = require("../../boxes/webm/ebml");
 const make_header_1 = require("../../boxes/webm/make-header");
 const all_segments_1 = require("../../boxes/webm/segments/all-segments");
+const log_1 = require("../../log");
 const cluster_segment_1 = require("./cluster-segment");
 const maxClusterTimestamp = 2 ** 15;
 const timestampToClusterTimestamp = (timestamp, timescale) => {
@@ -19,15 +20,16 @@ const canFitInCluster = ({ clusterStartTimestamp, chunk, timescale, }) => {
     return timecodeRelativeToCluster <= maxClusterTimestamp;
 };
 exports.canFitInCluster = canFitInCluster;
-const makeCluster = async (w, clusterStartTimestamp, timescale) => {
+const makeCluster = async ({ writer, clusterStartTimestamp, timescale, logLevel, }) => {
+    log_1.Log.verbose(logLevel, `Making new Matroska cluster with timestamp ${clusterStartTimestamp}`);
     const cluster = (0, cluster_segment_1.createClusterSegment)((0, exports.timestampToClusterTimestamp)(clusterStartTimestamp, timescale));
-    const clusterVIntPosition = w.getWrittenByteCount() +
+    const clusterVIntPosition = writer.getWrittenByteCount() +
         cluster.offsets.offset +
         (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).byteLength;
     let clusterSize = cluster.bytes.byteLength -
         (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).byteLength -
         cluster_segment_1.CLUSTER_MIN_VINT_WIDTH;
-    await w.write(cluster.bytes);
+    await writer.write(cluster.bytes);
     const addSample = async (chunk, trackNumber) => {
         const timecodeRelativeToCluster = (0, exports.timestampToClusterTimestamp)(chunk.timestamp, timescale) -
             (0, exports.timestampToClusterTimestamp)(clusterStartTimestamp, timescale);
@@ -44,8 +46,8 @@ const makeCluster = async (w, clusterStartTimestamp, timescale) => {
             timecodeRelativeToCluster,
         });
         clusterSize += simpleBlock.byteLength;
-        await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
-        await w.write(simpleBlock);
+        await writer.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
+        await writer.write(simpleBlock);
         return { timecodeRelativeToCluster };
     };
     const shouldMakeNewCluster = ({ isVideo, chunk, newT, }) => {
@@ -59,6 +61,7 @@ const makeCluster = async (w, clusterStartTimestamp, timescale) => {
         if (!canFit) {
             // We must create a new cluster
             // This is for example if we have an audio-only file
+            log_1.Log.verbose(logLevel, `Cannot fit ${chunk.timestamp} in cluster ${clusterStartTimestamp}. Creating new cluster`);
             return true;
         }
         const keyframe = chunk.type === 'key';

package/dist/create/matroska/create-matroska-media.d.ts

@@ -1,2 +1,2 @@
 import type { MediaFn, MediaFnGeneratorInput } from '../media-fn';
-export declare const createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, }: MediaFnGeneratorInput) => Promise<MediaFn>;
+export declare const createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, }: MediaFnGeneratorInput) => Promise<MediaFn>;

package/dist/create/matroska/create-matroska-media.js

@@ -13,10 +13,10 @@ const matroska_seek_1 = require("./matroska-seek");
 const matroska_segment_1 = require("./matroska-segment");
 const matroska_trackentry_1 = require("./matroska-trackentry");
 const timescale = 1000000;
-const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, }) => {
+const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, }) => {
     var _a, _b, _c, _d, _e, _f, _g;
     const header = (0, matroska_header_1.makeMatroskaHeader)();
-    const w = await writer.createContent();
+    const w = await writer.createContent({ filename, mimeType: 'video/webm' });
     await w.write(header.bytes);
     const matroskaInfo = (0, matroska_info_1.makeMatroskaInfo)({
         timescale,
@@ -69,14 +69,27 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
     };
     await w.write(matroskaSegment.bytes);
     const clusterOffset = w.getWrittenByteCount();
-    let currentCluster = await (0, cluster_1.makeCluster)(w, 0, timescale);
+    let currentCluster = await (0, cluster_1.makeCluster)({
+        writer: w,
+        clusterStartTimestamp: 0,
+        timescale,
+        logLevel,
+    });
     seeks.push({
         hexString: all_segments_1.matroskaElements.Cluster,
         byte: clusterOffset - seekHeadOffset,
     });
     const trackNumberProgresses = {};
-    const getClusterOrMakeNew = async ({ chunk, isVideo, }) => {
-        const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
+    const getClusterOrMakeNew = async ({ chunk, isVideo, trackNumber, }) => {
+        const trackProgressValues = Object.values(trackNumberProgresses);
+        const smallestProgress = trackProgressValues.length === 0 ? 0 : Math.min(...trackProgressValues);
+        // In Safari, samples can arrive out of order, e.g public/bigbuckbunny.mp4
+        // Therefore, only updating track number progress if it is a keyframe
+        // to allow for timestamps to be lower than the previous one
+        // Also doing this AFTER smallestProgress is calculated
+        if (chunk.type === 'key') {
+            trackNumberProgresses[trackNumber] = chunk.timestamp;
+        }
         if (!currentCluster.shouldMakeNewCluster({
             newT: smallestProgress,
             isVideo,
@@ -84,7 +97,12 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
         })) {
             return { cluster: currentCluster, isNew: false, smallestProgress };
         }
-        currentCluster = await (0, cluster_1.makeCluster)(w, smallestProgress, timescale);
+        currentCluster = await (0, cluster_1.makeCluster)({
+            writer: w,
+            clusterStartTimestamp: smallestProgress,
+            timescale,
+            logLevel,
+        });
         return { cluster: currentCluster, isNew: true, smallestProgress };
     };
     const updateDuration = async (newDuration) => {
@@ -94,10 +112,10 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
     };
     const addSample = async ({ chunk, trackNumber, isVideo, }) => {
         var _a;
-        trackNumberProgresses[trackNumber] = chunk.timestamp;
         const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
             chunk,
             isVideo,
+            trackNumber,
         });
         const newDuration = Math.round((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
         await updateDuration(newDuration);
@@ -132,9 +150,8 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
                 }
             });
         },
-        save: async () => {
-            const file = await w.save();
-            return file;
+        save: () => {
+            return w.save();
         },
         remove: async () => {
             await w.remove();

package/dist/create/media-fn.d.ts

@@ -28,4 +28,5 @@ export type MediaFnGeneratorInput = {
     onBytesProgress: (totalBytes: number) => void;
     onMillisecondsProgress: (totalMilliseconds: number) => void;
     logLevel: LogLevel;
+    filename: string;
 };

package/dist/emit-available-info.d.ts

@@ -3,7 +3,7 @@ import type { ParseResult } from './parse-result';
 import type { ParserState } from './parser-state';
 export declare const emitAvailableInfo: ({ hasInfo, parseResult, moreFields, state, returnValue, contentLength, name, }: {
     hasInfo: Record<keyof Options<ParseMediaFields>, boolean>;
-    parseResult: ParseResult;
+    parseResult: ParseResult | null;
     moreFields: ParseMediaCallbacks<AllParseMediaFields>;
     state: ParserState;
     returnValue: ParseMediaResult<AllParseMediaFields>;