@remotion/media-parser 4.0.282 → 4.0.284

package/dist/readers/state/emitted-fields.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emittedState = void 0;
+const emittedState = () => {
+    const emittedFields = {
+        audioCodec: false,
+        container: false,
+        dimensions: false,
+        durationInSeconds: false,
+        fps: false,
+        internalStats: false,
+        isHdr: false,
+        location: false,
+        metadata: false,
+        mimeType: false,
+        name: false,
+        rotation: false,
+        size: false,
+        structure: false,
+        tracks: false,
+        videoCodec: false,
+        unrotatedDimensions: false,
+        slowDurationInSeconds: false,
+        slowFps: false,
+        slowKeyframes: false,
+        slowNumberOfFrames: false,
+        keyframes: false,
+        images: false,
+        numberOfAudioChannels: false,
+        sampleRate: false,
+        slowAudioBitrate: false,
+        slowVideoBitrate: false,
+        m3uStreams: false,
+    };
+    return emittedFields;
+};
+exports.emittedState = emittedState;

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

@@ -0,0 +1,4 @@
+export declare const flacState: () => {
+    setBlockingBitStrategy: (strategy: number) => void;
+    getBlockingBitStrategy: () => number | undefined;
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flacState = void 0;
+const flacState = () => {
+    let blockingBitStrategy;
+    return {
+        setBlockingBitStrategy: (strategy) => {
+            blockingBitStrategy = strategy;
+        },
+        getBlockingBitStrategy: () => blockingBitStrategy,
+    };
+};
+exports.flacState = flacState;

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

@@ -0,0 +1,14 @@
+import type { Options, ParseMediaFields } from '../fields';
+import type { Track } from '../get-tracks';
+import type { LogLevel } 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[];
+    ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;
+};
+export type TracksState = ReturnType<typeof makeTracksSectionState>;

package/dist/readers/state/has-tracks-section.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTracksSectionState = void 0;
+const log_1 = require("../log");
+const makeTracksSectionState = (canSkipTracksState, src) => {
+    const tracks = [];
+    let doneWithTracks = false;
+    return {
+        hasAllTracks: () => doneWithTracks,
+        getIsDone: () => doneWithTracks,
+        setIsDone: (logLevel) => {
+            if (doneWithTracks) {
+                throw new Error('Error in Media Parser: Tracks have already been parsed');
+            }
+            log_1.Log.verbose(logLevel, 'All tracks have been parsed');
+            doneWithTracks = true;
+        },
+        addTrack: (track) => {
+            tracks.push(track);
+        },
+        getTracks: () => tracks,
+        ensureHasTracksAtEnd: (fields) => {
+            if (canSkipTracksState.canSkipTracks()) {
+                return;
+            }
+            if (!fields.tracks) {
+                return;
+            }
+            if (!doneWithTracks) {
+                throw new Error('Error in Media Parser: End of parsing of ' +
+                    src +
+                    ' has been reached, but no tracks have been found ');
+            }
+        },
+    };
+};
+exports.makeTracksSectionState = makeTracksSectionState;

package/dist/readers/state/images.d.ts

@@ -0,0 +1,9 @@
+export type MediaParserEmbeddedImage = {
+    description: string | null;
+    mimeType: string | null;
+    data: Uint8Array;
+};
+export declare const imagesState: () => {
+    images: MediaParserEmbeddedImage[];
+    addImage: (image: MediaParserEmbeddedImage) => void;
+};

package/dist/readers/state/images.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imagesState = void 0;
+const imagesState = () => {
+    const images = [];
+    const addImage = (image) => {
+        images.push(image);
+    };
+    return {
+        images,
+        addImage,
+    };
+};
+exports.imagesState = imagesState;

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

@@ -0,0 +1,12 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { ParserState } from '../parser-state';
+export type FlatSample = {
+    track: VideoTrack | AudioTrack | OtherTrack;
+    samplePosition: SamplePosition;
+};
+export declare const calculateFlatSamples: (state: ParserState) => any[];
+export declare const cachedSamplePositionsState: () => {
+    getSamples: (mdatStart: number) => FlatSample[] | null;
+    setSamples: (mdatStart: number, samples: FlatSample[]) => void;
+};

package/dist/readers/state/iso-base-media/cached-sample-positions.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedSamplePositionsState = exports.calculateFlatSamples = void 0;
+const get_sample_positions_from_track_1 = require("../../containers/iso-base-media/get-sample-positions-from-track");
+const traversal_1 = require("../../containers/iso-base-media/traversal");
+const get_tracks_1 = require("../../get-tracks");
+const calculateFlatSamples = (state) => {
+    const tracks = (0, get_tracks_1.getTracks)(state);
+    const allTracks = [
+        ...tracks.videoTracks,
+        ...tracks.audioTracks,
+        ...tracks.otherTracks,
+    ];
+    const flatSamples = allTracks
+        .map((track) => {
+        const { samplePositions } = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
+            trakBox: track.trakBox,
+            moofBoxes: (0, traversal_1.getMoofBoxes)(state.structure.getIsoStructure().boxes),
+            tfraBoxes: (0, traversal_1.getTfraBoxes)(state.structure.getIsoStructure()),
+        });
+        return samplePositions.map((samplePosition) => {
+            return {
+                track,
+                samplePosition,
+            };
+        });
+    })
+        .flat(1);
+    return flatSamples;
+};
+exports.calculateFlatSamples = calculateFlatSamples;
+const cachedSamplePositionsState = () => {
+    const cachedForMdatStart = {};
+    return {
+        getSamples: (mdatStart) => {
+            if (cachedForMdatStart[mdatStart]) {
+                return cachedForMdatStart[mdatStart];
+            }
+            return null;
+        },
+        setSamples: (mdatStart, samples) => {
+            cachedForMdatStart[mdatStart] = samples;
+        },
+    };
+};
+exports.cachedSamplePositionsState = cachedSamplePositionsState;

package/dist/readers/state/iso-base-media/iso-state.d.ts

@@ -0,0 +1,24 @@
+import type { MediaParserController } from '../../controller/media-parser-controller';
+import type { LogLevel } from '../../log';
+import type { ParseMediaSrc } from '../../options';
+import type { ReaderInterface } from '../../readers/reader';
+export declare const isoBaseMediaState: ({ contentLength, controller, readerInterface, src, logLevel, }: {
+    contentLength: number;
+    controller: MediaParserController;
+    readerInterface: ReaderInterface;
+    src: ParseMediaSrc;
+    logLevel: LogLevel;
+}) => {
+    flatSamples: {
+        getSamples: (mdatStart: number) => import("./cached-sample-positions").FlatSample[] | null;
+        setSamples: (mdatStart: number, samples: import("./cached-sample-positions").FlatSample[]) => void;
+    };
+    moov: {
+        setMoovBox: (moov: MediaParserController) => void;
+        getMoovBox: () => any;
+    };
+    mfra: {
+        triggerLoad: () => Promise<IsoBaseMediaBox[] | null> | null;
+    };
+};
+export type IsoBaseMediaState = ReturnType<typeof isoBaseMediaState>;

package/dist/readers/state/iso-base-media/iso-state.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isoBaseMediaState = void 0;
+const cached_sample_positions_1 = require("./cached-sample-positions");
+const lazy_mfra_load_1 = require("./lazy-mfra-load");
+const moov_box_1 = require("./moov-box");
+const isoBaseMediaState = ({ contentLength, controller, readerInterface, src, logLevel, }) => {
+    return {
+        flatSamples: (0, cached_sample_positions_1.cachedSamplePositionsState)(),
+        moov: (0, moov_box_1.moovState)(),
+        mfra: (0, lazy_mfra_load_1.lazyMfraLoad)({
+            contentLength,
+            controller,
+            readerInterface,
+            src,
+            logLevel,
+        }),
+    };
+};
+exports.isoBaseMediaState = isoBaseMediaState;

package/dist/readers/state/iso-base-media/lazy-mfra-load.d.ts

@@ -0,0 +1,13 @@
+import type { MediaParserController } from '../../controller/media-parser-controller';
+import { type LogLevel } from '../../log';
+import type { ParseMediaSrc } from '../../options';
+import type { ReaderInterface } from '../../readers/reader';
+export declare const lazyMfraLoad: ({ contentLength, controller, readerInterface, src, logLevel, }: {
+    contentLength: number;
+    controller: MediaParserController;
+    readerInterface: ReaderInterface;
+    src: ParseMediaSrc;
+    logLevel: LogLevel;
+}) => {
+    triggerLoad: () => Promise<IsoBaseMediaBox[] | null> | null;
+};

package/dist/readers/state/iso-base-media/lazy-mfra-load.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyMfraLoad = void 0;
+const get_mfra_seeking_box_1 = require("../../containers/iso-base-media/get-mfra-seeking-box");
+const log_1 = require("../../log");
+const lazyMfraLoad = ({ contentLength, controller, readerInterface, src, logLevel, }) => {
+    let prom = null;
+    const triggerLoad = () => {
+        if (prom) {
+            return prom;
+        }
+        log_1.Log.verbose(logLevel, 'Moof box found, trying to lazy load mfra');
+        prom = (0, get_mfra_seeking_box_1.getMfraSeekingBox)({
+            contentLength,
+            controller,
+            readerInterface,
+            src,
+            logLevel,
+        }).then((boxes) => {
+            log_1.Log.verbose(logLevel, 'Lazily found mfra atom.');
+            return boxes;
+        });
+        return prom;
+    };
+    return {
+        triggerLoad,
+    };
+};
+exports.lazyMfraLoad = lazyMfraLoad;

package/dist/readers/state/iso-base-media/moov-box.d.ts

@@ -0,0 +1,5 @@
+import type { MoovBox } from '../../containers/iso-base-media/moov/moov';
+export declare const moovState: () => {
+    setMoovBox: (moov: MoovBox) => void;
+    getMoovBox: () => any;
+};

package/dist/readers/state/iso-base-media/moov-box.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moovState = void 0;
+const moovState = () => {
+    let moovBox = null;
+    return {
+        setMoovBox: (moov) => {
+            moovBox = moov;
+        },
+        getMoovBox: () => moovBox,
+    };
+};
+exports.moovState = moovState;

package/dist/readers/state/keyframes.d.ts

@@ -0,0 +1,6 @@
+import type { MediaParserKeyframe } from '../options';
+export declare const keyframesState: () => {
+    addKeyframe: (keyframe: MediaParserKeyframe) => void;
+    getKeyframes: () => MediaParserKeyframe[];
+};
+export type KeyframesState = ReturnType<typeof keyframesState>;

package/dist/readers/state/keyframes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyframesState = void 0;
+const keyframesState = () => {
+    const keyframes = [];
+    return {
+        addKeyframe: (keyframe) => {
+            keyframes.push(keyframe);
+        },
+        getKeyframes: () => {
+            return keyframes;
+        },
+    };
+};
+exports.keyframesState = keyframesState;

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

@@ -0,0 +1,44 @@
+import type { M3uAssociatedPlaylist, M3uStream } from '../containers/m3u/get-streams';
+import type { LogLevel } from '../log';
+import type { IsoBaseMediaStructure } from '../parse-result';
+import type { OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
+export type M3uStreamOrInitialUrl = {
+    type: 'selected-stream';
+    stream: M3uStream;
+} | {
+    type: 'initial-url';
+    url: string;
+};
+export type ExistingM3uRun = {
+    continue: () => Promise<ExistingM3uRun | null>;
+    abort: () => void;
+};
+export declare const m3uState: (logLevel: LogLevel) => {
+    setSelectedMainPlaylist: (stream: M3uStreamOrInitialUrl) => void;
+    getSelectedMainPlaylist: () => M3uStreamOrInitialUrl | null;
+    setHasEmittedVideoTrack: (src: string, callback: OnVideoSample | null) => void;
+    hasEmittedVideoTrack: (src: string) => any;
+    setHasEmittedAudioTrack: (src: string, callback: OnAudioSample | null) => void;
+    hasEmittedAudioTrack: (src: string) => any;
+    setHasEmittedDoneWithTracks: (src: string) => void;
+    hasEmittedDoneWithTracks: (src: string) => boolean;
+    setReadyToIterateOverM3u: () => void;
+    isReadyToIterateOverM3u: () => boolean;
+    setAllChunksProcessed: (src: string) => void;
+    getAllChunksProcessedForPlaylist: (src: string) => boolean;
+    getAllChunksProcessedOverall: () => boolean;
+    setHasFinishedManifest: () => void;
+    hasFinishedManifest: () => boolean;
+    setM3uStreamRun: (playlistUrl: string, run: ExistingM3uRun | null) => void;
+    setTracksDone: (playlistUrl: string) => boolean;
+    getTrackDone: (playlistUrl: string) => boolean;
+    getM3uStreamRun: (playlistUrl: string) => ExistingM3uRun;
+    abortM3UStreamRuns: () => void;
+    setAssociatedPlaylists: (playlists: M3uAssociatedPlaylist[]) => void;
+    getAssociatedPlaylists: () => M3uAssociatedPlaylist[] | null;
+    getSelectedPlaylists: () => any[];
+    sampleSorter: any;
+    setMp4HeaderSegment: (playlistUrl: string, structure: IsoBaseMediaStructure) => void;
+    getMp4HeaderSegment: (playlistUrl: string) => IsoBaseMediaStructure;
+};
+export type M3uState = ReturnType<typeof m3uState>;

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.m3uState = void 0;
+const sample_sorter_1 = require("../containers/m3u/sample-sorter");
+const log_1 = require("../log");
+const m3uState = (logLevel) => {
+    let selectedMainPlaylist = null;
+    let associatedPlaylists = null;
+    const hasEmittedVideoTrack = {};
+    const hasEmittedAudioTrack = {};
+    const hasEmittedDoneWithTracks = {};
+    let hasFinishedManifest = false;
+    let readyToIterateOverM3u = false;
+    const allChunksProcessed = {};
+    const m3uStreamRuns = {};
+    const tracksDone = {};
+    const getMainPlaylistUrl = () => {
+        if (!selectedMainPlaylist) {
+            throw new Error('No main playlist selected');
+        }
+        const playlistUrl = selectedMainPlaylist.type === 'initial-url'
+            ? selectedMainPlaylist.url
+            : selectedMainPlaylist.stream.src;
+        return playlistUrl;
+    };
+    const getSelectedPlaylists = () => {
+        return [
+            getMainPlaylistUrl(),
+            ...(associatedPlaylists !== null && associatedPlaylists !== void 0 ? associatedPlaylists : []).map((p) => p.src),
+        ];
+    };
+    const getAllChunksProcessedForPlaylist = (src) => allChunksProcessed[src];
+    const mp4HeaderSegments = {};
+    const setMp4HeaderSegment = (playlistUrl, structure) => {
+        mp4HeaderSegments[playlistUrl] = structure;
+    };
+    const getMp4HeaderSegment = (playlistUrl) => {
+        return mp4HeaderSegments[playlistUrl];
+    };
+    return {
+        setSelectedMainPlaylist: (stream) => {
+            selectedMainPlaylist = stream;
+        },
+        getSelectedMainPlaylist: () => selectedMainPlaylist,
+        setHasEmittedVideoTrack: (src, callback) => {
+            hasEmittedVideoTrack[src] = callback;
+        },
+        hasEmittedVideoTrack: (src) => {
+            const value = hasEmittedVideoTrack[src];
+            if (value === undefined) {
+                return false;
+            }
+            return value;
+        },
+        setHasEmittedAudioTrack: (src, callback) => {
+            hasEmittedAudioTrack[src] = callback;
+        },
+        hasEmittedAudioTrack: (src) => {
+            const value = hasEmittedAudioTrack[src];
+            if (value === undefined) {
+                return false;
+            }
+            return value;
+        },
+        setHasEmittedDoneWithTracks: (src) => {
+            hasEmittedDoneWithTracks[src] = true;
+        },
+        hasEmittedDoneWithTracks: (src) => hasEmittedDoneWithTracks[src] !== undefined,
+        setReadyToIterateOverM3u: () => {
+            readyToIterateOverM3u = true;
+        },
+        isReadyToIterateOverM3u: () => readyToIterateOverM3u,
+        setAllChunksProcessed: (src) => {
+            allChunksProcessed[src] = true;
+        },
+        getAllChunksProcessedForPlaylist,
+        getAllChunksProcessedOverall: () => {
+            if (!selectedMainPlaylist) {
+                return false;
+            }
+            const selectedPlaylists = getSelectedPlaylists();
+            return selectedPlaylists.every((url) => allChunksProcessed[url]);
+        },
+        setHasFinishedManifest: () => {
+            hasFinishedManifest = true;
+        },
+        hasFinishedManifest: () => hasFinishedManifest,
+        setM3uStreamRun: (playlistUrl, run) => {
+            if (!run) {
+                delete m3uStreamRuns[playlistUrl];
+                return;
+            }
+            m3uStreamRuns[playlistUrl] = run;
+        },
+        setTracksDone: (playlistUrl) => {
+            tracksDone[playlistUrl] = true;
+            const selectedPlaylists = getSelectedPlaylists();
+            return selectedPlaylists.every((url) => tracksDone[url]);
+        },
+        getTrackDone: (playlistUrl) => {
+            return tracksDone[playlistUrl];
+        },
+        getM3uStreamRun: (playlistUrl) => { var _a; return (_a = m3uStreamRuns[playlistUrl]) !== null && _a !== void 0 ? _a : null; },
+        abortM3UStreamRuns: () => {
+            const values = Object.values(m3uStreamRuns);
+            if (values.length === 0) {
+                return;
+            }
+            log_1.Log.trace(logLevel, `Aborting ${values.length} M3U stream runs`);
+            values.forEach((run) => {
+                run.abort();
+            });
+        },
+        setAssociatedPlaylists: (playlists) => {
+            associatedPlaylists = playlists;
+        },
+        getAssociatedPlaylists: () => associatedPlaylists,
+        getSelectedPlaylists,
+        sampleSorter: (0, sample_sorter_1.sampleSorter)({ logLevel, getAllChunksProcessedForPlaylist }),
+        setMp4HeaderSegment,
+        getMp4HeaderSegment,
+    };
+};
+exports.m3uState = m3uState;

package/dist/readers/state/may-skip-video-data.d.ts

@@ -0,0 +1,4 @@
+import type { ParserState } from './parser-state';
+export declare const maySkipVideoData: ({ state }: {
+    state: ParserState;
+}) => boolean;

package/dist/readers/state/may-skip-video-data.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maySkipVideoData = void 0;
+const need_samples_for_fields_1 = require("./need-samples-for-fields");
+const maySkipVideoData = ({ state }) => {
+    const hasAllTracksAndNoCallbacks = state.callbacks.tracks.hasAllTracks() &&
+        Object.values(state.callbacks.videoSampleCallbacks).length === 0 &&
+        Object.values(state.callbacks.audioSampleCallbacks).length === 0;
+    const hasNoTrackHandlers = !state.callbacks.hasAudioTrackHandlers &&
+        !state.callbacks.hasVideoTrackHandlers;
+    const noCallbacksNeeded = hasNoTrackHandlers || hasAllTracksAndNoCallbacks;
+    return (noCallbacksNeeded &&
+        !(0, need_samples_for_fields_1.needsToIterateOverSamples)({
+            emittedFields: state.emittedFields,
+            fields: state.fields,
+        }));
+};
+exports.maySkipVideoData = maySkipVideoData;

package/dist/readers/state/mp3.d.ts

@@ -0,0 +1,15 @@
+export type Mp3Info = {
+    sampleRate: number;
+    mpegVersion: 1 | 2;
+    layer: number;
+    startOfMpegStream: number;
+};
+export type Mp3CbrInfo = {
+    bitrateKbit: number;
+};
+export declare const makeMp3State: () => {
+    getMp3Info: () => Mp3Info | null;
+    setMp3Info: (info: Mp3Info) => void;
+    getCbrMp3Info: () => Mp3CbrInfo | null;
+    setCbrMp3Info: (info: Mp3CbrInfo) => void;
+};

package/dist/readers/state/mp3.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMp3State = void 0;
+const makeMp3State = () => {
+    let mp3Info = null;
+    // cbr  = constant bit rate
+    let cbrMp3Info = null;
+    return {
+        getMp3Info: () => mp3Info,
+        setMp3Info: (info) => {
+            mp3Info = info;
+        },
+        getCbrMp3Info: () => cbrMp3Info,
+        setCbrMp3Info: (info) => {
+            cbrMp3Info = info;
+        },
+    };
+};
+exports.makeMp3State = makeMp3State;

package/dist/readers/state/need-samples-for-fields.d.ts

@@ -0,0 +1,6 @@
+import type { AllOptions, Options, ParseMediaFields } from '../fields';
+export declare const fieldsNeedSamplesMap: Record<keyof Options<ParseMediaFields>, boolean>;
+export declare const needsToIterateOverSamples: ({ fields, emittedFields, }: {
+    fields: Options<ParseMediaFields>;
+    emittedFields: AllOptions<ParseMediaFields>;
+}) => boolean;

package/dist/readers/state/need-samples-for-fields.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.needsToIterateOverSamples = exports.fieldsNeedSamplesMap = void 0;
+exports.fieldsNeedSamplesMap = {
+    slowDurationInSeconds: true,
+    slowFps: true,
+    slowKeyframes: true,
+    slowNumberOfFrames: true,
+    audioCodec: false,
+    container: false,
+    dimensions: false,
+    durationInSeconds: false,
+    fps: false,
+    internalStats: false,
+    isHdr: false,
+    name: false,
+    rotation: false,
+    size: false,
+    structure: false,
+    tracks: false,
+    unrotatedDimensions: false,
+    videoCodec: false,
+    metadata: false,
+    location: false,
+    mimeType: false,
+    keyframes: false,
+    images: false,
+    numberOfAudioChannels: false,
+    sampleRate: false,
+    slowAudioBitrate: true,
+    slowVideoBitrate: true,
+    m3uStreams: false,
+};
+const needsToIterateOverSamples = ({ fields, emittedFields, }) => {
+    const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});
+    const selectedKeys = keys.filter((k) => fields[k]);
+    return selectedKeys.some((k) => exports.fieldsNeedSamplesMap[k] && !emittedFields[k]);
+};
+exports.needsToIterateOverSamples = needsToIterateOverSamples;