@remotion/media-parser 4.0.194 → 4.0.196

package/dist/boxes/webm/segments.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectSegment = void 0;
+const add_new_matroska_tracks_1 = require("../../add-new-matroska-tracks");
+const get_track_1 = require("./get-track");
+const all_segments_1 = require("./segments/all-segments");
 const duration_1 = require("./segments/duration");
 const info_1 = require("./segments/info");
-const main_1 = require("./segments/main");
 const muxing_1 = require("./segments/muxing");
+const parse_children_1 = require("./segments/parse-children");
 const seek_1 = require("./segments/seek");
 const seek_head_1 = require("./segments/seek-head");
 const seek_position_1 = require("./segments/seek-position");
@@ -14,111 +17,244 @@ const tracks_1 = require("./segments/tracks");
 const unknown_1 = require("./segments/unknown");
 const void_1 = require("./segments/void");
 const writing_1 = require("./segments/writing");
-const expectSegment = (iterator) => {
-    const segmentId = iterator.getMatroskaSegmentId();
+const parseSegment = async ({ segmentId, iterator, length, parserContext, }) => {
+    if (length === 0) {
+        throw new Error(`Expected length of ${segmentId} to be greater than 0`);
+    }
     if (segmentId === '0x') {
         return {
             type: 'unknown-segment',
             id: segmentId,
         };
     }
-    if (segmentId === '0x18538067') {
-        return (0, main_1.parseMainSegment)(iterator);
-    }
+    // Log this to debug
+    /*
+    console.log(
+        'segmentId',
+        segmentId,
+        getSegmentName(segmentId),
+        iterator.counter.getOffset(),
+    );
+    */
     if (segmentId === '0x114d9b74') {
-        return (0, seek_head_1.parseSeekHeadSegment)(iterator);
+        return (0, seek_head_1.parseSeekHeadSegment)(iterator, length, parserContext);
+    }
+    if (segmentId === '0x53ab') {
+        return (0, seek_1.parseSeekIdSegment)(iterator);
     }
     if (segmentId === '0x4dbb') {
-        return (0, seek_1.parseSeekSegment)(iterator);
+        return (0, seek_1.parseSeekSegment)(iterator, length, parserContext);
     }
     if (segmentId === '0x53ac') {
-        return (0, seek_position_1.parseSeekPositionSegment)(iterator);
+        return (0, seek_position_1.parseSeekPositionSegment)(iterator, length);
     }
     if (segmentId === '0xec') {
-        return (0, void_1.parseVoidSegment)(iterator);
+        return (0, void_1.parseVoidSegment)(iterator, length);
     }
     if (segmentId === '0x1549a966') {
-        return (0, info_1.parseInfoSegment)(iterator);
+        return (0, info_1.parseInfoSegment)(iterator, length, parserContext);
     }
-    if (segmentId === '0x2ad7b183') {
-        return (0, timestamp_scale_1.parseTimestampScaleSegment)(iterator);
+    if (segmentId === all_segments_1.matroskaElements.TimestampScale) {
+        const timestampScale = (0, timestamp_scale_1.parseTimestampScaleSegment)(iterator);
+        parserContext.parserState.setTimescale(timestampScale.timestampScale);
+        return timestampScale;
     }
     if (segmentId === '0x4d80') {
-        return (0, muxing_1.parseMuxingSegment)(iterator);
+        return (0, muxing_1.parseMuxingSegment)(iterator, length);
     }
     if (segmentId === '0x5741') {
-        return (0, writing_1.parseWritingSegment)(iterator);
+        return (0, writing_1.parseWritingSegment)(iterator, length);
     }
     if (segmentId === '0x4489') {
-        return (0, duration_1.parseDurationSegment)(iterator);
+        return (0, duration_1.parseDurationSegment)(iterator, length);
     }
     if (segmentId === '0x1654ae6b') {
-        return (0, tracks_1.parseTracksSegment)(iterator);
-    }
-    if (segmentId === '0xae') {
-        return (0, track_entry_1.parseTrackEntry)(iterator);
+        return (0, tracks_1.parseTracksSegment)(iterator, length, parserContext);
+    }
+    if (segmentId === all_segments_1.matroskaElements.TrackEntry) {
+        const trackEntry = await (0, track_entry_1.parseTrackEntry)(iterator, length, parserContext);
+        parserContext.parserState.onTrackEntrySegment(trackEntry);
+        const track = (0, get_track_1.getTrack)({
+            track: trackEntry,
+            timescale: parserContext.parserState.getTimescale(),
+        });
+        if (track) {
+            await (0, add_new_matroska_tracks_1.registerTrack)({
+                state: parserContext.parserState,
+                options: parserContext,
+                track,
+            });
+        }
+        return trackEntry;
     }
     if (segmentId === '0xd7') {
-        return (0, track_entry_1.parseTrackNumber)(iterator);
+        return (0, track_entry_1.parseTrackNumber)(iterator, length);
     }
     if (segmentId === '0x73c5') {
-        return (0, track_entry_1.parseTrackUID)(iterator);
+        return (0, track_entry_1.parseTrackUID)(iterator, length);
     }
     if (segmentId === '0x9c') {
-        return (0, track_entry_1.parseFlagLacing)(iterator);
+        return (0, track_entry_1.parseFlagLacing)(iterator, length);
     }
     if (segmentId === '0x22b59c') {
-        return (0, track_entry_1.parseLanguageSegment)(iterator);
+        return (0, track_entry_1.parseLanguageSegment)(iterator, length);
     }
     if (segmentId === '0x86') {
-        return (0, track_entry_1.parseCodecSegment)(iterator);
+        return (0, track_entry_1.parseCodecSegment)(iterator, length);
     }
     if (segmentId === '0x83') {
-        return (0, track_entry_1.parseTrackTypeSegment)(iterator);
+        return (0, track_entry_1.parseTrackTypeSegment)(iterator, length);
     }
     if (segmentId === '0x55ee') {
-        return (0, track_entry_1.parseMaxBlockAdditionId)(iterator);
+        return (0, track_entry_1.parseMaxBlockAdditionId)(iterator, length);
     }
     if (segmentId === '0x55b0') {
-        return (0, track_entry_1.parseColorSegment)(iterator);
+        return (0, track_entry_1.parseColorSegment)(iterator, length);
     }
     if (segmentId === '0x23e383') {
-        return (0, track_entry_1.parseDefaultDurationSegment)(iterator);
+        return (0, track_entry_1.parseDefaultDurationSegment)(iterator, length);
     }
     if (segmentId === '0xe0') {
-        return (0, track_entry_1.parseVideoSegment)(iterator);
+        return (0, track_entry_1.parseVideoSegment)(iterator, length, parserContext);
+    }
+    if (segmentId === '0xe1') {
+        return (0, track_entry_1.parseAudioSegment)(iterator, length, parserContext);
     }
     if (segmentId === '0xb0') {
-        return (0, track_entry_1.parseWidthSegment)(iterator);
+        return (0, track_entry_1.parseWidthSegment)(iterator, length);
     }
     if (segmentId === '0xba') {
-        return (0, track_entry_1.parseHeightSegment)(iterator);
+        return (0, track_entry_1.parseHeightSegment)(iterator, length);
+    }
+    if (segmentId === all_segments_1.matroskaElements.DisplayWidth) {
+        return (0, track_entry_1.parseDisplayWidthSegment)(iterator, length);
+    }
+    if (segmentId === all_segments_1.matroskaElements.DisplayHeight) {
+        return (0, track_entry_1.parseDisplayHeightSegment)(iterator, length);
     }
     if (segmentId === '0x9a') {
-        return (0, track_entry_1.parseInterlacedSegment)(iterator);
+        return (0, track_entry_1.parseInterlacedSegment)(iterator, length);
     }
     if (segmentId === '0x53c0') {
-        return (0, track_entry_1.parseAlphaModeSegment)(iterator);
+        return (0, track_entry_1.parseAlphaModeSegment)(iterator, length);
     }
     if (segmentId === '0x63a2') {
-        return (0, track_entry_1.parseCodecPrivateSegment)(iterator);
+        return (0, track_entry_1.parseCodecPrivateSegment)(iterator, length);
     }
     if (segmentId === '0x7ba9') {
-        return (0, track_entry_1.parseTitleSegment)(iterator);
+        return (0, track_entry_1.parseTitleSegment)(iterator, length);
     }
     if (segmentId === '0xbf') {
-        return (0, track_entry_1.parseCrc32Segment)(iterator);
+        return (0, track_entry_1.parseCrc32Segment)(iterator, length);
     }
     if (segmentId === '0x73a4') {
-        return (0, track_entry_1.parseSegmentUUIDSegment)(iterator);
+        return (0, track_entry_1.parseSegmentUUIDSegment)(iterator, length);
     }
     if (segmentId === '0x88') {
-        return (0, track_entry_1.parseDefaultFlagSegment)(iterator);
+        return (0, track_entry_1.parseDefaultFlagSegment)(iterator, length);
+    }
+    if (segmentId === '0x1254c367') {
+        return (0, track_entry_1.parseTagsSegment)(iterator, length, parserContext);
+    }
+    if (segmentId === '0x7373') {
+        return (0, track_entry_1.parseTagSegment)(iterator, length);
+    }
+    if (segmentId === all_segments_1.matroskaElements.SamplingFrequency) {
+        return (0, track_entry_1.parseSamplingFrequencySegment)(iterator, length);
+    }
+    if (segmentId === all_segments_1.matroskaElements.Channels) {
+        return (0, track_entry_1.parseChannelsSegment)(iterator, length);
+    }
+    if (segmentId === all_segments_1.matroskaElements.BitDepth) {
+        return (0, track_entry_1.parseBitDepthSegment)(iterator, length);
+    }
+    if (segmentId === '0xe7') {
+        return (0, track_entry_1.parseTimestampSegment)(iterator, length);
+    }
+    if (segmentId === '0xa3') {
+        return (0, track_entry_1.parseSimpleBlockSegment)({
+            iterator,
+            length,
+            parserContext,
+        });
+    }
+    if (segmentId === '0xa0') {
+        return (0, track_entry_1.parseBlockGroupSegment)(iterator, length, parserContext);
+    }
+    if (segmentId === '0xa1') {
+        return (0, track_entry_1.parseBlockElementSegment)(iterator, length);
     }
-    const length = iterator.getVint();
     const bytesRemaining = iterator.byteLength() - iterator.counter.getOffset();
     const toDiscard = Math.min(bytesRemaining, length > 0 ? length : bytesRemaining);
     const child = (0, unknown_1.parseUnknownSegment)(iterator, segmentId, toDiscard);
     return child;
 };
+const expectSegment = async (iterator, parserContext) => {
+    const bytesRemaining_ = iterator.bytesRemaining();
+    if (bytesRemaining_ === 0) {
+        return {
+            status: 'incomplete',
+            segments: [],
+            continueParsing: () => {
+                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+            },
+            skipTo: null,
+        };
+    }
+    const offset = iterator.counter.getOffset();
+    const segmentId = iterator.getMatroskaSegmentId();
+    const length = iterator.getVint();
+    const bytesRemainingNow = iterator.byteLength() - iterator.counter.getOffset();
+    if (segmentId === '0x18538067' || segmentId === '0x1f43b675') {
+        const main = await (0, parse_children_1.expectChildren)({
+            iterator,
+            length,
+            initialChildren: [],
+            wrap: segmentId === '0x18538067'
+                ? (s) => ({
+                    type: 'main-segment',
+                    children: s,
+                })
+                : (s) => ({
+                    type: 'cluster-segment',
+                    children: s,
+                }),
+            parserContext,
+        });
+        if (main.status === 'incomplete') {
+            return {
+                status: 'incomplete',
+                segments: main.segments,
+                skipTo: null,
+                continueParsing: main.continueParsing,
+            };
+        }
+        return {
+            status: 'done',
+            segments: main.segments,
+        };
+    }
+    if (bytesRemainingNow < length) {
+        const bytesRead = iterator.counter.getOffset() - offset;
+        iterator.counter.decrement(bytesRead);
+        return {
+            status: 'incomplete',
+            segments: [],
+            continueParsing: () => {
+                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+            },
+            skipTo: null,
+        };
+    }
+    const segment = await parseSegment({
+        segmentId,
+        iterator,
+        length,
+        parserContext,
+    });
+    return {
+        status: 'done',
+        segments: [segment],
+    };
+};
 exports.expectSegment = expectSegment;

package/dist/boxes/webm/traversal.d.ts

@@ -0,0 +1,7 @@
+import type { AnySegment } from '../../parse-result';
+import type { MainSegment } from './segments/main';
+import type { CodecSegment, TrackEntrySegment } from './segments/track-entry';
+export declare const getMainSegment: (segments: AnySegment[]) => MainSegment | null;
+export declare const getTrackNumber: (track: TrackEntrySegment) => number | null;
+export declare const getTrackCodec: (track: TrackEntrySegment) => CodecSegment | null;
+export declare const getTrackByNumber: (tracks: TrackEntrySegment[], id: number) => TrackEntrySegment | undefined;

package/dist/boxes/webm/traversal.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrackByNumber = exports.getTrackCodec = exports.getTrackNumber = exports.getMainSegment = void 0;
+const getMainSegment = (segments) => {
+    return segments.find((s) => s.type === 'main-segment');
+};
+exports.getMainSegment = getMainSegment;
+const getTrackNumber = (track) => {
+    var _a;
+    const child = track.children.find((b) => b.type === 'track-number-segment');
+    return (_a = child === null || child === void 0 ? void 0 : child.trackNumber) !== null && _a !== void 0 ? _a : null;
+};
+exports.getTrackNumber = getTrackNumber;
+const getTrackCodec = (track) => {
+    const child = track.children.find((b) => b.type === 'codec-segment');
+    return child !== null && child !== void 0 ? child : null;
+};
+exports.getTrackCodec = getTrackCodec;
+const getTrackByNumber = (tracks, id) => {
+    return tracks.find((track) => {
+        const trackNumber = (0, exports.getTrackNumber)(track);
+        return trackNumber === id;
+    });
+};
+exports.getTrackByNumber = getTrackByNumber;

package/dist/buffer-iterator.d.ts

@@ -4,16 +4,23 @@ export declare class OffsetCounter {
     increment(amount: number): void;
     getOffset(): number;
     getDiscardedOffset(): number;
+    setDiscardedOffset(offset: number): void;
     discardBytes(amount: number): void;
     decrement(amount: number): void;
 }
 export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes?: number) => {
+    startReadingBits: () => void;
+    stopReadingBits: () => void;
     skipTo: (offset: number) => void;
     addData: (newData: Uint8Array) => void;
     counter: OffsetCounter;
+    peekB: (length: number) => void;
+    peekD: (length: number) => void;
+    getBits: (bits: number) => number;
     byteLength: () => number;
     bytesRemaining: () => number;
     isIsoBaseMedia: () => boolean;
+    leb128: () => number;
     discardFirstBytes: () => void;
     isWebm: () => boolean;
     discard: (length: number) => void;
@@ -29,10 +36,17 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes?
     getUint16: () => number;
     getInt16: () => number;
     getUint32: () => number;
-    getFixedPoint1616Number: () => number;
+    getFixedPointUnsigned1616Number: () => number;
+    getFixedPointSigned1616Number: () => number;
+    getFixedPointSigned230Number: () => number;
     getPascalString: () => number[];
     getDecimalBytes(length: number): number;
     getByteString(length: number): string;
     getFloat64: () => number;
+    getFloat32: () => number;
+    getUint32Le: () => number;
+    getInt32Le: () => number;
+    destroy: () => void;
+    isMp3: () => boolean;
 };
 export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/buffer-iterator.js

@@ -13,6 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _OffsetCounter_offset, _OffsetCounter_discardedBytes;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getArrayBufferIterator = exports.OffsetCounter = void 0;
+const all_segments_1 = require("./boxes/webm/segments/all-segments");
 class OffsetCounter {
     constructor(initial) {
         _OffsetCounter_offset.set(this, void 0);
@@ -32,6 +33,9 @@ class OffsetCounter {
     getDiscardedOffset() {
         return __classPrivateFieldGet(this, _OffsetCounter_offset, "f") - __classPrivateFieldGet(this, _OffsetCounter_discardedBytes, "f");
     }
+    setDiscardedOffset(offset) {
+        __classPrivateFieldSet(this, _OffsetCounter_discardedBytes, offset, "f");
+    }
     discardBytes(amount) {
         __classPrivateFieldSet(this, _OffsetCounter_discardedBytes, __classPrivateFieldGet(this, _OffsetCounter_discardedBytes, "f") + amount, "f");
     }
@@ -46,6 +50,7 @@ exports.OffsetCounter = OffsetCounter;
 _OffsetCounter_offset = new WeakMap(), _OffsetCounter_discardedBytes = new WeakMap();
 const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
 const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
+const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
 const matchesPattern = (pattern) => {
     return (data) => {
         return pattern.every((value, index) => data[index] === value);
@@ -59,7 +64,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         maxByteLength: maxBytes !== null && maxBytes !== void 0 ? maxBytes : 1000000000,
     });
     if (!buf.resize) {
-        throw new Error('`ArrayBuffer.resize` is not supported in this Runtime. Use at least Node.js 20 or Bun.');
+        throw new Error('`ArrayBuffer.resize` is not supported in this Runtime. On the server: Use at least Node.js 20 or Bun. In the browser: Chrome 111, Edge 111, Safari 16.4, Firefox 128, Opera 111');
     }
     let data = new Uint8Array(buf);
     data.set(initialData);
@@ -90,6 +95,21 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         counter.increment(4);
         return val;
     };
+    const getUint32Le = () => {
+        const val = view.getUint32(counter.getDiscardedOffset(), true);
+        counter.increment(4);
+        return val;
+    };
+    const getInt32Le = () => {
+        const val = view.getInt32(counter.getDiscardedOffset(), true);
+        counter.increment(4);
+        return val;
+    };
+    const getInt32 = () => {
+        const val = view.getInt32(counter.getDiscardedOffset());
+        counter.increment(4);
+        return val;
+    };
     const addData = (newData) => {
         const oldLength = buf.byteLength;
         const newLength = oldLength + newData.byteLength;
@@ -111,6 +131,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     const isWebm = () => {
         return matchesPattern(webmPattern)(data.subarray(0, 4));
     };
+    const isMp3 = () => {
+        return matchesPattern(mpegPattern)(data.subarray(0, 4));
+    };
     const removeBytesRead = () => {
         const bytesToRemove = counter.getDiscardedOffset();
         // Only to this operation if it is really worth it 😇
@@ -124,18 +147,84 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         view = new DataView(data.buffer);
     };
     const skipTo = (offset) => {
-        buf.resize(offset);
-        const currentOffset = counter.getOffset();
-        counter.increment(offset - currentOffset);
-        removeBytesRead();
+        const becomesSmaller = offset < counter.getOffset();
+        if (becomesSmaller) {
+            buf.resize(0);
+            counter.decrement(counter.getOffset() - offset);
+            counter.setDiscardedOffset(offset);
+        }
+        else {
+            buf.resize(offset);
+            const currentOffset = counter.getOffset();
+            counter.increment(offset - currentOffset);
+            removeBytesRead();
+        }
+    };
+    const peekB = (length) => {
+        // eslint-disable-next-line no-console
+        console.log([...getSlice(length)].map((b) => b.toString(16).padStart(2, '0')));
+        counter.decrement(length);
+    };
+    const peekD = (length) => {
+        // eslint-disable-next-line no-console
+        console.log([...getSlice(length)].map((b) => b));
+        counter.decrement(length);
+    };
+    const leb128 = () => {
+        let result = 0;
+        let shift = 0;
+        let byte;
+        do {
+            byte = getBits(8);
+            result |= (byte & 0x7f) << shift;
+            shift += 7;
+        } while (byte >= 0x80); // Continue if the high bit is set
+        return result;
+    };
+    let bitIndex = 0;
+    const stopReadingBits = () => {
+        bitIndex = 0;
+    };
+    let byteToShift = 0;
+    const startReadingBits = () => {
+        byteToShift = getUint8();
+    };
+    const getBits = (bits) => {
+        let result = 0;
+        let bitsCollected = 0;
+        while (bitsCollected < bits) {
+            if (bitIndex >= 8) {
+                bitIndex = 0;
+                byteToShift = getUint8();
+            }
+            const remainingBitsInByte = 8 - bitIndex;
+            const bitsToReadNow = Math.min(bits - bitsCollected, remainingBitsInByte);
+            const mask = (1 << bitsToReadNow) - 1;
+            const shift = remainingBitsInByte - bitsToReadNow;
+            result <<= bitsToReadNow;
+            result |= (byteToShift >> shift) & mask;
+            bitsCollected += bitsToReadNow;
+            bitIndex += bitsToReadNow;
+        }
+        return result;
+    };
+    const destroy = () => {
+        data = new Uint8Array(0);
+        buf.resize(0);
     };
     return {
+        startReadingBits,
+        stopReadingBits,
         skipTo,
         addData,
         counter,
+        peekB,
+        peekD,
+        getBits,
         byteLength,
         bytesRemaining,
         isIsoBaseMedia,
+        leb128,
         discardFirstBytes: removeBytesRead,
         isWebm,
         discard: (length) => {
@@ -157,62 +246,25 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
                 .join('')}`;
             // Catch void block
             // https://www.matroska.org/technical/elements.html
-            const knownIdsWithOneLength = [
-                '0xec',
-                '0xae',
-                '0xd7',
-                '0x9c',
-                '0x86',
-                '0x83',
-                '0xe0',
-                '0xb0',
-                '0xba',
-                '0x9a',
-                '0xe1',
-                '0xbf',
-                '0x88',
-            ];
-            if (knownIdsWithOneLength.includes(firstOneString)) {
+            if (all_segments_1.knownIdsWithOneLength.includes(firstOneString)) {
                 return firstOneString;
             }
             const firstTwo = getSlice(1);
-            const knownIdsWithTwoLength = [
-                '0x4dbb',
-                '0x53ac',
-                '0xec01',
-                '0x73c5',
-                '0x53c0',
-                '0x4d80',
-                '0x5741',
-                '0x4489',
-                '0x55ee',
-                '0x55b0',
-                '0x7ba9',
-                '0x63a2',
-                '0x73a4',
-            ];
             const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
                 .map((b) => {
                 return b.toString(16).padStart(2, '0');
             })
                 .join('')}`;
-            if (knownIdsWithTwoLength.includes(firstTwoString)) {
+            if (all_segments_1.knownIdsWithTwoLength.includes(firstTwoString)) {
                 return firstTwoString;
             }
-            const knownIdsWithThreeLength = [
-                '0x4d808c',
-                '0x57418c',
-                '0x448988',
-                '0x22b59c',
-                '0x23e383',
-            ];
             const firstThree = getSlice(1);
             const firstThreeString = `${firstTwoString}${Array.from(new Uint8Array(firstThree))
                 .map((b) => {
                 return b.toString(16).padStart(2, '0');
             })
                 .join('')}`;
-            if (knownIdsWithThreeLength.includes(firstThreeString)) {
+            if (all_segments_1.knownIdsWithThreeLength.includes(firstThreeString)) {
                 return firstThreeString;
             }
             const segmentId = getSlice(1);
@@ -271,10 +323,18 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         getUint32,
         // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_description_version_1
         // A 32-bit unsigned fixed-point number (16.16) that indicates the rate at which the sound samples were obtained.
-        getFixedPoint1616Number: () => {
+        getFixedPointUnsigned1616Number: () => {
             const val = getUint32();
             return val / 2 ** 16;
         },
+        getFixedPointSigned1616Number: () => {
+            const val = getInt32();
+            return val / 2 ** 16;
+        },
+        getFixedPointSigned230Number: () => {
+            const val = getInt32();
+            return val / 2 ** 30;
+        },
         getPascalString: () => {
             const val = getSlice(32);
             return [...Array.from(new Uint8Array(val))];
@@ -293,6 +353,15 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             counter.increment(8);
             return val;
         },
+        getFloat32: () => {
+            const val = view.getFloat32(counter.getDiscardedOffset());
+            counter.increment(4);
+            return val;
+        },
+        getUint32Le,
+        getInt32Le,
+        destroy,
+        isMp3,
     };
 };
 exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/combine-uint8array.d.ts

@@ -0,0 +1 @@
+export declare const combineUint8Arrays: (array1: Uint8Array | null, array2: Uint8Array) => Uint8Array;

package/dist/combine-uint8array.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineUint8Arrays = void 0;
+const combineUint8Arrays = (array1, array2) => {
+    if (!array1) {
+        return array2;
+    }
+    const combined = new Uint8Array(array1.length + array2.length);
+    combined.set(array1);
+    combined.set(array2, array1.length);
+    return combined;
+};
+exports.combineUint8Arrays = combineUint8Arrays;

package/dist/from-fetch.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const fetchReader: ReaderInterface;