@remotion/webcodecs 4.0.254 → 4.0.256

package/dist/codec-id.d.ts

@@ -0,0 +1,2 @@
+export type ConvertMediaVideoCodec = 'vp8' | 'vp9';
+export type ConvertMediaAudioCodec = 'opus';

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

@@ -19,7 +19,7 @@ export type EbmlParsedOrUint8Array<T extends Ebml> = {
     value: EbmlValueOrUint8Array<T>;
     minVintWidth: number | null;
 };
-export declare const measureEBMLVarInt: (value: number) => 2 | 1 | 4 | 3 | 5 | 6;
+export declare const measureEBMLVarInt: (value: number) => 2 | 1 | 6 | 5 | 3 | 4;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;
 export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => BytesAndOffset;
 export type PossibleEbmlOrUint8Array = Prettify<{

package/dist/resolve-audio-action.d.ts

@@ -0,0 +1,15 @@
+import type { AudioTrack } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './codec-id';
+export type AudioOperation = 'reencode' | 'copy' | 'drop';
+export type ResolveAudioActionFn = (options: {
+    canReencode: boolean;
+    canCopy: boolean;
+}) => AudioOperation | Promise<AudioOperation>;
+export declare const defaultResolveAudioAction: ResolveAudioActionFn;
+export declare const resolveAudioAction: ({ audioDecoderConfig, audioEncoderConfig, track, audioCodec, resolverFunction, }: {
+    audioDecoderConfig: AudioDecoderConfig | null;
+    audioEncoderConfig: AudioEncoderConfig | null;
+    track: AudioTrack;
+    audioCodec: ConvertMediaAudioCodec;
+    resolverFunction: ResolveAudioActionFn;
+}) => Promise<AudioOperation>;

package/dist/resolve-audio-action.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAudioAction = exports.defaultResolveAudioAction = void 0;
+const canCopyAudioTrack = (inputCodec, outputCodec) => {
+    if (outputCodec === 'opus') {
+        return inputCodec === 'opus';
+    }
+    throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+const defaultResolveAudioAction = ({ canReencode, canCopy, }) => {
+    if (canCopy) {
+        return 'copy';
+    }
+    if (canReencode) {
+        return 'reencode';
+    }
+    // TODO: Make a fail option?
+    return 'drop';
+};
+exports.defaultResolveAudioAction = defaultResolveAudioAction;
+const resolveAudioAction = async ({ audioDecoderConfig, audioEncoderConfig, track, audioCodec, resolverFunction, }) => {
+    const canReencode = Boolean(audioDecoderConfig && audioEncoderConfig);
+    const canCopy = canCopyAudioTrack(track.codecWithoutConfig, audioCodec);
+    const resolved = await resolverFunction({
+        canReencode,
+        canCopy,
+    });
+    return resolved;
+};
+exports.resolveAudioAction = resolveAudioAction;

package/dist/resolve-video-action.d.ts

@@ -0,0 +1,15 @@
+import type { VideoTrack } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './codec-id';
+export type VideoOperation = 'reencode' | 'copy' | 'drop';
+export type ResolveVideoActionFn = (options: {
+    canReencode: boolean;
+    canCopy: boolean;
+}) => VideoOperation | Promise<VideoOperation>;
+export declare const defaultResolveVideoAction: ResolveVideoActionFn;
+export declare const resolveVideoAction: ({ videoDecoderConfig, videoEncoderConfig, track, videoCodec, resolverFunction, }: {
+    videoDecoderConfig: VideoDecoderConfig | null;
+    videoEncoderConfig: VideoEncoderConfig | null;
+    videoCodec: ConvertMediaVideoCodec;
+    track: VideoTrack;
+    resolverFunction: ResolveVideoActionFn;
+}) => Promise<VideoOperation>;

package/dist/resolve-video-action.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVideoAction = exports.defaultResolveVideoAction = void 0;
+const canCopyVideoTrack = (inputCodec, outputCodec) => {
+    if (outputCodec === 'vp8') {
+        return inputCodec === 'vp8';
+    }
+    if (outputCodec === 'vp9') {
+        return inputCodec === 'vp9';
+    }
+    throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+const defaultResolveVideoAction = ({ canReencode, canCopy, }) => {
+    if (canCopy) {
+        return 'copy';
+    }
+    if (canReencode) {
+        return 'reencode';
+    }
+    // TODO: Make a fail option?
+    return 'drop';
+};
+exports.defaultResolveVideoAction = defaultResolveVideoAction;
+const resolveVideoAction = async ({ videoDecoderConfig, videoEncoderConfig, track, videoCodec, resolverFunction, }) => {
+    const canReencode = Boolean(videoDecoderConfig && videoEncoderConfig);
+    const canCopy = canCopyVideoTrack(track.codecWithoutConfig, videoCodec);
+    const resolved = await resolverFunction({
+        canReencode,
+        canCopy,
+    });
+    return resolved;
+};
+exports.resolveVideoAction = resolveVideoAction;

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

@@ -0,0 +1,5 @@
+export declare const normalizeVideoRotation: (rotation: number) => number;
+export declare const rotateVideoFrame: ({ frame, rotation, }: {
+    frame: VideoFrame;
+    rotation: number;
+}) => VideoFrame;

package/dist/rotate-video-frame.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rotateVideoFrame = exports.normalizeVideoRotation = void 0;
+const rotation_1 = require("./rotation");
+const normalizeVideoRotation = (rotation) => {
+    return ((rotation % 360) + 360) % 360;
+};
+exports.normalizeVideoRotation = normalizeVideoRotation;
+const rotateVideoFrame = ({ frame, rotation, }) => {
+    var _a;
+    const normalized = ((rotation % 360) + 360) % 360;
+    if (normalized % 360 === 0) {
+        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,
+    });
+    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));
+    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.rotateVideoFrame = rotateVideoFrame;

package/dist/select-container-creator.d.ts

@@ -1,2 +1,2 @@
 import type { ConvertMediaContainer } from './get-available-containers';
-export declare const selectContainerCreator: (container: ConvertMediaContainer) => ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, progressTracker, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
+export declare const selectContainerCreator: (container: ConvertMediaContainer) => ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, progressTracker, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;

package/dist/with-resolvers.d.ts

@@ -0,0 +1,5 @@
+export declare const withResolvers: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};

package/dist/with-resolvers.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withResolvers = void 0;
+const withResolvers = function () {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve: resolve, reject: reject };
+};
+exports.withResolvers = withResolvers;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.254",
+  "version": "4.0.256",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -17,15 +17,15 @@
   "author": "Jonny Burger <jonny@remotion.dev>",
   "license": "Remotion License (See https://remotion.dev/docs/webcodecs#license)",
   "dependencies": {
-    "@remotion/media-parser": "4.0.254",
-    "@remotion/licensing": "4.0.254"
+    "@remotion/media-parser": "4.0.256",
+    "@remotion/licensing": "4.0.256"
   },
   "peerDependencies": {},
   "devDependencies": {
     "@types/dom-webcodecs": "0.1.11",
     "eslint": "9.14.0",
-    "@remotion/example-videos": "4.0.254",
-    "@remotion/eslint-config-internal": "4.0.254"
+    "@remotion/example-videos": "4.0.256",
+    "@remotion/eslint-config-internal": "4.0.256"
   },
   "keywords": [],
   "publishConfig": {

package/dist/controller.d.ts

@@ -1,16 +0,0 @@
-import type { ParseMediaController } from '@remotion/media-parser';
-export type WebCodecsController = {
-    abort: (reason?: any) => void;
-    pause: ParseMediaController['pause'];
-    resume: ParseMediaController['resume'];
-    addEventListener: ParseMediaController['addEventListener'];
-    removeEventListener: ParseMediaController['removeEventListener'];
-    /**
-     * @deprecated Not public API
-     */
-    _internals: {
-        signal: AbortSignal;
-        checkForAbortAndPause: ParseMediaController['_internals']['checkForAbortAndPause'];
-    };
-};
-export declare const webcodecsController: () => WebCodecsController;

package/dist/controller.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.webcodecsController = void 0;
-const media_parser_1 = require("@remotion/media-parser");
-const webcodecsController = () => {
-    const controller = (0, media_parser_1.mediaParserController)();
-    return {
-        abort: controller.abort,
-        pause: controller.pause,
-        resume: controller.resume,
-        addEventListener: controller.addEventListener,
-        removeEventListener: controller.removeEventListener,
-        _internals: controller._internals,
-    };
-};
-exports.webcodecsController = webcodecsController;

package/dist/emitter.d.ts

@@ -1,20 +0,0 @@
-type MediaParserEventMap = {
-    pause: undefined;
-    resume: undefined;
-};
-export type MediaParserEventTypes = keyof MediaParserEventMap;
-export type CallbackListener<T extends MediaParserEventTypes> = (data: {
-    detail: MediaParserEventMap[T];
-}) => void;
-type MediaParserListeners = {
-    [EventType in MediaParserEventTypes]: CallbackListener<EventType>[];
-};
-export declare class MediaParserEmitter {
-    listeners: MediaParserListeners;
-    addEventListener<Q extends MediaParserEventTypes>(name: Q, callback: CallbackListener<Q>): void;
-    removeEventListener<Q extends MediaParserEventTypes>(name: Q, callback: CallbackListener<Q>): void;
-    private dispatchEvent;
-    dispatchPause: () => void;
-    dispatchResume: () => void;
-}
-export {};

package/dist/emitter.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MediaParserEmitter = void 0;
-class MediaParserEmitter {
-    constructor() {
-        this.listeners = {
-            pause: [],
-            resume: [],
-        };
-        this.dispatchPause = () => {
-            this.dispatchEvent('pause', undefined);
-        };
-        this.dispatchResume = () => {
-            this.dispatchEvent('resume', undefined);
-        };
-    }
-    addEventListener(name, callback) {
-        this.listeners[name].push(callback);
-    }
-    removeEventListener(name, callback) {
-        this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
-    }
-    dispatchEvent(dispatchName, context) {
-        this.listeners[dispatchName].forEach((callback) => {
-            callback({ detail: context });
-        });
-    }
-}
-exports.MediaParserEmitter = MediaParserEmitter;

package/dist/esm/node.mjs

@@ -1,71 +0,0 @@
-// src/writers/node.ts
-import fs from "node:fs";
-var createContent = (filename) => {
-  return async () => {
-    const writPromise = Promise.resolve();
-    const remove = async () => {
-      await fs.promises.unlink(filename).catch(() => {
-      });
-    };
-    await remove();
-    if (!fs.existsSync(filename)) {
-      fs.writeFileSync(filename, "");
-    }
-    const writeStream = fs.openSync(filename, "w");
-    let written = 0;
-    const write = async (data) => {
-      await new Promise((resolve, reject) => {
-        fs.write(writeStream, data, 0, data.length, undefined, (err) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          resolve();
-        });
-      });
-      written += data.byteLength;
-    };
-    const updateDataAt = (position, data) => {
-      return new Promise((resolve, reject) => {
-        fs.write(writeStream, data, 0, data.length, position, (err) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          resolve();
-        });
-      });
-    };
-    const writer = {
-      write: (arr) => {
-        writPromise.then(() => write(arr));
-        return writPromise;
-      },
-      updateDataAt: (position, data) => {
-        writPromise.then(() => updateDataAt(position, data));
-        return writPromise;
-      },
-      waitForFinish: async () => {
-        await writPromise;
-      },
-      getWrittenByteCount: () => written,
-      remove,
-      save: async () => {
-        try {
-          fs.closeSync(writeStream);
-          const file = await fs.promises.readFile(filename);
-          return new Blob([file]);
-        } catch (e) {
-          return Promise.reject(e);
-        }
-      }
-    };
-    return writer;
-  };
-};
-var nodeWriter = (path) => {
-  return { createContent: createContent(path) };
-};
-export {
-  nodeWriter
-};

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

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

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

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const media_parser_1 = require("@remotion/media-parser");
-const bun_test_1 = require("bun:test");
-const matroska_utils_1 = require("../create/matroska/matroska-utils");
-(0, bun_test_1.test)('Should make Matroska header that is same as input', async () => {
-    const headerOutput = (0, matroska_utils_1.makeMatroskaBytes)({
-        type: 'Header',
-        minVintWidth: 1,
-        value: [
-            {
-                type: 'EBMLVersion',
-                value: { value: 1, byteLength: 1 },
-                minVintWidth: 1,
-            },
-            {
-                type: 'EBMLReadVersion',
-                value: { value: 1, byteLength: 1 },
-                minVintWidth: 1,
-            },
-            {
-                type: 'EBMLMaxIDLength',
-                value: { value: 4, byteLength: 1 },
-                minVintWidth: 1,
-            },
-            {
-                type: 'EBMLMaxSizeLength',
-                value: { value: 8, byteLength: 1 },
-                minVintWidth: 1,
-            },
-            {
-                type: 'DocType',
-                value: 'webm',
-                minVintWidth: 1,
-            },
-            {
-                type: 'DocTypeVersion',
-                value: { value: 4, byteLength: 1 },
-                minVintWidth: 1,
-            },
-            {
-                type: 'DocTypeReadVersion',
-                value: { value: 2, byteLength: 1 },
-                minVintWidth: 1,
-            },
-        ],
-    });
-    const iterator = media_parser_1.MediaParserInternals.getArrayBufferIterator(headerOutput.bytes, headerOutput.bytes.length);
-    const state = media_parser_1.MediaParserInternals.makeParserState({
-        hasAudioTrackHandlers: false,
-        hasVideoTrackHandlers: false,
-        signal: undefined,
-        iterator,
-        fields: {},
-        onAudioTrack: null,
-        onVideoTrack: null,
-        supportsContentRange: true,
-        contentLength: null,
-        logLevel: 'info',
-    });
-    const parsed = await media_parser_1.MediaParserInternals.parseEbml(state);
-    (0, bun_test_1.expect)(parsed).toEqual({
-        type: 'Header',
-        minVintWidth: 1,
-        value: [
-            {
-                type: 'EBMLVersion',
-                value: { value: 1, byteLength: 1 },
-                minVintWidth: 1,
-            },
-            {
-                type: 'EBMLReadVersion',
-                value: { value: 1, byteLength: 1 },
-                minVintWidth: 1,
-            },
-            {
-                type: 'EBMLMaxIDLength',
-                value: { value: 4, byteLength: 1 },
-                minVintWidth: 1,
-            },
-            {
-                type: 'EBMLMaxSizeLength',
-                value: { value: 8, byteLength: 1 },
-                minVintWidth: 1,
-            },
-            {
-                type: 'DocType',
-                value: 'webm',
-                minVintWidth: 1,
-            },
-            {
-                type: 'DocTypeVersion',
-                value: { value: 4, byteLength: 1 },
-                minVintWidth: 1,
-            },
-            {
-                type: 'DocTypeReadVersion',
-                value: { value: 2, byteLength: 1 },
-                minVintWidth: 1,
-            },
-        ],
-    });
-});

package/dist/test/stsd.test.d.ts

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

package/dist/test/stsd.test.js

@@ -1,261 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const media_parser_1 = require("@remotion/media-parser");
-const bun_test_1 = require("bun:test");
-(0, bun_test_1.test)('Should be able to parse a STSD audio box correctly', async () => {
-    const buffer = Uint8Array.from([
-        // box size
-        0, 0, 0, 159,
-        // data format "stsd"
-        115, 116, 115, 100,
-        // reserved
-        0, 0, 0, 0, 0, 0,
-        // number of entries
-        0, 1,
-        // size
-        0, 0, 0, 143,
-        // "mp4a"
-        109, 112, 52, 97,
-        // reserved
-        0, 0, 0, 0, 0, 0,
-        // data reference index
-        0, 1,
-        // version
-        0, 1,
-        // revision level
-        0, 0, 0, 0, 0, 0,
-        // revision level
-        0, 2, 0, 16, 255, 254, 0, 0, 172, 68, 0, 0, 0, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0,
-        2, 0, 0, 0, 2, 0, 0, 0, 91, 119, 97, 118, 101, 0, 0, 0, 12, 102, 114, 109,
-        97, 109, 112, 52, 97, 0, 0, 0, 12, 109, 112, 52, 97, 0, 0, 0, 0, 0, 0, 0,
-        51, 101, 115, 100, 115, 0, 0, 0, 0, 3, 128, 128, 128, 34, 0, 0, 0, 4, 128,
-        128, 128, 20, 64, 20, 0, 24, 0, 0, 2, 238, 0, 0, 0, 0, 0, 5, 128, 128, 128,
-        2, 18, 16, 6, 128, 128, 128, 1, 2, 0, 0, 0, 8, 0, 0, 0, 0,
-    ]);
-    const iterator = media_parser_1.MediaParserInternals.getArrayBufferIterator(buffer, null);
-    iterator.discard(8);
-    const parsed = await media_parser_1.MediaParserInternals.parseStsd({
-        offset: 0,
-        size: 159,
-        state: media_parser_1.MediaParserInternals.makeParserState({
-            onAudioTrack: null,
-            onVideoTrack: () => () => undefined,
-            hasAudioTrackHandlers: true,
-            hasVideoTrackHandlers: true,
-            signal: undefined,
-            iterator,
-            fields: {},
-            supportsContentRange: true,
-            contentLength: null,
-            logLevel: 'info',
-        }),
-    });
-    (0, bun_test_1.expect)(parsed).toEqual({
-        offset: 0,
-        boxSize: 159,
-        type: 'stsd-box',
-        numberOfEntries: 1,
-        samples: [
-            {
-                size: 143,
-                offset: 16,
-                format: 'mp4a',
-                dataReferenceIndex: 1,
-                version: 1,
-                revisionLevel: 0,
-                vendor: [0, 0, 0, 0],
-                numberOfChannels: 2,
-                type: 'audio',
-                sampleSize: 16,
-                compressionId: -2,
-                packetSize: 0,
-                samplesPerPacket: 1024,
-                bitsPerSample: 2,
-                bytesPerFrame: 2,
-                bytesPerPacket: 1,
-                sampleRate: 44100,
-                children: [
-                    {
-                        boxSize: 91,
-                        boxType: 'wave',
-                        children: [
-                            {
-                                boxSize: 12,
-                                boxType: 'frma',
-                                children: [],
-                                offset: 76,
-                                type: 'regular-box',
-                            },
-                            {
-                                boxSize: 12,
-                                boxType: 'mp4a',
-                                children: [],
-                                offset: 88,
-                                type: 'regular-box',
-                            },
-                            {
-                                descriptors: [
-                                    {
-                                        objectTypeIndication: 'aac',
-                                        type: 'decoder-config-descriptor',
-                                        asNumber: 64,
-                                        avgBitrate: 0,
-                                        bufferSizeDB: 6144,
-                                        maxBitrate: 192000,
-                                        streamType: 5,
-                                        decoderSpecificConfigs: [
-                                            {
-                                                audioObjectType: 2,
-                                                channelConfiguration: 2,
-                                                samplingFrequencyIndex: 4,
-                                                type: 'mp4a-specific-config',
-                                                asBytes: new Uint8Array([18, 16]),
-                                            },
-                                        ],
-                                        upStream: 0,
-                                    },
-                                    {
-                                        type: 'sl-config-descriptor',
-                                    },
-                                ],
-                                esId: 0,
-                                sizeOfInstance: 34,
-                                tag: 3,
-                                type: 'esds-box',
-                                version: 0,
-                            },
-                            {
-                                boxSize: 8,
-                                boxType: '\u0000\u0000\u0000\u0000',
-                                children: [],
-                                offset: 151,
-                                type: 'regular-box',
-                            },
-                        ],
-                        offset: 68,
-                        type: 'regular-box',
-                    },
-                ],
-            },
-        ],
-    });
-});
-(0, bun_test_1.test)('Should be able to parse a STSD video box correctly', async () => {
-    const buffer = Uint8Array.from([
-        // box size
-        0, 0, 0, 158,
-        // data format "avc1"
-        97, 118, 99, 49,
-        // padding
-        0, 0, 0, 0, 0, 0,
-        // data reference index
-        0, 1,
-        // version
-        0, 0,
-        // revision level
-        0, 0,
-        // vendor
-        0, 0, 0, 0,
-        // temporal quality
-        0, 0, 0, 0,
-        // spatial quality
-        0, 0, 0, 0,
-        // width
-        4, 56,
-        // height
-        4, 56,
-        // horiz resolution
-        0, 72, 0, 0,
-        // vert resolution
-        0, 72, 0, 0,
-        // frame count
-        0, 0,
-        // compressor name
-        // 0
-        0, 0, 0, 1,
-        // 1
-        0, 0, 0, 0,
-        // 2
-        0, 0, 0, 0,
-        // 3
-        0, 0, 0, 0,
-        // 4
-        0, 0, 0, 0,
-        // 5
-        0, 0, 0, 0,
-        // 6
-        0, 0, 0, 0,
-        // 7
-        0, 0, 0, 0,
-        // 8
-        0, 0, 0, 0,
-        // depth
-        0, 24,
-        // color space
-        255, 255,
-        // avcC info (not parsed)
-        0, 0, 0, 56, 97, 118, 99, 67, 1, 100, 0, 32, 255, 225, 0, 27, 103, 100, 0,
-        32, 172, 217, 64, 68, 2, 39, 150, 92, 4, 64, 0, 0, 3, 0, 64, 0, 0, 12, 3,
-        198, 12, 101, 128, 1, 0, 6, 104, 235, 224, 140, 178, 44, 253, 248, 248, 0,
-        // pasp
-        0, 0, 0, 16, 112, 97, 115, 112, 0, 0, 0, 1, 0, 0, 0, 1,
-    ]);
-    const parsed = await media_parser_1.MediaParserInternals.processSample({
-        state: media_parser_1.MediaParserInternals.makeParserState({
-            onAudioTrack: null,
-            onVideoTrack: () => () => undefined,
-            hasAudioTrackHandlers: true,
-            hasVideoTrackHandlers: true,
-            signal: undefined,
-            iterator: media_parser_1.MediaParserInternals.getArrayBufferIterator(buffer, null),
-            fields: {
-                structure: true,
-            },
-            supportsContentRange: true,
-            contentLength: null,
-            logLevel: 'info',
-        }),
-    });
-    (0, bun_test_1.expect)(parsed.sample).toEqual({
-        size: 158,
-        format: 'avc1',
-        dataReferenceIndex: 1,
-        version: 0,
-        revisionLevel: 0,
-        vendor: [0, 0, 0, 0],
-        type: 'video',
-        temporalQuality: 0,
-        spacialQuality: 0,
-        width: 1080,
-        height: 1080,
-        horizontalResolutionPpi: 72,
-        verticalResolutionPpi: 72,
-        dataSize: 0,
-        frameCountPerSample: 1,
-        compressorName: [
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0,
-        ],
-        offset: 0,
-        depth: 24,
-        colorTableId: -1,
-        descriptors: [
-            {
-                privateData: new Uint8Array([
-                    1, 100, 0, 32, 255, 225, 0, 27, 103, 100, 0, 32, 172, 217, 64, 68, 2,
-                    39, 150, 92, 4, 64, 0, 0, 3, 0, 64, 0, 0, 12, 3, 198, 12, 101, 128, 1,
-                    0, 6, 104, 235, 224, 140, 178, 44, 253, 248, 248, 0,
-                ]),
-                type: 'avcc-box',
-                configurationString: '640020',
-            },
-            {
-                boxSize: 16,
-                offset: 142,
-                type: 'pasp-box',
-                hSpacing: 1,
-                vSpacing: 1,
-            },
-        ],
-    });
-});

package/dist/writers/node.d.ts

@@ -1,4 +0,0 @@
-import type { CreateContent } from './writer';
-export declare const nodeWriter: (path: string) => {
-    createContent: CreateContent;
-};

package/dist/writers/node.js

@@ -1,74 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodeWriter = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const createContent = (filename) => {
-    return async () => {
-        const writPromise = Promise.resolve();
-        const remove = async () => {
-            await node_fs_1.default.promises.unlink(filename).catch(() => { });
-        };
-        await remove();
-        if (!node_fs_1.default.existsSync(filename)) {
-            node_fs_1.default.writeFileSync(filename, '');
-        }
-        const writeStream = node_fs_1.default.openSync(filename, 'w');
-        let written = 0;
-        const write = async (data) => {
-            await new Promise((resolve, reject) => {
-                node_fs_1.default.write(writeStream, data, 0, data.length, undefined, (err) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve();
-                });
-            });
-            written += data.byteLength;
-        };
-        const updateDataAt = (position, data) => {
-            return new Promise((resolve, reject) => {
-                node_fs_1.default.write(writeStream, data, 0, data.length, position, (err) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve();
-                });
-            });
-        };
-        const writer = {
-            write: (arr) => {
-                writPromise.then(() => write(arr));
-                return writPromise;
-            },
-            updateDataAt: (position, data) => {
-                writPromise.then(() => updateDataAt(position, data));
-                return writPromise;
-            },
-            waitForFinish: async () => {
-                await writPromise;
-            },
-            getWrittenByteCount: () => written,
-            remove,
-            save: async () => {
-                try {
-                    node_fs_1.default.closeSync(writeStream);
-                    const file = await node_fs_1.default.promises.readFile(filename);
-                    return new Blob([file]);
-                }
-                catch (e) {
-                    return Promise.reject(e);
-                }
-            },
-        };
-        return writer;
-    };
-};
-const nodeWriter = (path) => {
-    return { createContent: createContent(path) };
-};
-exports.nodeWriter = nodeWriter;

package/dist/writers/writer.d.ts

@@ -1,15 +0,0 @@
-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;
-};