@remotion/media-parser 4.0.252 → 4.0.253

package/dist/abort.d.ts

@@ -0,0 +1 @@
+export declare const hasBeenAborted: (error: unknown) => error is MediaParserAbortError;

package/dist/abort.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasBeenAborted = void 0;
+const hasBeenAborted = (error) => {
+    return error instanceof MediaParserAbortError;
+};
+exports.hasBeenAborted = hasBeenAborted;

package/dist/containers/flac/get-channel-count.d.ts

@@ -1,2 +1,2 @@
 import type { BufferIterator } from '../../buffer-iterator';
-export declare const getChannelCount: (iterator: BufferIterator) => 5 | 2 | 8 | 1 | 7 | 3 | 4 | 6;
+export declare const getChannelCount: (iterator: BufferIterator) => 2 | 8 | 1 | 7 | 3 | 4 | 5 | 6;

package/dist/containers/iso-base-media/get-keyframes.js

@@ -7,10 +7,13 @@ const traversal_1 = require("./traversal");
 const getKeyframesFromIsoBaseMedia = (state) => {
     const { videoTracks } = (0, get_tracks_1.getTracksFromIsoBaseMedia)(state);
     const structure = state.getIsoStructure();
-    const moofBox = (0, traversal_1.getMoofBox)(structure.boxes);
+    const moofBox = (0, traversal_1.getMoofBoxes)(structure.boxes);
     const allSamples = videoTracks.map((t) => {
         const { timescale: ts } = t;
-        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)(t.trakBox, moofBox);
+        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
+            trakBox: t.trakBox,
+            moofBoxes: moofBox,
+        });
         const keyframes = samplePositions
             .filter((k) => {
             return k.isKeyframe;

package/dist/containers/iso-base-media/get-moov-atom.js

@@ -11,12 +11,12 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
     const { reader } = await state.readerInterface.read({
         src: state.src,
         range: endOfMdat,
-        signal: state.signal,
+        controller: state.controller,
     });
     const childState = (0, parser_state_1.makeParserState)({
         hasAudioTrackHandlers: false,
         hasVideoTrackHandlers: false,
-        signal: state.signal,
+        controller: state.controller,
         fields: {
             structure: true,
         },

package/dist/containers/iso-base-media/get-sample-positions-from-track.d.ts

@@ -1,4 +1,7 @@
 import type { SamplePosition } from '../../get-sample-positions';
 import type { IsoBaseMediaBox } from './base-media-box';
 import type { TrakBox } from './trak/trak';
-export declare const getSamplePositionsFromTrack: (trakBox: TrakBox, moofBox: IsoBaseMediaBox | null) => SamplePosition[];
+export declare const getSamplePositionsFromTrack: ({ trakBox, moofBoxes, }: {
+    trakBox: TrakBox;
+    moofBoxes: IsoBaseMediaBox[];
+}) => SamplePosition[];

package/dist/containers/iso-base-media/get-sample-positions-from-track.js

@@ -7,7 +7,7 @@ const get_sample_positions_1 = require("../../get-sample-positions");
 const get_sample_positions_from_lpcm_1 = require("../../get-sample-positions-from-lpcm");
 const samples_from_moof_1 = require("../../samples-from-moof");
 const traversal_1 = require("./traversal");
-const getSamplePositionsFromTrack = (trakBox, moofBox) => {
+const getSamplePositionsFromTrack = ({ trakBox, moofBoxes, }) => {
     const isLpcm = (0, get_audio_codec_1.isLpcmAudioCodec)(trakBox);
     const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
     if (isLpcm) {
@@ -46,8 +46,12 @@ const getSamplePositionsFromTrack = (trakBox, moofBox) => {
         sttsBox,
         cttsBox,
     });
-    if (samplePositions.length === 0 && moofBox) {
-        samplePositions = (0, samples_from_moof_1.getSamplesFromMoof)({ moofBox, trackId: tkhdBox.trackId });
+    if (samplePositions.length === 0 && moofBoxes.length > 0) {
+        samplePositions = moofBoxes
+            .map((m) => {
+            return (0, samples_from_moof_1.getSamplesFromMoof)({ moofBox: m, trackId: tkhdBox.trackId });
+        })
+            .flat(1);
     }
     return samplePositions;
 };

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

@@ -25,10 +25,10 @@ const parseMdatSection = async (state) => {
         state.getIsoStructure().boxes.push(moov);
         return (0, exports.parseMdatSection)(state);
     }
-    if (!state.iso.flatSamples.getSamples()) {
-        state.iso.flatSamples.setSamples((0, cached_sample_positions_1.calculateFlatSamples)(state));
+    if (!state.iso.flatSamples.getSamples(videoSection.start)) {
+        state.iso.flatSamples.setSamples(videoSection.start, (0, cached_sample_positions_1.calculateFlatSamples)(state));
     }
-    const flatSamples = state.iso.flatSamples.getSamples();
+    const flatSamples = state.iso.flatSamples.getSamples(videoSection.start);
     const { iterator } = state;
     const samplesWithIndex = flatSamples.find((sample) => {
         return sample.samplePosition.offset === iterator.counter.getOffset();

package/dist/containers/iso-base-media/traversal.d.ts

@@ -19,7 +19,7 @@ import type { TrakBox } from './trak/trak';
 import type { TrunBox } from './trun';
 export declare const getFtypBox: (segments: AnySegment[]) => FtypBox | null;
 export declare const getMoovBox: (state: ParserState) => MoovBox | null;
-export declare const getMoofBox: (main: AnySegment[]) => IsoBaseMediaBox | null;
+export declare const getMoofBoxes: (main: AnySegment[]) => IsoBaseMediaBox[];
 export declare const getMvhdBox: (moovBox: MoovBox) => MvhdBox | null;
 export declare const getTraks: (moovBox: MoovBox) => TrakBox[];
 export declare const getTkhdBox: (trakBox: TrakBox) => TkhdBox | null;

package/dist/containers/iso-base-media/traversal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTrunBoxes = exports.getTfhdBox = exports.getTfdtBox = exports.getStssBox = exports.getStscBox = exports.getStszBox = exports.getCttsBox = exports.getSttsBox = exports.getStcoBox = exports.getVideoDescriptors = exports.getStsdBox = exports.getStblBox = exports.getMdhdBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoofBox = exports.getMoovBox = exports.getFtypBox = void 0;
+exports.getTrunBoxes = exports.getTfhdBox = exports.getTfdtBox = exports.getStssBox = exports.getStscBox = exports.getStszBox = exports.getCttsBox = exports.getSttsBox = exports.getStcoBox = exports.getVideoDescriptors = exports.getStsdBox = exports.getStblBox = exports.getMdhdBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoofBoxes = exports.getMoovBox = exports.getFtypBox = void 0;
 const getFtypBox = (segments) => {
     const ftypBox = segments.find((s) => s.type === 'ftyp-box');
     if (!ftypBox || ftypBox.type !== 'ftyp-box') {
@@ -21,14 +21,11 @@ const getMoovBox = (state) => {
     return moovBox;
 };
 exports.getMoovBox = getMoovBox;
-const getMoofBox = (main) => {
-    const moofBox = main.find((s) => s.type === 'regular-box' && s.boxType === 'moof');
-    if (!moofBox || moofBox.type !== 'regular-box') {
-        return null;
-    }
-    return moofBox;
+const getMoofBoxes = (main) => {
+    const moofBoxes = main.filter((s) => s.type === 'regular-box' && s.boxType === 'moof');
+    return moofBoxes;
 };
-exports.getMoofBox = getMoofBox;
+exports.getMoofBoxes = getMoofBoxes;
 const getMvhdBox = (moovBox) => {
     const mvHdBox = moovBox.children.find((s) => s.type === 'mvhd-box');
     if (!mvHdBox || mvHdBox.type !== 'mvhd-box') {

package/dist/containers/webm/av1-codec-private.js

@@ -24,7 +24,7 @@ const parseAv1PrivateData = (data, colrAtom) => {
     const seq_tier_0 = iterator.getBits(1);
     // Level
     // The level parameter value SHALL equal the first level value indicated by seq_level_idx in the Sequence Header OBU
-    str += seq_level_idx.toString(16).padStart(2, '0');
+    str += String(seq_level_idx).padStart(2, '0');
     str += seq_tier_0 ? 'H' : 'M';
     str += '.';
     // bitDepth

package/dist/controller.d.ts

@@ -0,0 +1,17 @@
+import { MediaParserEmitter } from './emitter';
+import type { PauseSignal } from './pause-signal';
+export type MediaParserController = {
+    abort: (reason?: any) => void;
+    pause: PauseSignal['pause'];
+    resume: PauseSignal['resume'];
+    addEventListener: MediaParserEmitter['addEventListener'];
+    removeEventListener: MediaParserEmitter['removeEventListener'];
+    /**
+     * @deprecated Not public API
+     */
+    _internals: {
+        signal: AbortSignal;
+        checkForAbortAndPause: () => Promise<void>;
+    };
+};
+export declare const mediaParserController: () => MediaParserController;

package/dist/controller.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaParserController = void 0;
+const emitter_1 = require("./emitter");
+const pause_signal_1 = require("./pause-signal");
+const mediaParserController = () => {
+    const abortController = new AbortController();
+    const emitter = new emitter_1.MediaParserEmitter();
+    const pauseSignal = (0, pause_signal_1.makePauseSignal)(emitter);
+    const checkForAbortAndPause = async () => {
+        if (abortController.signal.aborted) {
+            throw new Error('Aborted');
+        }
+        await pauseSignal.waitUntilResume();
+    };
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        abort: (reason) => {
+            abortController.abort(reason);
+        },
+        pause: pauseSignal.pause,
+        resume: pauseSignal.resume,
+        addEventListener: emitter.addEventListener,
+        removeEventListener: emitter.removeEventListener,
+        _internals: {
+            signal: abortController.signal,
+            checkForAbortAndPause,
+        },
+    };
+};
+exports.mediaParserController = mediaParserController;

package/dist/download-and-parse-media.js

@@ -51,7 +51,7 @@ const downloadAndParseMedia = async (options) => {
         onVideoTrack: null,
         progressIntervalInMs: (_6 = options.progressIntervalInMs) !== null && _6 !== void 0 ? _6 : null,
         reader: (_7 = options.reader) !== null && _7 !== void 0 ? _7 : from_fetch_1.fetchReader,
-        signal: (_8 = options.signal) !== null && _8 !== void 0 ? _8 : undefined,
+        controller: (_8 = options.controller) !== null && _8 !== void 0 ? _8 : undefined,
         src: options.src,
         onError: async (err) => {
             var _a, _b;
@@ -63,6 +63,8 @@ const downloadAndParseMedia = async (options) => {
             }
             return action;
         },
+        acknowledgeRemotionLicense: Boolean(options.acknowledgeRemotionLicense),
+        apiName: 'parseAndDownloadMedia()',
     });
     await content.finish();
     return returnValue;

package/dist/emitter.d.ts

@@ -0,0 +1,20 @@
+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

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

package/dist/errors.d.ts

@@ -65,4 +65,8 @@ export declare class IsAnUnsupportedAudioTypeError extends Error {
         audioType: UnsupportedAudioType | null;
     });
 }
+export declare class MediaParserAbortError extends Error {
+    constructor(message: string);
+}
+export declare const hasBeenAborted: (error: unknown) => error is MediaParserAbortError;
 export {};

package/dist/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsAnUnsupportedAudioTypeError = exports.IsAnUnsupportedFileTypeError = exports.IsAPdfError = exports.IsAnImageError = exports.IsAGifError = void 0;
+exports.hasBeenAborted = exports.MediaParserAbortError = exports.IsAnUnsupportedAudioTypeError = exports.IsAnUnsupportedFileTypeError = exports.IsAPdfError = exports.IsAnImageError = exports.IsAGifError = void 0;
 class IsAGifError extends Error {
     constructor({ message, mimeType, sizeInBytes, fileName, }) {
         super(message);
@@ -69,3 +69,15 @@ class IsAnUnsupportedAudioTypeError extends Error {
     }
 }
 exports.IsAnUnsupportedAudioTypeError = IsAnUnsupportedAudioTypeError;
+class MediaParserAbortError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MediaParserAbortError';
+        this.cause = undefined;
+    }
+}
+exports.MediaParserAbortError = MediaParserAbortError;
+const hasBeenAborted = (error) => {
+    return error instanceof MediaParserAbortError;
+};
+exports.hasBeenAborted = hasBeenAborted;

package/dist/esm/from-fetch.mjs

@@ -1,3 +1,129 @@
+// src/errors.ts
+class IsAGifError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.fileName = "IsAGifError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAGifError);
+    }
+  }
+}
+
+class IsAnImageError extends Error {
+  imageType;
+  dimensions;
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    dimensions,
+    imageType,
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAnImageError";
+    this.imageType = imageType;
+    this.dimensions = dimensions;
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnImageError);
+    }
+  }
+}
+
+class IsAPdfError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAPdfError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAPdfError);
+    }
+  }
+}
+
+class IsAnUnsupportedFileTypeError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAnUnsupportedFileTypeError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnUnsupportedFileTypeError);
+    }
+  }
+}
+
+class IsAnUnsupportedAudioTypeError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  audioType;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName,
+    audioType
+  }) {
+    super(message);
+    this.name = "IsAnUnsupportedAudioTypeError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    this.audioType = audioType;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnUnsupportedAudioTypeError);
+    }
+  }
+}
+
+class MediaParserAbortError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MediaParserAbortError";
+    this.cause = undefined;
+  }
+}
+var hasBeenAborted = (error) => {
+  return error instanceof MediaParserAbortError;
+};
+
 // src/readers/from-fetch.ts
 function parseContentRange(input) {
   const matches = input.match(/^(\w+) ((\d+)-(\d+)|\*)\/(\d+|\*)$/);
@@ -31,7 +157,7 @@ var validateContentRangeAndDetectIfSupported = (actualRange, parsedContentRange,
   return { supportsContentRange: true };
 };
 var fetchReader = {
-  read: async ({ src, range, signal }) => {
+  read: async ({ src, range, controller }) => {
     if (typeof src !== "string") {
       throw new Error("src must be a string when using `fetchReader`");
     }
@@ -39,7 +165,7 @@ var fetchReader = {
     if (!resolvedUrl.startsWith("https://") && !resolvedUrl.startsWith("blob:") && !resolvedUrl.startsWith("http://")) {
       return Promise.reject(new Error(resolvedUrl + " is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass `reader: nodeReader` to parseMedia()."));
     }
-    const controller = new AbortController;
+    const ownController = new AbortController;
     const cache = typeof navigator !== "undefined" && navigator.userAgent.includes("Cloudflare-Workers") ? undefined : "no-store";
     const actualRange = range === null ? 0 : range;
     const res = await fetch(resolvedUrl, {
@@ -48,14 +174,14 @@ var fetchReader = {
       } : {
         Range: `bytes=${`${actualRange[0]}-${actualRange[1]}`}`
       },
-      signal: controller.signal,
+      signal: ownController.signal,
       cache
     });
     const contentRange = res.headers.get("content-range");
     const parsedContentRange = contentRange ? parseContentRange(contentRange) : null;
     const { supportsContentRange } = validateContentRangeAndDetectIfSupported(actualRange, parsedContentRange, res.status);
-    signal?.addEventListener("abort", () => {
-      controller.abort(new Error("Aborted by user"));
+    controller._internals.signal.addEventListener("abort", () => {
+      ownController.abort(new MediaParserAbortError("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}`);
@@ -69,8 +195,8 @@ var fetchReader = {
     const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
     const fallbackName = src.split("/").pop();
     const reader = res.body.getReader();
-    if (signal) {
-      signal.addEventListener("abort", () => {
+    if (controller) {
+      controller._internals.signal.addEventListener("abort", () => {
         reader.cancel().catch(() => {
         });
       }, { once: true });
@@ -79,7 +205,7 @@ var fetchReader = {
       reader: {
         reader,
         abort: () => {
-          controller.abort();
+          ownController.abort();
         }
       },
       contentLength,

package/dist/esm/from-node.mjs

@@ -3,23 +3,23 @@ import { createReadStream, statSync } from "fs";
 import { sep } from "path";
 import { Readable } from "stream";
 var nodeReader = {
-  read: ({ src, range, signal }) => {
+  read: ({ src, range, controller }) => {
     if (typeof src !== "string") {
       throw new Error("src must be a string when using `nodeReader`");
     }
-    const controller = new AbortController;
+    const ownController = new AbortController;
     const stream = createReadStream(src, {
       start: range === null ? 0 : typeof range === "number" ? range : range[0],
       end: range === null ? Infinity : typeof range === "number" ? Infinity : range[1],
-      signal: controller.signal
+      signal: ownController.signal
     });
-    signal?.addEventListener("abort", () => {
-      controller.abort();
+    controller._internals.signal.addEventListener("abort", () => {
+      ownController.abort();
     }, { once: true });
     const stats = statSync(src);
     const reader = Readable.toWeb(stream).getReader();
-    if (signal) {
-      signal.addEventListener("abort", () => {
+    if (controller) {
+      controller._internals.signal.addEventListener("abort", () => {
         reader.cancel().catch(() => {
         });
       }, { once: true });
@@ -28,7 +28,7 @@ var nodeReader = {
       reader: {
         reader,
         abort: () => {
-          controller.abort();
+          ownController.abort();
         }
       },
       contentLength: stats.size,

package/dist/esm/from-web-file.mjs

@@ -1,21 +1,21 @@
 // src/readers/from-web-file.ts
 var webFileReader = {
-  read: ({ src, range, signal }) => {
+  read: ({ src, range, controller }) => {
     if (typeof src === "string") {
       throw new Error("`inputTypeFileReader` only supports `File` objects");
     }
     const part = range === null ? src : typeof range === "number" ? src.slice(range) : src.slice(range[0], range[1]);
     const reader = new FileReader;
     reader.readAsArrayBuffer(src);
-    const controller = new AbortController;
-    if (controller) {
-      controller.signal.addEventListener("abort", () => {
+    const ownController = new AbortController;
+    if (ownController) {
+      ownController.signal.addEventListener("abort", () => {
         reader.abort();
       }, { once: true });
     }
-    if (signal) {
-      signal.addEventListener("abort", () => {
-        controller.abort();
+    if (controller) {
+      controller._internals.signal.addEventListener("abort", () => {
+        ownController.abort();
       }, { once: true });
     }
     return new Promise((resolve, reject) => {
@@ -27,7 +27,7 @@ var webFileReader = {
             reader: streamReader,
             abort() {
               streamReader.cancel();
-              controller.abort();
+              ownController.abort();
             }
           },
           contentLength: src.size,