@remotion/media-parser 4.0.251 → 4.0.253

package/dist/state/parser-state.d.ts

@@ -1,7 +1,9 @@
-import type { BufferIterator } from '../buffer-iterator';
+import { type BufferIterator } from '../buffer-iterator';
 import type { AvcPPs, AvcProfileInfo } from '../containers/avc/parse-avc';
-import type { LogLevel } from '../log';
-import type { Options, ParseMediaFields } from '../options';
+import { type LogLevel } from '../log';
+import type { MediaParserController } from '../media-parser-controller';
+import type { OnDiscardedData, Options, ParseMediaFields, ParseMediaMode, ParseMediaSrc } from '../options';
+import type { ReaderInterface } from '../readers/reader';
 import type { OnAudioTrack, OnVideoTrack } from '../webcodec-sample-types';
 export type InternalStats = {
     skippedBytes: number;
@@ -11,112 +13,22 @@ export type SpsAndPps = {
     sps: AvcProfileInfo;
     pps: AvcPPs;
 };
-export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, iterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }: {
+export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
-    signal: AbortSignal | undefined;
-    iterator: BufferIterator;
+    controller: MediaParserController;
     fields: Options<ParseMediaFields>;
-    supportsContentRange: boolean;
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
-    contentLength: number | null;
+    contentLength: number;
     logLevel: LogLevel;
+    mode: ParseMediaMode;
+    src: ParseMediaSrc;
+    readerInterface: ReaderInterface;
+    onDiscardedData: OnDiscardedData | null;
 }) => {
-    riff: {
-        getAvcProfile: () => SpsAndPps | null;
-        onProfile: (profile: SpsAndPps) => Promise<void>;
-        registerOnAvcProfileCallback: (callback: (profile: SpsAndPps) => Promise<void>) => void;
-        getNextTrackIndex: () => number;
-        incrementNextTrackIndex: () => void;
-    };
-    transportStream: {
-        nextPesHeaderStore: {
-            setNextPesHeader: (pesHeader: import("../containers/transport-stream/parse-pes").PacketPes) => void;
-            getNextPesHeader: () => import("../containers/transport-stream/parse-pes").PacketPes;
-        };
-        streamBuffers: Map<number, import("../containers/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
-    };
-    webm: {
-        onTrackEntrySegment: import("../containers/webm/segments").OnTrackEntrySegment;
-        getTrackInfoByNumber: (id: number) => import("../containers/webm/segments/track-entry").TrackInfo;
-        setTimestampOffset: (byteOffset: number, timestamp: number) => void;
-        getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
-        timescale: null;
-        getTimescale: () => number;
-        setTimescale: (newTimescale: number) => void;
-        addSegment: (seg: Omit<import("./webm").SegmentSection, "index">) => void;
-        addCluster: (cluster: import("./webm").ClusterSection) => void;
-        isInsideSegment: (iterator: BufferIterator) => import("./webm").SegmentSection | null;
-        isInsideCluster: (iterator: BufferIterator) => import("./webm").ClusterSection | null;
-    };
-    iso: {
-        getShouldReturnToVideoSectionAfterEnd: () => boolean;
-        setShouldReturnToVideoSectionAfterEnd: (value: boolean) => void;
-        flatSamples: {
-            getSamples: () => import("./iso-base-media/cached-sample-positions").FlatSample[] | null;
-            setSamples: (samples: import("./iso-base-media/cached-sample-positions").FlatSample[]) => void;
-        };
-    };
-    mp3Info: {
-        getMp3Info: () => import("./mp3").Mp3Info | null;
-        setMp3Info: (info: import("./mp3").Mp3Info) => void;
-    };
-    aac: {
-        addSample: ({ offset, size }: {
-            offset: number;
-            size: number;
-        }) => {
-            offset: number;
-            index: number;
-            size: number;
-        };
-        getSamples: () => {
-            offset: number;
-            index: number;
-            size: number;
-        }[];
-    };
-    flac: {
-        setBlockingBitStrategy: (strategy: number) => void;
-        getBlockingBitStrategy: () => number | undefined;
-    };
-    callbacks: {
-        registerVideoSampleCallback: (id: number, callback: import("../webcodec-sample-types").OnVideoSample | null) => Promise<void>;
-        onAudioSample: (trackId: number, audioSample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
-        getSamplesForTrack: (trackId: number) => number;
-        onVideoSample: (trackId: number, videoSample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
-        canSkipTracksState: {
-            canSkipTracks: () => boolean;
-        };
-        registerAudioSampleCallback: (id: number, callback: import("../webcodec-sample-types").OnAudioSample | null) => Promise<void>;
-        tracks: {
-            hasAllTracks: () => boolean;
-            setIsDone: () => void;
-            addTrack: (track: import("..").Track) => void;
-            getTracks: () => import("..").Track[];
-            ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;
-        };
-        audioSampleCallbacks: Record<number, import("../webcodec-sample-types").OnAudioSample>;
-        videoSampleCallbacks: Record<number, import("../webcodec-sample-types").OnVideoSample>;
-        hasAudioTrackHandlers: boolean;
-        hasVideoTrackHandlers: boolean;
-    };
-    getInternalStats: () => InternalStats;
-    getSkipBytes: () => number;
-    increaseSkippedBytes: (bytes: number) => void;
-    keyframes: {
-        addKeyframe: (keyframe: import("../options").MediaParserKeyframe) => void;
-        getKeyframes: () => import("../options").MediaParserKeyframe[];
-    };
-    structure: {
-        getStructureOrNull: () => import("../parse-result").Structure | null;
-        getStructure: () => import("../parse-result").Structure;
-        setStructure: (value: import("../parse-result").Structure) => void;
-    };
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
-    supportsContentRange: boolean;
     emittedFields: import("../options").AllOptions<ParseMediaFields>;
     fields: Partial<import("../options").AllOptions<ParseMediaFields>>;
     slowDurationAndFps: {
@@ -128,7 +40,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         getAudioBitrate: () => number | null;
         getVideoBitrate: () => number | null;
     };
-    contentLength: number | null;
+    contentLength: number;
     images: {
         images: import("./images").MediaParserEmbeddedImage[];
         addImage: (image: import("./images").MediaParserEmbeddedImage) => void;
@@ -156,7 +68,10 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         getBits: (bits: number) => number;
         bytesRemaining: () => number;
         leb128: () => number;
-        removeBytesRead: (force: boolean) => number | undefined;
+        removeBytesRead: (force: boolean, mode: ParseMediaMode) => {
+            bytesRemoved: number;
+            removedData: Uint8Array | null;
+        };
         discard: (length: number) => void;
         getEightByteNumber: (littleEndian?: boolean) => number;
         getFourByteNumber: () => number;
@@ -203,5 +118,112 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         };
         getFlacCodecNumber: () => number;
     };
+    controller: MediaParserController;
+    mode: ParseMediaMode;
+    eventLoop: {
+        eventLoopBreakIfNeeded: () => Promise<void>;
+    };
+    src: ParseMediaSrc;
+    readerInterface: ReaderInterface;
+    discardReadBytes: (force: boolean) => Promise<void>;
+    getStructureOrNull: () => import("../parse-result").Structure | null;
+    getStructure: () => import("../parse-result").Structure;
+    setStructure: (value: import("../parse-result").Structure) => void;
+    getFlacStructure: () => import("../containers/flac/types").FlacStructure;
+    getIsoStructure: () => import("../parse-result").IsoBaseMediaStructure;
+    getMp3Structure: () => import("../parse-result").Mp3Structure;
+    getRiffStructure: () => import("../containers/riff/riff-box").RiffStructure;
+    getTsStructure: () => import("../parse-result").TransportStreamStructure;
+    getWavStructure: () => import("../containers/wav/types").WavStructure;
+    getMatroskaStructure: () => import("../parse-result").MatroskaStructure;
+    riff: {
+        getAvcProfile: () => SpsAndPps | null;
+        onProfile: (profile: SpsAndPps) => Promise<void>;
+        registerOnAvcProfileCallback: (callback: (profile: SpsAndPps) => Promise<void>) => void;
+        getNextTrackIndex: () => number;
+        incrementNextTrackIndex: () => void;
+    };
+    transportStream: {
+        nextPesHeaderStore: {
+            setNextPesHeader: (pesHeader: import("../containers/transport-stream/parse-pes").PacketPes) => void;
+            getNextPesHeader: () => import("../containers/transport-stream/parse-pes").PacketPes;
+        };
+        streamBuffers: Map<number, import("../containers/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
+    };
+    webm: {
+        onTrackEntrySegment: import("../containers/webm/segments").OnTrackEntrySegment;
+        getTrackInfoByNumber: (id: number) => import("../containers/webm/segments/track-entry").TrackInfo;
+        setTimestampOffset: (byteOffset: number, timestamp: number) => void;
+        getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+        timescale: null;
+        getTimescale: () => number;
+        setTimescale: (newTimescale: number) => void;
+        addSegment: (seg: Omit<import("./webm").SegmentSection, "index">) => void;
+        addCluster: (cluster: import("./webm").ClusterSection) => void;
+        isInsideSegment: (iterator: BufferIterator) => import("./webm").SegmentSection | null;
+        isInsideCluster: (iterator: BufferIterator) => import("./webm").ClusterSection | null;
+    };
+    iso: {
+        flatSamples: {
+            getSamples: (mdatStart: number) => import("./iso-base-media/cached-sample-positions").FlatSample[] | null;
+            setSamples: (mdatStart: number, samples: import("./iso-base-media/cached-sample-positions").FlatSample[]) => void;
+        };
+        moov: {
+            setMoovBox: (moov: import("../containers/iso-base-media/moov/moov").MoovBox) => void;
+            getMoovBox: () => import("../containers/iso-base-media/moov/moov").MoovBox | null;
+        };
+    };
+    mp3Info: {
+        getMp3Info: () => import("./mp3").Mp3Info | null;
+        setMp3Info: (info: import("./mp3").Mp3Info) => void;
+    };
+    aac: {
+        addSample: ({ offset, size }: {
+            offset: number;
+            size: number;
+        }) => {
+            offset: number;
+            index: number;
+            size: number;
+        };
+        getSamples: () => {
+            offset: number;
+            index: number;
+            size: number;
+        }[];
+    };
+    flac: {
+        setBlockingBitStrategy: (strategy: number) => void;
+        getBlockingBitStrategy: () => number | undefined;
+    };
+    callbacks: {
+        registerVideoSampleCallback: (id: number, callback: import("../webcodec-sample-types").OnVideoSample | null) => Promise<void>;
+        onAudioSample: (trackId: number, audioSample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
+        getSamplesForTrack: (trackId: number) => number;
+        onVideoSample: (trackId: number, videoSample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
+        canSkipTracksState: {
+            canSkipTracks: () => boolean;
+        };
+        registerAudioSampleCallback: (id: number, callback: import("../webcodec-sample-types").OnAudioSample | null) => Promise<void>;
+        tracks: {
+            hasAllTracks: () => boolean;
+            getIsDone: () => boolean;
+            setIsDone: (logLevel: LogLevel) => void;
+            addTrack: (track: import("..").Track) => void;
+            getTracks: () => import("..").Track[];
+            ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;
+        };
+        audioSampleCallbacks: Record<number, import("../webcodec-sample-types").OnAudioSample>;
+        videoSampleCallbacks: Record<number, import("../webcodec-sample-types").OnVideoSample>;
+        hasAudioTrackHandlers: boolean;
+        hasVideoTrackHandlers: boolean;
+    };
+    getInternalStats: () => InternalStats;
+    getSkipBytes: () => number;
+    increaseSkippedBytes: (bytes: number) => void;
+    keyframes: {
+        addKeyframe: (keyframe: import("../options").MediaParserKeyframe) => void;
+        getKeyframes: () => import("../options").MediaParserKeyframe[];
+    };
 };
 export type ParserState = ReturnType<typeof makeParserState>;

package/dist/state/parser-state.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeParserState = void 0;
+const buffer_iterator_1 = require("../buffer-iterator");
+const log_1 = require("../log");
 const aac_state_1 = require("./aac-state");
 const emitted_fields_1 = require("./emitted-fields");
 const flac_state_1 = require("./flac-state");
 const images_1 = require("./images");
 const iso_state_1 = require("./iso-base-media/iso-state");
 const keyframes_1 = require("./keyframes");
+const last_eventloop_break_1 = require("./last-eventloop-break");
 const mp3_1 = require("./mp3");
 const riff_1 = require("./riff");
 const sample_callbacks_1 = require("./sample-callbacks");
@@ -15,8 +18,9 @@ const structure_1 = require("./structure");
 const transport_stream_1 = require("./transport-stream");
 const video_section_1 = require("./video-section");
 const webm_1 = require("./webm");
-const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, iterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }) => {
+const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, }) => {
     let skippedBytes = 0;
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), contentLength);
     const increaseSkippedBytes = (bytes) => {
         skippedBytes += bytes;
     };
@@ -26,6 +30,15 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
     const slowDurationAndFps = (0, slow_duration_fps_1.slowDurationAndFpsState)();
     const mp3Info = (0, mp3_1.makeMp3State)();
     const images = (0, images_1.imagesState)();
+    const discardReadBytes = async (force) => {
+        const { bytesRemoved, removedData } = iterator.removeBytesRead(force, mode);
+        if (bytesRemoved) {
+            log_1.Log.verbose(logLevel, `Freed ${bytesRemoved} bytes`);
+        }
+        if (removedData && onDiscardedData) {
+            await onDiscardedData(removedData);
+        }
+    };
     return {
         riff: (0, riff_1.riffSpecificState)(),
         transportStream: (0, transport_stream_1.transportStreamState)(),
@@ -35,7 +48,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
         aac: (0, aac_state_1.aacState)(),
         flac: (0, flac_state_1.flacState)(),
         callbacks: (0, sample_callbacks_1.sampleCallback)({
-            signal,
+            controller,
             hasAudioTrackHandlers,
             hasVideoTrackHandlers,
             fields,
@@ -54,10 +67,9 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
         getSkipBytes: () => skippedBytes,
         increaseSkippedBytes,
         keyframes,
-        structure,
+        ...structure,
         onAudioTrack,
         onVideoTrack,
-        supportsContentRange,
         emittedFields,
         fields,
         slowDurationAndFps,
@@ -66,6 +78,12 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
         videoSection: (0, video_section_1.videoSectionState)(),
         logLevel,
         iterator,
+        controller,
+        mode,
+        eventLoop: (0, last_eventloop_break_1.eventLoopState)(logLevel),
+        src,
+        readerInterface,
+        discardReadBytes,
     };
 };
 exports.makeParserState = makeParserState;

package/dist/state/sample-callbacks.d.ts

@@ -1,10 +1,11 @@
+import type { MediaParserController } from '../media-parser-controller';
 import type { AllOptions, Options, ParseMediaFields } from '../options';
 import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
 import { type KeyframesState } from './keyframes';
 import type { SlowDurationAndFpsState } from './slow-duration-fps';
 import type { StructureState } from './structure';
-export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, }: {
-    signal: AbortSignal | undefined;
+export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, }: {
+    controller: MediaParserController;
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     fields: Options<ParseMediaFields>;
@@ -23,7 +24,8 @@ export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoT
     registerAudioSampleCallback: (id: number, callback: OnAudioSample | null) => Promise<void>;
     tracks: {
         hasAllTracks: () => boolean;
-        setIsDone: () => void;
+        getIsDone: () => boolean;
+        setIsDone: (logLevel: import("..").LogLevel) => void;
         addTrack: (track: import("..").Track) => void;
         getTracks: () => import("..").Track[];
         ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;

package/dist/state/sample-callbacks.js

@@ -4,7 +4,7 @@ exports.sampleCallback = void 0;
 const can_skip_tracks_1 = require("./can-skip-tracks");
 const has_tracks_section_1 = require("./has-tracks-section");
 const need_samples_for_fields_1 = require("./need-samples-for-fields");
-const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, }) => {
+const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, }) => {
     const videoSampleCallbacks = {};
     const audioSampleCallbacks = {};
     const queuedAudioSamples = {};
@@ -31,7 +31,7 @@ const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers,
             queuedVideoSamples[id] = [];
         },
         onAudioSample: async (trackId, audioSample) => {
-            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            if (controller._internals.signal.aborted) {
                 throw new Error('Aborted');
             }
             if (typeof samplesForTrack[trackId] === 'undefined') {
@@ -54,7 +54,7 @@ const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers,
             return (_a = samplesForTrack[trackId]) !== null && _a !== void 0 ? _a : 0;
         },
         onVideoSample: async (trackId, videoSample) => {
-            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            if (controller._internals.signal.aborted) {
                 throw new Error('Aborted');
             }
             if (typeof samplesForTrack[trackId] === 'undefined') {

package/dist/state/structure.d.ts

@@ -3,5 +3,12 @@ export declare const structureState: () => {
     getStructureOrNull: () => Structure | null;
     getStructure: () => Structure;
     setStructure: (value: Structure) => void;
+    getFlacStructure: () => import("../containers/flac/types").FlacStructure;
+    getIsoStructure: () => import("../parse-result").IsoBaseMediaStructure;
+    getMp3Structure: () => import("../parse-result").Mp3Structure;
+    getRiffStructure: () => import("../containers/riff/riff-box").RiffStructure;
+    getTsStructure: () => import("../parse-result").TransportStreamStructure;
+    getWavStructure: () => import("../containers/wav/types").WavStructure;
+    getMatroskaStructure: () => import("../parse-result").MatroskaStructure;
 };
 export type StructureState = ReturnType<typeof structureState>;

package/dist/state/structure.js

@@ -3,19 +3,69 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.structureState = void 0;
 const structureState = () => {
     let structure = null;
+    const getStructure = () => {
+        if (structure === null) {
+            throw new Error('Expected structure');
+        }
+        return structure;
+    };
     return {
         getStructureOrNull: () => {
             return structure;
         },
-        getStructure: () => {
-            if (structure === null) {
-                throw new Error('Expected structure');
-            }
-            return structure;
-        },
+        getStructure,
         setStructure: (value) => {
             structure = value;
         },
+        getFlacStructure: () => {
+            const struc = getStructure();
+            if (struc.type !== 'flac') {
+                throw new Error('Invalid structure type');
+            }
+            return struc;
+        },
+        getIsoStructure: () => {
+            const struc = getStructure();
+            if (struc.type !== 'iso-base-media') {
+                throw new Error('Invalid structure type');
+            }
+            return struc;
+        },
+        getMp3Structure: () => {
+            const struc = getStructure();
+            if (struc.type !== 'mp3') {
+                throw new Error('Invalid structure type');
+            }
+            return struc;
+        },
+        getRiffStructure: () => {
+            const struc = getStructure();
+            if (struc.type !== 'riff') {
+                throw new Error('Invalid structure type');
+            }
+            return struc;
+        },
+        getTsStructure: () => {
+            const struc = getStructure();
+            if (struc.type !== 'transport-stream') {
+                throw new Error('Invalid structure type');
+            }
+            return struc;
+        },
+        getWavStructure: () => {
+            const struc = getStructure();
+            if (struc.type !== 'wav') {
+                throw new Error('Invalid structure type');
+            }
+            return struc;
+        },
+        getMatroskaStructure: () => {
+            const struc = getStructure();
+            if (struc.type !== 'matroska') {
+                throw new Error('Invalid structure type');
+            }
+            return struc;
+        },
     };
 };
 exports.structureState = structureState;

package/dist/throttled-progress.d.ts

@@ -1,3 +1,4 @@
+import type { MediaParserController } from './media-parser-controller';
 import type { ParseMediaOnProgress, ParseMediaProgress } from './options';
 type ReturnType = {
     get: () => ParseMediaProgress;
@@ -5,10 +6,10 @@ type ReturnType = {
     stopAndGetLastProgress: () => void;
 };
 export type ParseMediaProgressFn = (state: (prevState: ParseMediaProgress) => ParseMediaProgress) => void;
-export declare const throttledStateUpdate: ({ updateFn, everyMilliseconds, signal, }: {
+export declare const throttledStateUpdate: ({ updateFn, everyMilliseconds, controller, }: {
     updateFn: ParseMediaOnProgress | null;
     everyMilliseconds: number;
-    signal: AbortSignal | undefined;
+    controller: MediaParserController;
     totalBytes: number | null;
 }) => ReturnType;
 export {};

package/dist/throttled-progress.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.throttledStateUpdate = void 0;
-const throttledStateUpdate = ({ updateFn, everyMilliseconds, signal, }) => {
+const throttledStateUpdate = ({ updateFn, everyMilliseconds, controller, }) => {
     let currentState = {
         bytes: 0,
         percentage: null,
@@ -28,7 +28,7 @@ const throttledStateUpdate = ({ updateFn, everyMilliseconds, signal, }) => {
     const onAbort = () => {
         clearInterval(interval);
     };
-    signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
+    controller._internals.signal.addEventListener('abort', onAbort, { once: true });
     return {
         get: () => currentState,
         update: (fn) => {
@@ -36,7 +36,7 @@ const throttledStateUpdate = ({ updateFn, everyMilliseconds, signal, }) => {
         },
         stopAndGetLastProgress: () => {
             clearInterval(interval);
-            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+            controller._internals.signal.removeEventListener('abort', onAbort);
             return currentState;
         },
     };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.251";
+export declare const VERSION = "4.0.253";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Automatically generated on publish
-exports.VERSION = '4.0.251';
+exports.VERSION = '4.0.253';

package/dist/writers/node.d.ts

@@ -0,0 +1,4 @@
+import type { CreateContent } from './writer';
+export declare const nodeWriter: (path: string) => {
+    createContent: CreateContent;
+};

package/dist/writers/node.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeWriter = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const log_1 = require("../log");
+const createContent = (filename) => {
+    return async ({ logLevel }) => {
+        let writPromise = Promise.resolve();
+        const remove = async () => {
+            log_1.Log.verbose(logLevel, 'Removing file', filename);
+            await node_fs_1.default.promises.unlink(filename).catch(() => { });
+        };
+        await remove();
+        if (!node_fs_1.default.existsSync(filename)) {
+            log_1.Log.verbose(logLevel, 'Creating file', filename);
+            node_fs_1.default.writeFileSync(filename, '');
+        }
+        const writeStream = node_fs_1.default.openSync(filename, 'w');
+        let written = 0;
+        const write = async (data) => {
+            await new Promise((resolve, reject) => {
+                node_fs_1.default.write(writeStream, data, 0, data.length, undefined, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    log_1.Log.verbose(logLevel, 'Wrote', data.length, 'bytes to', filename);
+                    resolve();
+                });
+            });
+            written += data.byteLength;
+        };
+        const updateDataAt = (position, data) => {
+            return new Promise((resolve, reject) => {
+                node_fs_1.default.write(writeStream, data, 0, data.length, position, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    log_1.Log.verbose(logLevel, 'Wrote', data.length, 'bytes to', filename, 'at position', position);
+                    resolve();
+                });
+            });
+        };
+        const writer = {
+            write: (arr) => {
+                writPromise = writPromise.then(() => write(arr));
+                return writPromise;
+            },
+            updateDataAt: (position, data) => {
+                writPromise = writPromise.then(() => updateDataAt(position, data));
+                return writPromise;
+            },
+            getWrittenByteCount: () => written,
+            remove,
+            finish: async () => {
+                await writPromise;
+                try {
+                    log_1.Log.verbose(logLevel, 'Closing file', filename);
+                    node_fs_1.default.closeSync(writeStream);
+                    return Promise.resolve();
+                }
+                catch (e) {
+                    return Promise.reject(e);
+                }
+            },
+            getBlob: async () => {
+                const file = await node_fs_1.default.promises.readFile(filename);
+                return new Blob([file]);
+            },
+        };
+        return writer;
+    };
+};
+const nodeWriter = (path) => {
+    return { createContent: createContent(path) };
+};
+exports.nodeWriter = nodeWriter;

package/dist/writers/writer.d.ts

@@ -0,0 +1,17 @@
+import type { LogLevel } from '../log';
+export type Writer = {
+    write: (arr: Uint8Array) => Promise<void>;
+    finish: () => Promise<void>;
+    getWrittenByteCount: () => number;
+    updateDataAt: (position: number, data: Uint8Array) => Promise<void>;
+    remove: () => Promise<void>;
+    getBlob: () => Promise<Blob>;
+};
+export type CreateContent = (options: {
+    filename: string;
+    mimeType: string;
+    logLevel: LogLevel;
+}) => Promise<Writer>;
+export type WriterInterface = {
+    createContent: CreateContent;
+};

package/dist/writers/writer.js

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