@remotion/media-parser 4.0.298 → 4.0.300

package/dist/options.d.ts

@@ -2,17 +2,17 @@ import type { M3uStream } from './containers/m3u/get-streams';
 import type { SelectM3uAssociatedPlaylistsFn, SelectM3uStreamFn } from './containers/m3u/select-stream';
 import type { MediaParserController } from './controller/media-parser-controller';
 import type { Options, ParseMediaFields } from './fields';
-import type { Dimensions } from './get-dimensions';
+import type { MediaParserDimensions } from './get-dimensions';
 import type { MediaParserLocation } from './get-location';
-import type { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, VideoTrack } from './get-tracks';
-import type { LogLevel } from './log';
+import type { MediaParserAudioCodec, MediaParserTrack, MediaParserVideoCodec } from './get-tracks';
+import type { MediaParserLogLevel } from './log';
 import type { MediaParserMetadataEntry } from './metadata/get-metadata';
 import type { IsoBaseMediaStructure, MediaParserStructureUnstable } from './parse-result';
-import type { ReaderInterface } from './readers/reader';
+import type { MediaParserReaderInterface } from './readers/reader';
 import type { SeekingHints } from './seeking-hints';
 import type { MediaParserEmbeddedImage } from './state/images';
 import type { InternalStats } from './state/parser-state';
-import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
+import type { MediaParserOnAudioTrack, MediaParserOnVideoTrack } from './webcodec-sample-types';
 import type { WriterInterface } from './writers/writer';
 export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'vorbis' | 'unknown';
 export type AllParseMediaFields = {
@@ -21,7 +21,7 @@ export type AllParseMediaFields = {
     slowDurationInSeconds: true;
     slowNumberOfFrames: true;
     slowFps: true;
-    structure: true;
+    slowStructure: true;
     fps: true;
     videoCodec: true;
     audioCodec: true;
@@ -45,10 +45,6 @@ export type AllParseMediaFields = {
     slowAudioBitrate: true;
     m3uStreams: true;
 };
-export type MediaParserTracks = {
-    videoTracks: VideoTrack[];
-    audioTracks: AudioTrack[];
-};
 export type MediaParserContainer = 'mp4' | 'webm' | 'avi' | 'transport-stream' | 'mp3' | 'aac' | 'flac' | 'm3u8' | 'wav';
 export type MediaParserKeyframe = {
     positionInBytes: number;
@@ -58,17 +54,17 @@ export type MediaParserKeyframe = {
     trackId: number;
 };
 export type ParseMediaCallbacksMandatory = {
-    onDimensions: null | ((dimensions: Dimensions | null) => unknown | Promise<unknown>);
+    onDimensions: null | ((dimensions: MediaParserDimensions | null) => unknown | Promise<unknown>);
     onDurationInSeconds: null | ((durationInSeconds: number | null) => unknown | Promise<unknown>);
     onSlowDurationInSeconds: null | ((durationInSeconds: number) => unknown | Promise<unknown>);
     onSlowFps: null | ((fps: number) => unknown | Promise<unknown>);
-    onStructure: null | ((structure: MediaParserStructureUnstable) => unknown | Promise<unknown>);
+    onSlowStructure: null | ((structure: MediaParserStructureUnstable) => unknown | Promise<unknown>);
     onFps: null | ((fps: number | null) => unknown | Promise<unknown>);
     onVideoCodec: null | ((codec: MediaParserVideoCodec | null) => unknown | Promise<unknown>);
     onAudioCodec: null | ((codec: MediaParserAudioCodec | null) => unknown | Promise<unknown>);
-    onTracks: null | ((tracks: MediaParserTracks) => unknown | Promise<unknown>);
+    onTracks: null | ((tracks: MediaParserTrack[]) => unknown | Promise<unknown>);
     onRotation: null | ((rotation: number | null) => unknown | Promise<unknown>);
-    onUnrotatedDimensions: null | ((dimensions: Dimensions | null) => unknown | Promise<unknown>);
+    onUnrotatedDimensions: null | ((dimensions: MediaParserDimensions | null) => unknown | Promise<unknown>);
     onInternalStats: null | ((internalStats: InternalStats) => unknown | Promise<unknown>);
     onSize: null | ((size: number | null) => unknown | Promise<unknown>);
     onName: null | ((name: string) => unknown | Promise<unknown>);
@@ -89,17 +85,17 @@ export type ParseMediaCallbacksMandatory = {
 };
 export type ParseMediaCallbacks = Partial<ParseMediaCallbacksMandatory>;
 export interface ParseMediaData {
-    dimensions: Dimensions | null;
+    dimensions: MediaParserDimensions | null;
     durationInSeconds: number | null;
     slowDurationInSeconds: number;
     slowFps: number;
-    structure: MediaParserStructureUnstable;
+    slowStructure: MediaParserStructureUnstable;
     fps: number | null;
     videoCodec: MediaParserVideoCodec | null;
     audioCodec: MediaParserAudioCodec | null;
-    tracks: MediaParserTracks;
+    tracks: MediaParserTrack[];
     rotation: number | null;
-    unrotatedDimensions: Dimensions | null;
+    unrotatedDimensions: MediaParserDimensions | null;
     isHdr: boolean;
     internalStats: InternalStats;
     size: number | null;
@@ -118,7 +114,7 @@ export interface ParseMediaData {
     slowAudioBitrate: number | null;
     m3uStreams: M3uStream[] | null;
 }
-export type ParseMediaResult<T extends Partial<ParseMediaFields>> = {
+export type ParseMediaResult<T extends Partial<ParseMediaFields>> = {} extends T ? Record<never, never> : {
     [K in keyof T]: T[K] extends true ? K extends keyof ParseMediaData ? ParseMediaData[K] : never : never;
 };
 export type ParseMediaProgress = {
@@ -128,14 +124,14 @@ export type ParseMediaProgress = {
 };
 export type ParseMediaOnProgress = (progress: ParseMediaProgress) => void | Promise<void>;
 type ReaderParams = {
-    reader: ReaderInterface;
+    reader: MediaParserReaderInterface;
 };
 export type M3uPlaylistContext = {
     mp4HeaderSegment: IsoBaseMediaStructure | null;
     isLastChunkInPlaylist: boolean;
 };
 export type SerializeableOptionalParseMediaParams<F extends Options<ParseMediaFields>> = {
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     progressIntervalInMs: number | null;
     fields: F | null;
     acknowledgeRemotionLicense: boolean;
@@ -150,8 +146,8 @@ type OptionalParseMediaParams<F extends Options<ParseMediaFields>> = Serializeab
     selectM3uAssociatedPlaylists: SelectM3uAssociatedPlaylistsFn;
 };
 type ParseMediaSampleCallbacks = {
-    onAudioTrack: OnAudioTrack | null;
-    onVideoTrack: OnVideoTrack | null;
+    onAudioTrack: MediaParserOnAudioTrack | null;
+    onVideoTrack: MediaParserOnVideoTrack | null;
 };
 export type ParseMediaMode = 'query' | 'download';
 export type ParseMediaSrc = string | Blob | URL;

package/dist/parse-loop.js

@@ -118,10 +118,10 @@ const parseLoop = async ({ state, throttledState, onError, }) => {
     }
     state.samplesObserved.setLastSampleObserved();
     // After the last sample, you might queue a last seek again.
-    if (state.controller._internals.seekSignal.getSeek()) {
+    if (state.controller._internals.seekSignal.getSeek() !== null) {
         log_1.Log.verbose(state.logLevel, 'Reached end of samples, but there is a pending seek. Trying to seek...');
         await (0, work_on_seek_request_1.workOnSeekRequest)((0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state));
-        if (state.controller._internals.seekSignal.getSeek()) {
+        if (state.controller._internals.seekSignal.getSeek() !== null) {
             throw new Error('Reached the end of the file even though a seek was requested. This is likely a bug in the parser. You can report this at https://remotion.dev/report and we will fix it as soon as possible.');
         }
         await (0, exports.parseLoop)({

package/dist/parse-media-on-worker-entry.js

@@ -6,7 +6,7 @@ const serialize_error_1 = require("./worker/serialize-error");
 const convertToWorkerPayload = (
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 payload) => {
-    const { onAudioCodec, onContainer, onDimensions, onUnrotatedDimensions, onVideoCodec, onFps, onAudioTrack, onDurationInSeconds, onImages, onInternalStats, onIsHdr, onKeyframes, onLocation, onM3uStreams, onMetadata, onMimeType, onName, onNumberOfAudioChannels, onParseProgress, onRotation, onSampleRate, onSlowAudioBitrate, onSize, onSlowDurationInSeconds, onSlowFps, onSlowKeyframes, onSlowNumberOfFrames, onSlowVideoBitrate, onStructure, onTracks, onVideoTrack, selectM3uStream, selectM3uAssociatedPlaylists, src, ...others } = payload;
+    const { onAudioCodec, onContainer, onDimensions, onUnrotatedDimensions, onVideoCodec, onFps, onAudioTrack, onDurationInSeconds, onImages, onInternalStats, onIsHdr, onKeyframes, onLocation, onM3uStreams, onMetadata, onMimeType, onName, onNumberOfAudioChannels, onParseProgress, onRotation, onSampleRate, onSlowAudioBitrate, onSize, onSlowDurationInSeconds, onSlowFps, onSlowKeyframes, onSlowNumberOfFrames, onSlowVideoBitrate, onSlowStructure, onTracks, onVideoTrack, selectM3uStream, selectM3uAssociatedPlaylists, src, ...others } = payload;
     return {
         type: 'request-worker',
         payload: others,
@@ -33,7 +33,7 @@ payload) => {
         postSlowKeyframes: Boolean(onSlowKeyframes),
         postSlowNumberOfFrames: Boolean(onSlowNumberOfFrames),
         postSlowVideoBitrate: Boolean(onSlowVideoBitrate),
-        postStructure: Boolean(onStructure),
+        postSlowStructure: Boolean(onSlowStructure),
         postTracks: Boolean(onTracks),
         postUnrotatedDimensions: Boolean(onUnrotatedDimensions),
         postVideoCodec: Boolean(onVideoCodec),
@@ -179,8 +179,8 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
                     await ((_p = params.onSlowVideoBitrate) === null || _p === void 0 ? void 0 : _p.call(params, data.payload.value));
                     return { payloadType: 'void' };
                 }
-                if (data.payload.callbackType === 'structure') {
-                    await ((_q = params.onStructure) === null || _q === void 0 ? void 0 : _q.call(params, data.payload.value));
+                if (data.payload.callbackType === 'slow-structure') {
+                    await ((_q = params.onSlowStructure) === null || _q === void 0 ? void 0 : _q.call(params, data.payload.value));
                     return { payloadType: 'void' };
                 }
                 if (data.payload.callbackType === 'fps') {
@@ -270,7 +270,15 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
                         registeredCallback: Boolean(possibleCallback),
                     };
                 }
-                if (data.payload.callbackType === 'on-audio-video-sample') {
+                if (data.payload.callbackType === 'on-audio-sample') {
+                    const callback = callbacks[data.payload.trackId];
+                    if (!callback) {
+                        throw new Error(`No callback registered for track ${data.payload.trackId}`);
+                    }
+                    await callback(data.payload.value);
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'on-video-sample') {
                     const callback = callbacks[data.payload.trackId];
                     if (!callback) {
                         throw new Error(`No callback registered for track ${data.payload.trackId}`);

package/dist/parse-media.js

@@ -34,7 +34,7 @@ const parseMedia = (options) => {
         onSlowKeyframes: (_0 = options.onSlowKeyframes) !== null && _0 !== void 0 ? _0 : null,
         onSlowNumberOfFrames: (_1 = options.onSlowNumberOfFrames) !== null && _1 !== void 0 ? _1 : null,
         onSlowVideoBitrate: (_2 = options.onSlowVideoBitrate) !== null && _2 !== void 0 ? _2 : null,
-        onStructure: (_3 = options.onStructure) !== null && _3 !== void 0 ? _3 : null,
+        onSlowStructure: (_3 = options.onSlowStructure) !== null && _3 !== void 0 ? _3 : null,
         onM3uStreams: (_4 = options.onM3uStreams) !== null && _4 !== void 0 ? _4 : null,
         onTracks: (_5 = options.onTracks) !== null && _5 !== void 0 ? _5 : null,
         onUnrotatedDimensions: (_6 = options.onUnrotatedDimensions) !== null && _6 !== void 0 ? _6 : null,

package/dist/perform-seek.d.ts

@@ -2,9 +2,9 @@ import type { MediaParserController } from './controller/media-parser-controller
 import type { PrefetchCache } from './fetch';
 import type { AllOptions, ParseMediaFields } from './fields';
 import type { BufferIterator } from './iterator/buffer-iterator';
-import type { LogLevel } from './log';
+import type { MediaParserLogLevel } from './log';
 import type { ParseMediaMode, ParseMediaSrc } from './options';
-import type { ReaderInterface } from './readers/reader';
+import type { MediaParserReaderInterface } from './readers/reader';
 import type { CurrentReader } from './state/current-reader';
 import type { SeekInfiniteLoop } from './state/seek-infinite-loop';
 import type { MediaSectionState } from './state/video-section';
@@ -14,12 +14,12 @@ export declare const performSeek: ({ seekTo, userInitiated, controller, mediaSec
     controller: MediaParserController;
     mediaSection: MediaSectionState;
     iterator: BufferIterator;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     mode: ParseMediaMode;
     contentLength: number;
     seekInfiniteLoop: SeekInfiniteLoop;
     currentReader: CurrentReader;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     fields: Partial<AllOptions<ParseMediaFields>>;
     src: ParseMediaSrc;
     discardReadBytes: (force: boolean) => Promise<void>;

package/dist/readers/from-fetch.d.ts

@@ -1,6 +1,6 @@
 import type { MediaParserController } from '../controller/media-parser-controller';
 import type { ParseMediaRange } from '../options';
-import type { CreateAdjacentFileSource, PreloadContent, ReadContent, ReaderInterface, ReadWholeAsText } from './reader';
+import type { CreateAdjacentFileSource, MediaParserReaderInterface, PreloadContent, ReadContent, ReadWholeAsText } from './reader';
 interface ParsedContentRange {
     unit: string;
     start?: number | null;
@@ -29,5 +29,5 @@ export declare const fetchReadContent: ReadContent;
 export declare const fetchPreload: PreloadContent;
 export declare const fetchReadWholeAsText: ReadWholeAsText;
 export declare const fetchCreateAdjacentFileSource: CreateAdjacentFileSource;
-export declare const fetchReader: ReaderInterface;
+export declare const fetchReader: MediaParserReaderInterface;
 export {};

package/dist/readers/from-node.d.ts

@@ -1,5 +1,5 @@
-import type { CreateAdjacentFileSource, ReadContent, ReadWholeAsText, ReaderInterface } from './reader';
+import type { CreateAdjacentFileSource, MediaParserReaderInterface, ReadContent, ReadWholeAsText } from './reader';
 export declare const nodeReadContent: ReadContent;
 export declare const nodeReadWholeAsText: ReadWholeAsText;
 export declare const nodeCreateAdjacentFileSource: CreateAdjacentFileSource;
-export declare const nodeReader: ReaderInterface;
+export declare const nodeReader: MediaParserReaderInterface;

package/dist/readers/from-node.js

@@ -3,70 +3,79 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeReader = exports.nodeCreateAdjacentFileSource = exports.nodeReadWholeAsText = exports.nodeReadContent = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const nodeReadContent = ({ src, range, controller }) => {
+const nodeReadContent = async ({ src, range, controller, }) => {
     if (typeof src !== 'string') {
         throw new Error('src must be a string when using `nodeReader`');
     }
+    await Promise.resolve();
     const ownController = new AbortController();
-    const stream = (0, fs_1.createReadStream)(src, {
-        start: range === null ? 0 : typeof range === 'number' ? range : range[0],
-        end: range === null
-            ? Infinity
-            : typeof range === 'number'
+    try {
+        if (!(0, fs_1.existsSync)(src)) {
+            throw new Error(`File does not exist: ${src}`);
+        }
+        const stream = (0, fs_1.createReadStream)(src, {
+            start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+            end: range === null
                 ? Infinity
-                : range[1],
-    });
-    controller._internals.signal.addEventListener('abort', () => {
-        ownController.abort();
-    }, { once: true });
-    const stats = (0, fs_1.statSync)(src);
-    let readerCancelled = false;
-    const reader = new ReadableStream({
-        start(c) {
-            if (readerCancelled) {
-                return;
-            }
-            stream.on('data', (chunk) => {
-                c.enqueue(chunk);
-            });
-            stream.on('end', () => {
-                if (readerCancelled) {
-                    return;
-                }
-                c.close();
-            });
-            stream.on('error', (err) => {
-                c.error(err);
-            });
-        },
-        cancel() {
-            readerCancelled = true;
-            stream.destroy();
-        },
-    }).getReader();
-    if (controller) {
+                : typeof range === 'number'
+                    ? Infinity
+                    : range[1],
+        });
         controller._internals.signal.addEventListener('abort', () => {
-            reader.cancel().catch(() => { });
+            ownController.abort();
         }, { once: true });
-    }
-    return Promise.resolve({
-        reader: {
-            reader,
-            abort: async () => {
-                try {
-                    stream.destroy();
-                    ownController.abort();
-                    await reader.cancel();
+        const stats = (0, fs_1.statSync)(src);
+        let readerCancelled = false;
+        const reader = new ReadableStream({
+            start(c) {
+                if (readerCancelled) {
+                    return;
                 }
-                catch (_a) { }
+                stream.on('data', (chunk) => {
+                    c.enqueue(chunk);
+                });
+                stream.on('end', () => {
+                    if (readerCancelled) {
+                        return;
+                    }
+                    c.close();
+                });
+                stream.on('error', (err) => {
+                    c.error(err);
+                });
+            },
+            cancel() {
+                readerCancelled = true;
+                stream.destroy();
+            },
+        }).getReader();
+        if (controller) {
+            controller._internals.signal.addEventListener('abort', () => {
+                reader.cancel().catch(() => { });
+            }, { once: true });
+        }
+        return Promise.resolve({
+            reader: {
+                reader,
+                abort: async () => {
+                    try {
+                        stream.destroy();
+                        ownController.abort();
+                        await reader.cancel();
+                    }
+                    catch (_a) { }
+                },
             },
-        },
-        contentLength: stats.size,
-        contentType: null,
-        name: src.split(path_1.sep).pop(),
-        supportsContentRange: true,
-        needsContentRange: true,
-    });
+            contentLength: stats.size,
+            contentType: null,
+            name: src.split(path_1.sep).pop(),
+            supportsContentRange: true,
+            needsContentRange: true,
+        });
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
 };
 exports.nodeReadContent = nodeReadContent;
 const nodeReadWholeAsText = (src) => {

package/dist/readers/from-web-file.d.ts

@@ -1,5 +1,5 @@
-import type { CreateAdjacentFileSource, ReadContent, ReaderInterface, ReadWholeAsText } from './reader';
+import type { CreateAdjacentFileSource, MediaParserReaderInterface, ReadContent, ReadWholeAsText } from './reader';
 export declare const webFileReadContent: ReadContent;
 export declare const webFileReadWholeAsText: ReadWholeAsText;
 export declare const webFileCreateAdjacentFileSource: CreateAdjacentFileSource;
-export declare const webFileReader: ReaderInterface;
+export declare const webFileReader: MediaParserReaderInterface;

package/dist/readers/reader.d.ts

@@ -1,5 +1,5 @@
 import type { MediaParserController } from '../controller/media-parser-controller';
-import type { LogLevel } from '../log';
+import type { MediaParserLogLevel } from '../log';
 import type { ParseMediaRange, ParseMediaSrc } from '../options';
 import type { PrefetchCache } from './from-fetch';
 export type Reader = {
@@ -18,24 +18,24 @@ export type ReadContent = (options: {
     src: ParseMediaSrc;
     range: ParseMediaRange;
     controller: MediaParserController;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     prefetchCache: PrefetchCache;
 }) => Promise<ReadResult>;
 export type ReadWholeAsText = (src: ParseMediaSrc) => Promise<string>;
 export type PreloadContent = (options: {
     src: ParseMediaSrc;
     range: ParseMediaRange;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     prefetchCache: PrefetchCache;
 }) => void;
 export type ClearPreloadCache = (options: {
     src: ParseMediaSrc;
     range: ParseMediaRange;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     prefetchCache: PrefetchCache;
 }) => void;
 export type CreateAdjacentFileSource = (relativePath: string, src: ParseMediaSrc) => string;
-export type ReaderInterface = {
+export type MediaParserReaderInterface = {
     read: ReadContent;
     readWholeAsText: ReadWholeAsText;
     createAdjacentFileSource: CreateAdjacentFileSource;

package/dist/readers/universal.d.ts

@@ -1,2 +1,2 @@
-import type { ReaderInterface } from './reader';
-export declare const universalReader: ReaderInterface;
+import type { MediaParserReaderInterface } from './reader';
+export declare const universalReader: MediaParserReaderInterface;

package/dist/readers/web.d.ts

@@ -1,2 +1,2 @@
-import type { ReaderInterface } from './reader';
-export declare const webReader: ReaderInterface;
+import type { MediaParserReaderInterface } from './reader';
+export declare const webReader: MediaParserReaderInterface;

package/dist/register-track.d.ts

@@ -1,28 +1,28 @@
-import type { AudioTrack, Track, VideoTrack } from './get-tracks';
-import type { LogLevel } from './log';
+import type { MediaParserAudioTrack, MediaParserTrack, MediaParserVideoTrack } from './get-tracks';
+import type { MediaParserLogLevel } from './log';
 import type { MediaParserContainer } from './options';
 import type { TracksState } from './state/has-tracks-section';
 import type { ParserState } from './state/parser-state';
 import type { CallbacksState } from './state/sample-callbacks';
-import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
+import type { MediaParserOnAudioTrack, MediaParserOnVideoTrack } from './webcodec-sample-types';
 export declare const registerVideoTrack: ({ track, container, logLevel, onVideoTrack, registerVideoSampleCallback, tracks, }: {
-    track: Track;
+    track: MediaParserTrack;
     container: MediaParserContainer;
-    logLevel: LogLevel;
-    onVideoTrack: OnVideoTrack | null;
+    logLevel: MediaParserLogLevel;
+    onVideoTrack: MediaParserOnVideoTrack | null;
     registerVideoSampleCallback: CallbacksState["registerVideoSampleCallback"];
     tracks: TracksState;
-}) => Promise<import("./webcodec-sample-types").OnVideoSample | null>;
+}) => Promise<import("./webcodec-sample-types").MediaParserOnVideoSample | null>;
 export declare const registerAudioTrack: ({ track, container, tracks, logLevel, onAudioTrack, registerAudioSampleCallback, }: {
-    track: AudioTrack;
+    track: MediaParserAudioTrack;
     container: MediaParserContainer;
     tracks: TracksState;
-    logLevel: LogLevel;
-    onAudioTrack: OnAudioTrack | null;
+    logLevel: MediaParserLogLevel;
+    onAudioTrack: MediaParserOnAudioTrack | null;
     registerAudioSampleCallback: CallbacksState["registerAudioSampleCallback"];
-}) => Promise<import("./webcodec-sample-types").OnAudioSample | null>;
+}) => Promise<import("./webcodec-sample-types").MediaParserOnAudioSample | null>;
 export declare const registerVideoTrackWhenProfileIsAvailable: ({ state, track, container, }: {
     state: ParserState;
-    track: VideoTrack;
+    track: MediaParserVideoTrack;
     container: MediaParserContainer;
 }) => void;

package/dist/remotion-license-acknowledge.d.ts

@@ -1,6 +1,6 @@
-import type { LogLevel } from './log';
+import type { MediaParserLogLevel } from './log';
 export declare const warnIfRemotionLicenseNotAcknowledged: ({ acknowledgeRemotionLicense, logLevel, apiName, }: {
     acknowledgeRemotionLicense: boolean;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     apiName: string;
 }) => void;

package/dist/seek-backwards.d.ts

@@ -1,17 +1,17 @@
 import type { MediaParserController } from './controller/media-parser-controller';
 import type { PrefetchCache } from './fetch';
 import type { BufferIterator } from './iterator/buffer-iterator';
-import type { LogLevel } from './log';
+import type { MediaParserLogLevel } from './log';
 import type { ParseMediaSrc } from './options';
-import type { ReaderInterface } from './readers/reader';
+import type { MediaParserReaderInterface } from './readers/reader';
 import type { CurrentReader } from './state/current-reader';
 export declare const seekBackwards: ({ iterator, seekTo, readerInterface, src, controller, logLevel, currentReader, prefetchCache, }: {
     iterator: BufferIterator;
     seekTo: number;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     src: ParseMediaSrc;
     controller: MediaParserController;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     currentReader: CurrentReader;
     prefetchCache: PrefetchCache;
 }) => Promise<void>;

package/dist/seek-forwards.d.ts

@@ -2,18 +2,18 @@ import type { MediaParserController } from './controller/media-parser-controller
 import type { PrefetchCache } from './fetch';
 import type { AllOptions, ParseMediaFields } from './fields';
 import type { BufferIterator } from './iterator/buffer-iterator';
-import type { LogLevel } from './log';
+import type { MediaParserLogLevel } from './log';
 import type { ParseMediaSrc } from './options';
-import type { ReaderInterface } from './readers/reader';
+import type { MediaParserReaderInterface } from './readers/reader';
 import type { CurrentReader } from './state/current-reader';
 export declare const seekForward: ({ seekTo, userInitiated, iterator, fields, logLevel, currentReader, readerInterface, src, controller, discardReadBytes, prefetchCache, }: {
     seekTo: number;
     userInitiated: boolean;
     iterator: BufferIterator;
     fields: Partial<AllOptions<ParseMediaFields>>;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     currentReader: CurrentReader;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     src: ParseMediaSrc;
     controller: MediaParserController;
     discardReadBytes: (force: boolean) => Promise<void>;

package/dist/server-worker.module.d.ts

@@ -0,0 +1,2 @@
+import type { ParseMediaOnWorker } from './options';
+export declare const parseMediaOnServerWorker: ParseMediaOnWorker;

package/dist/server-worker.module.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMediaOnServerWorker = void 0;
+const parse_media_on_worker_entry_1 = require("./parse-media-on-worker-entry");
+const parseMediaOnServerWorker = (params) => {
+    if (typeof Worker === 'undefined') {
+        throw new Error('"Worker" is not available. Cannot call parseMediaOnServerWorker()');
+    }
+    const worker = new Worker(new URL('./worker-server-entry', import.meta.url));
+    return (0, parse_media_on_worker_entry_1.parseMediaOnWorkerImplementation)(params, worker, 'parseMediaOnServerWorker');
+};
+exports.parseMediaOnServerWorker = parseMediaOnServerWorker;

package/dist/state/can-skip-tracks.js

@@ -15,7 +15,7 @@ const needsTracksForField = ({ field, structure, }) => {
         field === 'fps' ||
         field === 'isHdr' ||
         field === 'rotation' ||
-        field === 'structure' ||
+        field === 'slowStructure' ||
         field === 'tracks' ||
         field === 'unrotatedDimensions' ||
         field === 'videoCodec' ||

package/dist/state/emitted-fields.js

@@ -16,7 +16,7 @@ const emittedState = () => {
         name: false,
         rotation: false,
         size: false,
-        structure: false,
+        slowStructure: false,
         tracks: false,
         videoCodec: false,
         unrotatedDimensions: false,

package/dist/state/has-tracks-section.d.ts

@@ -1,14 +1,14 @@
 import type { Options, ParseMediaFields } from '../fields';
-import type { Track } from '../get-tracks';
-import type { LogLevel } from '../log';
+import type { MediaParserTrack } from '../get-tracks';
+import type { MediaParserLogLevel } from '../log';
 import type { ParseMediaSrc } from '../options';
 import type { CanSkipTracksState } from './can-skip-tracks';
 export declare const makeTracksSectionState: (canSkipTracksState: CanSkipTracksState, src: ParseMediaSrc) => {
     hasAllTracks: () => boolean;
     getIsDone: () => boolean;
-    setIsDone: (logLevel: LogLevel) => void;
-    addTrack: (track: Track) => void;
-    getTracks: () => Track[];
+    setIsDone: (logLevel: MediaParserLogLevel) => void;
+    addTrack: (track: MediaParserTrack) => void;
+    getTracks: () => MediaParserTrack[];
     ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;
 };
 export type TracksState = ReturnType<typeof makeTracksSectionState>;

package/dist/state/iso-base-media/cached-sample-positions.d.ts

@@ -1,9 +1,9 @@
 import type { JumpMark } from '../../containers/iso-base-media/mdat/calculate-jump-marks';
 import type { SamplePosition } from '../../get-sample-positions';
-import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { MediaParserAudioTrack, MediaParserOtherTrack, MediaParserVideoTrack } from '../../get-tracks';
 import type { ParserState } from '../parser-state';
 export type FlatSample = {
-    track: VideoTrack | AudioTrack | OtherTrack;
+    track: MediaParserVideoTrack | MediaParserAudioTrack | MediaParserOtherTrack;
     samplePosition: SamplePosition;
 };
 export type MinimalFlatSampleForTesting = {
@@ -21,7 +21,7 @@ export declare const calculateFlatSamples: ({ state, mediaSectionStart, }: {
     state: ParserState;
     mediaSectionStart: number;
 }) => {
-    track: VideoTrack | AudioTrack | OtherTrack;
+    track: import("../../get-tracks").MediaParserTrack;
     samplePosition: SamplePosition;
 }[][];
 export declare const cachedSamplePositionsState: () => {