@remotion/media-parser 4.0.240 → 4.0.242

package/dist/boxes/webm/get-sample-from-block.js

@@ -4,7 +4,7 @@ exports.getSampleFromBlock = void 0;
 const buffer_iterator_1 = require("../../buffer-iterator");
 const all_segments_1 = require("./segments/all-segments");
 const block_simple_block_flags_1 = require("./segments/block-simple-block-flags");
-const getSampleFromBlock = (ebml, parserContext, offset) => {
+const getSampleFromBlock = (ebml, state, offset) => {
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(ebml.value, ebml.value.length);
     const trackNumber = iterator.getVint();
     if (trackNumber === null) {
@@ -14,9 +14,9 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
     const { keyframe } = (0, block_simple_block_flags_1.parseBlockFlags)(iterator, ebml.type === 'SimpleBlock'
         ? all_segments_1.matroskaElements.SimpleBlock
         : all_segments_1.matroskaElements.Block);
-    const { codec, trackTimescale } = parserContext.parserState.getTrackInfoByNumber(trackNumber);
-    const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(offset);
-    const timescale = parserContext.parserState.getTimescale();
+    const { codec, trackTimescale } = state.webm.getTrackInfoByNumber(trackNumber);
+    const clusterOffset = state.webm.getTimestampOffsetForByteOffset(offset);
+    const timescale = state.webm.getTimescale();
     if (clusterOffset === undefined) {
         throw new Error('Could not find offset for byte offset ' + offset);
     }
@@ -39,6 +39,8 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
             duration: undefined,
             trackId: trackNumber,
             timestamp: timecodeInMicroseconds,
+            offset,
+            timescale,
         };
         if (keyframe === null) {
             iterator.destroy();
@@ -66,6 +68,8 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
             duration: undefined,
             cts: timecodeInMicroseconds,
             dts: timecodeInMicroseconds,
+            offset,
+            timescale,
         };
         iterator.destroy();
         return {

package/dist/boxes/webm/make-header.d.ts

@@ -1,8 +1,8 @@
 import type { BytesAndOffset, PossibleEbmlOrUint8Array } from './segments/all-segments';
 import { matroskaElements } from './segments/all-segments';
-export declare const webmPattern: Uint8Array;
-export declare const matroskaToHex: (matrId: (typeof matroskaElements)[keyof typeof matroskaElements]) => Uint8Array;
+export declare const webmPattern: Uint8Array<ArrayBuffer>;
+export declare const matroskaToHex: (matrId: (typeof matroskaElements)[keyof typeof matroskaElements]) => Uint8Array<ArrayBufferLike>;
 export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => BytesAndOffset;
 export declare const padMatroskaBytes: (fields: PossibleEbmlOrUint8Array, totalLength: number) => BytesAndOffset[];
-export declare const combineUint8Arrays: (arrays: Uint8Array[]) => Uint8Array;
+export declare const combineUint8Arrays: (arrays: Uint8Array[]) => Uint8Array<ArrayBufferLike>;
 export declare function serializeUint16(value: number): Uint8Array;

package/dist/boxes/webm/parse-ebml.d.ts

@@ -1,12 +1,12 @@
 import { type BufferIterator } from '../../buffer-iterator';
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import type { PossibleEbml } from './segments/all-segments';
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
-export declare const parseEbml: (iterator: BufferIterator, parserContext: ParserContext) => Promise<Prettify<PossibleEbml>>;
-export declare const postprocessEbml: ({ offset, ebml, parserContext, }: {
+export declare const parseEbml: (iterator: BufferIterator, state: ParserState) => Promise<Prettify<PossibleEbml>>;
+export declare const postprocessEbml: ({ offset, ebml, state, }: {
     offset: number;
     ebml: Prettify<PossibleEbml>;
-    parserContext: ParserContext;
+    state: ParserState;
 }) => Promise<Prettify<PossibleEbml>>;

package/dist/boxes/webm/parse-ebml.js

@@ -5,7 +5,7 @@ const register_track_1 = require("../../register-track");
 const get_sample_from_block_1 = require("./get-sample-from-block");
 const make_track_1 = require("./make-track");
 const all_segments_1 = require("./segments/all-segments");
-const parseEbml = async (iterator, parserContext) => {
+const parseEbml = async (iterator, state) => {
     const hex = iterator.getMatroskaSegmentId();
     if (hex === null) {
         throw new Error('Not enough bytes left to parse EBML - this should not happen');
@@ -83,12 +83,12 @@ const parseEbml = async (iterator, parserContext) => {
                 break;
             }
             const offset = iterator.counter.getOffset();
-            const value = await (0, exports.parseEbml)(iterator, parserContext);
+            const value = await (0, exports.parseEbml)(iterator, state);
             // eslint-disable-next-line @typescript-eslint/no-use-before-define
             const remapped = await (0, exports.postprocessEbml)({
                 offset,
                 ebml: value,
-                parserContext,
+                state,
             });
             children.push(remapped);
             const offsetNow = iterator.counter.getOffset();
@@ -105,46 +105,46 @@ const parseEbml = async (iterator, parserContext) => {
     throw new Error(`Unknown segment type ${hasInMap.type}`);
 };
 exports.parseEbml = parseEbml;
-const postprocessEbml = async ({ offset, ebml, parserContext, }) => {
+const postprocessEbml = async ({ offset, ebml, state, }) => {
     if (ebml.type === 'TimestampScale') {
-        parserContext.parserState.setTimescale(ebml.value.value);
+        state.webm.setTimescale(ebml.value.value);
     }
     if (ebml.type === 'TrackEntry') {
-        parserContext.parserState.onTrackEntrySegment(ebml);
+        state.webm.onTrackEntrySegment(ebml);
         const track = (0, make_track_1.getTrack)({
             track: ebml,
-            timescale: parserContext.parserState.getTimescale(),
+            timescale: state.webm.getTimescale(),
         });
         if (track) {
             await (0, register_track_1.registerTrack)({
-                options: parserContext,
+                state,
                 track,
                 container: 'webm',
             });
         }
     }
     if (ebml.type === 'Timestamp') {
-        parserContext.parserState.setTimestampOffset(offset, ebml.value.value);
+        state.webm.setTimestampOffset(offset, ebml.value.value);
     }
     if (ebml.type === 'Block' || ebml.type === 'SimpleBlock') {
-        const sample = (0, get_sample_from_block_1.getSampleFromBlock)(ebml, parserContext, offset);
-        if (sample.type === 'video-sample' && parserContext.nullifySamples) {
-            await parserContext.parserState.onVideoSample(sample.videoSample.trackId, sample.videoSample);
+        const sample = (0, get_sample_from_block_1.getSampleFromBlock)(ebml, state, offset);
+        if (sample.type === 'video-sample' && state.nullifySamples) {
+            await state.callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
             return {
                 type: 'Block',
                 value: new Uint8Array([]),
                 minVintWidth: ebml.minVintWidth,
             };
         }
-        if (sample.type === 'audio-sample' && parserContext.nullifySamples) {
-            await parserContext.parserState.onAudioSample(sample.audioSample.trackId, sample.audioSample);
+        if (sample.type === 'audio-sample' && state.nullifySamples) {
+            await state.callbacks.onAudioSample(sample.audioSample.trackId, sample.audioSample);
             return {
                 type: 'Block',
                 value: new Uint8Array([]),
                 minVintWidth: ebml.minVintWidth,
             };
         }
-        if (sample.type === 'no-sample' && parserContext.nullifySamples) {
+        if (sample.type === 'no-sample' && state.nullifySamples) {
             return {
                 type: 'Block',
                 value: new Uint8Array([]),
@@ -164,15 +164,15 @@ const postprocessEbml = async ({ offset, ebml, parserContext, }) => {
         const hasReferenceBlock = ebml.value.find((c) => c.type === 'ReferenceBlock');
         const sample = block.value.length === 0
             ? null
-            : (0, get_sample_from_block_1.getSampleFromBlock)(block, parserContext, offset);
+            : (0, get_sample_from_block_1.getSampleFromBlock)(block, state, offset);
         if (sample && sample.type === 'partial-video-sample') {
             const completeFrame = {
                 ...sample.partialVideoSample,
                 type: hasReferenceBlock ? 'delta' : 'key',
             };
-            await parserContext.parserState.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
+            await state.callbacks.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
         }
-        if (parserContext.nullifySamples) {
+        if (state.nullifySamples) {
             return {
                 type: 'BlockGroup',
                 value: [],

package/dist/boxes/webm/parse-webm-header.d.ts

@@ -1,9 +1,9 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { Options, ParseMediaFields } from '../../options';
-import type { MatroskaStructure, ParseResult } from '../../parse-result';
-import type { ParserContext } from '../../parser-context';
-export declare const parseWebm: ({ counter, parserContext, fields, }: {
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseWebm: ({ counter, state, fields, }: {
     counter: BufferIterator;
-    parserContext: ParserContext;
+    state: ParserState;
     fields: Options<ParseMediaFields>;
-}) => Promise<ParseResult<MatroskaStructure>>;
+}) => Promise<ParseResult>;

package/dist/boxes/webm/parse-webm-header.js

@@ -6,12 +6,10 @@ const continueAfterMatroskaResult = (result, structure) => {
     if (result.status === 'done') {
         return {
             status: 'done',
-            segments: structure,
         };
     }
     return {
         status: 'incomplete',
-        segments: structure,
         continueParsing: async () => {
             const newResult = await result.continueParsing();
             return continueAfterMatroskaResult(newResult, structure);
@@ -20,13 +18,16 @@ const continueAfterMatroskaResult = (result, structure) => {
     };
 };
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
-const parseWebm = async ({ counter, parserContext, fields, }) => {
-    const structure = { type: 'matroska', boxes: [] };
+const parseWebm = async ({ counter, state, fields, }) => {
+    const structure = state.structure.getStructure();
+    if (structure.type !== 'matroska') {
+        throw new Error('Invalid structure type');
+    }
     const results = await (0, parse_children_1.expectChildren)({
         iterator: counter,
         length: Infinity,
         children: structure.boxes,
-        parserContext,
+        state,
         startOffset: counter.counter.getOffset(),
         fields,
         topLevelStructure: structure,

package/dist/boxes/webm/segments/parse-children.d.ts

@@ -1,22 +1,22 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { Options, ParseMediaFields } from '../../../options';
 import type { ExpectSegmentParseResult, MatroskaParseResult, MatroskaStructure } from '../../../parse-result';
-import type { ParserContext } from '../../../parser-context';
+import type { ParserState } from '../../../state/parser-state';
 import type { MatroskaSegment } from '../segments';
 import type { PossibleEbml } from './all-segments';
-export declare const expectAndProcessSegment: ({ iterator, parserContext, offset, children, fields, topLevelStructure, }: {
+export declare const expectAndProcessSegment: ({ iterator, state, offset, children, fields, topLevelStructure, }: {
     iterator: BufferIterator;
-    parserContext: ParserContext;
+    state: ParserState;
     offset: number;
     children: PossibleEbml[];
     fields: Options<ParseMediaFields>;
     topLevelStructure: MatroskaStructure;
 }) => Promise<ExpectSegmentParseResult>;
-export declare const expectChildren: ({ iterator, length, children, parserContext, startOffset, fields, topLevelStructure, }: {
+export declare const expectChildren: ({ iterator, length, children, state, startOffset, fields, topLevelStructure, }: {
     iterator: BufferIterator;
     length: number;
     children: MatroskaSegment[];
-    parserContext: ParserContext;
+    state: ParserState;
     startOffset: number;
     fields: Options<ParseMediaFields>;
     topLevelStructure: MatroskaStructure;

package/dist/boxes/webm/segments/parse-children.js

@@ -6,14 +6,14 @@ const segments_1 = require("../segments");
 const processParseResult = ({ parseResult, children, state, fields, topLevelStructure, }) => {
     if (parseResult.segment && !children.includes(parseResult.segment)) {
         children.push(parseResult.segment);
-        if ((0, has_all_info_1.hasAllInfo)({ fields, state, structure: topLevelStructure })) {
+        if ((0, has_all_info_1.hasAllInfo)({ fields, state })) {
             return {
                 status: 'done',
                 segment: parseResult.segment,
             };
         }
         if (parseResult.segment.type === 'Tracks') {
-            state.tracks.setIsDone();
+            state.callbacks.tracks.setIsDone();
         }
     }
     if (parseResult.status === 'incomplete') {
@@ -38,10 +38,10 @@ const processParseResult = ({ parseResult, children, state, fields, topLevelStru
         segment: parseResult.segment,
     };
 };
-const expectAndProcessSegment = async ({ iterator, parserContext, offset, children, fields, topLevelStructure, }) => {
+const expectAndProcessSegment = async ({ iterator, state, offset, children, fields, topLevelStructure, }) => {
     const segment = await (0, segments_1.expectSegment)({
         iterator,
-        parserContext,
+        state,
         offset,
         children,
         fields,
@@ -50,13 +50,13 @@ const expectAndProcessSegment = async ({ iterator, parserContext, offset, childr
     return processParseResult({
         children,
         parseResult: segment,
-        state: parserContext.parserState,
+        state,
         fields,
         topLevelStructure,
     });
 };
 exports.expectAndProcessSegment = expectAndProcessSegment;
-const continueAfterSegmentResult = async ({ result, length, children, parserContext, iterator, startOffset, fields, topLevelStructure, }) => {
+const continueAfterSegmentResult = async ({ result, length, children, state, iterator, startOffset, fields, topLevelStructure, }) => {
     if (result.status === 'done') {
         throw new Error('Should not continue after done');
     }
@@ -70,7 +70,7 @@ const continueAfterSegmentResult = async ({ result, length, children, parserCont
                     children,
                     iterator,
                     length,
-                    parserContext,
+                    state,
                     startOffset,
                     fields,
                     topLevelStructure,
@@ -87,7 +87,7 @@ const continueAfterSegmentResult = async ({ result, length, children, parserCont
                 children,
                 iterator,
                 length,
-                parserContext,
+                state,
                 startOffset,
                 fields,
                 topLevelStructure,
@@ -96,7 +96,7 @@ const continueAfterSegmentResult = async ({ result, length, children, parserCont
         skipTo: null,
     };
 };
-const expectChildren = async ({ iterator, length, children, parserContext, startOffset, fields, topLevelStructure, }) => {
+const expectChildren = async ({ iterator, length, children, state, startOffset, fields, topLevelStructure, }) => {
     while (iterator.counter.getOffset() < startOffset + length) {
         if (iterator.bytesRemaining() === 0) {
             break;
@@ -104,7 +104,7 @@ const expectChildren = async ({ iterator, length, children, parserContext, start
         const currentOffset = iterator.counter.getOffset();
         const child = await (0, exports.expectAndProcessSegment)({
             iterator,
-            parserContext,
+            state,
             offset: currentOffset,
             children,
             fields,
@@ -112,8 +112,7 @@ const expectChildren = async ({ iterator, length, children, parserContext, start
         });
         if ((0, has_all_info_1.hasAllInfo)({
             fields,
-            state: parserContext.parserState,
-            structure: topLevelStructure,
+            state,
         })) {
             return {
                 status: 'done',
@@ -128,7 +127,7 @@ const expectChildren = async ({ iterator, length, children, parserContext, start
                         children,
                         iterator,
                         length: length - (currentOffset - startOffset),
-                        parserContext,
+                        state,
                         startOffset: currentOffset,
                         fields,
                         topLevelStructure,

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

@@ -1,13 +1,13 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { Options, ParseMediaFields } from '../../options';
 import type { ExpectSegmentParseResult, MatroskaStructure } from '../../parse-result';
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import { type PossibleEbml, type TrackEntry } from './segments/all-segments';
 export type MatroskaSegment = PossibleEbml;
 export type OnTrackEntrySegment = (trackEntry: TrackEntry) => void;
-export declare const expectSegment: ({ iterator, parserContext, offset, children, fields, topLevelStructure, }: {
+export declare const expectSegment: ({ iterator, state, offset, children, fields, topLevelStructure, }: {
     iterator: BufferIterator;
-    parserContext: ParserContext;
+    state: ParserState;
     offset: number;
     children: PossibleEbml[];
     fields: Options<ParseMediaFields>;

package/dist/boxes/webm/segments.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectSegment = void 0;
 const parse_ebml_1 = require("./parse-ebml");
 const parse_children_1 = require("./segments/parse-children");
-const continueAfterMatroskaParseResult = async ({ result, iterator, parserContext, segment, }) => {
+const continueAfterMatroskaParseResult = async ({ result, iterator, state, segment, }) => {
     if (result.status === 'done') {
         throw new Error('Should not continue after done');
     }
@@ -19,7 +19,7 @@ const continueAfterMatroskaParseResult = async ({ result, iterator, parserContex
             return continueAfterMatroskaParseResult({
                 result: proceeded,
                 iterator,
-                parserContext,
+                state,
                 segment,
             });
         },
@@ -27,7 +27,7 @@ const continueAfterMatroskaParseResult = async ({ result, iterator, parserContex
         status: 'incomplete',
     };
 };
-const expectSegment = async ({ iterator, parserContext, offset, children, fields, topLevelStructure, }) => {
+const expectSegment = async ({ iterator, state, offset, children, fields, topLevelStructure, }) => {
     iterator.counter.decrement(iterator.counter.getOffset() - offset);
     if (iterator.bytesRemaining() === 0) {
         return {
@@ -35,7 +35,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
             continueParsing: () => {
                 return (0, parse_children_1.expectAndProcessSegment)({
                     iterator,
-                    parserContext,
+                    state,
                     offset,
                     children,
                     fields,
@@ -53,7 +53,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
             continueParsing: () => {
                 return (0, parse_children_1.expectAndProcessSegment)({
                     iterator,
-                    parserContext,
+                    state,
                     offset,
                     children,
                     fields,
@@ -73,7 +73,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
             continueParsing: () => {
                 return (0, exports.expectSegment)({
                     iterator,
-                    parserContext,
+                    state,
                     offset,
                     children,
                     fields,
@@ -94,7 +94,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
             iterator,
             length,
             children: newSegment.value,
-            parserContext,
+            state,
             startOffset: iterator.counter.getOffset(),
             fields,
             topLevelStructure,
@@ -105,7 +105,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
                 continueParsing: () => {
                     return continueAfterMatroskaParseResult({
                         iterator,
-                        parserContext,
+                        state,
                         result: main,
                         segment: newSegment,
                     });
@@ -127,7 +127,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
             continueParsing: () => {
                 return (0, exports.expectSegment)({
                     iterator,
-                    parserContext,
+                    state,
                     offset,
                     children,
                     fields,
@@ -140,7 +140,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
         segmentId,
         iterator,
         length,
-        parserContext,
+        state,
         headerReadSoFar: iterator.counter.getOffset() - offset,
     });
     return {
@@ -149,13 +149,13 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
     };
 };
 exports.expectSegment = expectSegment;
-const parseSegment = async ({ segmentId, iterator, length, parserContext, headerReadSoFar, }) => {
+const parseSegment = async ({ segmentId, iterator, length, state, headerReadSoFar, }) => {
     if (length < 0) {
         throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
     }
     iterator.counter.decrement(headerReadSoFar);
     const offset = iterator.counter.getOffset();
-    const ebml = await (0, parse_ebml_1.parseEbml)(iterator, parserContext);
-    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, parserContext });
+    const ebml = await (0, parse_ebml_1.parseEbml)(iterator, state);
+    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, state });
     return remapped;
 };

package/dist/buffer-iterator.d.ts

@@ -20,16 +20,14 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getBits: (bits: number) => number;
     byteLength: () => number;
     bytesRemaining: () => number;
-    isIsoBaseMedia: () => boolean;
     leb128: () => number;
     removeBytesRead: () => void;
-    isWebm: () => boolean;
     discard: (length: number) => void;
     getEightByteNumber: (littleEndian?: boolean) => number;
     getFourByteNumber: () => number;
-    getSlice: (amount: number) => Uint8Array;
+    getSlice: (amount: number) => Uint8Array<ArrayBuffer>;
     getAtom: () => string;
-    isRiff: () => boolean;
+    detectFileType: () => import("./file-types/detect-file-type").FileType;
     getPaddedFourByteNumber: () => number;
     getMatroskaSegmentId: () => string | null;
     getVint: () => number | null;
@@ -57,14 +55,12 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getInt32Le: () => number;
     getInt32: () => number;
     destroy: () => void;
-    isMp3: () => boolean;
     disallowDiscard: () => void;
     allowDiscard: () => void;
     startBox: (size: number) => {
         discardRest: () => void;
         expectNoMoreBytes: () => void;
     };
-    isTransportStream: () => boolean;
     readExpGolomb: () => number;
 };
 export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/buffer-iterator.js

@@ -14,8 +14,8 @@ var _OffsetCounter_offset, _OffsetCounter_discardedBytes;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getArrayBufferIterator = exports.OffsetCounter = void 0;
 /* eslint-disable @typescript-eslint/no-use-before-define */
-const make_header_1 = require("./boxes/webm/make-header");
 const all_segments_1 = require("./boxes/webm/segments/all-segments");
+const file_types_1 = require("./file-types");
 class OffsetCounter {
     constructor(initial) {
         _OffsetCounter_offset.set(this, void 0);
@@ -53,14 +53,6 @@ class OffsetCounter {
 }
 exports.OffsetCounter = OffsetCounter;
 _OffsetCounter_offset = new WeakMap(), _OffsetCounter_discardedBytes = new WeakMap();
-const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
-const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
-const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
-const matchesPattern = (pattern) => {
-    return (data) => {
-        return pattern.every((value, index) => data[index] === value);
-    };
-};
 const makeOffsetCounter = () => {
     return new OffsetCounter(0);
 };
@@ -211,21 +203,6 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     const bytesRemaining = () => {
         return data.byteLength - counter.getDiscardedOffset();
     };
-    const isIsoBaseMedia = () => {
-        return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
-    };
-    const isRiff = () => {
-        return matchesPattern(riffPattern)(data.subarray(0, 4));
-    };
-    const isWebm = () => {
-        return matchesPattern(make_header_1.webmPattern)(data.subarray(0, 4));
-    };
-    const isMp3 = () => {
-        return matchesPattern(mpegPattern)(data.subarray(0, 4));
-    };
-    const isTransportStream = () => {
-        return data[0] === 0x47;
-    };
     const removeBytesRead = () => {
         if (!discardAllowed) {
             return;
@@ -348,10 +325,8 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         getBits,
         byteLength,
         bytesRemaining,
-        isIsoBaseMedia,
         leb128,
         removeBytesRead,
-        isWebm,
         discard,
         getEightByteNumber,
         getFourByteNumber,
@@ -360,7 +335,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             const atom = getSlice(4);
             return new TextDecoder().decode(atom);
         },
-        isRiff,
+        detectFileType: () => {
+            return (0, file_types_1.detectFileType)(data);
+        },
         getPaddedFourByteNumber,
         getMatroskaSegmentId: () => {
             if (bytesRemaining() === 0) {
@@ -533,11 +510,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         getInt32Le,
         getInt32,
         destroy,
-        isMp3,
         disallowDiscard,
         allowDiscard,
         startBox,
-        isTransportStream,
         readExpGolomb,
     };
 };

package/dist/convert-audio-or-video-sample.js

@@ -12,6 +12,8 @@ const convertAudioOrVideoSampleToWebCodecsTimestamps = (sample, timescale) => {
         data: sample.data,
         trackId: sample.trackId,
         type: sample.type,
+        offset: sample.offset,
+        timescale: 1000000,
     };
 };
 exports.convertAudioOrVideoSampleToWebCodecsTimestamps = convertAudioOrVideoSampleToWebCodecsTimestamps;

package/dist/create/iso-base-media/codec-specific/avc1.d.ts

@@ -1,2 +1,2 @@
 import type { Avc1Data } from './create-codec-specific-data';
-export declare const createAvc1Data: ({ avccBox, pasp, width, height, horizontalResolution, verticalResolution, compressorName, depth, }: Avc1Data) => Uint8Array;
+export declare const createAvc1Data: ({ avccBox, pasp, width, height, horizontalResolution, verticalResolution, compressorName, depth, }: Avc1Data) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/codec-specific/create-codec-specific-data.d.ts

@@ -19,4 +19,4 @@ export type Mp4aData = {
     codecPrivate: Uint8Array | null;
 };
 export type CodecSpecificData = Avc1Data | Mp4aData;
-export declare const createCodecSpecificData: (track: MakeTrackAudio | MakeTrackVideo) => Uint8Array;
+export declare const createCodecSpecificData: (track: MakeTrackAudio | MakeTrackVideo) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/codec-specific/mp4a.d.ts

@@ -1,2 +1,2 @@
 import type { Mp4aData } from './create-codec-specific-data';
-export declare const createMp4a: ({ sampleRate, channelCount, avgBitrate, maxBitrate, codecPrivate, }: Mp4aData) => Uint8Array;
+export declare const createMp4a: ({ sampleRate, channelCount, avgBitrate, maxBitrate, codecPrivate, }: Mp4aData) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/create-colr.d.ts

@@ -3,4 +3,4 @@ export declare const createColr: ({ fullRange, matrixIndex, primaries, transferF
     matrixIndex: number;
     primaries: number;
     transferFunction: number;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/create-ftyp.d.ts

@@ -2,9 +2,9 @@ export declare const createFtyp: ({ majorBrand, minorBrand, compatibleBrands, }:
     majorBrand: string;
     minorBrand: number;
     compatibleBrands: string[];
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;
 export declare const createIsoBaseMediaFtyp: ({ majorBrand, minorBrand, compatibleBrands, }: {
     majorBrand: string;
     minorBrand: number;
     compatibleBrands: string[];
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/create-ilst.d.ts

@@ -1 +1 @@
-export declare const createIlst: (items: Uint8Array[]) => Uint8Array;
+export declare const createIlst: (items: Uint8Array[]) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/create-mdia.d.ts

@@ -2,4 +2,4 @@ export declare const createMdia: ({ mdhd, hdlr, minf, }: {
     mdhd: Uint8Array;
     hdlr: Uint8Array;
     minf: Uint8Array;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/create-moov.d.ts

@@ -2,4 +2,4 @@ export declare const createMoov: ({ mvhd, traks, udta, }: {
     mvhd: Uint8Array;
     traks: Uint8Array[];
     udta: Uint8Array;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;