@remotion/media-parser 4.0.232 → 4.0.234

package/dist/boxes/iso-base-media/esds/decoder-specific-config.d.ts

@@ -1,5 +1,4 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { LogLevel } from '../../../log';
 type UnknownDecoderSpecificConfig = {
     type: 'unknown-decoder-specific-config';
 };
@@ -11,5 +10,5 @@ type AudioSpecificConfig = {
     asBytes: Uint8Array;
 };
 export type DecoderSpecificConfig = UnknownDecoderSpecificConfig | AudioSpecificConfig;
-export declare const parseDecoderSpecificConfig: (iterator: BufferIterator, logLevel: LogLevel) => DecoderSpecificConfig;
+export declare const parseDecoderSpecificConfig: (iterator: BufferIterator) => DecoderSpecificConfig;
 export {};

package/dist/boxes/iso-base-media/esds/decoder-specific-config.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDecoderSpecificConfig = void 0;
-const log_1 = require("../../../log");
-const parseDecoderSpecificConfig = (iterator, logLevel) => {
+const parseDecoderSpecificConfig = (iterator) => {
     const layerTag = iterator.getUint8();
     const layerSize = iterator.getPaddedFourByteNumber();
     const start = iterator.counter.getOffset();
@@ -28,9 +27,6 @@ const parseDecoderSpecificConfig = (iterator, logLevel) => {
     if (read < layerSize) {
         iterator.discard(layerSize - read);
     }
-    if (bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136) {
-        log_1.Log.warn(logLevel, 'Chrome has a bug and might not be able to decode this audio. It will be fixed, see: https://issues.chromium.org/issues/360083330');
-    }
     return {
         type: 'mp4a-specific-config',
         audioObjectType,

package/dist/boxes/iso-base-media/esds/esds-descriptors.d.ts

@@ -1,5 +1,4 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { LogLevel } from '../../../log';
 import type { DecoderSpecificConfig } from './decoder-specific-config';
 type AudioObjectType = 'aac' | 'mp3' | 'unknown';
 type DecoderConfigDescriptor = {
@@ -23,9 +22,8 @@ export type Descriptor = DecoderConfigDescriptor | SlConfigDescriptor | UnknownD
 type DescriptorAndNext = {
     descriptor: Descriptor | null;
 };
-export declare const processDescriptor: ({ iterator, logLevel, }: {
+export declare const processDescriptor: ({ iterator, }: {
     iterator: BufferIterator;
-    logLevel: LogLevel;
 }) => DescriptorAndNext;
-export declare const parseDescriptors: (iterator: BufferIterator, maxBytes: number, logLevel: LogLevel) => Descriptor[];
+export declare const parseDescriptors: (iterator: BufferIterator, maxBytes: number) => Descriptor[];
 export {};

package/dist/boxes/iso-base-media/esds/esds-descriptors.js

@@ -14,7 +14,7 @@ const mapToObjectAudioIndicator = (num) => {
     }
     return 'unknown';
 };
-const processDescriptor = ({ iterator, logLevel, }) => {
+const processDescriptor = ({ iterator, }) => {
     const tag = iterator.getUint8();
     if (tag === 4) {
         const size = iterator.getPaddedFourByteNumber();
@@ -31,7 +31,7 @@ const processDescriptor = ({ iterator, logLevel, }) => {
         const avgBitrate = iterator.getUint32();
         const decoderSpecificConfigs = [];
         while (size - (iterator.counter.getOffset() - initialOffset) > 0) {
-            const decoderSpecificConfig = (0, decoder_specific_config_1.parseDecoderSpecificConfig)(iterator, logLevel);
+            const decoderSpecificConfig = (0, decoder_specific_config_1.parseDecoderSpecificConfig)(iterator);
             decoderSpecificConfigs.push(decoderSpecificConfig);
         }
         return {
@@ -62,14 +62,13 @@ const processDescriptor = ({ iterator, logLevel, }) => {
     };
 };
 exports.processDescriptor = processDescriptor;
-const parseDescriptors = (iterator, maxBytes, logLevel) => {
+const parseDescriptors = (iterator, maxBytes) => {
     const descriptors = [];
     const initialOffset = iterator.counter.getOffset();
     while (iterator.bytesRemaining() > 0 &&
         iterator.counter.getOffset() - initialOffset < maxBytes) {
         const { descriptor } = (0, exports.processDescriptor)({
             iterator,
-            logLevel,
         });
         if (descriptor) {
             descriptors.push(descriptor);

package/dist/boxes/iso-base-media/esds/esds.d.ts

@@ -1,5 +1,4 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { LogLevel } from '../../../log';
 import type { Descriptor } from './esds-descriptors';
 export interface EsdsBox {
     type: 'esds-box';
@@ -9,9 +8,8 @@ export interface EsdsBox {
     esId: number;
     descriptors: Descriptor[];
 }
-export declare const parseEsds: ({ data, size, fileOffset, logLevel, }: {
+export declare const parseEsds: ({ data, size, fileOffset, }: {
     data: BufferIterator;
     size: number;
     fileOffset: number;
-    logLevel: LogLevel;
 }) => EsdsBox;

package/dist/boxes/iso-base-media/esds/esds.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseEsds = void 0;
 const esds_descriptors_1 = require("./esds-descriptors");
-const parseEsds = ({ data, size, fileOffset, logLevel, }) => {
+const parseEsds = ({ data, size, fileOffset, }) => {
     const version = data.getUint8();
     // Flags, we discard them
     data.discard(3);
@@ -12,7 +12,7 @@ const parseEsds = ({ data, size, fileOffset, logLevel, }) => {
     // disard 1 byte, currently unknown
     data.discard(1);
     const remaining = size - (data.counter.getOffset() - fileOffset);
-    const descriptors = (0, esds_descriptors_1.parseDescriptors)(data, remaining, logLevel);
+    const descriptors = (0, esds_descriptors_1.parseDescriptors)(data, remaining);
     const remainingNow = size - (data.counter.getOffset() - fileOffset);
     data.discard(remainingNow);
     return {

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

@@ -1,11 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSamplePositionsFromTrack = void 0;
+const get_audio_codec_1 = require("../../get-audio-codec");
 const get_fps_1 = require("../../get-fps");
 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 isLpcm = (0, get_audio_codec_1.isLpcmAudioCodec)(trakBox);
+    const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
+    if (isLpcm) {
+        return (0, get_sample_positions_from_lpcm_1.getSamplePositionsFromLpcm)(trakBox);
+    }
     const stszBox = (0, traversal_1.getStszBox)(trakBox);
     const stcoBox = (0, traversal_1.getStcoBox)(trakBox);
     const stscBox = (0, traversal_1.getStscBox)(trakBox);
@@ -13,7 +20,6 @@ const getSamplePositionsFromTrack = (trakBox, moofBox) => {
     const sttsBox = (0, traversal_1.getSttsBox)(trakBox);
     const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
     const cttsBox = (0, traversal_1.getCttsBox)(trakBox);
-    const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
     if (!tkhdBox) {
         throw new Error('Expected tkhd box in trak box');
     }

package/dist/boxes/iso-base-media/process-box.js

@@ -444,7 +444,6 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             data: iterator,
             size: boxSize,
             fileOffset,
-            logLevel,
         });
         return {
             type: 'complete',

package/dist/boxes/iso-base-media/stsd/samples.js

@@ -45,6 +45,7 @@ const audioTags = [
     'MAC6 ',
     'ima4',
     'fl32',
+    'lpcm',
     'fl64',
     'in24',
     'in32',
@@ -182,16 +183,16 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
             };
         }
         if (version === 2) {
-            const numberOfChannels = iterator.getUint16();
+            iterator.getUint16(); // always 3
             const sampleSize = iterator.getUint16();
             const compressionId = iterator.getUint16();
             const packetSize = iterator.getUint16();
             iterator.getFixedPointUnsigned1616Number(); // LQ sample rate;
             iterator.getUint32(); // ignore
             const higherSampleRate = iterator.getFloat64();
-            iterator.getUint32(); // ignore;
+            const numAudioChannel = iterator.getUint32(); // ignore;
             iterator.getUint32(); // ignore, always 0x7F000000?
-            const bitsPerCodedSample = iterator.getUint32();
+            const bitsPerChannel = iterator.getUint32();
             iterator.getUint32(); // ignore;
             const bytesPerFrame = iterator.getUint32();
             const samplesPerPacket = iterator.getUint32();
@@ -219,7 +220,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                     vendor: [...Array.from(new Uint8Array(vendor))],
                     size: boxSize,
                     type: 'audio',
-                    numberOfChannels,
+                    numberOfChannels: numAudioChannel,
                     sampleSize,
                     compressionId,
                     packetSize,
@@ -227,7 +228,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                     samplesPerPacket,
                     bytesPerPacket: null,
                     bytesPerFrame,
-                    bitsPerSample: bitsPerCodedSample,
+                    bitsPerSample: bitsPerChannel,
                     children: children.segments.boxes,
                 },
             };

package/dist/create/event-emitter.d.ts

@@ -0,0 +1,31 @@
+type Input = {
+    timestamp: number;
+    keyFrame: boolean;
+};
+type Output = {
+    timestamp: number;
+};
+type Processed = {};
+type Progress = {
+    smallestProgress: number;
+};
+type IoEventMap = {
+    input: Input;
+    output: Output;
+    processed: Processed;
+    progress: Progress;
+};
+export type IoEventTypes = keyof IoEventMap;
+export type CallbackListener<T extends IoEventTypes> = (data: {
+    detail: IoEventMap[T];
+}) => void;
+type IoListeners = {
+    [EventType in IoEventTypes]: CallbackListener<EventType>[];
+};
+export declare class IoEventEmitter {
+    listeners: IoListeners;
+    addEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    removeEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    dispatchEvent<T extends IoEventTypes>(dispatchName: T, context: IoEventMap[T]): void;
+}
+export {};

package/dist/create/event-emitter.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoEventEmitter = void 0;
+class IoEventEmitter {
+    constructor() {
+        this.listeners = {
+            input: [],
+            output: [],
+            processed: [],
+            progress: [],
+        };
+    }
+    addEventListener(name, callback) {
+        this.listeners[name].push(callback);
+    }
+    removeEventListener(name, callback) {
+        this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
+    }
+    dispatchEvent(dispatchName, context) {
+        this.listeners[dispatchName].forEach((callback) => {
+            callback({ detail: context });
+        });
+    }
+}
+exports.IoEventEmitter = IoEventEmitter;

package/dist/create/iso-base-media/create-iso-base-media.d.ts

@@ -1,2 +1,2 @@
 import type { MediaFn, MediaFnGeneratorInput } from '../media-fn';
-export declare const createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, }: MediaFnGeneratorInput) => Promise<MediaFn>;
+export declare const createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, progressTracker, }: MediaFnGeneratorInput) => Promise<MediaFn>;

package/dist/create/iso-base-media/create-iso-base-media.js

@@ -6,7 +6,7 @@ const log_1 = require("../../log");
 const create_ftyp_1 = require("./create-ftyp");
 const mp4_header_1 = require("./mp4-header");
 const primitives_1 = require("./primitives");
-const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, }) => {
+const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, progressTracker, }) => {
     const header = (0, create_ftyp_1.createIsoBaseMediaFtyp)({
         compatibleBrands: ['isom', 'iso2', 'avc1', 'mp42'],
         majorBrand: 'isom',
@@ -70,6 +70,7 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
         await w.write(chunk.data);
         mdatSize += chunk.data.length;
         onBytesProgress(w.getWrittenByteCount());
+        progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
         if (codecPrivate) {
             addCodecPrivateToTrack({ trackNumber, codecPrivate });
         }
@@ -109,6 +110,7 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
     const addTrack = (track) => {
         const trackNumber = currentTracks.length + 1;
         currentTracks.push({ ...track, trackNumber });
+        progressTracker.registerTrack(trackNumber);
         return Promise.resolve({ trackNumber });
     };
     const waitForFinishPromises = [];

package/dist/create/matroska/cluster.js

@@ -15,7 +15,7 @@ const canFitInCluster = ({ clusterStartTimestamp, chunk, timescale, }) => {
     const timecodeRelativeToCluster = (0, exports.timestampToClusterTimestamp)(chunk.timestamp, timescale) -
         (0, exports.timestampToClusterTimestamp)(clusterStartTimestamp, timescale);
     if (timecodeRelativeToCluster < 0) {
-        throw new Error(`timecodeRelativeToCluster is negative`);
+        throw new Error(`timecodeRelativeToCluster is negative, tried to add ${chunk.timestamp} to ${clusterStartTimestamp}`);
     }
     return timecodeRelativeToCluster <= maxClusterTimestamp;
 };

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

@@ -1,2 +1,2 @@
 import type { MediaFn, MediaFnGeneratorInput } from '../media-fn';
-export declare const createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, }: MediaFnGeneratorInput) => Promise<MediaFn>;
+export declare const createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, progressTracker, }: MediaFnGeneratorInput) => Promise<MediaFn>;

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

@@ -13,7 +13,7 @@ const matroska_seek_1 = require("./matroska-seek");
 const matroska_segment_1 = require("./matroska-segment");
 const matroska_trackentry_1 = require("./matroska-trackentry");
 const timescale = 1000000;
-const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, }) => {
+const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, progressTracker, }) => {
     var _a, _b, _c, _d, _e, _f, _g;
     const header = (0, matroska_header_1.makeMatroskaHeader)();
     const w = await writer.createContent({ filename, mimeType: 'video/webm' });
@@ -79,17 +79,11 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
         hexString: all_segments_1.matroskaElements.Cluster,
         byte: clusterOffset - seekHeadOffset,
     });
-    const trackNumberProgresses = {};
-    const getClusterOrMakeNew = async ({ chunk, isVideo, trackNumber, }) => {
-        const trackProgressValues = Object.values(trackNumberProgresses);
-        const smallestProgress = trackProgressValues.length === 0 ? 0 : Math.min(...trackProgressValues);
+    const getClusterOrMakeNew = async ({ chunk, isVideo, }) => {
         // In Safari, samples can arrive out of order, e.g public/bigbuckbunny.mp4
         // Therefore, only updating track number progress if it is a keyframe
         // to allow for timestamps to be lower than the previous one
-        // Also doing this AFTER smallestProgress is calculated
-        if (chunk.type === 'key') {
-            trackNumberProgresses[trackNumber] = chunk.timestamp;
-        }
+        const smallestProgress = progressTracker.getSmallestProgress();
         if (!currentCluster.shouldMakeNewCluster({
             newT: smallestProgress,
             isVideo,
@@ -115,7 +109,6 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
         const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
             chunk,
             isVideo,
-            trackNumber,
         });
         const newDuration = Math.round((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
         await updateDuration(newDuration);
@@ -129,12 +122,16 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
                 trackNumber,
             });
         }
+        if (chunk.type === 'key') {
+            progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
+        }
         onBytesProgress(w.getWrittenByteCount());
         onMillisecondsProgress(newDuration);
     };
     const addTrack = async (track) => {
         currentTracks.push(track);
         const newTracks = (0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks);
+        progressTracker.registerTrack(track.trackNumber);
         await w.updateDataAt(tracksOffset, (0, make_header_1.combineUint8Arrays)(newTracks.map((b) => b.bytes)));
     };
     const operationProm = { current: Promise.resolve() };

package/dist/create/media-fn.d.ts

@@ -2,6 +2,7 @@ import type { LogLevel } from '../log';
 import type { AudioOrVideoSample } from '../webcodec-sample-types';
 import type { WriterInterface } from '../writers/writer';
 import type { MakeTrackAudio, MakeTrackVideo } from './make-track-info';
+import type { ProgressTracker } from './progress-tracker';
 export type MediaFn = {
     save: () => Promise<Blob>;
     remove: () => Promise<void>;
@@ -28,4 +29,5 @@ export type MediaFnGeneratorInput = {
     onMillisecondsProgress: (totalMilliseconds: number) => void;
     logLevel: LogLevel;
     filename: string;
+    progressTracker: ProgressTracker;
 };

package/dist/create/progress-tracker.d.ts

@@ -0,0 +1,7 @@
+export declare const makeProgressTracker: () => {
+    registerTrack: (trackNumber: number) => void;
+    getSmallestProgress: () => number;
+    updateTrackProgress: (trackNumber: number, progress: number) => void;
+    waitForProgress: () => Promise<void>;
+};
+export type ProgressTracker = ReturnType<typeof makeProgressTracker>;

package/dist/create/progress-tracker.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeProgressTracker = void 0;
+const event_emitter_1 = require("./event-emitter");
+const with_resolvers_1 = require("./with-resolvers");
+const makeProgressTracker = () => {
+    const trackNumberProgresses = {};
+    const eventEmitter = new event_emitter_1.IoEventEmitter();
+    const calculateSmallestProgress = () => {
+        const progressValues = Object.values(trackNumberProgresses);
+        if (progressValues.length === 0) {
+            return 0;
+        }
+        return Math.min(...progressValues);
+    };
+    return {
+        registerTrack: (trackNumber) => {
+            trackNumberProgresses[trackNumber] = 0;
+        },
+        getSmallestProgress: () => {
+            return calculateSmallestProgress();
+        },
+        updateTrackProgress: (trackNumber, progress) => {
+            if (trackNumberProgresses[trackNumber] === undefined) {
+                throw new Error(`Tried to update progress for a track that was not registered: ${trackNumber}`);
+            }
+            trackNumberProgresses[trackNumber] = progress;
+            eventEmitter.dispatchEvent('progress', {
+                smallestProgress: calculateSmallestProgress(),
+            });
+        },
+        waitForProgress: () => {
+            const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+            const on = () => {
+                eventEmitter.removeEventListener('processed', on);
+                resolve();
+            };
+            eventEmitter.addEventListener('processed', on);
+            return promise;
+        },
+    };
+};
+exports.makeProgressTracker = makeProgressTracker;

package/dist/create/wav/create-wav.d.ts

@@ -1,2 +1,2 @@
 import type { MediaFn, MediaFnGeneratorInput } from '../media-fn';
-export declare const createWav: ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, }: MediaFnGeneratorInput) => Promise<MediaFn>;
+export declare const createWav: ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, progressTracker, }: MediaFnGeneratorInput) => Promise<MediaFn>;

package/dist/create/wav/create-wav.js

@@ -15,7 +15,7 @@ const numberTo16BitLittleEndian = (num) => {
 };
 const BIT_DEPTH = 16;
 const BYTES_PER_SAMPLE = BIT_DEPTH / 8;
-const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, }) => {
+const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, progressTracker, }) => {
     const w = await writer.createContent({ filename, mimeType: 'audio/wav' });
     await w.write(new Uint8Array([0x52, 0x49, 0x46, 0x46])); // "RIFF"
     const sizePosition = w.getWrittenByteCount();
@@ -75,6 +75,7 @@ const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsPr
                 throw new Error('Only one track supported for WAV');
             }
             operationProm.current = operationProm.current.then(() => addSample(chunk));
+            progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
             return operationProm.current;
         },
         updateTrackSampleRate: () => {
@@ -101,6 +102,7 @@ const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsPr
                 numberOfChannels: track.numberOfChannels,
             });
             await updateBlockAlign(track.numberOfChannels);
+            progressTracker.registerTrack(1);
             return Promise.resolve({ trackNumber: 1 });
         },
     };

package/dist/create/with-resolvers.d.ts

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

package/dist/create/with-resolvers.js

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

package/dist/emit-available-info.js

@@ -6,10 +6,11 @@ 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_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
 const emitAvailableInfo = ({ hasInfo, parseResult, moreFields, state, returnValue, contentLength, name, }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     const keys = Object.keys(hasInfo);
     for (const key of keys) {
         if (key === 'structure') {
@@ -132,12 +133,20 @@ const emitAvailableInfo = ({ hasInfo, parseResult, moreFields, state, returnValu
             }
             continue;
         }
+        if (key === 'isHdr') {
+            if (returnValue.isHdr === undefined && hasInfo.isHdr && parseResult) {
+                const isHdr = (0, get_is_hdr_1.getIsHdr)(parseResult.segments, state);
+                (_o = moreFields.onIsHdr) === null || _o === void 0 ? void 0 : _o.call(moreFields, isHdr);
+                returnValue.isHdr = isHdr;
+            }
+            continue;
+        }
         if (key === 'container') {
             if (returnValue.container === undefined &&
                 hasInfo.container &&
                 parseResult) {
                 const container = (0, get_container_1.getContainer)(parseResult.segments);
-                (_o = moreFields.onContainer) === null || _o === void 0 ? void 0 : _o.call(moreFields, container);
+                (_p = moreFields.onContainer) === null || _p === void 0 ? void 0 : _p.call(moreFields, container);
                 returnValue.container = container;
             }
             continue;