@remotion/media-parser 4.0.227 → 4.0.229

package/dist/boxes/iso-base-media/mdat/mdat.js

@@ -73,21 +73,20 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signa
             break;
         }
         const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
+        const timestamp = Math.floor((samplesWithIndex.samplePosition.cts * 1000000) /
+            samplesWithIndex.track.timescale);
+        const duration = Math.floor((samplesWithIndex.samplePosition.duration * 1000000) /
+            samplesWithIndex.track.timescale);
         if (samplesWithIndex.track.type === 'audio') {
-            const timestamp = Math.floor((samplesWithIndex.samplePosition.cts * 1000000) /
-                samplesWithIndex.track.timescale);
             await options.parserState.onAudioSample(samplesWithIndex.track.trackId, {
                 data: bytes,
                 timestamp,
                 trackId: samplesWithIndex.track.trackId,
                 type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
+                duration,
             });
         }
         if (samplesWithIndex.track.type === 'video') {
-            const timestamp = Math.floor((samplesWithIndex.samplePosition.cts * 1000000) /
-                samplesWithIndex.track.timescale);
-            const duration = Math.floor((samplesWithIndex.samplePosition.duration * 1000000) /
-                samplesWithIndex.track.timescale);
             await options.parserState.onVideoSample(samplesWithIndex.track.trackId, {
                 data: bytes,
                 timestamp,

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

@@ -1,2 +1,2 @@
-export declare const measureEBMLVarInt: (value: number) => 2 | 1 | 4 | 3 | 5 | 6;
+export declare const measureEBMLVarInt: (value: number) => 1 | 4 | 2 | 3 | 5 | 6;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;

package/dist/boxes/webm/get-sample-from-block.js

@@ -63,6 +63,7 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
             trackId: trackNumber,
             timestamp: timecodeInMicroseconds,
             type: 'key',
+            duration: undefined,
         };
         iterator.destroy();
         return {

package/dist/create/cluster.d.ts

@@ -1,19 +1,18 @@
+import type { AudioOrVideoSample } from '../webcodec-sample-types';
 import type { Writer } from '../writers/writer';
-export type AudioOrVideoSample = {
-    timestamp: number;
-    type: 'key' | 'delta';
-    copyTo(destination: AllowSharedBufferSource): void;
-    byteLength: number;
-    duration: number | null;
-};
 export declare const timestampToClusterTimestamp: (timestamp: number) => number;
-export declare const makeCluster: (w: Writer, timestamp: number) => Promise<{
+export declare const canFitInCluster: ({ clusterStartTimestamp, chunk, }: {
+    clusterStartTimestamp: number;
+    chunk: AudioOrVideoSample;
+}) => boolean;
+export declare const makeCluster: (w: Writer, clusterStartTimestamp: number) => Promise<{
     addSample: (chunk: AudioOrVideoSample, trackNumber: number) => Promise<{
         timecodeRelativeToCluster: number;
     }>;
-    shouldMakeNewCluster: ({ isVideo, keyframe, newT, }: {
+    shouldMakeNewCluster: ({ isVideo, chunk, newT, }: {
         newT: number;
-        keyframe: boolean;
+        chunk: AudioOrVideoSample;
         isVideo: boolean;
     }) => boolean;
+    startTimestamp: number;
 }>;

package/dist/create/cluster.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeCluster = exports.timestampToClusterTimestamp = void 0;
+exports.makeCluster = exports.canFitInCluster = exports.timestampToClusterTimestamp = void 0;
 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");
@@ -11,8 +11,17 @@ const timestampToClusterTimestamp = (timestamp) => {
     return Math.round((timestamp / timescale_1.CREATE_TIME_SCALE) * 1000);
 };
 exports.timestampToClusterTimestamp = timestampToClusterTimestamp;
-const makeCluster = async (w, timestamp) => {
-    const cluster = (0, cluster_segment_1.createClusterSegment)((0, exports.timestampToClusterTimestamp)(timestamp));
+const canFitInCluster = ({ clusterStartTimestamp, chunk, }) => {
+    const timecodeRelativeToCluster = (0, exports.timestampToClusterTimestamp)(chunk.timestamp) -
+        (0, exports.timestampToClusterTimestamp)(clusterStartTimestamp);
+    if (timecodeRelativeToCluster < 0) {
+        throw new Error(`timecodeRelativeToCluster is negative`);
+    }
+    return timecodeRelativeToCluster <= maxClusterTimestamp;
+};
+exports.canFitInCluster = canFitInCluster;
+const makeCluster = async (w, clusterStartTimestamp) => {
+    const cluster = (0, cluster_segment_1.createClusterSegment)((0, exports.timestampToClusterTimestamp)(clusterStartTimestamp));
     const clusterVIntPosition = w.getWrittenByteCount() +
         cluster.offsets.offset +
         (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).byteLength;
@@ -21,19 +30,14 @@ const makeCluster = async (w, timestamp) => {
         cluster_segment_1.CLUSTER_MIN_VINT_WIDTH;
     await w.write(cluster.bytes);
     const addSample = async (chunk, trackNumber) => {
-        const arr = new Uint8Array(chunk.byteLength);
-        chunk.copyTo(arr);
         const timecodeRelativeToCluster = (0, exports.timestampToClusterTimestamp)(chunk.timestamp) -
-            (0, exports.timestampToClusterTimestamp)(timestamp);
-        if (timecodeRelativeToCluster < 0) {
-            throw new Error(`timecodeRelativeToCluster is negative (track ${trackNumber})`);
-        }
-        if (timecodeRelativeToCluster > maxClusterTimestamp) {
+            (0, exports.timestampToClusterTimestamp)(clusterStartTimestamp);
+        if (!(0, exports.canFitInCluster)({ clusterStartTimestamp, chunk })) {
             throw new Error(`timecodeRelativeToCluster is too big: ${timecodeRelativeToCluster} > ${maxClusterTimestamp}`);
         }
         const keyframe = chunk.type === 'key';
         const simpleBlock = (0, cluster_segment_1.makeSimpleBlock)({
-            bytes: arr,
+            bytes: chunk.data,
             invisible: false,
             keyframe,
             lacing: 0,
@@ -45,11 +49,26 @@ const makeCluster = async (w, timestamp) => {
         await w.write(simpleBlock);
         return { timecodeRelativeToCluster };
     };
-    const shouldMakeNewCluster = ({ isVideo, keyframe, newT, }) => {
+    const shouldMakeNewCluster = ({ isVideo, chunk, newT, }) => {
         const newTimestamp = (0, exports.timestampToClusterTimestamp)(newT);
-        const oldTimestamp = (0, exports.timestampToClusterTimestamp)(timestamp);
+        const oldTimestamp = (0, exports.timestampToClusterTimestamp)(clusterStartTimestamp);
+        const canFit = (0, exports.canFitInCluster)({
+            chunk,
+            clusterStartTimestamp,
+        });
+        if (!canFit) {
+            // We must create a new cluster
+            // This is for example if we have an audio-only file
+            return true;
+        }
+        const keyframe = chunk.type === 'key';
+        // TODO: Timestamp falls apart when video only
         return newTimestamp - oldTimestamp >= 2000 && keyframe && isVideo;
     };
-    return { addSample, shouldMakeNewCluster };
+    return {
+        addSample,
+        shouldMakeNewCluster,
+        startTimestamp: clusterStartTimestamp,
+    };
 };
 exports.makeCluster = makeCluster;

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

@@ -1,8 +1,8 @@
+import type { AudioOrVideoSample } from '../webcodec-sample-types';
 import type { WriterInterface } from '../writers/writer';
-import type { AudioOrVideoSample } from './cluster';
 import type { MakeTrackAudio, MakeTrackVideo } from './matroska-trackentry';
 export type MediaFn = {
-    save: () => Promise<File>;
+    save: () => Promise<Blob>;
     remove: () => Promise<void>;
     addSample: (chunk: AudioOrVideoSample, trackNumber: number, isVideo: boolean) => Promise<void>;
     updateDuration: (duration: number) => Promise<void>;
@@ -12,4 +12,8 @@ export type MediaFn = {
     addWaitForFinishPromise: (promise: () => Promise<void>) => void;
     waitForFinish: () => Promise<void>;
 };
-export declare const createMedia: (writer: WriterInterface) => Promise<MediaFn>;
+export declare const createMedia: ({ writer, onBytesProgress, onMillisecondsProgress, }: {
+    writer: WriterInterface;
+    onBytesProgress: (totalBytes: number) => void;
+    onMillisecondsProgress: (totalMilliseconds: number) => void;
+}) => Promise<MediaFn>;

package/dist/create/create-media.js

@@ -13,7 +13,7 @@ const matroska_seek_1 = require("./matroska-seek");
 const matroska_segment_1 = require("./matroska-segment");
 const matroska_trackentry_1 = require("./matroska-trackentry");
 const timescale_1 = require("./timescale");
-const createMedia = async (writer) => {
+const createMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, }) => {
     var _a, _b, _c, _d, _e, _f, _g;
     const header = (0, matroska_header_1.makeMatroskaHeader)();
     const w = await writer.createContent();
@@ -59,11 +59,13 @@ const createMedia = async (writer) => {
     const updateSeekWrite = async () => {
         const updatedSeek = (0, matroska_seek_1.createMatroskaSeekHead)(seeks);
         await w.updateDataAt(seekHeadOffset, (0, make_header_1.combineUint8Arrays)(updatedSeek.map((b) => b.bytes)));
+        onBytesProgress(w.getWrittenByteCount());
     };
     const segmentOffset = w.getWrittenByteCount();
     const updateSegmentSize = async (size) => {
         const data = (0, ebml_1.getVariableInt)(size, matroska_segment_1.MATROSKA_SEGMENT_MIN_VINT_WIDTH);
         await w.updateDataAt(segmentOffset + (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Segment).byteLength, data);
+        onBytesProgress(w.getWrittenByteCount());
     };
     await w.write(matroskaSegment.bytes);
     const clusterOffset = w.getWrittenByteCount();
@@ -77,8 +79,8 @@ const createMedia = async (writer) => {
         const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
         if (!currentCluster.shouldMakeNewCluster({
             newT: smallestProgress,
-            keyframe: chunk.type === 'key',
             isVideo,
+            chunk,
         })) {
             return { cluster: currentCluster, isNew: false, smallestProgress };
         }
@@ -88,6 +90,7 @@ const createMedia = async (writer) => {
     const updateDuration = async (newDuration) => {
         const blocks = (0, make_duration_with_padding_1.makeDurationWithPadding)(newDuration);
         await w.updateDataAt(durationOffset, blocks.bytes);
+        onBytesProgress(w.getWrittenByteCount());
     };
     const addSample = async (chunk, trackNumber, isVideo) => {
         var _a;
@@ -108,6 +111,8 @@ const createMedia = async (writer) => {
                 trackNumber,
             });
         }
+        onBytesProgress(w.getWrittenByteCount());
+        onMillisecondsProgress(newDuration);
     };
     const addTrack = async (track) => {
         currentTracks.push(track);

package/dist/create/polyfill-audio-sample.d.ts

@@ -0,0 +1,3 @@
+import type { AudioSample } from '../webcodec-sample-types';
+import type { AudioOrVideoSample } from './cluster';
+export declare const polyfillAudioChunk: (audioSample: AudioSample) => AudioOrVideoSample;

package/dist/create/polyfill-audio-sample.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polyfillAudioChunk = void 0;
+const polyfillAudioChunk = (audioSample) => {
+    var _a;
+    return {
+        ...audioSample,
+        duration: (_a = audioSample.duration) !== null && _a !== void 0 ? _a : null,
+        copyTo(destination) {
+            return destination.write(audioSample.data);
+        },
+        byteLength: audioSample.data.length,
+    };
+};
+exports.polyfillAudioChunk = polyfillAudioChunk;

package/dist/esm/buffer.mjs

@@ -1,24 +1,21 @@
-// src/writers/buffer.ts
+// src/writers/buffer-implementation/writer.ts
 var createContent = () => {
   const buf = new ArrayBuffer(0, {
-    maxByteLength: 1e8
+    maxByteLength: 200000000
   });
   if (!buf.resize) {
     throw new Error("Could not create buffer writer");
   }
-  let data = new Uint8Array(buf);
   const write = (newData) => {
     const oldLength = buf.byteLength;
     const newLength = oldLength + newData.byteLength;
     buf.resize(newLength);
     const newArray = new Uint8Array(buf);
     newArray.set(newData, oldLength);
-    data = newArray;
   };
   const updateDataAt = (position, newData) => {
     const newArray = new Uint8Array(buf);
     newArray.set(newData, position);
-    data = newArray;
   };
   let writPromise = Promise.resolve();
   let removed = false;
@@ -31,11 +28,11 @@ var createContent = () => {
       if (removed) {
         return Promise.reject(new Error("Already called .remove() on the result"));
       }
-      return Promise.resolve(new File([data], "hithere", {}));
+      const arr = new Uint8Array(buf);
+      return Promise.resolve(new File([arr.slice()], "hi", { type: "video/webm" }));
     },
     remove() {
       removed = true;
-      data = new Uint8Array(0);
       return Promise.resolve();
     },
     getWrittenByteCount: () => buf.byteLength,
@@ -49,6 +46,8 @@ var createContent = () => {
   };
   return Promise.resolve(writer);
 };
+
+// src/writers/buffer.ts
 var bufferWriter = {
   createContent
 };

package/dist/esm/from-fetch.mjs

@@ -55,7 +55,7 @@ var fetchReader = {
     const parsedContentRange = contentRange ? parseContentRange(contentRange) : null;
     const { supportsContentRange } = validateContentRangeAndDetectIfSupported(actualRange, parsedContentRange, res.status);
     signal?.addEventListener("abort", () => {
-      controller.abort();
+      controller.abort(new Error("Aborted by user"));
     }, { once: true });
     if (res.status.toString().startsWith("4") || res.status.toString().startsWith("5")) {
       throw new Error(`Server returned status code ${res.status} for ${src} and range ${actualRange}`);

package/dist/esm/index.mjs

@@ -55,7 +55,7 @@ var fetchReader = {
     const parsedContentRange = contentRange ? parseContentRange(contentRange) : null;
     const { supportsContentRange } = validateContentRangeAndDetectIfSupported(actualRange, parsedContentRange, res.status);
     signal?.addEventListener("abort", () => {
-      controller.abort();
+      controller.abort(new Error("Aborted by user"));
     }, { once: true });
     if (res.status.toString().startsWith("4") || res.status.toString().startsWith("5")) {
       throw new Error(`Server returned status code ${res.status} for ${src} and range ${actualRange}`);
@@ -1070,24 +1070,29 @@ var maxClusterTimestamp = 2 ** 15;
 var timestampToClusterTimestamp = (timestamp) => {
   return Math.round(timestamp / CREATE_TIME_SCALE * 1000);
 };
-var makeCluster = async (w, timestamp) => {
-  const cluster = createClusterSegment(timestampToClusterTimestamp(timestamp));
+var canFitInCluster = ({
+  clusterStartTimestamp,
+  chunk
+}) => {
+  const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp) - timestampToClusterTimestamp(clusterStartTimestamp);
+  if (timecodeRelativeToCluster < 0) {
+    throw new Error(`timecodeRelativeToCluster is negative`);
+  }
+  return timecodeRelativeToCluster <= maxClusterTimestamp;
+};
+var makeCluster = async (w, clusterStartTimestamp) => {
+  const cluster = createClusterSegment(timestampToClusterTimestamp(clusterStartTimestamp));
   const clusterVIntPosition = w.getWrittenByteCount() + cluster.offsets.offset + matroskaToHex(matroskaElements.Cluster).byteLength;
   let clusterSize = cluster.bytes.byteLength - matroskaToHex(matroskaElements.Cluster).byteLength - CLUSTER_MIN_VINT_WIDTH;
   await w.write(cluster.bytes);
   const addSample = async (chunk, trackNumber2) => {
-    const arr = new Uint8Array(chunk.byteLength);
-    chunk.copyTo(arr);
-    const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp) - timestampToClusterTimestamp(timestamp);
-    if (timecodeRelativeToCluster < 0) {
-      throw new Error(`timecodeRelativeToCluster is negative (track ${trackNumber2})`);
-    }
-    if (timecodeRelativeToCluster > maxClusterTimestamp) {
+    const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp) - timestampToClusterTimestamp(clusterStartTimestamp);
+    if (!canFitInCluster({ clusterStartTimestamp, chunk })) {
       throw new Error(`timecodeRelativeToCluster is too big: ${timecodeRelativeToCluster} > ${maxClusterTimestamp}`);
     }
     const keyframe = chunk.type === "key";
     const simpleBlock2 = makeSimpleBlock({
-      bytes: arr,
+      bytes: chunk.data,
       invisible: false,
       keyframe,
       lacing: 0,
@@ -1101,14 +1106,26 @@ var makeCluster = async (w, timestamp) => {
   };
   const shouldMakeNewCluster = ({
     isVideo,
-    keyframe,
+    chunk,
     newT
   }) => {
     const newTimestamp = timestampToClusterTimestamp(newT);
-    const oldTimestamp = timestampToClusterTimestamp(timestamp);
+    const oldTimestamp = timestampToClusterTimestamp(clusterStartTimestamp);
+    const canFit = canFitInCluster({
+      chunk,
+      clusterStartTimestamp
+    });
+    if (!canFit) {
+      return true;
+    }
+    const keyframe = chunk.type === "key";
     return newTimestamp - oldTimestamp >= 2000 && keyframe && isVideo;
   };
-  return { addSample, shouldMakeNewCluster };
+  return {
+    addSample,
+    shouldMakeNewCluster,
+    startTimestamp: clusterStartTimestamp
+  };
 };
 
 // src/create/make-duration-with-padding.ts
@@ -1815,7 +1832,11 @@ var makeMatroskaTracks = (tracks2) => {
 };
 
 // src/create/create-media.ts
-var createMedia = async (writer) => {
+var createMedia = async ({
+  writer,
+  onBytesProgress,
+  onMillisecondsProgress
+}) => {
   const header = makeMatroskaHeader();
   const w = await writer.createContent();
   await w.write(header.bytes);
@@ -1859,11 +1880,13 @@ var createMedia = async (writer) => {
   const updateSeekWrite = async () => {
     const updatedSeek = createMatroskaSeekHead(seeks);
     await w.updateDataAt(seekHeadOffset, combineUint8Arrays(updatedSeek.map((b) => b.bytes)));
+    onBytesProgress(w.getWrittenByteCount());
   };
   const segmentOffset = w.getWrittenByteCount();
   const updateSegmentSize = async (size) => {
     const data = getVariableInt(size, MATROSKA_SEGMENT_MIN_VINT_WIDTH);
     await w.updateDataAt(segmentOffset + matroskaToHex(matroskaElements.Segment).byteLength, data);
+    onBytesProgress(w.getWrittenByteCount());
   };
   await w.write(matroskaSegment.bytes);
   const clusterOffset = w.getWrittenByteCount();
@@ -1880,8 +1903,8 @@ var createMedia = async (writer) => {
     const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
     if (!currentCluster.shouldMakeNewCluster({
       newT: smallestProgress,
-      keyframe: chunk.type === "key",
-      isVideo
+      isVideo,
+      chunk
     })) {
       return { cluster: currentCluster, isNew: false, smallestProgress };
     }
@@ -1891,6 +1914,7 @@ var createMedia = async (writer) => {
   const updateDuration = async (newDuration) => {
     const blocks = makeDurationWithPadding(newDuration);
     await w.updateDataAt(durationOffset, blocks.bytes);
+    onBytesProgress(w.getWrittenByteCount());
   };
   const addSample = async (chunk, trackNumber2, isVideo) => {
     trackNumberProgresses[trackNumber2] = chunk.timestamp;
@@ -1909,6 +1933,8 @@ var createMedia = async (writer) => {
         trackNumber: trackNumber2
       });
     }
+    onBytesProgress(w.getWrittenByteCount());
+    onMillisecondsProgress(newDuration);
   };
   const addTrack = async (track) => {
     currentTracks.push(track);
@@ -1959,6 +1985,40 @@ var createMedia = async (writer) => {
   };
 };
 
+// src/log.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isEqualOrBelowLogLevel = (currentLevel, level) => {
+  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+var Log = {
+  trace: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
+      return console.log(...args);
+    }
+  },
+  verbose: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
+      return console.log(...args);
+    }
+  },
+  info: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "info")) {
+      return console.log(...args);
+    }
+  },
+  warn: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
+      return console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    return console.error(...args);
+  }
+};
+
 // src/boxes/iso-base-media/traversal.ts
 var getMoovBox = (segments) => {
   const moovBox = segments.find((s) => s.type === "moov-box");
@@ -4337,18 +4397,18 @@ var parseMdat = async ({
       break;
     }
     const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
+    const timestamp = Math.floor(samplesWithIndex.samplePosition.cts * 1e6 / samplesWithIndex.track.timescale);
+    const duration2 = Math.floor(samplesWithIndex.samplePosition.duration * 1e6 / samplesWithIndex.track.timescale);
     if (samplesWithIndex.track.type === "audio") {
-      const timestamp = Math.floor(samplesWithIndex.samplePosition.cts * 1e6 / samplesWithIndex.track.timescale);
       await options.parserState.onAudioSample(samplesWithIndex.track.trackId, {
         data: bytes,
         timestamp,
         trackId: samplesWithIndex.track.trackId,
-        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
+        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta",
+        duration: duration2
       });
     }
     if (samplesWithIndex.track.type === "video") {
-      const timestamp = Math.floor(samplesWithIndex.samplePosition.cts * 1e6 / samplesWithIndex.track.timescale);
-      const duration2 = Math.floor(samplesWithIndex.samplePosition.duration * 1e6 / samplesWithIndex.track.timescale);
       await options.parserState.onVideoSample(samplesWithIndex.track.trackId, {
         data: bytes,
         timestamp,
@@ -6126,7 +6186,8 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
       data: iterator.getSlice(remainingNow),
       trackId: trackNumber2,
       timestamp: timecodeInMicroseconds,
-      type: "key"
+      type: "key",
+      duration: undefined
     };
     iterator.destroy();
     return {
@@ -6818,7 +6879,8 @@ var parseMedia = async ({
 };
 // src/index.ts
 var MediaParserInternals = {
-  createMedia
+  createMedia,
+  Log
 };
 export {
   parseMedia,

package/dist/esm/web-fs.mjs

@@ -54,6 +54,12 @@ var webFsWriter = {
   createContent
 };
 var canUseWebFsWriter = async () => {
+  if (!("storage" in navigator)) {
+    return false;
+  }
+  if (!("getDirectory" in navigator.storage)) {
+    return false;
+  }
   const directoryHandle = await navigator.storage.getDirectory();
   const fileHandle = await directoryHandle.getFileHandle("remotion-probe-web-fs-support", {
     create: true

package/dist/index.d.ts

@@ -1,10 +1,24 @@
+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, ParseMediaFields, ParseMediaResult, TracksField, } from './options';
+export type { Options, ParseMediaContainer, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOptions, ParseMediaResult, TracksField, } from './options';
 export { parseMedia } from './parse-media';
-export { AudioSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, VideoSample, } from './webcodec-sample-types';
+export { AudioOrVideoSample, AudioSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, VideoSample, } from './webcodec-sample-types';
 export type { MediaFn } from './create/create-media';
 export { Dimensions } from './get-dimensions';
 export type { ReaderInterface } from './readers/reader';
+export type { LogLevel };
 export declare const MediaParserInternals: {
-    createMedia: (writer: import("./writers/writer").WriterInterface) => Promise<import("./create/create-media").MediaFn>;
+    createMedia: ({ writer, onBytesProgress, onMillisecondsProgress, }: {
+        writer: import("./writers/writer").WriterInterface;
+        onBytesProgress: (totalBytes: number) => void;
+        onMillisecondsProgress: (totalMilliseconds: number) => void;
+    }) => Promise<import("./create/create-media").MediaFn>;
+    Log: {
+        trace: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+        verbose: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+        info: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+        warn: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+        error: (...args: Parameters<typeof console.log>) => void;
+    };
 };

package/dist/index.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MediaParserInternals = exports.parseMedia = void 0;
 const create_media_1 = require("./create/create-media");
+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 = {
     createMedia: create_media_1.createMedia,
+    Log: log_1.Log,
 };

package/dist/log.d.ts

@@ -0,0 +1,10 @@
+export declare const logLevels: readonly ["trace", "verbose", "info", "warn", "error"];
+export type LogLevel = (typeof logLevels)[number];
+export declare const isEqualOrBelowLogLevel: (currentLevel: LogLevel, level: LogLevel) => boolean;
+export declare const Log: {
+    trace: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    verbose: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    info: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    warn: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    error: (...args: Parameters<typeof console.log>) => void;
+};

package/dist/log.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = exports.isEqualOrBelowLogLevel = exports.logLevels = void 0;
+/* eslint-disable no-console */
+exports.logLevels = ['trace', 'verbose', 'info', 'warn', 'error'];
+const getNumberForLogLevel = (level) => {
+    return exports.logLevels.indexOf(level);
+};
+const isEqualOrBelowLogLevel = (currentLevel, level) => {
+    return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+exports.isEqualOrBelowLogLevel = isEqualOrBelowLogLevel;
+exports.Log = {
+    trace: (logLevel, ...args) => {
+        if ((0, exports.isEqualOrBelowLogLevel)(logLevel, 'trace')) {
+            return console.log(...args);
+        }
+    },
+    verbose: (logLevel, ...args) => {
+        if ((0, exports.isEqualOrBelowLogLevel)(logLevel, 'verbose')) {
+            return console.log(...args);
+        }
+    },
+    info: (logLevel, ...args) => {
+        if ((0, exports.isEqualOrBelowLogLevel)(logLevel, 'info')) {
+            return console.log(...args);
+        }
+    },
+    warn: (logLevel, ...args) => {
+        if ((0, exports.isEqualOrBelowLogLevel)(logLevel, 'warn')) {
+            return console.warn(...args);
+        }
+    },
+    error: (...args) => {
+        return console.error(...args);
+    },
+};

package/dist/options.d.ts

@@ -107,11 +107,14 @@ export type ParseMediaResult<Fields extends Options<ParseMediaFields>> = (Fields
 } : {}) & (Fields['container'] extends true ? {
     container: ParseMediaContainer | null;
 } : {});
-export type ParseMedia = <F extends Options<ParseMediaFields>>(options: {
-    src: string | File;
+export type ParseMediaDynamicOptions<F extends Options<ParseMediaFields>> = {
     fields?: F;
+} & ParseMediaCallbacks<F>;
+export type ParseMediaOptions<F extends Options<ParseMediaFields>> = {
+    src: string | File;
     reader?: ReaderInterface;
     onAudioTrack?: OnAudioTrack;
     onVideoTrack?: OnVideoTrack;
     signal?: AbortSignal;
-} & ParseMediaCallbacks<F>) => Promise<ParseMediaResult<F>>;
+} & ParseMediaDynamicOptions<F>;
+export type ParseMedia = <F extends Options<ParseMediaFields>>(options: ParseMediaOptions<F>) => Promise<ParseMediaResult<F>>;

package/dist/readers/from-fetch.js

@@ -80,7 +80,7 @@ exports.fetchReader = {
             : null;
         const { supportsContentRange } = validateContentRangeAndDetectIfSupported(actualRange, parsedContentRange, res.status);
         signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
-            controller.abort();
+            controller.abort(new Error('Aborted by user'));
         }, { once: true });
         if (res.status.toString().startsWith('4') ||
             res.status.toString().startsWith('5')) {

package/dist/webcodec-sample-types.d.ts

@@ -4,6 +4,7 @@ export type AudioSample = {
     timestamp: number;
     trackId: number;
     type: 'key' | 'delta';
+    duration: number | undefined;
 };
 export type VideoSample = {
     data: Uint8Array;
@@ -18,3 +19,9 @@ export type OnAudioSample = (sample: AudioSample) => void | Promise<void>;
 export type OnVideoSample = (sample: VideoSample) => void | Promise<void>;
 export type OnAudioTrack = (track: AudioTrack) => OnAudioSample | Promise<OnAudioSample | null> | null;
 export type OnVideoTrack = (track: VideoTrack) => OnVideoSample | Promise<OnVideoSample | null> | null;
+export type AudioOrVideoSample = {
+    timestamp: number;
+    type: 'key' | 'delta';
+    data: Uint8Array;
+    duration: number | undefined;
+};

package/dist/writers/buffer-implementation/multi-buffer.js

@@ -0,0 +1 @@
+"use strict";

package/dist/writers/buffer-implementation/writer.d.ts

@@ -0,0 +1,2 @@
+import type { Writer } from '../writer';
+export declare const createContent: () => Promise<Writer>;

package/dist/writers/buffer-implementation/writer.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContent = void 0;
+const createContent = () => {
+    const buf = new ArrayBuffer(0, {
+        // TODO: Educate that the buffer is limited to 2GB
+        maxByteLength: 200000000,
+    });
+    if (!buf.resize) {
+        throw new Error('Could not create buffer writer');
+    }
+    const write = (newData) => {
+        const oldLength = buf.byteLength;
+        const newLength = oldLength + newData.byteLength;
+        buf.resize(newLength);
+        const newArray = new Uint8Array(buf);
+        newArray.set(newData, oldLength);
+    };
+    const updateDataAt = (position, newData) => {
+        const newArray = new Uint8Array(buf);
+        newArray.set(newData, position);
+    };
+    let writPromise = Promise.resolve();
+    let removed = false;
+    const writer = {
+        write: (arr) => {
+            writPromise = writPromise.then(() => write(arr));
+            return writPromise;
+        },
+        save: () => {
+            if (removed) {
+                return Promise.reject(new Error('Already called .remove() on the result'));
+            }
+            const arr = new Uint8Array(buf);
+            return Promise.resolve(
+            // TODO: Unhardcode MIME type and file name
+            new File([arr.slice()], 'hi', { type: 'video/webm' }));
+        },
+        remove() {
+            removed = true;
+            return Promise.resolve();
+        },
+        getWrittenByteCount: () => buf.byteLength,
+        updateDataAt: (position, newData) => {
+            writPromise = writPromise.then(() => updateDataAt(position, newData));
+            return writPromise;
+        },
+        waitForFinish: async () => {
+            await writPromise;
+        },
+    };
+    return Promise.resolve(writer);
+};
+exports.createContent = createContent;

package/dist/writers/buffer.js

@@ -1,58 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bufferWriter = void 0;
-const createContent = () => {
-    const buf = new ArrayBuffer(0, {
-        // TODO: Educate that the buffer is limited to 100MB
-        maxByteLength: 100000000,
-    });
-    if (!buf.resize) {
-        throw new Error('Could not create buffer writer');
-    }
-    let data = new Uint8Array(buf);
-    const write = (newData) => {
-        const oldLength = buf.byteLength;
-        const newLength = oldLength + newData.byteLength;
-        buf.resize(newLength);
-        const newArray = new Uint8Array(buf);
-        newArray.set(newData, oldLength);
-        data = newArray;
-    };
-    const updateDataAt = (position, newData) => {
-        const newArray = new Uint8Array(buf);
-        newArray.set(newData, position);
-        data = newArray;
-    };
-    let writPromise = Promise.resolve();
-    let removed = false;
-    const writer = {
-        write: (arr) => {
-            writPromise = writPromise.then(() => write(arr));
-            return writPromise;
-        },
-        save: () => {
-            if (removed) {
-                return Promise.reject(new Error('Already called .remove() on the result'));
-            }
-            // TODO: Unhardcode name
-            return Promise.resolve(new File([data], 'hithere', {}));
-        },
-        remove() {
-            removed = true;
-            data = new Uint8Array(0);
-            return Promise.resolve();
-        },
-        getWrittenByteCount: () => buf.byteLength,
-        updateDataAt: (position, newData) => {
-            writPromise = writPromise.then(() => updateDataAt(position, newData));
-            return writPromise;
-        },
-        waitForFinish: async () => {
-            await writPromise;
-        },
-    };
-    return Promise.resolve(writer);
-};
+const writer_1 = require("./buffer-implementation/writer");
 exports.bufferWriter = {
-    createContent,
+    createContent: writer_1.createContent,
 };

package/dist/writers/web-fs.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.canUseWebFsWriter = exports.webFsWriter = void 0;
 const createContent = async () => {
     const directoryHandle = await navigator.storage.getDirectory();
+    // TODO: Unhardcode WebM
     const filename = `media-parser-${Math.random().toString().replace('0.', '')}.webm`;
     const fileHandle = await directoryHandle.getFileHandle(filename, {
         create: true,
@@ -58,6 +59,12 @@ exports.webFsWriter = {
     createContent,
 };
 const canUseWebFsWriter = async () => {
+    if (!('storage' in navigator)) {
+        return false;
+    }
+    if (!('getDirectory' in navigator.storage)) {
+        return false;
+    }
     const directoryHandle = await navigator.storage.getDirectory();
     const fileHandle = await directoryHandle.getFileHandle('remotion-probe-web-fs-support', {
         create: true,

package/dist/writers/writer.d.ts

@@ -1,6 +1,6 @@
 export type Writer = {
     write: (arr: Uint8Array) => Promise<void>;
-    save: () => Promise<File>;
+    save: () => Promise<File | Blob>;
     getWrittenByteCount: () => number;
     updateDataAt: (position: number, data: Uint8Array) => Promise<void>;
     waitForFinish: () => Promise<void>;

package/package.json

@@ -3,14 +3,14 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.227",
+  "version": "4.0.229",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.14.0",
-    "@remotion/renderer": "4.0.227",
-    "@remotion/eslint-config-internal": "4.0.227"
+    "@remotion/example-videos": "4.0.229",
+    "@remotion/eslint-config-internal": "4.0.229"
   },
   "publishConfig": {
     "access": "public"
@@ -77,7 +77,7 @@
     }
   },
   "author": "Jonny Burger <jonny@remotion.dev>",
-  "license": "SEE LICENSE IN LICENSE.md",
+  "license": "Remotion License https://remotion.dev/license",
   "keywords": [
     "remotion",
     "ffmpeg",