@remotion/media-parser 4.0.256 → 4.0.257

package/dist/boxes/webm/segments/block-simple-block-flags.d.ts

@@ -1,9 +0,0 @@
-import type { BufferIterator } from '../../../buffer-iterator';
-import { matroskaElements } from './all-segments';
-type BlockFlags = {
-    invisible: boolean;
-    lacing: number;
-    keyframe: boolean | null;
-};
-export declare const parseBlockFlags: (iterator: BufferIterator, type: (typeof matroskaElements)["Block"] | (typeof matroskaElements)["SimpleBlock"]) => BlockFlags;
-export {};

package/dist/boxes/webm/segments/block-simple-block-flags.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBlockFlags = void 0;
-const all_segments_1 = require("./all-segments");
-const parseBlockFlags = (iterator, type) => {
-    if (type === all_segments_1.matroskaElements.Block) {
-        iterator.startReadingBits();
-        // Reserved
-        iterator.getBits(4);
-        const invisible = Boolean(iterator.getBits(1));
-        const lacing = iterator.getBits(2);
-        // unused
-        iterator.getBits(1);
-        iterator.stopReadingBits();
-        return {
-            invisible,
-            lacing,
-            keyframe: null,
-        };
-    }
-    if (type === all_segments_1.matroskaElements.SimpleBlock) {
-        iterator.startReadingBits();
-        const keyframe = Boolean(iterator.getBits(1));
-        // Reserved
-        iterator.getBits(3);
-        const invisible = Boolean(iterator.getBits(1));
-        const lacing = iterator.getBits(2);
-        iterator.getBits(1);
-        iterator.stopReadingBits();
-        return {
-            invisible,
-            lacing,
-            keyframe,
-        };
-    }
-    throw new Error('Unexpected type');
-};
-exports.parseBlockFlags = parseBlockFlags;

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

@@ -1,23 +0,0 @@
-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 { MatroskaSegment } from '../segments';
-import type { PossibleEbml } from './all-segments';
-export declare const expectAndProcessSegment: ({ iterator, parserContext, offset, children, fields, topLevelStructure, }: {
-    iterator: BufferIterator;
-    parserContext: ParserContext;
-    offset: number;
-    children: PossibleEbml[];
-    fields: Options<ParseMediaFields>;
-    topLevelStructure: MatroskaStructure;
-}) => Promise<ExpectSegmentParseResult>;
-export declare const expectChildren: ({ iterator, length, children, parserContext, startOffset, fields, topLevelStructure, }: {
-    iterator: BufferIterator;
-    length: number;
-    children: MatroskaSegment[];
-    parserContext: ParserContext;
-    startOffset: number;
-    fields: Options<ParseMediaFields>;
-    topLevelStructure: MatroskaStructure;
-}) => Promise<MatroskaParseResult>;

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

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectChildren = exports.expectAndProcessSegment = void 0;
-const has_all_info_1 = require("../../../has-all-info");
-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 })) {
-            return {
-                status: 'done',
-                segment: parseResult.segment,
-            };
-        }
-        if (parseResult.segment.type === 'Tracks') {
-            state.tracks.setIsDone();
-        }
-    }
-    if (parseResult.status === 'incomplete') {
-        // No need to decrement because expectSegment already does it
-        return {
-            status: 'incomplete',
-            segment: parseResult.segment,
-            continueParsing: async () => {
-                const newParseResult = await parseResult.continueParsing();
-                return processParseResult({
-                    children,
-                    parseResult: newParseResult,
-                    state,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-        };
-    }
-    return {
-        status: 'done',
-        segment: parseResult.segment,
-    };
-};
-const expectAndProcessSegment = async ({ iterator, parserContext, offset, children, fields, topLevelStructure, }) => {
-    const segment = await (0, segments_1.expectSegment)({
-        iterator,
-        parserContext,
-        offset,
-        children,
-        fields,
-        topLevelStructure,
-    });
-    return processParseResult({
-        children,
-        parseResult: segment,
-        state: parserContext.parserState,
-        fields,
-        topLevelStructure,
-    });
-};
-exports.expectAndProcessSegment = expectAndProcessSegment;
-const continueAfterSegmentResult = async ({ result, length, children, parserContext, iterator, startOffset, fields, topLevelStructure, }) => {
-    if (result.status === 'done') {
-        throw new Error('Should not continue after done');
-    }
-    const segmentResult = await result.continueParsing();
-    if (segmentResult.status === 'done') {
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                return (0, exports.expectChildren)({
-                    children,
-                    iterator,
-                    length,
-                    parserContext,
-                    startOffset,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            skipTo: null,
-        };
-    }
-    return {
-        status: 'incomplete',
-        continueParsing: () => {
-            return continueAfterSegmentResult({
-                result: segmentResult,
-                children,
-                iterator,
-                length,
-                parserContext,
-                startOffset,
-                fields,
-                topLevelStructure,
-            });
-        },
-        skipTo: null,
-    };
-};
-const expectChildren = async ({ iterator, length, children, parserContext, startOffset, fields, topLevelStructure, }) => {
-    while (iterator.counter.getOffset() < startOffset + length) {
-        if (iterator.bytesRemaining() === 0) {
-            break;
-        }
-        const currentOffset = iterator.counter.getOffset();
-        const child = await (0, exports.expectAndProcessSegment)({
-            iterator,
-            parserContext,
-            offset: currentOffset,
-            children,
-            fields,
-            topLevelStructure,
-        });
-        if ((0, has_all_info_1.hasAllInfo)({
-            fields,
-            state: parserContext.parserState,
-            structure: topLevelStructure,
-        })) {
-            return {
-                status: 'done',
-            };
-        }
-        if (child.status === 'incomplete') {
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return continueAfterSegmentResult({
-                        result: child,
-                        children,
-                        iterator,
-                        length: length - (currentOffset - startOffset),
-                        parserContext,
-                        startOffset: currentOffset,
-                        fields,
-                        topLevelStructure,
-                    });
-                },
-                skipTo: null,
-            };
-        }
-    }
-    return {
-        status: 'done',
-    };
-};
-exports.expectChildren = expectChildren;

package/dist/boxes/webm/segments/track-entry.d.ts

@@ -1,9 +0,0 @@
-import type { TrackEntry } from './all-segments';
-export type TrackInfo = {
-    codec: string;
-    trackTimescale: number | null;
-};
-type TrackType = 'video' | 'audio' | 'complex' | 'subtitle' | 'button' | 'control' | 'metadata';
-export declare const trackTypeToString: (trackType: number) => TrackType;
-export type GetTracks = () => TrackEntry[];
-export {};

package/dist/boxes/webm/segments/track-entry.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackTypeToString = void 0;
-const trackTypeToString = (trackType) => {
-    switch (trackType) {
-        case 1:
-            return 'video';
-        case 2:
-            return 'audio';
-        case 3:
-            return 'complex';
-        case 4:
-            return 'subtitle';
-        case 5:
-            return 'button';
-        case 6:
-            return 'control';
-        case 7:
-            return 'metadata';
-        default:
-            throw new Error(`Unknown track type: ${trackType}`);
-    }
-};
-exports.trackTypeToString = trackTypeToString;

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

@@ -1,15 +0,0 @@
-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 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, }: {
-    iterator: BufferIterator;
-    parserContext: ParserContext;
-    offset: number;
-    children: PossibleEbml[];
-    fields: Options<ParseMediaFields>;
-    topLevelStructure: MatroskaStructure;
-}) => Promise<ExpectSegmentParseResult>;

package/dist/boxes/webm/segments.js

@@ -1,161 +0,0 @@
-"use strict";
-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, }) => {
-    if (result.status === 'done') {
-        throw new Error('Should not continue after done');
-    }
-    const proceeded = await result.continueParsing();
-    if (proceeded.status === 'done') {
-        return {
-            status: 'done',
-            segment,
-        };
-    }
-    return {
-        continueParsing() {
-            return continueAfterMatroskaParseResult({
-                result: proceeded,
-                iterator,
-                parserContext,
-                segment,
-            });
-        },
-        segment: null,
-        status: 'incomplete',
-    };
-};
-const expectSegment = async ({ iterator, parserContext, offset, children, fields, topLevelStructure, }) => {
-    iterator.counter.decrement(iterator.counter.getOffset() - offset);
-    if (iterator.bytesRemaining() === 0) {
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, parse_children_1.expectAndProcessSegment)({
-                    iterator,
-                    parserContext,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
-    }
-    const segmentId = iterator.getMatroskaSegmentId();
-    if (segmentId === null) {
-        iterator.counter.decrement(iterator.counter.getOffset() - offset);
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, parse_children_1.expectAndProcessSegment)({
-                    iterator,
-                    parserContext,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
-    }
-    const offsetBeforeVInt = iterator.counter.getOffset();
-    const length = iterator.getVint();
-    const offsetAfterVInt = iterator.counter.getOffset();
-    if (length === null) {
-        iterator.counter.decrement(iterator.counter.getOffset() - offset);
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, exports.expectSegment)({
-                    iterator,
-                    parserContext,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
-    }
-    const bytesRemainingNow = iterator.byteLength() - iterator.counter.getOffset();
-    if (segmentId === '0x18538067' || segmentId === '0x1f43b675') {
-        const newSegment = {
-            type: segmentId === '0x18538067' ? 'Segment' : 'Cluster',
-            minVintWidth: offsetAfterVInt - offsetBeforeVInt,
-            value: [],
-        };
-        const main = await (0, parse_children_1.expectChildren)({
-            iterator,
-            length,
-            children: newSegment.value,
-            parserContext,
-            startOffset: iterator.counter.getOffset(),
-            fields,
-            topLevelStructure,
-        });
-        if (main.status === 'incomplete') {
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return continueAfterMatroskaParseResult({
-                        iterator,
-                        parserContext,
-                        result: main,
-                        segment: newSegment,
-                    });
-                },
-                segment: newSegment,
-            };
-        }
-        return {
-            status: 'done',
-            segment: newSegment,
-        };
-    }
-    if (bytesRemainingNow < length) {
-        const bytesRead = iterator.counter.getOffset() - offset;
-        iterator.counter.decrement(bytesRead);
-        return {
-            status: 'incomplete',
-            segment: null,
-            continueParsing: () => {
-                return (0, exports.expectSegment)({
-                    iterator,
-                    parserContext,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-        };
-    }
-    const segment = await parseSegment({
-        segmentId,
-        iterator,
-        length,
-        parserContext,
-        headerReadSoFar: iterator.counter.getOffset() - offset,
-    });
-    return {
-        status: 'done',
-        segment,
-    };
-};
-exports.expectSegment = expectSegment;
-const parseSegment = async ({ segmentId, iterator, length, parserContext, 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 });
-    return remapped;
-};

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

@@ -1,33 +0,0 @@
-import type { MatroskaSegment } from './segments';
-import type { AudioSegment, ClusterSegment, CodecIdSegment, ColourSegment, DisplayHeightSegment, DisplayWidthSegment, HeightSegment, MainSegment, MatrixCoefficientsSegment, PrimariesSegment, RangeSegment, TimestampScaleSegment, TrackEntry, TrackTypeSegment, TransferCharacteristicsSegment, VideoSegment, WidthSegment } from './segments/all-segments';
-export declare const getMainSegment: (segments: MatroskaSegment[]) => MainSegment | null;
-export declare const getTrackNumber: (track: TrackEntry) => import("./segments/all-segments").UintWithSize | null;
-export declare const getTrackCodec: (track: TrackEntry) => CodecIdSegment | null;
-export declare const getTrackTimestampScale: (track: TrackEntry) => import("./segments/all-segments").FloatWithSize | null;
-export declare const getTrackByNumber: (tracks: TrackEntry[], id: number) => TrackEntry | undefined;
-export declare const getTrackId: (track: TrackEntry) => number;
-export declare const getCodecSegment: (track: TrackEntry) => CodecIdSegment | null;
-export declare const getColourSegment: (track: TrackEntry) => ColourSegment | null;
-export declare const getTransferCharacteristicsSegment: (color: ColourSegment) => TransferCharacteristicsSegment | null;
-export declare const getMatrixCoefficientsSegment: (color: ColourSegment) => MatrixCoefficientsSegment | null;
-export declare const getPrimariesSegment: (color: ColourSegment) => PrimariesSegment | null;
-export declare const getRangeSegment: (color: ColourSegment) => RangeSegment | null;
-export declare const getDisplayHeightSegment: (track: TrackEntry) => DisplayHeightSegment | null;
-export declare const getTrackTypeSegment: (track: TrackEntry) => TrackTypeSegment | null;
-export declare const getWidthSegment: (track: TrackEntry) => WidthSegment | null;
-export declare const getHeightSegment: (track: TrackEntry) => HeightSegment | null;
-export declare const getDisplayWidthSegment: (track: TrackEntry) => DisplayWidthSegment | null;
-export declare const getTracksSegment: (segment: MainSegment) => {
-    type: "Tracks";
-    value: import("./segments/all-segments").PossibleEbml[];
-    minVintWidth: number | null;
-} | null;
-export declare const getTrackWithUid: (segment: MainSegment, trackUid: string) => number | null;
-export declare const getTimescaleSegment: (segment: MainSegment) => TimestampScaleSegment | null;
-export declare const getVideoSegment: (track: TrackEntry) => VideoSegment | null;
-export declare const getAudioSegment: (track: TrackEntry) => AudioSegment | null;
-export declare const getSampleRate: (track: TrackEntry) => number | null;
-export declare const getNumberOfChannels: (track: TrackEntry) => number;
-export declare const getBitDepth: (track: TrackEntry) => number | null;
-export declare const getPrivateData: (track: TrackEntry) => Uint8Array | null;
-export declare const getClusterSegment: (segment: MainSegment) => ClusterSegment | null;