@remotion/media-parser 4.0.234 → 4.0.236

package/dist/parse-media.js

@@ -6,13 +6,17 @@ const emit_available_info_1 = require("./emit-available-info");
 const has_all_info_1 = require("./has-all-info");
 const log_1 = require("./log");
 const parse_video_1 = require("./parse-video");
-const parser_state_1 = require("./parser-state");
 const from_fetch_1 = require("./readers/from-fetch");
+const parser_state_1 = require("./state/parser-state");
 const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, logLevel = 'info', onParseProgress, ...more }) => {
+    let iterator = null;
+    let parseResult = null;
     const state = (0, parser_state_1.makeParserState)({
-        hasAudioCallbacks: onAudioTrack !== null,
-        hasVideoCallbacks: onVideoTrack !== null,
+        hasAudioTrackHandlers: Boolean(onAudioTrack),
+        hasVideoTrackHandlers: Boolean(onVideoTrack),
         signal,
+        getIterator: () => iterator,
+        fields: fields !== null && fields !== void 0 ? fields : {},
     });
     const { reader, contentLength, name, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
     let currentReader = reader;
@@ -22,18 +26,7 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
             process.env.DISABLE_CONTENT_RANGE === 'true');
     const returnValue = {};
     const moreFields = more;
-    let iterator = null;
-    let parseResult = null;
-    // TODO: Should be possible to skip if `null` is returned
-    const canSkipVideoData = !onVideoTrack && !onAudioTrack;
-    if (canSkipVideoData) {
-        log_1.Log.verbose(logLevel, 'Only parsing metadata, because no onVideoTrack and onAudioTrack callbacks were passed.');
-    }
-    else {
-        log_1.Log.verbose(logLevel, 'Parsing video data, because onVideoTrack/onAudioTrack callbacks were passed.');
-    }
     const options = {
-        canSkipVideoData,
         onAudioTrack: onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : null,
         onVideoTrack: onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : null,
         parserState: state,
@@ -43,15 +36,9 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
         supportsContentRange,
         nextTrackIndex: 0,
     };
-    const hasAllInfo = () => {
-        if (parseResult === null) {
-            return false;
-        }
-        const availableInfo = (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, parseResult, state);
-        return Object.values(availableInfo).every(Boolean);
-    };
     const triggerInfoEmit = () => {
-        const availableInfo = (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, parseResult, state);
+        var _a;
+        const availableInfo = (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, (_a = parseResult === null || parseResult === void 0 ? void 0 : parseResult.segments) !== null && _a !== void 0 ? _a : null, state);
         (0, emit_available_info_1.emitAvailableInfo)({
             hasInfo: availableInfo,
             moreFields,
@@ -108,19 +95,32 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
                 options,
                 signal: signal !== null && signal !== void 0 ? signal : null,
                 logLevel,
+                fields: fields !== null && fields !== void 0 ? fields : {},
             });
         }
-        // TODO Better: Check if no active listeners are registered
-        // Also maybe check for canSkipVideoData
-        if (hasAllInfo() && !onVideoTrack && !onAudioTrack) {
+        if (parseResult.status === 'incomplete' && parseResult.skipTo !== null) {
+            state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
+        }
+        if ((0, has_all_info_1.hasAllInfo)({
+            fields: fields !== null && fields !== void 0 ? fields : {},
+            structure: parseResult.segments,
+            state,
+        })) {
+            log_1.Log.verbose(logLevel, 'Got all info, skipping to the end.');
+            if (contentLength !== null) {
+                state.increaseSkippedBytes(contentLength - iterator.counter.getOffset());
+            }
             break;
         }
-        if (parseResult &&
-            parseResult.status === 'incomplete' &&
-            parseResult.skipTo !== null) {
+        if (parseResult.status === 'incomplete' && parseResult.skipTo !== null) {
             if (!supportsContentRange) {
                 throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
             }
+            if (parseResult.skipTo === contentLength) {
+                log_1.Log.verbose(logLevel, 'Skipped to end of file, not fetching.');
+                break;
+            }
+            log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${parseResult.skipTo}`);
             currentReader.abort();
             const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
             currentReader = newReader;
@@ -131,7 +131,9 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
     // Force assign
     (0, emit_available_info_1.emitAvailableInfo)({
         hasInfo: Object.keys(fields !== null && fields !== void 0 ? fields : {}).reduce((acc, key) => {
-            acc[key] = true;
+            if (fields === null || fields === void 0 ? void 0 : fields[key]) {
+                acc[key] = true;
+            }
             return acc;
         }, {}),
         moreFields,
@@ -143,6 +145,7 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
     });
     currentReader.abort();
     iterator === null || iterator === void 0 ? void 0 : iterator.destroy();
+    state.tracks.ensureHasTracksAtEnd();
     return returnValue;
 };
 exports.parseMedia = parseMedia;

package/dist/parse-result.d.ts

@@ -3,6 +3,8 @@ import type { EsdsBox } from './boxes/iso-base-media/esds/esds';
 import type { FtypBox } from './boxes/iso-base-media/ftyp';
 import type { MdatBox } from './boxes/iso-base-media/mdat/mdat';
 import type { MdhdBox } from './boxes/iso-base-media/mdhd';
+import type { HdlrBox } from './boxes/iso-base-media/meta/hdlr';
+import type { IlstBox } from './boxes/iso-base-media/meta/ilst';
 import type { MoovBox } from './boxes/iso-base-media/moov/moov';
 import type { MvhdBox } from './boxes/iso-base-media/mvhd';
 import type { Av1CBox } from './boxes/iso-base-media/stsd/av1c';
@@ -34,7 +36,7 @@ export interface RegularBox extends BaseBox {
     offset: number;
     type: 'regular-box';
 }
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | EsdsBox | MdatBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | ColorParameterBox | TfdtBox | TfhdBox;
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | MdatBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox;
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox | RiffBox;
 export type IsoBaseMediaStructure = {
     type: 'iso-base-media';

package/dist/parse-video.d.ts

@@ -1,5 +1,6 @@
 import type { BufferIterator } from './buffer-iterator';
 import { type LogLevel } from './log';
+import type { Options, ParseMediaFields } from './options';
 import type { IsoBaseMediaBox, ParseResult, Structure } from './parse-result';
 import type { ParserContext } from './parser-context';
 export type PartialMdatBox = {
@@ -15,9 +16,10 @@ export type BoxAndNext = {
 } | {
     type: 'incomplete';
 } | PartialMdatBox;
-export declare const parseVideo: ({ iterator, options, signal, logLevel, }: {
+export declare const parseVideo: ({ iterator, options, signal, logLevel, fields, }: {
     iterator: BufferIterator;
     options: ParserContext;
     signal: AbortSignal | null;
     logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
 }) => Promise<ParseResult<Structure>>;

package/dist/parse-video.js

@@ -5,12 +5,13 @@ const process_box_1 = require("./boxes/iso-base-media/process-box");
 const parse_box_1 = require("./boxes/riff/parse-box");
 const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
 const log_1 = require("./log");
-const parseVideo = ({ iterator, options, signal, logLevel, }) => {
+const parseVideo = ({ iterator, options, signal, logLevel, fields, }) => {
     if (iterator.bytesRemaining() === 0) {
         return Promise.reject(new Error('no bytes'));
     }
     if (iterator.isRiff()) {
-        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, options }));
+        log_1.Log.verbose(logLevel, 'Detected RIFF container');
+        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, options, fields }));
     }
     if (iterator.isIsoBaseMedia()) {
         log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
@@ -23,11 +24,12 @@ const parseVideo = ({ iterator, options, signal, logLevel, }) => {
             continueMdat: false,
             signal,
             logLevel,
+            fields,
         });
     }
     if (iterator.isWebm()) {
         log_1.Log.verbose(logLevel, 'Detected Matroska container');
-        return (0, parse_webm_header_1.parseWebm)(iterator, options);
+        return (0, parse_webm_header_1.parseWebm)({ counter: iterator, parserContext: options, fields });
     }
     if (iterator.isMp3()) {
         return Promise.reject(new Error('MP3 files are not yet supported'));

package/dist/parser-context.d.ts

@@ -1,9 +1,8 @@
-import type { ParserState } from './parser-state';
+import type { ParserState } from './state/parser-state';
 import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
 export type ParserContext = {
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
-    canSkipVideoData: boolean;
     parserState: ParserState;
     nullifySamples: boolean;
     supportsContentRange: boolean;

package/dist/register-track.d.ts

@@ -1,6 +1,6 @@
 import type { Track, VideoTrack } from './get-tracks';
 import type { ParserContext } from './parser-context';
-import type { ParserState } from './parser-state';
+import type { ParserState } from './state/parser-state';
 export declare const registerTrack: ({ state, options, track, }: {
     state: ParserState;
     options: ParserContext;

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

@@ -0,0 +1,9 @@
+import type { Options, ParseMediaFields } from '../options';
+export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, }: {
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
+    fields: Options<ParseMediaFields>;
+}) => {
+    canSkipTracks: () => boolean;
+};
+export type CanSkipTracksState = ReturnType<typeof makeCanSkipTracksState>;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCanSkipTracksState = void 0;
+const needsTracksField = {
+    audioCodec: true,
+    container: false,
+    dimensions: true,
+    durationInSeconds: true,
+    fps: true,
+    internalStats: false,
+    isHdr: true,
+    name: false,
+    rotation: true,
+    size: false,
+    structure: true,
+    tracks: true,
+    unrotatedDimensions: true,
+    videoCodec: true,
+    metadata: true,
+};
+const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, }) => {
+    return {
+        canSkipTracks: () => {
+            if (hasAudioTrackHandlers || hasVideoTrackHandlers) {
+                return false;
+            }
+            const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});
+            const selectedKeys = keys.filter((k) => fields[k]);
+            return !selectedKeys.some((k) => needsTracksField[k]);
+        },
+    };
+};
+exports.makeCanSkipTracksState = makeCanSkipTracksState;

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

@@ -0,0 +1,6 @@
+import type { CanSkipTracksState } from './can-skip-tracks';
+export declare const makeTracksSectionState: (canSkipTracksState: CanSkipTracksState) => {
+    hasAllTracks: () => boolean;
+    setIsDone: () => void;
+    ensureHasTracksAtEnd: () => void;
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTracksSectionState = void 0;
+const makeTracksSectionState = (canSkipTracksState) => {
+    let doneWithTracks = false;
+    return {
+        hasAllTracks: () => doneWithTracks,
+        setIsDone: () => {
+            doneWithTracks = true;
+        },
+        ensureHasTracksAtEnd: () => {
+            if (canSkipTracksState.canSkipTracks()) {
+                return;
+            }
+            if (!doneWithTracks) {
+                throw new Error('Error in Media Parser: End of parsing has been reached, but no tracks have been found');
+            }
+        },
+    };
+};
+exports.makeTracksSectionState = makeTracksSectionState;

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

@@ -0,0 +1,51 @@
+import type { AvcPPs, AvcProfileInfo } from '../boxes/avc/parse-avc';
+import type { OnTrackEntrySegment } from '../boxes/webm/segments';
+import type { TrackInfo } from '../boxes/webm/segments/track-entry';
+import type { BufferIterator } from '../buffer-iterator';
+import type { Options, ParseMediaFields } from '../options';
+import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
+export type InternalStats = {
+    skippedBytes: number;
+    finalCursorOffset: number;
+};
+export type SpsAndPps = {
+    sps: AvcProfileInfo;
+    pps: AvcPPs;
+};
+type AvcProfileInfoCallback = (profile: SpsAndPps) => Promise<void>;
+export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, }: {
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
+    signal: AbortSignal | undefined;
+    getIterator: () => BufferIterator | null;
+    fields: Options<ParseMediaFields>;
+}) => {
+    onTrackEntrySegment: OnTrackEntrySegment;
+    onProfile: (profile: SpsAndPps) => Promise<void>;
+    registerOnAvcProfileCallback: (callback: AvcProfileInfoCallback) => void;
+    getTrackInfoByNumber: (id: number) => TrackInfo;
+    registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
+    setTimestampOffset: (byteOffset: number, timestamp: number) => void;
+    getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+    registerAudioSampleCallback: (id: number, callback: OnAudioSample | null) => Promise<void>;
+    onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => Promise<void>;
+    onVideoSample: (trackId: number, videoSample: AudioOrVideoSample) => Promise<void>;
+    getTimescale: () => number;
+    setTimescale: (newTimescale: number) => void;
+    getSamplesForTrack: (trackId: number) => number;
+    getAvcProfile: () => SpsAndPps | null;
+    getInternalStats: () => InternalStats;
+    getSkipBytes: () => number;
+    increaseSkippedBytes: (bytes: number) => void;
+    maySkipVideoData: () => boolean;
+    tracks: {
+        hasAllTracks: () => boolean;
+        setIsDone: () => void;
+        ensureHasTracksAtEnd: () => void;
+    };
+    canSkipTracksState: {
+        canSkipTracks: () => boolean;
+    };
+};
+export type ParserState = ReturnType<typeof makeParserState>;
+export {};

package/dist/state/parser-state.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeParserState = void 0;
+const traversal_1 = require("../boxes/webm/traversal");
+const can_skip_tracks_1 = require("./can-skip-tracks");
+const has_tracks_section_1 = require("./has-tracks-section");
+const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, }) => {
+    const trackEntries = {};
+    const onTrackEntrySegment = (trackEntry) => {
+        var _a;
+        const trackId = (0, traversal_1.getTrackId)(trackEntry);
+        if (!trackId) {
+            throw new Error('Expected track id');
+        }
+        if (trackEntries[trackId]) {
+            return;
+        }
+        const codec = (0, traversal_1.getTrackCodec)(trackEntry);
+        if (!codec) {
+            throw new Error('Expected codec');
+        }
+        const trackTimescale = (0, traversal_1.getTrackTimestampScale)(trackEntry);
+        trackEntries[trackId] = {
+            codec: codec.value,
+            trackTimescale: (_a = trackTimescale === null || trackTimescale === void 0 ? void 0 : trackTimescale.value) !== null && _a !== void 0 ? _a : null,
+        };
+    };
+    const videoSampleCallbacks = {};
+    const audioSampleCallbacks = {};
+    const queuedAudioSamples = {};
+    const queuedVideoSamples = {};
+    let timescale = null;
+    let skippedBytes = 0;
+    const getTimescale = () => {
+        // https://www.matroska.org/technical/notes.html
+        // When using the default value of TimestampScale of “1,000,000”, one Segment Tick represents one millisecond.
+        if (timescale === null) {
+            return 1000000;
+        }
+        return timescale;
+    };
+    const increaseSkippedBytes = (bytes) => {
+        skippedBytes += bytes;
+    };
+    const setTimescale = (newTimescale) => {
+        timescale = newTimescale;
+    };
+    const timestampMap = new Map();
+    const setTimestampOffset = (byteOffset, timestamp) => {
+        timestampMap.set(byteOffset, timestamp);
+    };
+    const getTimestampOffsetForByteOffset = (byteOffset) => {
+        const entries = Array.from(timestampMap.entries());
+        const sortedByByteOffset = entries
+            .sort((a, b) => {
+            return a[0] - b[0];
+        })
+            .reverse();
+        for (const [offset, timestamp] of sortedByByteOffset) {
+            if (offset >= byteOffset) {
+                continue;
+            }
+            return timestamp;
+        }
+        return timestampMap.get(byteOffset);
+    };
+    const samplesForTrack = {};
+    const profileCallbacks = [];
+    const registerOnAvcProfileCallback = (callback) => {
+        profileCallbacks.push(callback);
+    };
+    let avcProfile = null;
+    const onProfile = async (profile) => {
+        avcProfile = profile;
+        for (const callback of profileCallbacks) {
+            await callback(profile);
+        }
+        profileCallbacks.length = 0;
+    };
+    const canSkipTracksState = (0, can_skip_tracks_1.makeCanSkipTracksState)({
+        hasAudioTrackHandlers,
+        fields,
+        hasVideoTrackHandlers,
+    });
+    const tracksState = (0, has_tracks_section_1.makeTracksSectionState)(canSkipTracksState);
+    return {
+        onTrackEntrySegment,
+        onProfile,
+        registerOnAvcProfileCallback,
+        getTrackInfoByNumber: (id) => trackEntries[id],
+        registerVideoSampleCallback: async (id, callback) => {
+            var _a;
+            if (callback === null) {
+                delete videoSampleCallbacks[id];
+                return;
+            }
+            videoSampleCallbacks[id] = callback;
+            for (const queued of (_a = queuedVideoSamples[id]) !== null && _a !== void 0 ? _a : []) {
+                await callback(queued);
+            }
+            queuedVideoSamples[id] = [];
+        },
+        setTimestampOffset,
+        getTimestampOffsetForByteOffset,
+        registerAudioSampleCallback: async (id, callback) => {
+            var _a;
+            if (callback === null) {
+                delete audioSampleCallbacks[id];
+                return;
+            }
+            audioSampleCallbacks[id] = callback;
+            for (const queued of (_a = queuedAudioSamples[id]) !== null && _a !== void 0 ? _a : []) {
+                await callback(queued);
+            }
+            queuedAudioSamples[id] = [];
+        },
+        onAudioSample: async (trackId, audioSample) => {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('Aborted');
+            }
+            if (typeof samplesForTrack[trackId] === 'undefined') {
+                samplesForTrack[trackId] = 0;
+            }
+            samplesForTrack[trackId]++;
+            const callback = audioSampleCallbacks[trackId];
+            if (callback) {
+                await callback(audioSample);
+            }
+        },
+        onVideoSample: async (trackId, videoSample) => {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('Aborted');
+            }
+            if (typeof samplesForTrack[trackId] === 'undefined') {
+                samplesForTrack[trackId] = 0;
+            }
+            samplesForTrack[trackId]++;
+            const callback = videoSampleCallbacks[trackId];
+            if (callback) {
+                await callback(videoSample);
+            }
+        },
+        getTimescale,
+        setTimescale,
+        getSamplesForTrack: (trackId) => {
+            var _a;
+            return (_a = samplesForTrack[trackId]) !== null && _a !== void 0 ? _a : 0;
+        },
+        getAvcProfile: () => {
+            return avcProfile;
+        },
+        getInternalStats: () => {
+            var _a, _b;
+            return ({
+                skippedBytes,
+                finalCursorOffset: (_b = (_a = getIterator()) === null || _a === void 0 ? void 0 : _a.counter.getOffset()) !== null && _b !== void 0 ? _b : 0,
+            });
+        },
+        getSkipBytes: () => skippedBytes,
+        increaseSkippedBytes,
+        maySkipVideoData: () => {
+            return (tracksState.hasAllTracks() &&
+                Object.values(videoSampleCallbacks).length === 0 &&
+                Object.values(audioSampleCallbacks).length === 0);
+        },
+        tracks: tracksState,
+        canSkipTracksState,
+    };
+};
+exports.makeParserState = makeParserState;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.234";
+export declare const VERSION = "4.0.236";

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.234';
+exports.VERSION = '4.0.236';

package/package.json

@@ -3,14 +3,14 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.234",
+  "version": "4.0.236",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.14.0",
-    "@remotion/example-videos": "4.0.234",
-    "@remotion/eslint-config-internal": "4.0.234"
+    "@remotion/example-videos": "4.0.236",
+    "@remotion/eslint-config-internal": "4.0.236"
   },
   "publishConfig": {
     "access": "public"
@@ -20,39 +20,39 @@
   },
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "require": "./dist/index.js",
       "module": "./dist/esm/index.mjs",
-      "types": "./dist/index.d.ts",
       "import": "./dist/esm/index.mjs"
     },
     "./node": {
+      "types": "./dist/readers/from-node.d.ts",
       "require": "./dist/readers/from-node.js",
       "module": "./dist/esm/from-node.mjs",
-      "types": "./dist/readers/from-node.d.ts",
       "import": "./dist/esm/from-node.mjs"
     },
     "./fetch": {
+      "types": "./dist/readers/from-fetch.d.ts",
       "require": "./dist/readers/from-fetch.js",
       "module": "./dist/esm/from-fetch.mjs",
-      "types": "./dist/readers/from-fetch.d.ts",
       "import": "./dist/esm/from-fetch.mjs"
     },
     "./web-file": {
+      "types": "./dist/readers/from-web-file.d.ts",
       "require": "./dist/readers/from-web-file.js",
       "module": "./dist/esm/from-web-file.mjs",
-      "types": "./dist/readers/from-web-file.d.ts",
       "import": "./dist/esm/from-web-file.mjs"
     },
     "./web-fs": {
+      "types": "./dist/writers/web-fs.d.ts",
       "require": "./dist/writers/web-fs.js",
       "module": "./dist/esm/web-fs.mjs",
-      "types": "./dist/writers/web-fs.d.ts",
       "import": "./dist/esm/web-fs.mjs"
     },
     "./buffer": {
+      "types": "./dist/writers/buffer.d.ts",
       "require": "./dist/writers/buffer.js",
       "module": "./dist/esm/buffer.mjs",
-      "types": "./dist/writers/buffer.d.ts",
       "import": "./dist/esm/buffer.mjs"
     },
     "./package.json": "./package.json"