@remotion/media-parser 4.0.194 → 4.0.196

package/dist/parser-state.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeParserState = void 0;
+const traversal_1 = require("./boxes/webm/traversal");
+const traversal_2 = require("./traversal");
+const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
+    const trackEntries = {};
+    const onTrackEntrySegment = (trackEntry) => {
+        const trackId = (0, traversal_2.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');
+        }
+        trackEntries[trackId] = codec;
+    };
+    const videoSampleCallbacks = {};
+    const audioSampleCallbacks = {};
+    let samplesThatHadToBeQueued = 0;
+    const queuedAudioSamples = {};
+    const queuedVideoSamples = {};
+    const declinedTrackNumbers = [];
+    let timescale = null;
+    const getTimescale = () => {
+        if (timescale === null) {
+            throw new Error('Timescale not set');
+        }
+        return timescale;
+    };
+    const setTimescale = (newTimescale) => {
+        timescale = newTimescale;
+    };
+    return {
+        onTrackEntrySegment,
+        getTrackInfoByNumber: (id) => trackEntries[id],
+        registerVideoSampleCallback: async (id, callback) => {
+            var _a;
+            if (callback === null) {
+                delete videoSampleCallbacks[id];
+                declinedTrackNumbers.push(id);
+                return;
+            }
+            videoSampleCallbacks[id] = callback;
+            for (const queued of (_a = queuedVideoSamples[id]) !== null && _a !== void 0 ? _a : []) {
+                await callback(queued);
+            }
+            queuedVideoSamples[id] = [];
+        },
+        registerAudioSampleCallback: async (id, callback) => {
+            var _a;
+            if (callback === null) {
+                delete audioSampleCallbacks[id];
+                declinedTrackNumbers.push(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) => {
+            var _a;
+            const callback = audioSampleCallbacks[trackId];
+            if (callback) {
+                await callback(audioSample);
+            }
+            else {
+                if (declinedTrackNumbers.includes(trackId)) {
+                    return;
+                }
+                if (!hasAudioCallbacks) {
+                    return;
+                }
+                (_a = queuedAudioSamples[trackId]) !== null && _a !== void 0 ? _a : (queuedAudioSamples[trackId] = []);
+                queuedAudioSamples[trackId].push(audioSample);
+                samplesThatHadToBeQueued++;
+            }
+        },
+        onVideoSample: async (trackId, videoSample) => {
+            var _a;
+            const callback = videoSampleCallbacks[trackId];
+            if (callback) {
+                await callback(videoSample);
+            }
+            else {
+                if (declinedTrackNumbers.includes(trackId)) {
+                    return;
+                }
+                if (!hasVideoCallbacks) {
+                    return;
+                }
+                (_a = queuedVideoSamples[trackId]) !== null && _a !== void 0 ? _a : (queuedVideoSamples[trackId] = []);
+                queuedVideoSamples[trackId].push(videoSample);
+                samplesThatHadToBeQueued++;
+            }
+        },
+        getInternalStats: () => {
+            return {
+                samplesThatHadToBeQueued,
+            };
+        },
+        getTimescale,
+        setTimescale,
+    };
+};
+exports.makeParserState = makeParserState;

package/dist/read-and-increment-offset.d.ts

@@ -0,0 +1,28 @@
+export declare class OffsetCounter {
+    #private;
+    constructor(initial: number);
+    increment(amount: number): void;
+    getOffset(): number;
+}
+export declare const getArrayBufferIterator: (data: ArrayBuffer, initialOffset: number) => {
+    view: DataView;
+    counter: OffsetCounter;
+    data: ArrayBuffer;
+    discard: (length: number) => void;
+    getSlice: (amount: number) => ArrayBuffer;
+    getAtom: () => string;
+    getMatroskaSegmentId: () => string;
+    getVint: (bytes: number) => number;
+    getUint8: () => number;
+    getEBML: () => number;
+    getInt8: () => number;
+    getUint16: () => number;
+    getInt16: () => number;
+    getUint32: () => number;
+    getFixedPoint1616Number: () => number;
+    getPascalString: () => number[];
+    getDecimalBytes(length: number): number;
+    getByteString(length: number): string;
+    getFloat64: () => number;
+};
+export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/read-and-increment-offset.js

@@ -0,0 +1,177 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _OffsetCounter_offset;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrayBufferIterator = exports.OffsetCounter = void 0;
+class OffsetCounter {
+    constructor(initial) {
+        _OffsetCounter_offset.set(this, void 0);
+        __classPrivateFieldSet(this, _OffsetCounter_offset, initial, "f");
+    }
+    increment(amount) {
+        if (amount < 0) {
+            throw new Error('Cannot increment by a negative amount');
+        }
+        __classPrivateFieldSet(this, _OffsetCounter_offset, __classPrivateFieldGet(this, _OffsetCounter_offset, "f") + amount, "f");
+    }
+    getOffset() {
+        return __classPrivateFieldGet(this, _OffsetCounter_offset, "f");
+    }
+}
+exports.OffsetCounter = OffsetCounter;
+_OffsetCounter_offset = new WeakMap();
+const makeOffsetCounter = (initial) => {
+    return new OffsetCounter(initial);
+};
+const getArrayBufferIterator = (data, initialOffset) => {
+    const view = new DataView(data);
+    const counter = makeOffsetCounter(initialOffset);
+    const getSlice = (amount) => {
+        const value = data.slice(counter.getOffset(), counter.getOffset() + amount);
+        counter.increment(amount);
+        return value;
+    };
+    const getUint8 = () => {
+        const val = view.getUint8(counter.getOffset());
+        counter.increment(1);
+        return val;
+    };
+    const getUint32 = () => {
+        const val = view.getUint32(counter.getOffset());
+        counter.increment(4);
+        return val;
+    };
+    return {
+        view,
+        counter,
+        data,
+        discard: (length) => {
+            counter.increment(length);
+        },
+        getSlice,
+        getAtom: () => {
+            const atom = getSlice(4);
+            return new TextDecoder().decode(atom);
+        },
+        getMatroskaSegmentId: () => {
+            const first = getSlice(1);
+            const firstOneString = `0x${Array.from(new Uint8Array(first))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            // Catch void block
+            const knownIdsWithOneLength = ['0xec', '0xae'];
+            if (knownIdsWithOneLength.includes(firstOneString)) {
+                return firstOneString;
+            }
+            const firstTwo = getSlice(1);
+            const knownIdsWithTwoLength = ['0x4dbb', '0x53ac', '0xec01'];
+            const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            if (knownIdsWithTwoLength.includes(firstTwoString)) {
+                return firstTwoString;
+            }
+            const knownIdsWithThreeLength = ['0x4d808c', '0x57418c', '0x448988'];
+            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)) {
+                return firstThreeString;
+            }
+            const segmentId = getSlice(1);
+            return `${firstThreeString}${Array.from(new Uint8Array(segmentId))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+        },
+        getVint: (bytes) => {
+            const slice = getSlice(bytes);
+            const d = [...Array.from(new Uint8Array(slice))];
+            const totalLength = d[0];
+            if (totalLength === 0) {
+                return 0;
+            }
+            // Calculate the actual length of the data based on the first set bit
+            let actualLength = 0;
+            while (((totalLength >> (7 - actualLength)) & 0x01) === 0) {
+                actualLength++;
+            }
+            actualLength += 1; // Include the first byte set as 1
+            // Combine the numbers to form the integer value
+            let value = 0;
+            // Mask the first byte properly then start combining
+            value = totalLength & (0xff >> actualLength);
+            for (let i = 1; i < actualLength; i++) {
+                value = (value << 8) | d[i];
+            }
+            return value;
+        },
+        getUint8,
+        getEBML: () => {
+            const val = getUint8();
+            // https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/#:~:text=The%20first%20four%20bytes%20(%201A,%E2%80%93%20read%20on%20for%20why).
+            // You drop the initial 0 bits and the first 1 bit to get the value. 0x81 is 0b10000001, so there are zero inital 0 bits, meaning length one byte, and the value is 1. The 0x9F value for length of the EBML header we saw earlier is 0b10011111, still one byte, value is 0b0011111, which is 31 (the python repl is very helpful for these conversions).
+            const actualValue = val & 0x7f; // 0x7F is binary 01111111, which masks out the first bit
+            return actualValue;
+        },
+        getInt8: () => {
+            const val = view.getInt8(counter.getOffset());
+            counter.increment(1);
+            return val;
+        },
+        getUint16: () => {
+            const val = view.getUint16(counter.getOffset());
+            counter.increment(2);
+            return val;
+        },
+        getInt16: () => {
+            const val = view.getInt16(counter.getOffset());
+            counter.increment(2);
+            return val;
+        },
+        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: () => {
+            const val = getUint32();
+            return val / 2 ** 16;
+        },
+        getPascalString: () => {
+            const val = getSlice(32);
+            return [...Array.from(new Uint8Array(val))];
+        },
+        getDecimalBytes(length) {
+            const bytes = getSlice(length);
+            const numbers = [...Array.from(new Uint8Array(bytes))];
+            return numbers.reduce((acc, byte, index) => acc + (byte << (8 * (numbers.length - index - 1))), 0);
+        },
+        getByteString(length) {
+            const bytes = getSlice(length);
+            return new TextDecoder().decode(bytes);
+        },
+        getFloat64: () => {
+            const val = view.getFloat64(counter.getOffset());
+            counter.increment(8);
+            return val;
+        },
+    };
+};
+exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/reader.d.ts

@@ -2,8 +2,8 @@ type ReadResult = {
     reader: ReadableStreamDefaultReader<Uint8Array>;
     contentLength: number | null;
 };
-type ReadContent = (src: string, range: [number, number] | number | null) => Promise<ReadResult>;
-type GetLength = (src: string) => Promise<number>;
+type ReadContent = (src: string | File, range: [number, number] | number | null) => Promise<ReadResult>;
+type GetLength = (src: string | File) => Promise<number>;
 export type ReaderInterface = {
     read: ReadContent;
     getLength: GetLength;

package/dist/traversal.d.ts

@@ -1,19 +1,56 @@
+import type { FtypBox } from './boxes/iso-base-media/ftyp';
+import type { MdhdBox } from './boxes/iso-base-media/mdhd';
 import type { MoovBox } from './boxes/iso-base-media/moov/moov';
 import type { MvhdBox } from './boxes/iso-base-media/mvhd';
+import type { CttsBox } from './boxes/iso-base-media/stsd/ctts';
 import type { StcoBox } from './boxes/iso-base-media/stsd/stco';
 import type { StscBox } from './boxes/iso-base-media/stsd/stsc';
 import type { StsdBox } from './boxes/iso-base-media/stsd/stsd';
+import type { StssBox } from './boxes/iso-base-media/stsd/stss';
 import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
+import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
 import type { TkhdBox } from './boxes/iso-base-media/tkhd';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { MainSegment } from './boxes/webm/segments/main';
+import type { TimestampScaleSegment } from './boxes/webm/segments/timestamp-scale';
+import type { AudioSegment, ClusterSegment, CodecSegment, DisplayHeightSegment, DisplayWidthSegment, HeightSegment, TrackEntrySegment, TrackTypeSegment, VideoSegment, WidthSegment } from './boxes/webm/segments/track-entry';
 import type { AnySegment, RegularBox } from './parse-result';
+export declare const getFtypBox: (segments: AnySegment[]) => FtypBox | null;
 export declare const getMoovBox: (segments: AnySegment[]) => MoovBox | null;
 export declare const getMvhdBox: (moovBox: MoovBox) => MvhdBox | null;
 export declare const getTraks: (moovBox: MoovBox) => TrakBox[];
 export declare const getTkhdBox: (trakBox: TrakBox) => TkhdBox | null;
 export declare const getMdiaBox: (trakBox: TrakBox) => RegularBox | null;
+export declare const getMdhdBox: (trakBox: TrakBox) => MdhdBox | null;
 export declare const getStblBox: (trakBox: TrakBox) => RegularBox | null;
 export declare const getStsdBox: (trakBox: TrakBox) => StsdBox | null;
+export declare const getVideoDescriptors: (trakBox: TrakBox) => Uint8Array | null;
 export declare const getStcoBox: (trakBox: TrakBox) => StcoBox | null;
+export declare const getSttsBox: (trakBox: TrakBox) => SttsBox | null;
+export declare const getCttsBox: (trakBox: TrakBox) => CttsBox | null;
 export declare const getStszBox: (trakBox: TrakBox) => StszBox | null;
 export declare const getStscBox: (trakBox: TrakBox) => StscBox | null;
+export declare const getStssBox: (trakBox: TrakBox) => StssBox | null;
+export declare const getClusterSegment: (segment: MainSegment) => ClusterSegment | null;
+export declare const getTracksSegment: (segment: MainSegment) => import("./boxes/webm/segments/tracks").TracksSegment | null;
+export declare const getTimescaleSegment: (segment: MainSegment) => TimestampScaleSegment | null;
+export declare const getVideoSegment: (track: TrackEntrySegment) => VideoSegment | null;
+export declare const getAudioSegment: (track: TrackEntrySegment) => AudioSegment | null;
+export declare const getSampleRate: (track: TrackEntrySegment) => number | null;
+export declare const getNumberOfChannels: (track: TrackEntrySegment) => number;
+export declare const getBitDepth: (track: TrackEntrySegment) => number | null;
+export declare const getPrivateData: (track: TrackEntrySegment) => Uint8Array | null;
+export declare const getWidthSegment: (track: TrackEntrySegment) => WidthSegment | null;
+export declare const getHeightSegment: (track: TrackEntrySegment) => HeightSegment | null;
+export declare const getDisplayWidthSegment: (track: TrackEntrySegment) => DisplayWidthSegment | null;
+export declare const getDisplayHeightSegment: (track: TrackEntrySegment) => DisplayHeightSegment | null;
+export declare const getTrackTypeSegment: (track: TrackEntrySegment) => TrackTypeSegment | null;
+export declare const getTrackId: (track: TrackEntrySegment) => number;
+export declare const getCodecSegment: (track: TrackEntrySegment) => CodecSegment | null;
+export declare const hasSkippedMdatProcessing: (anySegment: AnySegment[]) => {
+    skipped: false;
+    fileOffset?: undefined;
+} | {
+    skipped: boolean;
+    fileOffset: number;
+};

package/dist/traversal.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStscBox = exports.getStszBox = exports.getStcoBox = exports.getStsdBox = exports.getStblBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoovBox = void 0;
+exports.hasSkippedMdatProcessing = exports.getCodecSegment = exports.getTrackId = exports.getTrackTypeSegment = exports.getDisplayHeightSegment = exports.getDisplayWidthSegment = exports.getHeightSegment = exports.getWidthSegment = exports.getPrivateData = exports.getBitDepth = exports.getNumberOfChannels = exports.getSampleRate = exports.getAudioSegment = exports.getVideoSegment = exports.getTimescaleSegment = exports.getTracksSegment = exports.getClusterSegment = exports.getStssBox = exports.getStscBox = exports.getStszBox = exports.getCttsBox = exports.getSttsBox = exports.getStcoBox = exports.getVideoDescriptors = exports.getStsdBox = exports.getStblBox = exports.getMdhdBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoovBox = exports.getFtypBox = void 0;
+const getFtypBox = (segments) => {
+    const ftypBox = segments.find((s) => s.type === 'ftyp-box');
+    if (!ftypBox || ftypBox.type !== 'ftyp-box') {
+        return null;
+    }
+    return ftypBox;
+};
+exports.getFtypBox = getFtypBox;
 const getMoovBox = (segments) => {
     const moovBox = segments.find((s) => s.type === 'moov-box');
     if (!moovBox || moovBox.type !== 'moov-box') {
@@ -34,6 +42,15 @@ const getMdiaBox = (trakBox) => {
     return mdiaBox;
 };
 exports.getMdiaBox = getMdiaBox;
+const getMdhdBox = (trakBox) => {
+    const mdiaBox = (0, exports.getMdiaBox)(trakBox);
+    if (!mdiaBox) {
+        return null;
+    }
+    const mdhdBox = mdiaBox.children.find((c) => c.type === 'mdhd-box');
+    return mdhdBox;
+};
+exports.getMdhdBox = getMdhdBox;
 const getStblBox = (trakBox) => {
     const mdiaBox = (0, exports.getMdiaBox)(trakBox);
     if (!mdiaBox) {
@@ -59,6 +76,26 @@ const getStsdBox = (trakBox) => {
     return stsdBox;
 };
 exports.getStsdBox = getStsdBox;
+const getVideoDescriptors = (trakBox) => {
+    var _a;
+    const stsdBox = (0, exports.getStsdBox)(trakBox);
+    if (!stsdBox) {
+        return null;
+    }
+    const descriptors = stsdBox.samples.map((s) => {
+        return s.type === 'video'
+            ? s.descriptors.map((d) => {
+                return d.type === 'avcc-box'
+                    ? d.description
+                    : d.type === 'hvcc-box'
+                        ? d.data
+                        : null;
+            })
+            : [];
+    });
+    return (_a = descriptors.flat(1).filter(Boolean)[0]) !== null && _a !== void 0 ? _a : null;
+};
+exports.getVideoDescriptors = getVideoDescriptors;
 const getStcoBox = (trakBox) => {
     const stblBox = (0, exports.getStblBox)(trakBox);
     if (!stblBox || stblBox.type !== 'regular-box') {
@@ -68,6 +105,24 @@ const getStcoBox = (trakBox) => {
     return stcoBox;
 };
 exports.getStcoBox = getStcoBox;
+const getSttsBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const sttsBox = stblBox.children.find((s) => s.type === 'stts-box');
+    return sttsBox;
+};
+exports.getSttsBox = getSttsBox;
+const getCttsBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const cttsBox = stblBox.children.find((s) => s.type === 'ctts-box');
+    return cttsBox;
+};
+exports.getCttsBox = getCttsBox;
 const getStszBox = (trakBox) => {
     const stblBox = (0, exports.getStblBox)(trakBox);
     if (!stblBox || stblBox.type !== 'regular-box') {
@@ -86,3 +141,191 @@ const getStscBox = (trakBox) => {
     return stcoBox;
 };
 exports.getStscBox = getStscBox;
+const getStssBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const stssBox = stblBox.children.find((b) => b.type === 'stss-box');
+    return stssBox;
+};
+exports.getStssBox = getStssBox;
+const getClusterSegment = (segment) => {
+    const clusterSegment = segment.children.find((b) => b.type === 'cluster-segment');
+    return clusterSegment !== null && clusterSegment !== void 0 ? clusterSegment : null;
+};
+exports.getClusterSegment = getClusterSegment;
+const getTracksSegment = (segment) => {
+    const tracksSegment = segment.children.find((b) => b.type === 'tracks-segment');
+    if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+        return null;
+    }
+    return tracksSegment;
+};
+exports.getTracksSegment = getTracksSegment;
+const getTimescaleSegment = (segment) => {
+    const infoSegment = segment.children.find((b) => b.type === 'info-segment');
+    if (!infoSegment || infoSegment.type !== 'info-segment') {
+        return null;
+    }
+    const timescale = infoSegment.children.find((b) => b.type === 'timestamp-scale-segment');
+    if (!timescale || timescale.type !== 'timestamp-scale-segment') {
+        return null;
+    }
+    return timescale;
+};
+exports.getTimescaleSegment = getTimescaleSegment;
+const getVideoSegment = (track) => {
+    const videoSegment = track.children.find((b) => b.type === 'video-segment');
+    if (!videoSegment || videoSegment.type !== 'video-segment') {
+        return null;
+    }
+    return videoSegment !== null && videoSegment !== void 0 ? videoSegment : null;
+};
+exports.getVideoSegment = getVideoSegment;
+const getAudioSegment = (track) => {
+    const audioSegment = track.children.find((b) => b.type === 'audio-segment');
+    if (!audioSegment || audioSegment.type !== 'audio-segment') {
+        return null;
+    }
+    return audioSegment !== null && audioSegment !== void 0 ? audioSegment : null;
+};
+exports.getAudioSegment = getAudioSegment;
+const getSampleRate = (track) => {
+    const audioSegment = (0, exports.getAudioSegment)(track);
+    if (!audioSegment) {
+        return null;
+    }
+    const samplingFrequency = audioSegment.children.find((b) => b.type === 'sampling-frequency-segment');
+    if (!samplingFrequency ||
+        samplingFrequency.type !== 'sampling-frequency-segment') {
+        return null;
+    }
+    return samplingFrequency.samplingFrequency;
+};
+exports.getSampleRate = getSampleRate;
+const getNumberOfChannels = (track) => {
+    const audioSegment = (0, exports.getAudioSegment)(track);
+    if (!audioSegment) {
+        throw new Error('Could not find audio segment');
+    }
+    const channels = audioSegment.children.find((b) => b.type === 'channels-segment');
+    if (!channels || channels.type !== 'channels-segment') {
+        return 1;
+    }
+    return channels.channels;
+};
+exports.getNumberOfChannels = getNumberOfChannels;
+const getBitDepth = (track) => {
+    const audioSegment = (0, exports.getAudioSegment)(track);
+    if (!audioSegment) {
+        return null;
+    }
+    const bitDepth = audioSegment.children.find((b) => b.type === 'bit-depth-segment');
+    if (!bitDepth || bitDepth.type !== 'bit-depth-segment') {
+        return null;
+    }
+    return bitDepth.bitDepth;
+};
+exports.getBitDepth = getBitDepth;
+const getPrivateData = (track) => {
+    const privateData = track.children.find((b) => b.type === 'codec-private-segment');
+    if (!privateData || privateData.type !== 'codec-private-segment') {
+        return null;
+    }
+    return privateData.codecPrivateData;
+};
+exports.getPrivateData = getPrivateData;
+const getWidthSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const width = videoSegment.children.find((b) => b.type === 'width-segment');
+    if (!width || width.type !== 'width-segment') {
+        return null;
+    }
+    return width;
+};
+exports.getWidthSegment = getWidthSegment;
+const getHeightSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const height = videoSegment.children.find((b) => b.type === 'height-segment');
+    if (!height || height.type !== 'height-segment') {
+        return null;
+    }
+    return height;
+};
+exports.getHeightSegment = getHeightSegment;
+const getDisplayWidthSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const displayWidth = videoSegment.children.find((b) => b.type === 'display-width-segment');
+    if (!displayWidth || displayWidth.type !== 'display-width-segment') {
+        return null;
+    }
+    return displayWidth;
+};
+exports.getDisplayWidthSegment = getDisplayWidthSegment;
+const getDisplayHeightSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const displayHeight = videoSegment.children.find((b) => b.type === 'display-height-segment');
+    if (!displayHeight || displayHeight.type !== 'display-height-segment') {
+        return null;
+    }
+    return displayHeight;
+};
+exports.getDisplayHeightSegment = getDisplayHeightSegment;
+const getTrackTypeSegment = (track) => {
+    const trackType = track.children.find((b) => b.type === 'track-type-segment');
+    if (!trackType || trackType.type !== 'track-type-segment') {
+        return null;
+    }
+    return trackType;
+};
+exports.getTrackTypeSegment = getTrackTypeSegment;
+const getTrackId = (track) => {
+    const trackId = track.children.find((b) => b.type === 'track-number-segment');
+    if (!trackId || trackId.type !== 'track-number-segment') {
+        throw new Error('Expected track number segment');
+    }
+    return trackId.trackNumber;
+};
+exports.getTrackId = getTrackId;
+const getCodecSegment = (track) => {
+    const codec = track.children.find((b) => b.type === 'codec-segment');
+    if (!codec || codec.type !== 'codec-segment') {
+        return null;
+    }
+    return codec;
+};
+exports.getCodecSegment = getCodecSegment;
+const hasSkippedMdatProcessing = (anySegment) => {
+    const mdat = anySegment.find((b) => b.type === 'mdat-box');
+    if (!mdat) {
+        return {
+            skipped: false,
+        };
+    }
+    if (mdat.type !== 'mdat-box') {
+        throw new Error('Expected mdat-box');
+    }
+    if (mdat.samplesProcessed) {
+        return {
+            skipped: false,
+        };
+    }
+    return {
+        skipped: true,
+        fileOffset: mdat.fileOffset,
+    };
+};
+exports.hasSkippedMdatProcessing = hasSkippedMdatProcessing;

package/dist/understand-vorbis.d.ts

@@ -0,0 +1 @@
+declare const understand: (src: string) => Promise<void>;

package/dist/understand-vorbis.js

@@ -0,0 +1,12 @@
+"use strict";
+const understand = async (src) => {
+    const content = await Bun.file(src).arrayBuffer();
+    const firstBit = new DataView(content).getUint8(0);
+    const offset = new DataView(content).getUint8(1);
+    const offset2 = new DataView(content).getUint8(2);
+    const globalOffset = firstBit + 1;
+    const header = new TextDecoder().decode(content.slice(globalOffset, globalOffset + offset));
+    const comment = new TextDecoder().decode(content.slice(globalOffset + offset, globalOffset + offset2));
+    const rest = new TextDecoder().decode(content.slice(globalOffset + offset2 + offset, globalOffset + offset2 + offset + 50));
+    console.log({ firstBit, offset, offset2, header, comment, rest });
+};