@remotion/webcodecs 4.0.244 → 4.0.246

package/dist/test/stss.test.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const example_stts_1 = require("../create/iso-base-media/example-stts");
+const create_stss_1 = require("../create/iso-base-media/trak/mdia/minf/stbl/create-stss");
+const reference = new Uint8Array([
+    0x00, 0x00, 0x00, 0x28, 0x73, 0x74, 0x73, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00,
+    0x00, 0x29, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00,
+    0x65,
+]);
+(0, bun_test_1.test)('stss', () => {
+    (0, bun_test_1.expect)((0, create_stss_1.createStss)(example_stts_1.exampleVideoSamplePositions)).toEqual(reference);
+});

package/dist/test/stsz.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/stsz.test.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const example_stts_1 = require("../create/iso-base-media/example-stts");
+const create_stsz_1 = require("../create/iso-base-media/trak/mdia/minf/stbl/create-stsz");
+const refernce = new Uint8Array([
+    0, 0, 3, 12, 115, 116, 115, 122, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 190, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0,
+    3, 78, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0,
+    3, 79, 0, 0, 3, 78, 0, 0, 3, 78, 0, 0, 3, 79,
+]);
+(0, bun_test_1.test)('stsz', () => {
+    (0, bun_test_1.expect)((0, create_stsz_1.createStsz)(example_stts_1.exampleAudioSamplePositions)).toEqual(refernce);
+});

package/dist/test/stts.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/stts.test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const example_stts_1 = require("../create/iso-base-media/example-stts");
+const create_stts_1 = require("../create/iso-base-media/trak/mdia/minf/stbl/create-stts");
+const reference = new Uint8Array([
+    0x00, 0x00, 0x00, 0x18, 0x73, 0x74, 0x74, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x04, 0x00,
+]);
+(0, bun_test_1.test)('stts', () => {
+    return (0, bun_test_1.expect)((0, create_stts_1.createSttsAtom)(example_stts_1.exampleAudioSamplePositions)).toEqual(reference);
+});

package/dist/test/tkhd.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/tkhd.test.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const media_parser_1 = require("@remotion/media-parser");
+const bun_test_1 = require("bun:test");
+const create_tkhd_1 = require("../create/iso-base-media/trak/create-tkhd");
+const buffer = Uint8Array.from([
+    // size, 32 bit
+    0, 0, 0, 92,
+    // mvhd atom, 32 bit
+    116, 107, 104, 100,
+    // version, 8 unsigned bit
+    0,
+    // flags, 24 bit
+    0, 0, 15,
+    // creation time, 32 bit
+    226, 94, 106, 178,
+    // modification time, 32 bit
+    226, 94, 106, 182,
+    // track id, 32 bit
+    0, 0, 0, 5,
+    // reserved, 32 bit
+    0, 0, 0, 0,
+    // duration, 32 bit
+    0, 0, 7, 248,
+    // reserved, 32 bit
+    0, 0, 0, 0,
+    // reserved, 32 bit
+    0, 0, 0, 0,
+    // layer, 16 bit
+    0, 0,
+    // alternate group, 16 bit
+    0, 0,
+    // volume, 16 bit
+    0, 0,
+    // reserved, 16 bit
+    0, 0,
+    // matrix[0], 32 bit
+    0, 1, 0, 0,
+    // matrix[1], 32 bit
+    0, 0, 0, 0,
+    // matrix[2], 32 bit
+    0, 0, 0, 0,
+    // matrix[3], 32 bit
+    0, 0, 0, 0,
+    // matrix[4], 32 bit
+    0, 1, 0, 0,
+    // matrix[5], 32 bit
+    0, 0, 0, 0,
+    // matrix[6], 32 bit
+    0, 0, 0, 0,
+    // matrix[7], 32 bit
+    0, 0, 0, 0,
+    // matrix[8], 32 bit
+    64, 0, 0, 0,
+    // width, 32 bit
+    0, 0, 0, 0,
+    // height, 32 bit
+    0, 0, 0, 0,
+]);
+(0, bun_test_1.test)('Should be able to parse a TKHD box', () => {
+    const iterator = media_parser_1.MediaParserInternals.getArrayBufferIterator(buffer, null);
+    iterator.discard(8);
+    const mvhd = media_parser_1.MediaParserInternals.parseTkhd({
+        iterator,
+        offset: 0,
+        size: 92,
+    });
+    (0, bun_test_1.expect)(mvhd).toEqual({
+        type: 'tkhd-box',
+        boxSize: 92,
+        offset: 0,
+        alternateGroup: 0,
+        creationTime: 1714993714000,
+        duration: 2040,
+        modificationTime: 1714993718000,
+        trackId: 5,
+        version: 0,
+        layer: 0,
+        volume: 0,
+        matrix: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+        width: 0,
+        height: 0,
+        rotation: 0,
+        unrotatedWidth: 0,
+        unrotatedHeight: 0,
+    });
+});
+(0, bun_test_1.test)('Should be able to create a tkhd', () => {
+    (0, bun_test_1.expect)((0, create_tkhd_1.createTkhdForVideo)({
+        creationTime: 1714993714000,
+        modificationTime: 1714993718000,
+        trackId: 5,
+        duration: 2040,
+        volume: 0,
+        matrix: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+        width: 0,
+        height: 0,
+        flags: create_tkhd_1.TKHD_FLAGS.TRACK_ENABLED |
+            create_tkhd_1.TKHD_FLAGS.TRACK_IN_MOVIE |
+            create_tkhd_1.TKHD_FLAGS.TRACK_IN_PREVIEW |
+            create_tkhd_1.TKHD_FLAGS.TRACK_IN_POSTER,
+        timescale: 1000,
+    })).toEqual(buffer);
+});
+const buffer2 = new Uint8Array([
+    0x00, 0x00, 0x00, 0x5c, 0x74, 0x6b, 0x68, 0x64, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x04, 0x38, 0x00, 0x00, 0x07, 0x80, 0x00,
+    0x00,
+]);
+(0, bun_test_1.test)('Should be able to parse a TKHD box 2', () => {
+    const iterator = media_parser_1.MediaParserInternals.getArrayBufferIterator(buffer2, null);
+    iterator.discard(8);
+    const mvhd = media_parser_1.MediaParserInternals.parseTkhd({
+        iterator,
+        offset: 0,
+        size: 92,
+    });
+    (0, bun_test_1.expect)(mvhd).toEqual({
+        type: 'tkhd-box',
+        boxSize: 92,
+        offset: 0,
+        alternateGroup: 0,
+        creationTime: null,
+        duration: 0,
+        modificationTime: null,
+        trackId: 1,
+        version: 0,
+        layer: 0,
+        volume: 0,
+        matrix: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+        width: 1080,
+        height: 1920,
+        rotation: 0,
+        unrotatedWidth: 1080,
+        unrotatedHeight: 1920,
+    });
+    (0, bun_test_1.expect)((0, create_tkhd_1.createTkhdForVideo)({
+        creationTime: null,
+        modificationTime: null,
+        duration: 0,
+        height: 1920,
+        width: 1080,
+        matrix: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+        trackId: 1,
+        volume: 0,
+        flags: create_tkhd_1.TKHD_FLAGS.TRACK_ENABLED | create_tkhd_1.TKHD_FLAGS.TRACK_IN_MOVIE,
+        timescale: 1000,
+    })).toEqual(buffer2);
+});
+const audioTkhd = new Uint8Array([
+    0x00, 0x00, 0x00, 0x5c, 0x74, 0x6b, 0x68, 0x64, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x0f, 0xd6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x0,
+]);
+(0, bun_test_1.test)('tkhd', () => {
+    (0, bun_test_1.expect)((0, create_tkhd_1.createTkhdForAudio)({
+        creationTime: null,
+        flags: 3,
+        modificationTime: null,
+        trackId: 2,
+        duration: 4054,
+        volume: 1,
+        timescale: 1000,
+    })).toEqual(audioTkhd);
+});

package/dist/test/too.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/too.test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const create_too_1 = require("../create/iso-base-media/ilst/create-too");
+const reference = new Uint8Array([
+    0x0, 0x00, 0x00, 0x24, 0xa9, 0x74, 0x6f, 0x6f, 0x00, 0x00, 0x00, 0x1c, 0x64,
+    0x61, 0x74, 0x61, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x61,
+    0x76, 0x66, 0x36, 0x31, 0x2e, 0x37, 0x2e, 0x31, 0x30, 0x30,
+]);
+(0, bun_test_1.test)('create too', () => {
+    (0, bun_test_1.expect)((0, create_too_1.createToo)('Lavf61.7.100')).toEqual(reference);
+});

package/dist/test/url.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/url.test.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const create_url_1 = require("../create/iso-base-media/create-url");
+const reference = new Uint8Array([
+    0x00, 0x00, 0x00, 0x0c, 0x75, 0x72, 0x6c, 0x20, 0x00, 0x00, 0x00, 0x01,
+]);
+(0, bun_test_1.test)('url atom', () => {
+    const atom = (0, create_url_1.createUrlAtom)();
+    (0, bun_test_1.expect)(atom).toEqual(reference);
+});

package/dist/truthy.d.ts

@@ -0,0 +1,3 @@
+type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+export declare function truthy<T>(value: T): value is Truthy<T>;
+export {};

package/dist/truthy.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truthy = truthy;
+function truthy(value) {
+    return Boolean(value);
+}

package/dist/video-decoder.d.ts

@@ -1,4 +1,5 @@
-import type { AudioOrVideoSample, LogLevel, ProgressTracker } from '@remotion/media-parser';
+import type { AudioOrVideoSample, LogLevel } from '@remotion/media-parser';
+import type { ProgressTracker } from './create/progress-tracker';
 export type WebCodecsVideoDecoder = {
     processSample: (videoSample: AudioOrVideoSample) => Promise<void>;
     waitForFinish: () => Promise<void>;

package/dist/video-encoder.d.ts

@@ -1,4 +1,5 @@
-import type { LogLevel, ProgressTracker } from '@remotion/media-parser';
+import type { LogLevel } from '@remotion/media-parser';
+import type { ProgressTracker } from './create/progress-tracker';
 import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export type WebCodecsVideoEncoder = {
     encodeFrame: (videoFrame: VideoFrame, timestamp: number) => Promise<void>;

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

@@ -0,0 +1,2 @@
+import type { CreateContent } from '../writer';
+export declare const createContent: CreateContent;

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 = ({ filename, mimeType }) => {
+    const buf = new ArrayBuffer(0, {
+        // TODO: Educate that the buffer is limited to 2GB
+        maxByteLength: 2000000000,
+    });
+    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()], filename, { type: mimeType }));
+        },
+        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.d.ts

@@ -0,0 +1,2 @@
+import type { WriterInterface } from './writer';
+export declare const bufferWriter: WriterInterface;

package/dist/writers/buffer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferWriter = void 0;
+const writer_1 = require("./buffer-implementation/writer");
+exports.bufferWriter = {
+    createContent: writer_1.createContent,
+};

package/dist/writers/web-fs.d.ts

@@ -0,0 +1,3 @@
+import type { WriterInterface } from './writer';
+export declare const webFsWriter: WriterInterface;
+export declare const canUseWebFsWriter: () => Promise<boolean>;

package/dist/writers/web-fs.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canUseWebFsWriter = exports.webFsWriter = void 0;
+const createContent = async ({ filename }) => {
+    const directoryHandle = await navigator.storage.getDirectory();
+    const actualFilename = `__remotion_mediaparser:${filename}`;
+    const remove = async () => {
+        await directoryHandle.removeEntry(actualFilename, {
+            recursive: true,
+        });
+    };
+    await remove();
+    const fileHandle = await directoryHandle.getFileHandle(actualFilename, {
+        create: true,
+    });
+    const writable = await fileHandle.createWritable();
+    let written = 0;
+    let writPromise = Promise.resolve();
+    const write = async (arr) => {
+        await writable.write(arr);
+        written += arr.byteLength;
+    };
+    const updateDataAt = async (position, data) => {
+        await writable.seek(position);
+        await writable.write(data);
+        await writable.seek(written);
+    };
+    const writer = {
+        write: (arr) => {
+            writPromise = writPromise.then(() => write(arr));
+            return writPromise;
+        },
+        save: async () => {
+            try {
+                await writable.close();
+            }
+            catch (_a) {
+                // Ignore, could already be closed
+            }
+            const newHandle = await directoryHandle.getFileHandle(actualFilename, {
+                create: true,
+            });
+            const newFile = await newHandle.getFile();
+            return newFile;
+        },
+        getWrittenByteCount: () => written,
+        updateDataAt: (position, data) => {
+            writPromise = writPromise.then(() => updateDataAt(position, data));
+            return writPromise;
+        },
+        waitForFinish: async () => {
+            await writPromise;
+        },
+        remove,
+    };
+    return writer;
+};
+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,
+    });
+    const canUse = fileHandle.createWritable !== undefined;
+    return canUse;
+};
+exports.canUseWebFsWriter = canUseWebFsWriter;

package/dist/writers/writer.d.ts

@@ -0,0 +1,15 @@
+export type Writer = {
+    write: (arr: Uint8Array) => Promise<void>;
+    save: () => Promise<Blob>;
+    getWrittenByteCount: () => number;
+    updateDataAt: (position: number, data: Uint8Array) => Promise<void>;
+    waitForFinish: () => Promise<void>;
+    remove: () => Promise<void>;
+};
+export type CreateContent = (options: {
+    filename: string;
+    mimeType: string;
+}) => Promise<Writer>;
+export type WriterInterface = {
+    createContent: CreateContent;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.244",
+  "version": "4.0.246",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -17,20 +17,51 @@
   "author": "Jonny Burger <jonny@remotion.dev>",
   "license": "Remotion License (See https://remotion.dev/docs/webcodecs#license)",
   "dependencies": {
-    "@remotion/media-parser": "4.0.244",
-    "@remotion/licensing": "4.0.244"
+    "@remotion/media-parser": "4.0.246",
+    "@remotion/licensing": "4.0.246"
   },
   "peerDependencies": {},
   "devDependencies": {
     "@types/dom-webcodecs": "0.1.11",
     "eslint": "9.14.0",
-    "@remotion/example-videos": "4.0.244",
-    "@remotion/eslint-config-internal": "4.0.244"
+    "@remotion/example-videos": "4.0.246",
+    "@remotion/eslint-config-internal": "4.0.246"
   },
   "keywords": [],
   "publishConfig": {
     "access": "public"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "module": "./dist/esm/index.mjs",
+      "import": "./dist/esm/index.mjs"
+    },
+    "./web-fs": {
+      "types": "./dist/writers/web-fs.d.ts",
+      "require": "./dist/writers/web-fs.js",
+      "module": "./dist/esm/web-fs.mjs",
+      "import": "./dist/esm/web-fs.mjs"
+    },
+    "./buffer": {
+      "types": "./dist/writers/buffer.d.ts",
+      "require": "./dist/writers/buffer.js",
+      "module": "./dist/esm/buffer.mjs",
+      "import": "./dist/esm/buffer.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    ">=1.0": {
+      "web-fs": [
+        "dist/writers/web-fs.d.ts"
+      ],
+      "buffer": [
+        "dist/writers/buffer.d.ts"
+      ]
+    }
+  },
   "description": "Media conversion in the browser",
   "homepage": "https://remotion.dev/webcodecs",
   "scripts": {

package/dist/get-operation-id.js

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

package/dist/resizing/resizing.d.ts

@@ -1,13 +0,0 @@
-export type ResizingMode = {
-    type: 'width';
-    width: number;
-} | {
-    type: 'height';
-    height: number;
-} | {
-    type: 'max-height';
-    height: number;
-} | {
-    type: 'max-width';
-    width: number;
-};

package/dist/resizing.d.ts

@@ -1,13 +0,0 @@
-export type ResizingMode = {
-    type: 'width';
-    width: number;
-} | {
-    type: 'height';
-    height: number;
-} | {
-    type: 'max-height';
-    height: number;
-} | {
-    type: 'max-width';
-    width: number;
-};

package/dist/rotate-video-frame.d.ts

@@ -1,9 +0,0 @@
-import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
-import type { ResizingMode } from './resizing/mode';
-export declare const normalizeVideoRotation: (rotation: number) => number;
-export declare const rotateAndResizeVideoFrame: ({ frame, rotation, videoCodec, resizingMode, }: {
-    frame: VideoFrame;
-    rotation: number;
-    videoCodec: ConvertMediaVideoCodec;
-    resizingMode: ResizingMode | null;
-}) => VideoFrame;

package/dist/rotate-video-frame.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rotateAndResizeVideoFrame = exports.normalizeVideoRotation = void 0;
-const rotation_1 = require("./rotation");
-const normalizeVideoRotation = (rotation) => {
-    return ((rotation % 360) + 360) % 360;
-};
-exports.normalizeVideoRotation = normalizeVideoRotation;
-const rotateAndResizeVideoFrame = ({ frame, rotation, videoCodec, resizingMode, }) => {
-    var _a;
-    const normalized = ((rotation % 360) + 360) % 360;
-    if (normalized % 360 === 0 && resizingMode === null) {
-        return frame;
-    }
-    if (normalized % 90 !== 0) {
-        throw new Error('Only 90 degree rotations are supported');
-    }
-    const { height, width } = (0, rotation_1.calculateNewDimensionsFromDimensions)({
-        height: frame.displayHeight,
-        width: frame.displayWidth,
-        rotation,
-        videoCodec,
-        resizingMode,
-    });
-    const canvas = new OffscreenCanvas(width, height);
-    const ctx = canvas.getContext('2d');
-    if (!ctx) {
-        throw new Error('Could not get 2d context');
-    }
-    canvas.width = width;
-    canvas.height = height;
-    if (normalized === 90) {
-        ctx.translate(width, 0);
-    }
-    else if (normalized === 180) {
-        ctx.translate(width, height);
-    }
-    else if (normalized === 270) {
-        ctx.translate(0, height);
-    }
-    ctx.rotate(normalized * (Math.PI / 180));
-    if (frame.displayHeight !== height || frame.displayWidth !== width) {
-        ctx.scale(width / frame.displayWidth, height / frame.displayHeight);
-    }
-    ctx.drawImage(frame, 0, 0);
-    return new VideoFrame(canvas, {
-        displayHeight: height,
-        displayWidth: width,
-        duration: (_a = frame.duration) !== null && _a !== void 0 ? _a : undefined,
-        timestamp: frame.timestamp,
-    });
-};
-exports.rotateAndResizeVideoFrame = rotateAndResizeVideoFrame;

package/dist/scaling.d.ts

@@ -1,13 +0,0 @@
-export type ScalingMode = {
-    type: 'width';
-    width: number;
-} | {
-    type: 'height';
-    height: number;
-} | {
-    type: 'max-height';
-    height: number;
-} | {
-    type: 'max-width';
-    width: number;
-};