@remotion/media-parser 4.0.282 → 4.0.284

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

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

package/dist/containers/m3u/iterate-over-segment-files.js

@@ -4,6 +4,7 @@ exports.iteratorOverSegmentFiles = void 0;
 const media_parser_controller_1 = require("../../controller/media-parser-controller");
 const forward_controller_1 = require("../../forward-controller");
 const parse_media_1 = require("../../parse-media");
+const with_resolvers_1 = require("../../with-resolvers");
 const get_chunks_1 = require("./get-chunks");
 const get_playlist_1 = require("./get-playlist");
 const iteratorOverSegmentFiles = async ({ structure, onVideoTrack, m3uState, onAudioTrack, onDoneWithTracks, playlistUrl, logLevel, parentController, onInitialProgress, readerInterface, }) => {
@@ -20,7 +21,7 @@ const iteratorOverSegmentFiles = async ({ structure, onVideoTrack, m3uState, onA
     const makeContinuationFn = () => {
         return {
             continue() {
-                const { promise, reject, resolve } = Promise.withResolvers();
+                const { promise, reject, resolve } = (0, with_resolvers_1.withResolvers)();
                 resolver = resolve;
                 rejector = reject;
                 childController.resume();

package/dist/containers/transport-stream/process-audio.d.ts

@@ -0,0 +1,21 @@
+import type { LogLevel } from '../../log';
+import type { TransportStreamStructure } from '../../parse-result';
+import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
+import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
+import type { TransportStreamEntry } from './parse-pmt';
+import type { TransportStreamPacketBuffer } from './process-stream-buffers';
+export declare const canProcessAudio: ({ streamBuffer, }: {
+    streamBuffer: TransportStreamPacketBuffer;
+}) => boolean;
+export declare const processAudio: ({ transportStreamEntry, structure, offset, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }: {
+    transportStreamEntry: TransportStreamEntry;
+    structure: TransportStreamStructure;
+    sampleCallbacks: SampleCallbacks;
+    logLevel: LogLevel;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    transportStream: TransportStreamState;
+    offset: number;
+    makeSamplesStartAtZero: boolean;
+}) => Promise<void>;

package/dist/containers/transport-stream/process-audio.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAudio = exports.canProcessAudio = void 0;
+const adts_header_1 = require("./adts-header");
+const process_stream_buffers_1 = require("./process-stream-buffers");
+const canProcessAudio = ({ streamBuffer, }) => {
+    var _a, _b;
+    const expectedLength = (_b = (_a = (0, adts_header_1.readAdtsHeader)(streamBuffer.getBuffer())) === null || _a === void 0 ? void 0 : _a.frameLength) !== null && _b !== void 0 ? _b : null;
+    if (expectedLength === null) {
+        return false;
+    }
+    if (expectedLength > streamBuffer.getBuffer().length) {
+        return false;
+    }
+    return true;
+};
+exports.canProcessAudio = canProcessAudio;
+const processAudio = async ({ transportStreamEntry, structure, offset, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }) => {
+    var _a, _b;
+    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = transportStream;
+    const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+    if (!streamBuffer) {
+        throw new Error('Stream buffer not found');
+    }
+    const expectedLength = (_b = (_a = (0, adts_header_1.readAdtsHeader)(streamBuffer.getBuffer())) === null || _a === void 0 ? void 0 : _a.frameLength) !== null && _b !== void 0 ? _b : null;
+    if (expectedLength === null) {
+        throw new Error('Expected length is null');
+    }
+    if (expectedLength > streamBuffer.getBuffer().length) {
+        throw new Error('Expected length is greater than stream buffer length');
+    }
+    await (0, process_stream_buffers_1.processStreamBuffer)({
+        streamBuffer: (0, process_stream_buffers_1.makeTransportStreamPacketBuffer)({
+            buffers: streamBuffer.getBuffer().slice(0, expectedLength),
+            offset,
+            pesHeader: streamBuffer.pesHeader,
+        }),
+        programId: transportStreamEntry.pid,
+        structure,
+        sampleCallbacks,
+        logLevel,
+        onAudioTrack,
+        onVideoTrack,
+        transportStream,
+        makeSamplesStartAtZero,
+    });
+    const rest = streamBuffer.getBuffer().slice(expectedLength);
+    streamBuffers.set(transportStreamEntry.pid, (0, process_stream_buffers_1.makeTransportStreamPacketBuffer)({
+        buffers: rest,
+        pesHeader: nextPesHeader.getNextPesHeader(),
+        offset,
+    }));
+};
+exports.processAudio = processAudio;

package/dist/containers/transport-stream/process-sample-if-possible.d.ts

@@ -0,0 +1,2 @@
+import type { ParserState } from '../../state/parser-state';
+export declare const processSampleIfPossible: (state: ParserState) => Promise<boolean | undefined>;

package/dist/containers/transport-stream/process-sample-if-possible.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSampleIfPossible = void 0;
+const process_audio_1 = require("./process-audio");
+const process_stream_buffers_1 = require("./process-stream-buffers");
+const process_video_1 = require("./process-video");
+const traversal_1 = require("./traversal");
+const processSampleIfPossible = async (state) => {
+    const programMap = (0, traversal_1.findProgramMapOrNull)(state.structure.getTsStructure());
+    if (!programMap) {
+        return;
+    }
+    let processed = false;
+    for (const stream of programMap.streams) {
+        const streamBuffer = state.transportStream.streamBuffers.get(stream.pid);
+        if (!streamBuffer) {
+            continue;
+        }
+        if (stream.streamType === 27) {
+            if ((0, process_video_1.canProcessVideo)({ streamBuffer })) {
+                const rest = await (0, process_video_1.processVideo)({
+                    programId: stream.pid,
+                    structure: state.structure.getTsStructure(),
+                    streamBuffer,
+                    sampleCallbacks: state.callbacks,
+                    logLevel: state.logLevel,
+                    onAudioTrack: state.onAudioTrack,
+                    onVideoTrack: state.onVideoTrack,
+                    transportStream: state.transportStream,
+                    makeSamplesStartAtZero: state.makeSamplesStartAtZero,
+                });
+                state.transportStream.streamBuffers.delete(stream.pid);
+                state.transportStream.streamBuffers.set(stream.pid, (0, process_stream_buffers_1.makeTransportStreamPacketBuffer)({
+                    pesHeader: state.transportStream.nextPesHeaderStore.getNextPesHeader(),
+                    buffers: rest,
+                    offset: state.iterator.counter.getOffset(),
+                }));
+                processed = true;
+                break;
+            }
+        }
+        if (stream.streamType === 15) {
+            if ((0, process_audio_1.canProcessAudio)({ streamBuffer })) {
+                await (0, process_audio_1.processAudio)({
+                    structure: state.structure.getTsStructure(),
+                    offset: state.iterator.counter.getOffset(),
+                    sampleCallbacks: state.callbacks,
+                    logLevel: state.logLevel,
+                    onAudioTrack: state.onAudioTrack,
+                    onVideoTrack: state.onVideoTrack,
+                    transportStream: state.transportStream,
+                    makeSamplesStartAtZero: state.makeSamplesStartAtZero,
+                    transportStreamEntry: stream,
+                });
+                processed = true;
+                break;
+            }
+        }
+    }
+    return processed;
+};
+exports.processSampleIfPossible = processSampleIfPossible;

package/dist/containers/transport-stream/process-video.d.ts

@@ -0,0 +1,20 @@
+import type { LogLevel } from '../../log';
+import type { TransportStreamStructure } from '../../parse-result';
+import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
+import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
+import type { TransportStreamPacketBuffer } from './process-stream-buffers';
+export declare const canProcessVideo: ({ streamBuffer, }: {
+    streamBuffer: TransportStreamPacketBuffer;
+}) => boolean;
+export declare const processVideo: ({ programId, structure, streamBuffer, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }: {
+    programId: number;
+    structure: TransportStreamStructure;
+    streamBuffer: TransportStreamPacketBuffer;
+    sampleCallbacks: SampleCallbacks;
+    logLevel: LogLevel;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    transportStream: TransportStreamState;
+    makeSamplesStartAtZero: boolean;
+}) => Promise<Uint8Array>;

package/dist/containers/transport-stream/process-video.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processVideo = exports.canProcessVideo = void 0;
+const process_stream_buffers_1 = require("./process-stream-buffers");
+const canProcessVideo = ({ streamBuffer, }) => {
+    const indexOfSeparator = streamBuffer.get2ndSubArrayIndex();
+    if (indexOfSeparator === -1 || indexOfSeparator === 0) {
+        return false;
+    }
+    return true;
+};
+exports.canProcessVideo = canProcessVideo;
+const processVideo = async ({ programId, structure, streamBuffer, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }) => {
+    const indexOfSeparator = streamBuffer.get2ndSubArrayIndex();
+    if (indexOfSeparator === -1 || indexOfSeparator === 0) {
+        throw new Error('cannot process avc stream');
+    }
+    const buf = streamBuffer.getBuffer();
+    const packet = buf.slice(0, indexOfSeparator);
+    const rest = buf.slice(indexOfSeparator);
+    await (0, process_stream_buffers_1.processStreamBuffer)({
+        streamBuffer: (0, process_stream_buffers_1.makeTransportStreamPacketBuffer)({
+            offset: streamBuffer.offset,
+            pesHeader: streamBuffer.pesHeader,
+            // Replace the regular 0x00000001 with 0x00000002 to avoid confusion with other 0x00000001 (?)
+            buffers: packet,
+        }),
+        programId,
+        structure,
+        sampleCallbacks,
+        logLevel,
+        onAudioTrack,
+        onVideoTrack,
+        transportStream,
+        makeSamplesStartAtZero,
+    });
+    return rest;
+};
+exports.processVideo = processVideo;

package/dist/containers/transport-stream/start-offset.d.ts

@@ -0,0 +1,4 @@
+export declare const startOffsetStore: () => {
+    getOffset: () => number;
+    setOffset: (newOffset: number) => void;
+};

package/dist/containers/transport-stream/start-offset.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startOffsetStore = void 0;
+const startOffsetStore = () => {
+    let offset = 0;
+    return {
+        getOffset: () => offset,
+        setOffset: (newOffset) => {
+            offset = newOffset;
+        },
+    };
+};
+exports.startOffsetStore = startOffsetStore;

package/dist/controller/emitter.js

@@ -13,6 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _MediaParserEmitter_markAsReady;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MediaParserEmitter = void 0;
+const with_resolvers_1 = require("../with-resolvers");
 class MediaParserEmitter {
     constructor() {
         this.listeners = {
@@ -51,7 +52,7 @@ class MediaParserEmitter {
                 this.dispatchEvent('seek', { seek });
             });
         };
-        const { promise, resolve } = Promise.withResolvers();
+        const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
         this.readyPromise = promise;
         __classPrivateFieldSet(this, _MediaParserEmitter_markAsReady, resolve, "f");
     }

package/dist/esm/index.mjs

@@ -3805,7 +3805,8 @@ var mediaSectionState = () => {
     isCurrentByteInMediaSection,
     isByteInMediaSection,
     getCurrentMediaSection,
-    getMediaSectionAssertOnlyOne
+    getMediaSectionAssertOnlyOne,
+    mediaSections
   };
 };
 
@@ -7166,6 +7167,17 @@ var hasBeenAborted = (error) => {
   return error instanceof MediaParserAbortError || error.name === "MediaParserAbortError";
 };
 
+// src/with-resolvers.ts
+var withResolvers = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
 // src/controller/emitter.ts
 class MediaParserEmitter {
   listeners = {
@@ -7177,7 +7189,7 @@ class MediaParserEmitter {
   readyPromise;
   #markAsReady;
   constructor() {
-    const { promise, resolve } = Promise.withResolvers();
+    const { promise, resolve } = withResolvers();
     this.readyPromise = promise;
     this.#markAsReady = resolve;
   }
@@ -10337,7 +10349,7 @@ var iteratorOverSegmentFiles = async ({
   const makeContinuationFn = () => {
     return {
       continue() {
-        const { promise, reject, resolve } = Promise.withResolvers();
+        const { promise, reject, resolve } = withResolvers();
         resolver = resolve;
         rejector = reject;
         childController.resume();
@@ -14062,7 +14074,7 @@ var downloadAndParseMedia = async (options) => {
   return returnValue;
 };
 // src/version.ts
-var VERSION = "4.0.282";
+var VERSION = "4.0.284";
 
 // src/index.ts
 var MediaParserInternals = {

package/dist/esm/server-worker.mjs

@@ -1,3 +1,14 @@
+// src/with-resolvers.ts
+var withResolvers = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
 // src/errors.ts
 class IsAGifError extends Error {
   mimeType;
@@ -224,7 +235,7 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     throw new Error(`\`reader\` should not be provided to \`${apiName}\`. If you want to use it in the browser, use parseMediaOnWorker(). If you also want to read files from the file system, use parseMediaOnServerWorker().`);
   }
   post(worker, convertToWorkerPayload(params));
-  const { promise, resolve, reject } = Promise.withResolvers();
+  const { promise, resolve, reject } = withResolvers();
   const onAbort = () => {
     post(worker, { type: "request-abort" });
   };

package/dist/esm/worker-server-entry.mjs

@@ -452,6 +452,17 @@ var defaultSelectM3uStreamFn = ({ streams }) => {
   return Promise.resolve(streams[0].id);
 };
 
+// src/with-resolvers.ts
+var withResolvers = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
 // src/controller/emitter.ts
 class MediaParserEmitter {
   listeners = {
@@ -463,7 +474,7 @@ class MediaParserEmitter {
   readyPromise;
   #markAsReady;
   constructor() {
-    const { promise, resolve } = Promise.withResolvers();
+    const { promise, resolve } = withResolvers();
     this.readyPromise = promise;
     this.#markAsReady = resolve;
   }
@@ -5405,7 +5416,8 @@ var mediaSectionState = () => {
     isCurrentByteInMediaSection,
     isByteInMediaSection,
     getCurrentMediaSection,
-    getMediaSectionAssertOnlyOne
+    getMediaSectionAssertOnlyOne,
+    mediaSections
   };
 };
 
@@ -9869,7 +9881,7 @@ var iteratorOverSegmentFiles = async ({
   const makeContinuationFn = () => {
     return {
       continue() {
-        const { promise, reject, resolve } = Promise.withResolvers();
+        const { promise, reject, resolve } = withResolvers();
         resolver = resolve;
         rejector = reject;
         childController.resume();
@@ -14166,7 +14178,7 @@ var post = (message) => {
 var controller = mediaParserController();
 var executeCallback = (payload) => {
   const nonce = crypto.randomUUID();
-  const { promise, resolve, reject } = Promise.withResolvers();
+  const { promise, resolve, reject } = withResolvers();
   const cb = (msg) => {
     const data = msg.data;
     if (data.type === "acknowledge-callback" && data.nonce === nonce) {

package/dist/esm/worker-web-entry.mjs

@@ -387,6 +387,17 @@ var defaultSelectM3uStreamFn = ({ streams }) => {
   return Promise.resolve(streams[0].id);
 };
 
+// src/with-resolvers.ts
+var withResolvers = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
 // src/controller/emitter.ts
 class MediaParserEmitter {
   listeners = {
@@ -398,7 +409,7 @@ class MediaParserEmitter {
   readyPromise;
   #markAsReady;
   constructor() {
-    const { promise, resolve } = Promise.withResolvers();
+    const { promise, resolve } = withResolvers();
     this.readyPromise = promise;
     this.#markAsReady = resolve;
   }
@@ -5340,7 +5351,8 @@ var mediaSectionState = () => {
     isCurrentByteInMediaSection,
     isByteInMediaSection,
     getCurrentMediaSection,
-    getMediaSectionAssertOnlyOne
+    getMediaSectionAssertOnlyOne,
+    mediaSections
   };
 };
 
@@ -9782,7 +9794,7 @@ var iteratorOverSegmentFiles = async ({
   const makeContinuationFn = () => {
     return {
       continue() {
-        const { promise, reject, resolve } = Promise.withResolvers();
+        const { promise, reject, resolve } = withResolvers();
         resolver = resolve;
         rejector = reject;
         childController.resume();
@@ -14079,7 +14091,7 @@ var post = (message) => {
 var controller = mediaParserController();
 var executeCallback = (payload) => {
   const nonce = crypto.randomUUID();
-  const { promise, resolve, reject } = Promise.withResolvers();
+  const { promise, resolve, reject } = withResolvers();
   const cb = (msg) => {
     const data = msg.data;
     if (data.type === "acknowledge-callback" && data.nonce === nonce) {

package/dist/esm/worker.mjs

@@ -1,3 +1,14 @@
+// src/with-resolvers.ts
+var withResolvers = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
 // src/errors.ts
 class IsAGifError extends Error {
   mimeType;
@@ -224,7 +235,7 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     throw new Error(`\`reader\` should not be provided to \`${apiName}\`. If you want to use it in the browser, use parseMediaOnWorker(). If you also want to read files from the file system, use parseMediaOnServerWorker().`);
   }
   post(worker, convertToWorkerPayload(params));
-  const { promise, resolve, reject } = Promise.withResolvers();
+  const { promise, resolve, reject } = withResolvers();
   const onAbort = () => {
     post(worker, { type: "request-abort" });
   };

package/dist/index.d.ts

@@ -944,6 +944,7 @@ export declare const MediaParserInternals: {
                 mediaSections: import("./state/video-section").MediaSection[];
             }) => import("./state/video-section").MediaSection | null;
             getMediaSectionAssertOnlyOne: () => import("./state/video-section").MediaSection;
+            mediaSections: import("./state/video-section").MediaSection[];
         };
         logLevel: "trace" | "verbose" | "info" | "warn" | "error";
         iterator: {

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMediaOnWorkerImplementation = void 0;
+const with_resolvers_1 = require("./with-resolvers");
 const serialize_error_1 = require("./worker/serialize-error");
 const convertToWorkerPayload = (
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -48,16 +49,12 @@ payload) => {
 const post = (worker, payload) => {
     worker.postMessage(payload);
 };
-const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params }, workerUrlEntry, apiName) => {
-    if (typeof Worker === 'undefined') {
-        throw new Error('"Worker" is not available. Cannot call workerClient()');
-    }
+const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params }, worker, apiName) => {
     if (reader) {
         throw new Error(`\`reader\` should not be provided to \`${apiName}\`. If you want to use it in the browser, use parseMediaOnWorker(). If you also want to read files from the file system, use parseMediaOnServerWorker().`);
     }
-    const worker = new Worker(workerUrlEntry);
     post(worker, convertToWorkerPayload(params));
-    const { promise, resolve, reject } = Promise.withResolvers();
+    const { promise, resolve, reject } = (0, with_resolvers_1.withResolvers)();
     const onAbort = () => {
         post(worker, { type: 'request-abort' });
     };

package/dist/readers/state/aac-state.d.ts

@@ -0,0 +1,13 @@
+type AacSamplePosition = {
+    offset: number;
+    index: number;
+    size: number;
+};
+export declare const aacState: () => {
+    addSample: ({ offset, size }: {
+        offset: number;
+        size: number;
+    }) => AacSamplePosition;
+    getSamples: () => AacSamplePosition[];
+};
+export {};

package/dist/readers/state/aac-state.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aacState = void 0;
+const aacState = () => {
+    const samples = [];
+    return {
+        addSample: ({ offset, size }) => {
+            if (samples.find((s) => s.offset === offset)) {
+                throw new Error('Duplicate sample');
+            }
+            samples.push({ offset, index: samples.length, size });
+            return samples[samples.length - 1];
+        },
+        getSamples: () => samples,
+    };
+};
+exports.aacState = aacState;

package/dist/readers/state/can-skip-tracks.d.ts

@@ -0,0 +1,16 @@
+import type { Options, ParseMediaFields } from '../fields';
+import type { MediaParserStructureUnstable } from '../parse-result';
+import type { StructureState } from './structure';
+export declare const needsTracksForField: ({ field, structure, }: {
+    field: keyof Options<ParseMediaFields>;
+    structure: MediaParserStructureUnstable | null;
+}) => boolean;
+export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }: {
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
+    fields: Options<ParseMediaFields>;
+    structure: StructureState;
+}) => {
+    canSkipTracks: () => boolean;
+};
+export type CanSkipTracksState = ReturnType<typeof makeCanSkipTracksState>;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCanSkipTracksState = exports.needsTracksForField = void 0;
+const needsTracksForField = ({ field, structure, }) => {
+    if (field === 'dimensions') {
+        if ((structure === null || structure === void 0 ? void 0 : structure.type) === 'riff') {
+            return false;
+        }
+        return true;
+    }
+    if (field === 'audioCodec' ||
+        field === 'durationInSeconds' ||
+        field === 'slowDurationInSeconds' ||
+        field === 'slowFps' ||
+        field === 'fps' ||
+        field === 'isHdr' ||
+        field === 'rotation' ||
+        field === 'structure' ||
+        field === 'tracks' ||
+        field === 'unrotatedDimensions' ||
+        field === 'videoCodec' ||
+        field === 'metadata' ||
+        field === 'location' ||
+        field === 'slowKeyframes' ||
+        field === 'slowNumberOfFrames' ||
+        field === 'keyframes' ||
+        field === 'images' ||
+        field === 'sampleRate' ||
+        field === 'numberOfAudioChannels' ||
+        field === 'slowAudioBitrate' ||
+        field === 'slowVideoBitrate' ||
+        field === 'm3uStreams') {
+        return true;
+    }
+    if (field === 'container' ||
+        field === 'internalStats' ||
+        field === 'mimeType' ||
+        field === 'name' ||
+        field === 'size') {
+        return false;
+    }
+    throw new Error(`field not implemeted ${field}`);
+};
+exports.needsTracksForField = needsTracksForField;
+const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }) => {
+    return {
+        canSkipTracks: () => {
+            if (hasAudioTrackHandlers || hasVideoTrackHandlers) {
+                return false;
+            }
+            const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});
+            const selectedKeys = keys.filter((k) => fields[k]);
+            return !selectedKeys.some((k) => (0, exports.needsTracksForField)({
+                field: k,
+                structure: structure.getStructureOrNull(),
+            }));
+        },
+    };
+};
+exports.makeCanSkipTracksState = makeCanSkipTracksState;

package/dist/readers/state/current-reader.d.ts

@@ -0,0 +1,6 @@
+import type { Reader } from '../readers/reader';
+export declare const currentReader: (initialReader: Reader) => {
+    getCurrent: () => Reader;
+    setCurrent: (newReader: Reader) => void;
+};
+export type CurrentReader = ReturnType<typeof currentReader>;

package/dist/readers/state/current-reader.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentReader = void 0;
+const currentReader = (initialReader) => {
+    let current = initialReader;
+    return {
+        getCurrent: () => current,
+        setCurrent: (newReader) => {
+            current = newReader;
+        },
+    };
+};
+exports.currentReader = currentReader;

package/dist/readers/state/emitted-fields.d.ts

@@ -0,0 +1 @@
+export declare const emittedState: () => AllOptions<ParseMediaFields>;