@remotion/media-parser 4.0.228 → 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) => 1 | 2 | 5 | 3 | 6 | 4;
+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>;

package/dist/create/create-media.js

@@ -79,8 +79,8 @@ const createMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, })
         const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
         if (!currentCluster.shouldMakeNewCluster({
             newT: smallestProgress,
-            keyframe: chunk.type === 'key',
             isVideo,
+            chunk,
         })) {
             return { cluster: currentCluster, isNew: false, smallestProgress };
         }

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/index.mjs

@@ -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
@@ -1886,8 +1903,8 @@ var createMedia = async ({
     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 };
     }
@@ -4380,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,
@@ -6169,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 {

package/dist/index.d.ts

@@ -3,7 +3,7 @@ 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 { 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';

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,

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.228",
+  "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.228",
-    "@remotion/eslint-config-internal": "4.0.228"
+    "@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",