@remotion/media-parser 4.0.270 → 4.0.271

package/dist/has-all-info.js

@@ -1,21 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasAllInfo = exports.getAvailableInfo = void 0;
-const get_streams_1 = require("./containers/m3u/get-streams");
-const get_audio_codec_1 = require("./get-audio-codec");
-const get_container_1 = require("./get-container");
-const get_dimensions_1 = require("./get-dimensions");
-const get_duration_1 = require("./get-duration");
-const get_fps_1 = require("./get-fps");
-const get_is_hdr_1 = require("./get-is-hdr");
-const get_keyframes_1 = require("./get-keyframes");
-const get_number_of_audio_channels_1 = require("./get-number-of-audio-channels");
-const get_sample_rate_1 = require("./get-sample-rate");
-const get_tracks_1 = require("./get-tracks");
-const get_video_codec_1 = require("./get-video-codec");
-const get_metadata_1 = require("./metadata/get-metadata");
-const may_skip_video_data_1 = require("./state/may-skip-video-data");
-const getAvailableInfo = ({ fieldsToFetch, state, }) => {
+import { m3uHasStreams } from './containers/m3u/get-streams';
+import { hasAudioCodec } from './get-audio-codec';
+import { hasContainer } from './get-container';
+import { hasDimensions } from './get-dimensions';
+import { hasDuration, hasSlowDuration } from './get-duration';
+import { hasFps, hasFpsSuitedForSlowFps } from './get-fps';
+import { hasHdr } from './get-is-hdr';
+import { hasKeyframes } from './get-keyframes';
+import { hasNumberOfAudioChannels } from './get-number-of-audio-channels';
+import { hasSampleRate } from './get-sample-rate';
+import { getHasTracks } from './get-tracks';
+import { hasVideoCodec } from './get-video-codec';
+import { hasMetadata } from './metadata/get-metadata';
+import { maySkipVideoData } from './state/may-skip-video-data';
+export const getAvailableInfo = ({ fieldsToFetch, state, }) => {
     const keys = Object.entries(fieldsToFetch).filter(([, value]) => value);
     const structure = state.getStructureOrNull();
     const infos = keys.map(([_key]) => {
@@ -24,37 +21,37 @@ const getAvailableInfo = ({ fieldsToFetch, state, }) => {
             return false;
         }
         if (key === 'durationInSeconds') {
-            return Boolean(structure && (0, get_duration_1.hasDuration)(state));
+            return Boolean(structure && hasDuration(state));
         }
         if (key === 'slowDurationInSeconds') {
-            return Boolean(structure && (0, get_duration_1.hasSlowDuration)(state));
+            return Boolean(structure && hasSlowDuration(state));
         }
         if (key === 'dimensions' ||
             key === 'rotation' ||
             key === 'unrotatedDimensions') {
-            return Boolean(structure && (0, get_dimensions_1.hasDimensions)(state));
+            return Boolean(structure && hasDimensions(state));
         }
         if (key === 'fps') {
-            return Boolean(structure && (0, get_fps_1.hasFps)(state));
+            return Boolean(structure && hasFps(state));
         }
         if (key === 'slowFps') {
             // In case FPS is available an non-null, it also works for `slowFps`
-            return Boolean(structure && (0, get_fps_1.hasFpsSuitedForSlowFps)(state));
+            return Boolean(structure && hasFpsSuitedForSlowFps(state));
         }
         if (key === 'isHdr') {
-            return Boolean(structure && (0, get_is_hdr_1.hasHdr)(state));
+            return Boolean(structure && hasHdr(state));
         }
         if (key === 'videoCodec') {
-            return Boolean(structure && (0, get_video_codec_1.hasVideoCodec)(state));
+            return Boolean(structure && hasVideoCodec(state));
         }
         if (key === 'audioCodec') {
-            return Boolean(structure && (0, get_audio_codec_1.hasAudioCodec)(state));
+            return Boolean(structure && hasAudioCodec(state));
         }
         if (key === 'tracks') {
-            return Boolean(structure && (0, get_tracks_1.getHasTracks)(state));
+            return Boolean(structure && getHasTracks(state));
         }
         if (key === 'keyframes') {
-            return Boolean(structure && (0, get_keyframes_1.hasKeyframes)(state));
+            return Boolean(structure && hasKeyframes(state));
         }
         if (key === 'internalStats') {
             return true;
@@ -69,10 +66,10 @@ const getAvailableInfo = ({ fieldsToFetch, state, }) => {
             return true;
         }
         if (key === 'container') {
-            return Boolean(structure && (0, get_container_1.hasContainer)(structure));
+            return Boolean(structure && hasContainer(structure));
         }
         if (key === 'metadata' || key === 'location' || key === 'images') {
-            return Boolean(structure && (0, get_metadata_1.hasMetadata)(structure));
+            return Boolean(structure && hasMetadata(structure));
         }
         if (key === 'slowKeyframes' ||
             key === 'slowVideoBitrate' ||
@@ -81,13 +78,13 @@ const getAvailableInfo = ({ fieldsToFetch, state, }) => {
             return false;
         }
         if (key === 'numberOfAudioChannels') {
-            return (0, get_number_of_audio_channels_1.hasNumberOfAudioChannels)(state);
+            return hasNumberOfAudioChannels(state);
         }
         if (key === 'sampleRate') {
-            return (0, get_sample_rate_1.hasSampleRate)(state);
+            return hasSampleRate(state);
         }
         if (key === 'm3uStreams') {
-            return (0, get_streams_1.m3uHasStreams)(state);
+            return m3uHasStreams(state);
         }
         throw new Error(`Unknown key: ${key}`);
     });
@@ -98,16 +95,15 @@ const getAvailableInfo = ({ fieldsToFetch, state, }) => {
     }
     return Object.fromEntries(entries);
 };
-exports.getAvailableInfo = getAvailableInfo;
-const hasAllInfo = ({ fields, state, }) => {
-    const availableInfo = (0, exports.getAvailableInfo)({
+export const hasAllInfo = ({ fields, state, }) => {
+    const availableInfo = getAvailableInfo({
         fieldsToFetch: fields !== null && fields !== void 0 ? fields : {},
         state,
     });
     if (!Object.values(availableInfo).every(Boolean)) {
         return false;
     }
-    if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
+    if (maySkipVideoData({ state })) {
         return true;
     }
     if (state.callbacks.canSkipTracksState.canSkipTracks()) {
@@ -115,4 +111,3 @@ const hasAllInfo = ({ fields, state, }) => {
     }
     return false;
 };
-exports.hasAllInfo = hasAllInfo;

package/dist/index.d.ts

@@ -1,14 +1,16 @@
 import type { LogLevel } from './log';
 export type { MatroskaSegment } from './containers/webm/segments';
 export type { MatroskaElement } from './containers/webm/segments/all-segments';
-export { hasBeenAborted, IsAGifError, IsAnImageError, IsAnUnsupportedAudioTypeError, IsAnUnsupportedFileTypeError, IsAPdfError, MediaParserAbortError, } from './errors';
+export { hasBeenAborted, IsAGifError, IsAnImageError, IsAnUnsupportedFileTypeError, IsAPdfError, MediaParserAbortError, } from './errors';
 export type { SamplePosition } from './get-sample-positions';
 export type { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
-export type { MetadataEntry } from './metadata/get-metadata';
+export type { MediaParserMetadataEntry } from './metadata/get-metadata';
 export type { MediaParserKeyframe, ParseMediaSrc } from './options';
+export { parseMediaOnServerWorker } from './parse-media-on-server-worker';
+export { parseMediaOnWebWorker } from './parse-media-on-web-worker';
 export type { MediaParserEmbeddedImage } from './state/images';
 export { downloadAndParseMedia } from './download-and-parse-media';
-export type { MediaParserContainer, Options, ParseMediaCallbacks, ParseMediaFields, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, TracksField, } from './options';
+export type { MediaParserContainer, MediaParserTracks, Options, ParseMediaCallbacks, ParseMediaFields, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, } from './options';
 export { parseMedia } from './parse-media';
 export type { AudioOrVideoSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, } from './webcodec-sample-types';
 export type { Dimensions } from './get-dimensions';
@@ -727,7 +729,7 @@ export declare const MediaParserInternals: {
         size: number;
         state: import("./state/parser-state").ParserState;
     }) => Promise<import("./containers/iso-base-media/stsd/stsd").StsdBox>;
-    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, }: {
+    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, }: {
         hasAudioTrackHandlers: boolean;
         hasVideoTrackHandlers: boolean;
         controller: import("./media-parser-controller").MediaParserController;
@@ -742,6 +744,7 @@ export declare const MediaParserInternals: {
         onDiscardedData: import("./options").OnDiscardedData | null;
         selectM3uStreamFn: import("./containers/m3u/select-stream").SelectM3uStreamFn;
         selectM3uAssociatedPlaylistsFn: import("./containers/m3u/select-stream").SelectM3uAssociatedPlaylistsFn;
+        mp4HeaderSegment: import("./parse-result").IsoBaseMediaStructure | null;
     }) => {
         onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
         onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
@@ -838,17 +841,15 @@ export declare const MediaParserInternals: {
         };
         controller: import("./media-parser-controller").MediaParserController;
         mode: import("./options").ParseMediaMode;
-        eventLoop: {
-            eventLoopBreakIfNeeded: () => Promise<void>;
-        };
         src: import("./options").ParseMediaSrc;
         readerInterface: import("./readers/reader").ReaderInterface;
         discardReadBytes: (force: boolean) => Promise<void>;
         selectM3uStreamFn: import("./containers/m3u/select-stream").SelectM3uStreamFn;
         selectM3uAssociatedPlaylistsFn: import("./containers/m3u/select-stream").SelectM3uAssociatedPlaylistsFn;
-        getStructureOrNull: () => import("./parse-result").Structure | null;
-        getStructure: () => import("./parse-result").Structure;
-        setStructure: (value: import("./parse-result").Structure) => void;
+        mp4HeaderSegment: import("./parse-result").IsoBaseMediaStructure | null;
+        getStructureOrNull: () => import("./parse-result").MediaParserStructureUnstable | null;
+        getStructure: () => import("./parse-result").MediaParserStructureUnstable;
+        setStructure: (value: import("./parse-result").MediaParserStructureUnstable) => void;
         getFlacStructure: () => import("./containers/flac/types").FlacStructure;
         getIsoStructure: () => import("./parse-result").IsoBaseMediaStructure;
         getMp3Structure: () => import("./parse-result").Mp3Structure;
@@ -952,6 +953,8 @@ export declare const MediaParserInternals: {
                 addVideoSample: (src: string, sample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
                 getNextStreamToRun: (streams: string[]) => string;
             };
+            setMp4HeaderSegment: (playlistUrl: string, structure: import("./parse-result").IsoBaseMediaStructure) => void;
+            getMp4HeaderSegment: (playlistUrl: string) => import("./parse-result").IsoBaseMediaStructure;
         };
         callbacks: {
             registerVideoSampleCallback: (id: number, callback: import("./webcodec-sample-types").OnVideoSample | null) => Promise<void>;
@@ -1003,8 +1006,9 @@ export declare const MediaParserInternals: {
 };
 export type { Prettify } from './containers/webm/parse-ebml';
 export type { Ebml, EbmlValue, FloatWithSize, MainSegment, PossibleEbml, TrackEntry, UintWithSize, } from './containers/webm/segments/all-segments';
+export { MediaParserStructureUnstable } from './parse-result';
 export type { LogLevel };
-export { M3uStream } from './containers/m3u/get-streams';
+export { M3uAssociatedPlaylist, M3uStream } from './containers/m3u/get-streams';
 export { defaultSelectM3uAssociatedPlaylists, defaultSelectM3uStreamFn, SelectM3uAssociatedPlaylistsFn, SelectM3uStreamFn, SelectM3uStreamFnOptions, } from './containers/m3u/select-stream';
 export { mediaParserController, MediaParserController, } from './media-parser-controller';
 export { VERSION } from './version';

package/dist/index.js

@@ -1,49 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = exports.mediaParserController = exports.defaultSelectM3uStreamFn = exports.defaultSelectM3uAssociatedPlaylists = exports.MediaParserInternals = exports.parseMedia = exports.downloadAndParseMedia = exports.MediaParserAbortError = exports.IsAPdfError = exports.IsAnUnsupportedFileTypeError = exports.IsAnUnsupportedAudioTypeError = exports.IsAnImageError = exports.IsAGifError = exports.hasBeenAborted = void 0;
-const aac_codecprivate_1 = require("./aac-codecprivate");
-const buffer_iterator_1 = require("./buffer-iterator");
-const ftyp_1 = require("./containers/iso-base-media/ftyp");
-const mvhd_1 = require("./containers/iso-base-media/mvhd");
-const samples_1 = require("./containers/iso-base-media/stsd/samples");
-const stsd_1 = require("./containers/iso-base-media/stsd/stsd");
-const tkhd_1 = require("./containers/iso-base-media/tkhd");
-const parse_ebml_1 = require("./containers/webm/parse-ebml");
-const all_segments_1 = require("./containers/webm/segments/all-segments");
-const internal_parse_media_1 = require("./internal-parse-media");
-const log_1 = require("./log");
-const parser_state_1 = require("./state/parser-state");
-var errors_1 = require("./errors");
-Object.defineProperty(exports, "hasBeenAborted", { enumerable: true, get: function () { return errors_1.hasBeenAborted; } });
-Object.defineProperty(exports, "IsAGifError", { enumerable: true, get: function () { return errors_1.IsAGifError; } });
-Object.defineProperty(exports, "IsAnImageError", { enumerable: true, get: function () { return errors_1.IsAnImageError; } });
-Object.defineProperty(exports, "IsAnUnsupportedAudioTypeError", { enumerable: true, get: function () { return errors_1.IsAnUnsupportedAudioTypeError; } });
-Object.defineProperty(exports, "IsAnUnsupportedFileTypeError", { enumerable: true, get: function () { return errors_1.IsAnUnsupportedFileTypeError; } });
-Object.defineProperty(exports, "IsAPdfError", { enumerable: true, get: function () { return errors_1.IsAPdfError; } });
-Object.defineProperty(exports, "MediaParserAbortError", { enumerable: true, get: function () { return errors_1.MediaParserAbortError; } });
-var download_and_parse_media_1 = require("./download-and-parse-media");
-Object.defineProperty(exports, "downloadAndParseMedia", { enumerable: true, get: function () { return download_and_parse_media_1.downloadAndParseMedia; } });
-var parse_media_1 = require("./parse-media");
-Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
-exports.MediaParserInternals = {
-    Log: log_1.Log,
-    createAacCodecPrivate: aac_codecprivate_1.createAacCodecPrivate,
-    matroskaElements: all_segments_1.matroskaElements,
-    ebmlMap: all_segments_1.ebmlMap,
-    parseTkhd: tkhd_1.parseTkhd,
-    getArrayBufferIterator: buffer_iterator_1.getArrayBufferIterator,
-    parseStsd: stsd_1.parseStsd,
-    makeParserState: parser_state_1.makeParserState,
-    processSample: samples_1.processIsoFormatBox,
-    parseFtyp: ftyp_1.parseFtyp,
-    parseEbml: parse_ebml_1.parseEbml,
-    parseMvhd: mvhd_1.parseMvhd,
-    internalParseMedia: internal_parse_media_1.internalParseMedia,
+import { createAacCodecPrivate } from './aac-codecprivate';
+import { getArrayBufferIterator } from './buffer-iterator';
+import { parseFtyp } from './containers/iso-base-media/ftyp';
+import { parseMvhd } from './containers/iso-base-media/mvhd';
+import { processIsoFormatBox } from './containers/iso-base-media/stsd/samples';
+import { parseStsd } from './containers/iso-base-media/stsd/stsd';
+import { parseTkhd } from './containers/iso-base-media/tkhd';
+import { parseEbml } from './containers/webm/parse-ebml';
+import { ebmlMap, matroskaElements, } from './containers/webm/segments/all-segments';
+import { internalParseMedia } from './internal-parse-media';
+import { Log } from './log';
+import { makeParserState } from './state/parser-state';
+export { hasBeenAborted, IsAGifError, IsAnImageError, IsAnUnsupportedFileTypeError, IsAPdfError, MediaParserAbortError, } from './errors';
+export { parseMediaOnServerWorker } from './parse-media-on-server-worker';
+export { parseMediaOnWebWorker } from './parse-media-on-web-worker';
+export { downloadAndParseMedia } from './download-and-parse-media';
+export { parseMedia } from './parse-media';
+export const MediaParserInternals = {
+    Log,
+    createAacCodecPrivate,
+    matroskaElements,
+    ebmlMap,
+    parseTkhd,
+    getArrayBufferIterator,
+    parseStsd,
+    makeParserState,
+    processSample: processIsoFormatBox,
+    parseFtyp,
+    parseEbml,
+    parseMvhd,
+    internalParseMedia,
 };
-var select_stream_1 = require("./containers/m3u/select-stream");
-Object.defineProperty(exports, "defaultSelectM3uAssociatedPlaylists", { enumerable: true, get: function () { return select_stream_1.defaultSelectM3uAssociatedPlaylists; } });
-Object.defineProperty(exports, "defaultSelectM3uStreamFn", { enumerable: true, get: function () { return select_stream_1.defaultSelectM3uStreamFn; } });
-var media_parser_controller_1 = require("./media-parser-controller");
-Object.defineProperty(exports, "mediaParserController", { enumerable: true, get: function () { return media_parser_controller_1.mediaParserController; } });
-var version_1 = require("./version");
-Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
+export { defaultSelectM3uAssociatedPlaylists, defaultSelectM3uStreamFn, } from './containers/m3u/select-stream';
+export { mediaParserController, } from './media-parser-controller';
+export { VERSION } from './version';

package/dist/init-video.d.ts

@@ -4,4 +4,4 @@ export declare const initVideo: ({ state, mimeType, name, contentLength, }: {
     mimeType: string | null;
     name: string | null;
     contentLength: number;
-}) => Promise<never> | undefined;
+}) => Promise<undefined>;

package/dist/init-video.js

@@ -1,20 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initVideo = void 0;
-const errors_1 = require("./errors");
-const log_1 = require("./log");
-const initVideo = ({ state, mimeType, name, contentLength, }) => {
+import { getMoovFromFromIsoStructure } from './containers/iso-base-media/traversal';
+import { IsAGifError, IsAPdfError, IsAnImageError, IsAnUnsupportedFileTypeError, } from './errors';
+import { getTracksFromMoovBox } from './get-tracks';
+import { Log } from './log';
+import { registerAudioTrack, registerVideoTrack } from './register-track';
+export const initVideo = async ({ state, mimeType, name, contentLength, }) => {
     const fileType = state.iterator.detectFileType();
     if (fileType.type === 'riff') {
-        log_1.Log.verbose(state.logLevel, 'Detected RIFF container');
+        Log.verbose(state.logLevel, 'Detected RIFF container');
         state.setStructure({
             type: 'riff',
             boxes: [],
         });
         return;
     }
+    if (state.mp4HeaderSegment) {
+        Log.verbose(state.logLevel, 'Detected ISO Base Media segment');
+        const moovAtom = getMoovFromFromIsoStructure(state.mp4HeaderSegment);
+        if (!moovAtom) {
+            throw new Error('No moov box found');
+        }
+        const tracks = getTracksFromMoovBox(moovAtom);
+        for (const track of tracks.videoTracks) {
+            await registerVideoTrack({
+                state,
+                track,
+                container: 'mp4',
+            });
+        }
+        for (const track of tracks.audioTracks) {
+            await registerAudioTrack({
+                state,
+                track,
+                container: 'mp4',
+            });
+        }
+        state.callbacks.tracks.setIsDone(state.logLevel);
+        state.setStructure({
+            type: 'iso-base-media',
+            boxes: [],
+        });
+        return;
+    }
     if (fileType.type === 'iso-base-media') {
-        log_1.Log.verbose(state.logLevel, 'Detected ISO Base Media container');
+        Log.verbose(state.logLevel, 'Detected ISO Base Media container');
         state.setStructure({
             type: 'iso-base-media',
             boxes: [],
@@ -22,7 +50,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         return;
     }
     if (fileType.type === 'webm') {
-        log_1.Log.verbose(state.logLevel, 'Detected Matroska container');
+        Log.verbose(state.logLevel, 'Detected Matroska container');
         state.setStructure({
             boxes: [],
             type: 'matroska',
@@ -30,7 +58,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         return;
     }
     if (fileType.type === 'transport-stream') {
-        log_1.Log.verbose(state.logLevel, 'Detected MPEG-2 Transport Stream');
+        Log.verbose(state.logLevel, 'Detected MPEG-2 Transport Stream');
         state.setStructure({
             boxes: [],
             type: 'transport-stream',
@@ -38,7 +66,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         return;
     }
     if (fileType.type === 'mp3') {
-        log_1.Log.verbose(state.logLevel, 'Detected MP3');
+        Log.verbose(state.logLevel, 'Detected MP3');
         const structure = {
             boxes: [],
             type: 'mp3',
@@ -47,7 +75,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         return;
     }
     if (fileType.type === 'wav') {
-        log_1.Log.verbose(state.logLevel, 'Detected WAV');
+        Log.verbose(state.logLevel, 'Detected WAV');
         const structure = {
             boxes: [],
             type: 'wav',
@@ -56,7 +84,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         return;
     }
     if (fileType.type === 'flac') {
-        log_1.Log.verbose(state.logLevel, 'Detected FLAC');
+        Log.verbose(state.logLevel, 'Detected FLAC');
         const structure = {
             boxes: [],
             type: 'flac',
@@ -65,7 +93,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         return;
     }
     if (fileType.type === 'aac') {
-        log_1.Log.verbose(state.logLevel, 'Detected AAC');
+        Log.verbose(state.logLevel, 'Detected AAC');
         state.setStructure({
             type: 'aac',
             boxes: [],
@@ -73,7 +101,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         return;
     }
     if (fileType.type === 'm3u') {
-        log_1.Log.verbose(state.logLevel, 'Detected M3U');
+        Log.verbose(state.logLevel, 'Detected M3U');
         state.setStructure({
             type: 'm3u',
             boxes: [],
@@ -81,7 +109,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         return;
     }
     if (fileType.type === 'gif') {
-        return Promise.reject(new errors_1.IsAGifError({
+        return Promise.reject(new IsAGifError({
             message: 'GIF files are not yet supported',
             mimeType,
             sizeInBytes: contentLength,
@@ -89,7 +117,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         }));
     }
     if (fileType.type === 'pdf') {
-        return Promise.reject(new errors_1.IsAPdfError({
+        return Promise.reject(new IsAPdfError({
             message: 'GIF files are not supported',
             mimeType,
             sizeInBytes: contentLength,
@@ -100,7 +128,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         fileType.type === 'jpeg' ||
         fileType.type === 'png' ||
         fileType.type === 'webp') {
-        return Promise.reject(new errors_1.IsAnImageError({
+        return Promise.reject(new IsAnImageError({
             message: 'Image files are not supported',
             imageType: fileType.type,
             dimensions: fileType.dimensions,
@@ -110,7 +138,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
         }));
     }
     if (fileType.type === 'unknown') {
-        return Promise.reject(new errors_1.IsAnUnsupportedFileTypeError({
+        return Promise.reject(new IsAnUnsupportedFileTypeError({
             message: 'Unknown file format',
             mimeType,
             sizeInBytes: contentLength,
@@ -119,4 +147,3 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
     }
     return Promise.reject(new Error('Unknown video format ' + fileType));
 };
-exports.initVideo = initVideo;