@remotion/media-parser 4.0.277 → 4.0.279

package/dist/readers/from-node.js

@@ -1,12 +1,15 @@
-import { createReadStream, promises, statSync } from 'fs';
-import { dirname, join, relative, sep } from 'path';
-import { Readable } from 'stream';
-export const nodeReadContent = ({ src, range, controller }) => {
+"use strict";
+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 stream_1 = require("stream");
+const nodeReadContent = ({ src, range, controller }) => {
     if (typeof src !== 'string') {
         throw new Error('src must be a string when using `nodeReader`');
     }
     const ownController = new AbortController();
-    const stream = createReadStream(src, {
+    const stream = (0, fs_1.createReadStream)(src, {
         start: range === null ? 0 : typeof range === 'number' ? range : range[0],
         end: range === null
             ? Infinity
@@ -18,8 +21,8 @@ export const nodeReadContent = ({ src, range, controller }) => {
     controller._internals.signal.addEventListener('abort', () => {
         ownController.abort();
     }, { once: true });
-    const stats = statSync(src);
-    const reader = Readable.toWeb(stream).getReader();
+    const stats = (0, fs_1.statSync)(src);
+    const reader = stream_1.Readable.toWeb(stream).getReader();
     if (controller) {
         controller._internals.signal.addEventListener('abort', () => {
             reader.cancel().catch(() => { });
@@ -34,30 +37,33 @@ export const nodeReadContent = ({ src, range, controller }) => {
         },
         contentLength: stats.size,
         contentType: null,
-        name: src.split(sep).pop(),
+        name: src.split(path_1.sep).pop(),
         supportsContentRange: true,
         needsContentRange: true,
     });
 };
-export const nodeReadWholeAsText = (src) => {
+exports.nodeReadContent = nodeReadContent;
+const nodeReadWholeAsText = (src) => {
     if (typeof src !== 'string') {
         throw new Error('src must be a string when using `nodeReader`');
     }
-    return promises.readFile(src, 'utf8');
+    return fs_1.promises.readFile(src, 'utf8');
 };
-export const nodeCreateAdjacentFileSource = (relativePath, src) => {
+exports.nodeReadWholeAsText = nodeReadWholeAsText;
+const nodeCreateAdjacentFileSource = (relativePath, src) => {
     if (typeof src !== 'string') {
         throw new Error('src must be a string when using `nodeReader`');
     }
-    const result = join(dirname(src), relativePath);
-    const rel = relative(dirname(src), result);
+    const result = (0, path_1.join)((0, path_1.dirname)(src), relativePath);
+    const rel = (0, path_1.relative)((0, path_1.dirname)(src), result);
     if (rel.startsWith('..')) {
         throw new Error('Path is outside of the parent directory - not allowing reading of arbitrary files');
     }
     return result;
 };
-export const nodeReader = {
-    read: nodeReadContent,
-    readWholeAsText: nodeReadWholeAsText,
-    createAdjacentFileSource: nodeCreateAdjacentFileSource,
+exports.nodeCreateAdjacentFileSource = nodeCreateAdjacentFileSource;
+exports.nodeReader = {
+    read: exports.nodeReadContent,
+    readWholeAsText: exports.nodeReadWholeAsText,
+    createAdjacentFileSource: exports.nodeCreateAdjacentFileSource,
 };

package/dist/readers/from-web-file.js

@@ -1,4 +1,7 @@
-export const webFileReadContent = ({ src, range, controller }) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFileReader = exports.webFileCreateAdjacentFileSource = exports.webFileReadWholeAsText = exports.webFileReadContent = void 0;
+const webFileReadContent = ({ src, range, controller }) => {
     if (typeof src === 'string' || src instanceof URL) {
         throw new Error('`inputTypeFileReader` only supports `File` objects');
     }
@@ -44,14 +47,17 @@ export const webFileReadContent = ({ src, range, controller }) => {
         };
     });
 };
-export const webFileReadWholeAsText = () => {
+exports.webFileReadContent = webFileReadContent;
+const webFileReadWholeAsText = () => {
     throw new Error('`webFileReader` cannot read auxiliary files.');
 };
-export const webFileCreateAdjacentFileSource = () => {
+exports.webFileReadWholeAsText = webFileReadWholeAsText;
+const webFileCreateAdjacentFileSource = () => {
     throw new Error('`webFileReader` cannot create adjacent file sources.');
 };
-export const webFileReader = {
-    read: webFileReadContent,
-    readWholeAsText: webFileReadWholeAsText,
-    createAdjacentFileSource: webFileCreateAdjacentFileSource,
+exports.webFileCreateAdjacentFileSource = webFileCreateAdjacentFileSource;
+exports.webFileReader = {
+    read: exports.webFileReadContent,
+    readWholeAsText: exports.webFileReadWholeAsText,
+    createAdjacentFileSource: exports.webFileCreateAdjacentFileSource,
 };

package/dist/readers/reader.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/readers/universal.js

@@ -1,35 +1,38 @@
-import { fetchCreateAdjacentFileSource, fetchReadContent, fetchReadWholeAsText, } from './from-fetch';
-import { nodeCreateAdjacentFileSource, nodeReadContent, nodeReadWholeAsText, } from './from-node';
-import { webFileCreateAdjacentFileSource, webFileReadContent, webFileReadWholeAsText, } from './from-web-file';
-export const universalReader = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.universalReader = void 0;
+const from_fetch_1 = require("./from-fetch");
+const from_node_1 = require("./from-node");
+const from_web_file_1 = require("./from-web-file");
+exports.universalReader = {
     read: (params) => {
         if (params.src instanceof Blob) {
-            return webFileReadContent(params);
+            return (0, from_web_file_1.webFileReadContent)(params);
         }
         if (params.src.toString().startsWith('http') ||
             params.src.toString().startsWith('blob:')) {
-            return fetchReadContent(params);
+            return (0, from_fetch_1.fetchReadContent)(params);
         }
-        return nodeReadContent(params);
+        return (0, from_node_1.nodeReadContent)(params);
     },
     readWholeAsText: (src) => {
         if (src instanceof Blob) {
-            return webFileReadWholeAsText(src);
+            return (0, from_web_file_1.webFileReadWholeAsText)(src);
         }
         if (src.toString().startsWith('http') ||
             src.toString().startsWith('blob:')) {
-            return fetchReadWholeAsText(src);
+            return (0, from_fetch_1.fetchReadWholeAsText)(src);
         }
-        return nodeReadWholeAsText(src);
+        return (0, from_node_1.nodeReadWholeAsText)(src);
     },
     createAdjacentFileSource: (relativePath, src) => {
         if (src instanceof Blob) {
-            return webFileCreateAdjacentFileSource(relativePath, src);
+            return (0, from_web_file_1.webFileCreateAdjacentFileSource)(relativePath, src);
         }
         if (src.toString().startsWith('http') ||
             src.toString().startsWith('blob:')) {
-            return fetchCreateAdjacentFileSource(relativePath, src);
+            return (0, from_fetch_1.fetchCreateAdjacentFileSource)(relativePath, src);
         }
-        return nodeCreateAdjacentFileSource(relativePath, src);
+        return (0, from_node_1.nodeCreateAdjacentFileSource)(relativePath, src);
     },
 };

package/dist/readers/web.js

@@ -1,22 +1,25 @@
-import { fetchCreateAdjacentFileSource, fetchReadContent, fetchReadWholeAsText, } from './from-fetch';
-import { webFileCreateAdjacentFileSource, webFileReadContent, webFileReadWholeAsText, } from './from-web-file';
-export const webReader = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webReader = void 0;
+const from_fetch_1 = require("./from-fetch");
+const from_web_file_1 = require("./from-web-file");
+exports.webReader = {
     read: (params) => {
         if (params.src instanceof Blob) {
-            return webFileReadContent(params);
+            return (0, from_web_file_1.webFileReadContent)(params);
         }
-        return fetchReadContent(params);
+        return (0, from_fetch_1.fetchReadContent)(params);
     },
     createAdjacentFileSource: (relativePath, src) => {
         if (src instanceof Blob) {
-            return webFileCreateAdjacentFileSource(relativePath, src);
+            return (0, from_web_file_1.webFileCreateAdjacentFileSource)(relativePath, src);
         }
-        return fetchCreateAdjacentFileSource(relativePath, src);
+        return (0, from_fetch_1.fetchCreateAdjacentFileSource)(relativePath, src);
     },
     readWholeAsText: (src) => {
         if (src instanceof Blob) {
-            return webFileReadWholeAsText(src);
+            return (0, from_web_file_1.webFileReadWholeAsText)(src);
         }
-        return fetchReadWholeAsText(src);
+        return (0, from_fetch_1.fetchReadWholeAsText)(src);
     },
 };

package/dist/register-track.js

@@ -1,8 +1,12 @@
-import { addAvcProfileToTrack } from './add-avc-profile-to-track';
-import { Log } from './log';
-export const registerVideoTrack = async ({ state, track, container, }) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerVideoTrackWhenProfileIsAvailable = exports.registerAudioTrack = exports.registerVideoTrack = void 0;
+const add_avc_profile_to_track_1 = require("./add-avc-profile-to-track");
+const log_1 = require("./log");
+const work_on_seek_request_1 = require("./work-on-seek-request");
+const registerVideoTrack = async ({ state, track, container, }) => {
     if (state.callbacks.tracks.getTracks().find((t) => t.trackId === track.trackId)) {
-        Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
+        log_1.Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
         return null;
     }
     if (track.type !== 'video') {
@@ -14,11 +18,13 @@ export const registerVideoTrack = async ({ state, track, container, }) => {
     }
     const callback = await state.onVideoTrack({ track, container });
     await state.callbacks.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    await (0, work_on_seek_request_1.workOnSeekRequest)(state);
     return callback;
 };
-export const registerAudioTrack = async ({ state, track, container, }) => {
+exports.registerVideoTrack = registerVideoTrack;
+const registerAudioTrack = async ({ state, track, container, }) => {
     if (state.callbacks.tracks.getTracks().find((t) => t.trackId === track.trackId)) {
-        Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
+        log_1.Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
         return null;
     }
     if (track.type !== 'audio') {
@@ -30,14 +36,17 @@ export const registerAudioTrack = async ({ state, track, container, }) => {
     }
     const callback = await state.onAudioTrack({ track, container });
     await state.callbacks.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    await (0, work_on_seek_request_1.workOnSeekRequest)(state);
     return callback;
 };
-export const registerVideoTrackWhenProfileIsAvailable = ({ state, track, container, }) => {
+exports.registerAudioTrack = registerAudioTrack;
+const registerVideoTrackWhenProfileIsAvailable = ({ state, track, container, }) => {
     state.riff.registerOnAvcProfileCallback(async (profile) => {
-        await registerVideoTrack({
+        await (0, exports.registerVideoTrack)({
             state,
-            track: addAvcProfileToTrack(track, profile),
+            track: (0, add_avc_profile_to_track_1.addAvcProfileToTrack)(track, profile),
             container,
         });
     });
 };
+exports.registerVideoTrackWhenProfileIsAvailable = registerVideoTrackWhenProfileIsAvailable;

package/dist/remotion-license-acknowledge.js

@@ -1,6 +1,9 @@
-import { Log } from './log';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnIfRemotionLicenseNotAcknowledged = void 0;
+const log_1 = require("./log");
 let warningShown = false;
-export const warnIfRemotionLicenseNotAcknowledged = ({ acknowledgeRemotionLicense, logLevel, apiName, }) => {
+const warnIfRemotionLicenseNotAcknowledged = ({ acknowledgeRemotionLicense, logLevel, apiName, }) => {
     if (acknowledgeRemotionLicense) {
         return;
     }
@@ -8,6 +11,7 @@ export const warnIfRemotionLicenseNotAcknowledged = ({ acknowledgeRemotionLicens
         return;
     }
     warningShown = true;
-    Log.warn(logLevel, 'Note: Some companies are required to obtain a license to use @remotion/media-parser. See: https://remotion.dev/license');
-    Log.warn(logLevel, `Pass \`acknowledgeRemotionLicense: true\` to \`${apiName}\` function to make this message disappear.`);
+    log_1.Log.warn(logLevel, 'Note: Some companies are required to obtain a license to use @remotion/media-parser. See: https://remotion.dev/license');
+    log_1.Log.warn(logLevel, `Pass \`acknowledgeRemotionLicense: true\` to \`${apiName}\` function to make this message disappear.`);
 };
+exports.warnIfRemotionLicenseNotAcknowledged = warnIfRemotionLicenseNotAcknowledged;

package/dist/run-parse-iteration.d.ts

@@ -1,8 +1,5 @@
 import type { ParseResult } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const runParseIteration: ({ state, mimeType, contentLength, name, }: {
+export declare const runParseIteration: ({ state, }: {
     state: ParserState;
-    mimeType: string | null;
-    contentLength: number;
-    name: string | null;
 }) => Promise<ParseResult>;

package/dist/run-parse-iteration.js

@@ -1,54 +1,55 @@
-import { parseAac } from './containers/aac/parse-aac';
-import { parseFlac } from './containers/flac/parse-flac';
-import { parseIsoBaseMedia } from './containers/iso-base-media/parse-boxes';
-import { parseM3u } from './containers/m3u/parse-m3u';
-import { parseMp3 } from './containers/mp3/parse-mp3';
-import { parseRiff } from './containers/riff/parse-riff';
-import { parseTransportStream } from './containers/transport-stream/parse-transport-stream';
-import { parseWav } from './containers/wav/parse-wav';
-import { parseWebm } from './containers/webm/parse-webm-header';
-import { initVideo } from './init-video';
-export const runParseIteration = async ({ state, mimeType, contentLength, name, }) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runParseIteration = void 0;
+const parse_aac_1 = require("./containers/aac/parse-aac");
+const parse_flac_1 = require("./containers/flac/parse-flac");
+const parse_boxes_1 = require("./containers/iso-base-media/parse-boxes");
+const parse_m3u_1 = require("./containers/m3u/parse-m3u");
+const parse_mp3_1 = require("./containers/mp3/parse-mp3");
+const parse_riff_1 = require("./containers/riff/parse-riff");
+const parse_transport_stream_1 = require("./containers/transport-stream/parse-transport-stream");
+const parse_wav_1 = require("./containers/wav/parse-wav");
+const parse_webm_header_1 = require("./containers/webm/parse-webm-header");
+const init_video_1 = require("./init-video");
+const runParseIteration = async ({ state, }) => {
     const structure = state.getStructureOrNull();
     // m3u8 is busy parsing the chunks once the manifest has been read
     if (structure && structure.type === 'm3u') {
-        return parseM3u({ state });
+        return (0, parse_m3u_1.parseM3u)({ state });
     }
     if (state.iterator.bytesRemaining() === 0) {
         return Promise.reject(new Error('no bytes'));
     }
     if (structure === null) {
-        await initVideo({
+        await (0, init_video_1.initVideo)({
             state,
-            mimeType,
-            name,
-            contentLength,
         });
         return null;
     }
     if (structure.type === 'riff') {
-        return parseRiff(state);
+        return (0, parse_riff_1.parseRiff)(state);
     }
     if (structure.type === 'mp3') {
-        return parseMp3(state);
+        return (0, parse_mp3_1.parseMp3)(state);
     }
     if (structure.type === 'iso-base-media') {
-        return parseIsoBaseMedia(state);
+        return (0, parse_boxes_1.parseIsoBaseMedia)(state);
     }
     if (structure.type === 'matroska') {
-        return parseWebm(state);
+        return (0, parse_webm_header_1.parseWebm)(state);
     }
     if (structure.type === 'transport-stream') {
-        return parseTransportStream(state);
+        return (0, parse_transport_stream_1.parseTransportStream)(state);
     }
     if (structure.type === 'wav') {
-        return parseWav(state);
+        return (0, parse_wav_1.parseWav)(state);
     }
     if (structure.type === 'aac') {
-        return parseAac(state);
+        return (0, parse_aac_1.parseAac)(state);
     }
     if (structure.type === 'flac') {
-        return parseFlac({ state, iterator: state.iterator });
+        return (0, parse_flac_1.parseFlac)({ state, iterator: state.iterator });
     }
     return Promise.reject(new Error('Unknown video format ' + structure));
 };
+exports.runParseIteration = runParseIteration;

package/dist/samples-from-moof.js

@@ -1,15 +1,18 @@
-import { getTfdtBox, getTfhdBox, getTrunBoxes, } from './containers/iso-base-media/traversal';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamplesFromMoof = void 0;
+const traversal_1 = require("./containers/iso-base-media/traversal");
 const getSamplesFromTraf = (trafSegment, moofOffset) => {
     var _a, _b, _c, _d, _e, _f, _g;
     if (trafSegment.type !== 'regular-box' || trafSegment.boxType !== 'traf') {
         throw new Error('Expected traf-box');
     }
-    const tfhdBox = getTfhdBox(trafSegment);
+    const tfhdBox = (0, traversal_1.getTfhdBox)(trafSegment);
     const defaultSampleDuration = (_a = tfhdBox === null || tfhdBox === void 0 ? void 0 : tfhdBox.defaultSampleDuration) !== null && _a !== void 0 ? _a : null;
     const defaultSampleSize = (_b = tfhdBox === null || tfhdBox === void 0 ? void 0 : tfhdBox.defaultSampleSize) !== null && _b !== void 0 ? _b : null;
     const defaultSampleFlags = (_c = tfhdBox === null || tfhdBox === void 0 ? void 0 : tfhdBox.defaultSampleFlags) !== null && _c !== void 0 ? _c : null;
-    const tfdtBox = getTfdtBox(trafSegment);
-    const trunBoxes = getTrunBoxes(trafSegment);
+    const tfdtBox = (0, traversal_1.getTfdtBox)(trafSegment);
+    const trunBoxes = (0, traversal_1.getTrunBoxes)(trafSegment);
     let time = 0;
     let offset = 0;
     let dataOffset = 0;
@@ -57,16 +60,17 @@ const getSamplesFromTraf = (trafSegment, moofOffset) => {
     }
     return samples;
 };
-export const getSamplesFromMoof = ({ moofBox, trackId, }) => {
+const getSamplesFromMoof = ({ moofBox, trackId, }) => {
     if (moofBox.type !== 'regular-box') {
         throw new Error('Expected moof-box');
     }
     const trafs = moofBox.children.filter((c) => c.type === 'regular-box' && c.boxType === 'traf');
     const mapped = trafs.map((traf) => {
-        const tfhdBox = getTfhdBox(traf);
+        const tfhdBox = (0, traversal_1.getTfhdBox)(traf);
         return (tfhdBox === null || tfhdBox === void 0 ? void 0 : tfhdBox.trackId) === trackId
             ? getSamplesFromTraf(traf, moofBox.offset)
             : [];
     });
     return mapped.flat(1);
 };
+exports.getSamplesFromMoof = getSamplesFromMoof;

package/dist/seek-backwards.d.ts

@@ -0,0 +1,2 @@
+import type { ParserState } from './state/parser-state';
+export declare const seekBackwards: (state: ParserState, seekTo: number) => Promise<void>;

package/dist/seek-backwards.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seekBackwards = void 0;
+const log_1 = require("./log");
+const seekBackwards = async (state, seekTo) => {
+    const { iterator } = state;
+    // (a) data has not been discarded yet
+    const howManyBytesNotYetDiscarded = iterator.counter.getDiscardedOffset();
+    const howManyBytesWeCanGoBack = iterator.counter.getOffset() - howManyBytesNotYetDiscarded;
+    if (iterator.counter.getOffset() - howManyBytesWeCanGoBack <= seekTo) {
+        iterator.skipTo(seekTo);
+        return;
+    }
+    // (b) data has been discarded, making new reader
+    const time = Date.now();
+    log_1.Log.verbose(state.logLevel, `Seeking in video from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
+    const { reader: newReader } = await state.readerInterface.read({
+        src: state.src,
+        range: seekTo,
+        controller: state.controller,
+    });
+    iterator.replaceData(new Uint8Array([]), seekTo);
+    log_1.Log.verbose(state.logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
+    state.currentReader = newReader;
+};
+exports.seekBackwards = seekBackwards;

package/dist/seek-forwards.d.ts

@@ -0,0 +1,2 @@
+import type { ParserState } from './state/parser-state';
+export declare const seekForward: (state: ParserState, seekTo: number) => Promise<import("./readers/reader").Reader | undefined>;

package/dist/seek-forwards.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seekForward = void 0;
+const log_1 = require("./log");
+const seekForward = async (state, seekTo) => {
+    const { iterator } = state;
+    const alreadyHasBuffer = iterator.bytesRemaining() >= seekTo - iterator.counter.getOffset();
+    log_1.Log.verbose(state.logLevel, `Performing seek from ${iterator.counter.getOffset()} to ${seekTo}`);
+    // (a) starting byte has already been fetched
+    if (alreadyHasBuffer) {
+        iterator.skipTo(seekTo);
+        log_1.Log.verbose(state.logLevel, `Already read ahead enough, skipping forward`);
+        return state.currentReader;
+    }
+    // (b) starting byte has not been fetched yet, making new reader
+    const time = Date.now();
+    log_1.Log.verbose(state.logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
+    const { reader: newReader } = await state.readerInterface.read({
+        src: state.src,
+        range: seekTo,
+        controller: state.controller,
+    });
+    iterator.skipTo(seekTo);
+    await state.discardReadBytes(true);
+    log_1.Log.verbose(state.logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
+    state.currentReader = newReader;
+};
+exports.seekForward = seekForward;

package/dist/seek-signal.d.ts

@@ -0,0 +1,22 @@
+export type SeekSignal = {
+    seek: (seek: Seek) => void;
+    getSeek: () => Seek | undefined;
+    clearSeekIfStillSame: (previousSeek: Seek) => {
+        hasChanged: boolean;
+    };
+};
+type SeekToTime = {
+    type: 'keyframe-before-time-in-seconds';
+    time: number;
+};
+type SeekToByte = {
+    type: 'byte';
+    byte: number;
+};
+type ForceSeekToByte = {
+    type: 'force-seek-to-byte';
+    byte: number;
+};
+export type Seek = SeekToTime | SeekToByte | ForceSeekToByte;
+export declare const makeSeekSignal: () => SeekSignal;
+export {};

package/dist/seek-signal.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSeekSignal = void 0;
+const makeSeekSignal = () => {
+    let seek;
+    return {
+        seek: (time) => {
+            if (seek) {
+                throw new Error('Seek already requested, must wait');
+            }
+            seek = time;
+        },
+        getSeek() {
+            return seek;
+        },
+        // In the meanwhile a new seek could have been queued
+        clearSeekIfStillSame(previousSeek) {
+            if (seek === previousSeek) {
+                seek = undefined;
+                return { hasChanged: false };
+            }
+            return { hasChanged: true };
+        },
+    };
+};
+exports.makeSeekSignal = makeSeekSignal;

package/dist/seeking-info.d.ts

@@ -0,0 +1,8 @@
+import type { IsoBaseMediaBox } from './containers/iso-base-media/base-media-box';
+import type { MoovBox } from './containers/iso-base-media/moov/moov';
+export type IsoBaseMediaSeekingInfo = {
+    type: 'iso-base-media-seeking-info';
+    moovBox: MoovBox;
+    moofBoxes: IsoBaseMediaBox[];
+};
+export type SeekingInfo = IsoBaseMediaSeekingInfo;

package/dist/seeking-info.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/skip.js

@@ -1,4 +1,8 @@
-export const makeSkip = (skipTo) => ({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSkip = void 0;
+const makeSkip = (skipTo) => ({
     action: 'skip',
     skipTo,
 });
+exports.makeSkip = makeSkip;

package/dist/state/aac-state.js

@@ -1,4 +1,7 @@
-export const aacState = () => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aacState = void 0;
+const aacState = () => {
     const samples = [];
     return {
         addSample: ({ offset, size }) => {
@@ -11,3 +14,4 @@ export const aacState = () => {
         getSamples: () => samples,
     };
 };
+exports.aacState = aacState;

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

@@ -1,9 +1,9 @@
-import type { Options, ParseMediaFields } from '../options';
+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;
+    structure: MediaParserStructureUnstable | null;
 }) => boolean;
 export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }: {
     hasAudioTrackHandlers: boolean;

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

@@ -1,6 +1,9 @@
-export const needsTracksForField = ({ field, structure, }) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCanSkipTracksState = exports.needsTracksForField = void 0;
+const needsTracksForField = ({ field, structure, }) => {
     if (field === 'dimensions') {
-        if (structure.type === 'riff') {
+        if ((structure === null || structure === void 0 ? void 0 : structure.type) === 'riff') {
             return false;
         }
         return true;
@@ -38,7 +41,8 @@ export const needsTracksForField = ({ field, structure, }) => {
     }
     throw new Error(`field not implemeted ${field}`);
 };
-export const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }) => {
+exports.needsTracksForField = needsTracksForField;
+const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }) => {
     return {
         canSkipTracks: () => {
             if (hasAudioTrackHandlers || hasVideoTrackHandlers) {
@@ -46,7 +50,11 @@ export const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideo
             }
             const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});
             const selectedKeys = keys.filter((k) => fields[k]);
-            return !selectedKeys.some((k) => needsTracksForField({ field: k, structure: structure.getStructure() }));
+            return !selectedKeys.some((k) => (0, exports.needsTracksForField)({
+                field: k,
+                structure: structure.getStructureOrNull(),
+            }));
         },
     };
 };
+exports.makeCanSkipTracksState = makeCanSkipTracksState;

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

@@ -1,2 +1,2 @@
-import type { AllOptions, ParseMediaFields } from '../options';
+import type { AllOptions, ParseMediaFields } from '../fields';
 export declare const emittedState: () => AllOptions<ParseMediaFields>;

package/dist/state/emitted-fields.js

@@ -1,4 +1,7 @@
-export const emittedState = () => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emittedState = void 0;
+const emittedState = () => {
     const emittedFields = {
         audioCodec: false,
         container: false,
@@ -31,3 +34,4 @@ export const emittedState = () => {
     };
     return emittedFields;
 };
+exports.emittedState = emittedState;