@vkontakte/videoplayer-core 2.0.131-dev.abb2b2b1.0 → 2.0.131-dev.c93c80a1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.131-dev.abb2b2b1.0",
+  "version": "2.0.131-dev.c93c80a1.0",
   "author": "vk.com",
   "description": "Videoplayer core library based on the vk.com platform",
   "homepage": "https://vk.com",
@@ -54,7 +54,7 @@
     "**/*.d.ts"
   ],
   "dependencies": {
-    "@vkontakte/videoplayer-shared": "1.0.58",
+    "@vkontakte/videoplayer-shared": "1.0.59-dev.3ed4b6b9.0",
     "hls.js": "~1.4.7"
   }
 }

package/types/providers/DashProvider/baseDashProvider.d.ts

@@ -41,6 +41,7 @@ export default abstract class BaseDashProvider implements IProvider {
     protected audioStreamsMap: Map<Stream, IAudioTrack[]>;
     protected videoTrackSwitchHistory: TrackHistory<IVideoTrack>;
     protected audioTrackSwitchHistory: TrackHistory<import("../../player/types").IBaseTrack>;
+    private readonly selectedRepresentations;
     constructor(params: IParams);
     protected abstract seek(position: Milliseconds, forcePrecise: boolean): void;
     protected getProviderSubscriptionInfo(): IProviderSubscriptionInfo;

package/types/providers/DashProvider/lib/buffer.d.ts

@@ -12,6 +12,7 @@ export interface Dependencies {
 }
 export interface Gap extends IRange<Milliseconds> {
     representation: Representation['id'];
+    persistent: boolean;
 }
 export declare class BufferManager {
     currentLiveSegmentServerLatency$: IValueSubject<number>;
@@ -60,6 +61,7 @@ export declare class BufferManager {
     private index;
     private lastDataObtainedTimestampMs;
     private loadByteRangeSegmentsTimeoutId;
+    private sourceBufferBufferedDiff;
     constructor(kind: StreamKind, mediaSource: MediaSource, representations: Representation[], { fetcher, tuning, getCurrentPosition, isActiveLowLatency, compatibilityMode, manifest }: Dependencies);
     startWith: (param_0: string) => Promise<void | undefined>;
     switchToWithPreviousAbort(newRepresentationId: Representation['id'], dropBuffer?: boolean): void;
@@ -108,6 +110,7 @@ export declare class BufferManager {
     private pruneBuffer;
     private abortBuffer;
     getDebugBufferState(): IRange<Milliseconds> | undefined;
+    getBufferedTo(): number | null;
     getForwardBufferDuration(currentPosition?: Milliseconds | undefined): Milliseconds;
     private detectGaps;
     private detectGapsWhenIdle;

package/types/providers/DashProvider/lib/fetcher.d.ts

@@ -42,9 +42,9 @@ export declare class Fetcher {
     recoverableError$: Subject<IError>;
     error$: Subject<IError>;
     private abortAllController;
-    private subscription;
     private compatibilityMode;
     private useEnableSubtitlesParam;
+    private readonly subscription;
     constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam }: IParams);
     private onHeadersReceived;
     fetchManifest: (param_0: string) => Promise<string | null | undefined>;
@@ -54,5 +54,6 @@ export declare class Fetcher {
     private fetchByteRangeRepresentation;
     private fetchTemplateRepresentation;
     private doFetch;
+    private unsubscribeAbortSubscription;
 }
 export declare const suppressAbort: (e: Error | unknown) => void | never;

package/types/providers/DashProvider/lib/player.d.ts

@@ -68,6 +68,7 @@ export declare class Player {
     private stallWatchdogSubscription;
     private livePauseWatchdogSubscription;
     private destroyController;
+    private initedPruneBufferCallback;
     constructor(params: Params);
     initManifest: (param_0: HTMLVideoElement, param_1: string, param_2: number) => Promise<void | undefined>;
     updateManifest: () => Promise<Manifest | null | undefined>;

package/types/providers/DashProvider/lib/sourceBufferBufferedDiff.d.ts

@@ -0,0 +1,19 @@
+export declare class SourceBufferBufferedDiff {
+    private lastUpdateTs;
+    private lastCallTs;
+    private prevRanges;
+    private readonly sourceBuffer;
+    private readonly mediaSource;
+    private readonly subscription;
+    constructor(mediaSource: MediaSource, sourceBuffer: SourceBuffer);
+    private updateend;
+    /**
+     * если длина массивов разная - считаем, что какие то сегменты удалили
+     *
+     * если длина одинаковая - считаем, что сегменты удалили в том случае,
+     * если в новом массиве хотя бы 1 сегмент стал меньше
+     */
+    private isRangesRemoved;
+    wasUpdated(): boolean;
+    destroy(): void;
+}

package/types/providers/DashProvider/lib/utils.d.ts

@@ -1,5 +1,6 @@
 import { Representation, Segment, SegmentReference, Stream, TemplateSegment, TemplateSegmentReference, TextRepresentation } from '../../../providers/DashProvider/lib/types';
 import { IAudioStream, IAudioTrack, IInternalTextTrack, IVideoStream, IVideoTrack } from '../../../player/types';
+import { IRange, Milliseconds } from '@vkontakte/videoplayer-shared';
 export declare const representationToVideoTrack: ({ id, width, height, bitrate, fps, quality: qualityString, streamId }: Representation) => IVideoTrack | undefined;
 export declare const representationToAudioTrack: ({ id, bitrate }: Representation) => IAudioTrack;
 export declare const representationToTextTrack: ({ language, label }: Stream, { id, url, isAuto }: Representation & {
@@ -13,3 +14,13 @@ export declare const isTemplateSegment: (segment: Segment) => segment is Templat
 export declare const isTemplateSegmentReference: (segmentReference: SegmentReference) => segmentReference is TemplateSegmentReference;
 export declare const isAbortError: (e: Error | unknown) => boolean;
 export declare const isTextRepresentation: (representation: Representation | TextRepresentation) => representation is TextRepresentation;
+/**
+ * @mutates intervals
+ */
+export declare const mergeIntervals: (intervals: IRange<Milliseconds>[]) => IRange<Milliseconds>[];
+export declare const findInIterator: <T>(iterable: MapIterator<T> | SetIterator<T>, matchFn: (arg: T) => boolean) => T | null;
+/**
+ * даёт `true` каждые `ms` миллисекунд
+ */
+export declare const semaphor: (ms: number) => () => boolean;
+export declare const createTimeRanges: (buffered: TimeRanges) => number[];

package/types/providers/DashProviderNew/baseDashProvider.d.ts

@@ -0,0 +1,57 @@
+import { IAudioTrack, IDashURLSource, IHLSSource, IInternalTextTrack, IVideoTrack } from '../../player/types';
+import { CommonInit, IProviderSubscriptionInfo, ProviderState, Representation, Stream } from './lib/types';
+import { IProvider, IProviderParams } from '../../providers/types';
+import { TrackHistory } from '../../utils/autoSelectTrack';
+import { IStateMachine } from '../../utils/StateMachine/types';
+import { ISubscription, ITracer, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Player } from './lib/player';
+import { Scene3D } from '../../utils/3d/Scene3D';
+import DroppedFramesManager from '../../providers/utils/HTMLVideoElement/DroppedFramesManager';
+import TextTrackManager from '../../providers/utils/HTMLVideoElement/TextTrackManager';
+import StallsManager from '../../providers/utils/StallsManager';
+import { ElementSizeManager } from './lib/ElementSizeManager';
+type IParams = IProviderParams<IDashURLSource> & {
+    sourceHls?: IHLSSource;
+};
+export default abstract class BaseDashProvider implements IProvider {
+    scene3D: Scene3D | undefined;
+    protected subscription: ISubscription;
+    protected videoState: IStateMachine<ProviderState>;
+    protected video: HTMLVideoElement;
+    protected player: Player;
+    protected params: IParams;
+    protected tracer: ITracer;
+    protected textTracksManager: TextTrackManager;
+    protected droppedFramesManager: DroppedFramesManager;
+    protected stallsManager: StallsManager;
+    protected elementSizeManager: ElementSizeManager;
+    protected videoTracksMap: Map<IVideoTrack, {
+        stream: Stream;
+        representation: Representation;
+    }>;
+    protected audioTracksMap: Map<IAudioTrack, {
+        stream: Stream;
+        representation: Representation;
+    }>;
+    protected textTracksMap: Map<IInternalTextTrack, {
+        stream: Stream;
+        representation: Representation;
+    }>;
+    protected videoStreamsMap: Map<Stream, IVideoTrack[]>;
+    protected audioStreamsMap: Map<Stream, IAudioTrack[]>;
+    protected videoTrackSwitchHistory: TrackHistory<IVideoTrack>;
+    protected audioTrackSwitchHistory: TrackHistory<import("../../player/types").IBaseTrack>;
+    private readonly selectedRepresentations;
+    constructor(params: IParams);
+    protected abstract seek(position: Milliseconds, forcePrecise: boolean): void;
+    protected getProviderSubscriptionInfo(): IProviderSubscriptionInfo;
+    protected subscribe(): void;
+    protected selectVideoAudioRepresentations(): [Representation, Representation | undefined] | undefined;
+    protected prepare(manifestOffset?: number): void;
+    protected syncPlayback: () => undefined;
+    protected init3DScene: (init: CommonInit) => void;
+    protected destroy3DScene: () => void;
+    protected playIfAllowed(): void;
+    destroy(): void;
+}
+export {};

package/types/providers/DashProviderNew/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const DASH_LIVE_UPDATE_INTERVAL_MS = 1000;
+export declare const DASH_STALL_UPDATE_INTERVAL_MS = 50;
+export declare const DASH_LIVE_STALL_REINIT_INTERVAL_MS = 2000;

package/types/providers/DashProviderNew/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NewDashProvider } from './newDashProvider';
+export { default as NewDashCmafLiveProvider } from './newDashCmafLiveProvider';

package/types/providers/DashProviderNew/lib/ElementSizeManager.d.ts

@@ -0,0 +1,19 @@
+import { IObservableVideo } from '../../../providers/utils/HTMLVideoElement/observable';
+import { IListener, IRectangle, ISubscription, ValueSubject } from '@vkontakte/videoplayer-shared';
+interface ConnectParams {
+    video: HTMLVideoElement;
+    observableVideo: IObservableVideo;
+}
+export declare class ElementSizeManager {
+    private readonly subscription;
+    private readonly pipSize$;
+    private readonly videoSize$;
+    private readonly elementSize$;
+    private pictureInPictureWindowRemoveEventListener;
+    connect({ observableVideo, video }: ConnectParams): void;
+    getValue(): IRectangle<number> | undefined;
+    subscribe(listener: IListener<IRectangle<number> | undefined>, error?: IListener<Error | unknown>): ISubscription;
+    getObservable(): ValueSubject<IRectangle<number> | undefined>;
+    destroy(): void;
+}
+export {};

package/types/providers/DashProviderNew/lib/LiveTextManager.d.ts

@@ -0,0 +1,23 @@
+import { IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Dependencies } from './buffer';
+import { Manifest, Stream, TextRepresentation } from './types';
+export declare class LiveTextManager {
+    currentRepresentation$: IValueSubject<TextRepresentation | null>;
+    private readonly maxRepresentations;
+    private representationsCursor;
+    private representations;
+    private readonly getCurrentPosition;
+    private currentSegment;
+    constructor(streams: Stream[], deps: Pick<Dependencies, 'getCurrentPosition'>);
+    updateLive(manifest: Manifest | null): void;
+    seekLive(streams?: Stream[]): void;
+    maintain(currentPosition?: Milliseconds | undefined): void;
+    destroy(): void;
+    /**
+     * @todo support multi-streams
+     * @see https://jira.mvk.com/browse/VP-2420
+     */
+    private processStreams;
+    static isSupported(streams?: Stream[]): boolean;
+    private static filterRepresentations;
+}

package/types/providers/DashProviderNew/lib/buffer.d.ts

@@ -0,0 +1,117 @@
+import { ITuningConfig } from '../../../utils/tuningConfig';
+import { IError, IRange, ISubject, IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+import type { Fetcher } from './fetcher';
+import { CommonInit, Manifest, Representation, Stream, StreamKind } from './types';
+export interface Dependencies {
+    fetcher: Fetcher;
+    tuning: ITuningConfig;
+    getCurrentPosition: () => Milliseconds | undefined;
+    isActiveLowLatency: () => boolean;
+    compatibilityMode?: boolean;
+    manifest: Manifest | null;
+}
+export interface Gap extends IRange<Milliseconds> {
+    representation: Representation['id'];
+}
+export declare class BufferManager {
+    currentLiveSegmentServerLatency$: IValueSubject<number>;
+    currentLowLatencySegmentLength$: IValueSubject<number>;
+    currentSegmentLength$: IValueSubject<number>;
+    onLastSegment$: IValueSubject<boolean>;
+    fullyBuffered$: IValueSubject<boolean>;
+    playingRepresentation$: IValueSubject<Representation['id'] | undefined>;
+    playingRepresentationInit$: IValueSubject<CommonInit | undefined>;
+    error$: ISubject<IError>;
+    gaps: Gap[];
+    private subscription;
+    private kind;
+    private initData;
+    private parsedInitData;
+    private representations;
+    private segments;
+    private allInitsLoaded;
+    private activeSegments;
+    private mediaSource;
+    private playingRepresentationId;
+    private downloadingRepresentationId;
+    private switchingToRepresentationId;
+    private sourceBuffer;
+    private downloadAbortController;
+    private switchAbortController;
+    private destroyAbortController;
+    private readonly getCurrentPosition;
+    private readonly isActiveLowLatency;
+    private tuning;
+    private forwardBufferTarget;
+    private fetcher;
+    private bufferLimit;
+    private sourceBufferTaskQueue;
+    private gapDetectionIdleCallback;
+    private initLoadIdleCallback;
+    private failedDownloads;
+    private baseUrls;
+    private baseUrlsIndex;
+    private compatibilityMode;
+    private preloadOnly;
+    private isLive;
+    private liveUpdateSegmentIndex;
+    private liveInitialAdditionalOffset;
+    private isSeekingLive;
+    private index;
+    private lastDataObtainedTimestampMs;
+    private loadByteRangeSegmentsTimeoutId;
+    constructor(kind: StreamKind, mediaSource: MediaSource, representations: Representation[], { fetcher, tuning, getCurrentPosition, isActiveLowLatency, compatibilityMode, manifest }: Dependencies);
+    startWith: (param_0: string) => Promise<void | undefined>;
+    switchToWithPreviousAbort(newRepresentationId: Representation['id'], dropBuffer?: boolean): void;
+    switchTo: (param_0: string, param_1: boolean | undefined) => Promise<void | undefined>;
+    switchToOld: (param_0: string, param_1: boolean | undefined) => Promise<void | undefined>;
+    warmUpMediaSource(): void;
+    abort(): Promise<boolean>;
+    maintain(currentPosition?: Milliseconds | undefined): void;
+    get lastDataObtainedTimestamp(): number;
+    private searchGaps;
+    private getActualLiveStartingSegments;
+    getLiveSegmentsToLoadState(manifest: Manifest | null): IRange<Milliseconds> | undefined;
+    seekLive: (param_0: Stream[] | undefined) => Promise<void | undefined>;
+    updateLive(manifest: Manifest | null): void;
+    proceedLowLatencyLive(): void;
+    private updateLowLatencyLiveIfNeeded;
+    findSegmentStartTime(position: Milliseconds): Milliseconds | undefined;
+    setTarget(time: Milliseconds): void;
+    setPreloadOnly(preloadOnly: boolean): void;
+    destroy(): void;
+    private selectForwardBufferSegments;
+    private selectForwardBufferSegmentsLive;
+    private selectForwardBufferSegmentsRecord;
+    private loadSegments;
+    private loadTemplateSegment;
+    private updateRepresentationsBaseUrlIfNeeded;
+    private loadByteRangeSegments;
+    private prepareByteRangeFetchSegmentParams;
+    private prepareTemplateFetchSegmentParams;
+    private abortActiveSegments;
+    private onSomeTemplateDataLoaded;
+    /**
+     * Закидываем в буфер сегменты атомарнее чем сегмент целиком. Например, по боксам в мпеге и по блокам в вебме.
+     * Таким образом не ждём его полной загрузки и готовы играть его намного быстрее
+     * @param dataView – данные, размер буфера – весь запрос
+     * @param globalFrom – Отступ dataView от начала файла, совпадает с отсупами сегментов
+     * @param loaded – Объём загруженных в dataView данных (всё что больше – пока нули)
+     * @private
+     */
+    private onSomeByteRangesDataLoaded;
+    private onSegmentFullyAppended;
+    private abortSegment;
+    private loadNextInit;
+    private loadInit;
+    private dropBuffer;
+    private pruneBuffer;
+    private abortBuffer;
+    getDebugBufferState(): IRange<Milliseconds> | undefined;
+    getBufferedTo(): number | null;
+    getForwardBufferDuration(currentPosition?: Milliseconds | undefined): Milliseconds;
+    private detectGaps;
+    private detectGapsWhenIdle;
+    private checkEjectedSegments;
+    private handleAsyncError;
+}

package/types/providers/DashProviderNew/lib/fetcher.d.ts

@@ -0,0 +1,59 @@
+import { HttpConnectionType } from '../../../player/types';
+import type ThroughputEstimator from '../../../utils/ThroughputEstimator';
+import { Byte, IValueSubject, Milliseconds, IRange, Subject, ITracer, IError } from '@vkontakte/videoplayer-shared';
+import { CommonInit, GenericContainerParser, Segment, SegmentReference } from './types';
+export declare enum RangeMethod {
+    HEADER = 0,
+    PARAM = 1
+}
+export interface IParams {
+    throughputEstimator?: ThroughputEstimator;
+    requestQuic: boolean;
+    compatibilityMode?: boolean;
+    tracer: ITracer;
+    useEnableSubtitlesParam?: boolean;
+}
+export type Priority = 'high' | 'low' | 'auto';
+export interface FetchParamsWithUrl extends FetchParams {
+    url: string;
+}
+export interface FetchParams {
+    range?: IRange<Byte>;
+    rangeMethod?: RangeMethod;
+    onProgress?: (dataView: DataView, loaded: number) => void;
+    onProgressTasks?: Promise<void>[];
+    signal?: AbortSignal;
+    priority?: Priority;
+    measureThroughput?: boolean;
+    isLowLatency?: boolean;
+}
+export type RepresentationFetchResult = {
+    init: CommonInit | null;
+    segments: Segment[];
+    dataView: DataView;
+};
+export declare class Fetcher {
+    private throughputEstimator;
+    private requestQuic;
+    private tracer;
+    lastConnectionType$: IValueSubject<HttpConnectionType | undefined>;
+    lastConnectionReused$: IValueSubject<boolean | undefined>;
+    lastRequestFirstBytes$: IValueSubject<Milliseconds | undefined>;
+    recoverableError$: Subject<IError>;
+    error$: Subject<IError>;
+    private abortAllController;
+    private compatibilityMode;
+    private useEnableSubtitlesParam;
+    private readonly subscription;
+    constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam }: IParams);
+    private onHeadersReceived;
+    fetchManifest: (param_0: string) => Promise<string | null | undefined>;
+    fetch: (param_0: string, param_1: FetchParams) => Promise<ArrayBuffer | null | undefined>;
+    fetchRepresentation(segmentReference: SegmentReference, parser: GenericContainerParser<unknown>, priority?: Priority): Promise<RepresentationFetchResult | null>;
+    destroy(): void;
+    private fetchByteRangeRepresentation;
+    private fetchTemplateRepresentation;
+    private doFetch;
+    private unsubscribeAbortSubscription;
+}
+export declare const suppressAbort: (e: Error | unknown) => void | never;

package/types/providers/DashProviderNew/lib/parsers/ietf/index.d.ts

@@ -0,0 +1,13 @@
+/** @fork https://github.com/sozialhelden/ietf-language-tags */
+export interface ILanguageSubtag {
+    langtag?: string;
+    language?: string;
+    extlang?: string;
+    script?: string;
+    region?: string;
+    variants?: string[];
+    extensions?: Record<string, string>;
+    privateuse?: string;
+}
+/** @fork https://github.com/sozialhelden/ietf-language-tags */
+export declare const parseLangAttribute: (attr: string) => ILanguageSubtag | null;

package/types/providers/DashProviderNew/lib/parsers/index.d.ts

@@ -0,0 +1,3 @@
+import { ContainerParser, MpegParser } from '../../../../providers/DashProviderNew/lib/types';
+export declare const getContainerParser: (mime: string) => ContainerParser;
+export declare const isMp4Parser: (parser: ContainerParser) => parser is MpegParser;

package/types/providers/DashProviderNew/lib/parsers/mpd.d.ts

@@ -0,0 +1,3 @@
+import { Manifest } from '../types';
+export declare const replaceSegmentTemplate: (template: string, data: Partial<Record<"representationId" | "segmentNumber" | "bandwidth" | "segmentTime", string>>) => string;
+export declare const parse: (text: string, manifestUrl: string) => Manifest;

package/types/providers/DashProviderNew/lib/parsers/mpeg/BoxModel.d.ts

@@ -0,0 +1,20 @@
+import { type Box } from '../../../../../providers/DashProviderNew/lib/parsers/mpeg/box';
+/**
+ * Queryable object to get needed boxes from structure
+ */
+export declare class BoxModel {
+    private readonly index;
+    constructor(initialSet: Box[]);
+    /**
+     * Processes index creation
+     */
+    private indexBoxLevel;
+    /**
+     * Returns first box of given type
+     */
+    find<T extends Box>(type: string): T | null;
+    /**
+     * Returns all boxes of given typoe
+     */
+    findAll<T extends Box>(type: string): T[];
+}

package/types/providers/DashProviderNew/lib/parsers/mpeg/BoxParser.d.ts

@@ -0,0 +1,21 @@
+import { type Box } from '../../../../../providers/DashProviderNew/lib/parsers/mpeg/box';
+import { BoxTypeEnum } from '../../../../../providers/DashProviderNew/lib/parsers/mpeg/BoxTypeEnum';
+export declare const BOX_TYPE_MAP: Record<BoxTypeEnum, typeof Box>;
+export interface BoxParserOptions {
+    offset: number;
+}
+/**
+ * Box parsing object
+ */
+export declare class BoxParser {
+    private options;
+    constructor(opts?: Partial<BoxParserOptions>);
+    /**
+     * Parses DataView into the set of boxes
+     */
+    parse(view: DataView): Box[];
+    /**
+     * Creates boxes from source DataView with exact type
+     */
+    private createBox;
+}

package/types/providers/DashProviderNew/lib/parsers/mpeg/BoxTypeEnum.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 'Known' box types
+ */
+export declare enum BoxTypeEnum {
+    FtypBox = "ftyp",
+    MoovBox = "moov",
+    MvhdBox = "mvhd",
+    MoofBox = "moof",
+    MdatBox = "mdat",
+    SidxBox = "sidx",
+    TrakBox = "trak",
+    MdiaBox = "mdia",
+    MfhdBox = "mfhd",
+    TkhdBox = "tkhd",
+    TrafBox = "traf",
+    TfhdBox = "tfhd",
+    TfdtBox = "tfdt",
+    TrunBox = "trun",
+    MinfBox = "minf",
+    Sv3dBox = "sv3d",
+    St3dBox = "st3d",
+    PrhdBox = "prhd",
+    ProjBox = "proj",
+    EquiBox = "equi",
+    UuidBox = "uuid",
+    StblBox = "stbl",
+    StsdBox = "stsd",
+    Avc1Box = "avc1",
+    UnknownBox = "unknown"
+}

package/types/providers/DashProviderNew/lib/parsers/mpeg/box.d.ts

@@ -0,0 +1,74 @@
+import { type BoxParser } from '../../../../../providers/DashProviderNew/lib/parsers/mpeg/BoxParser';
+/**
+ * Generic boxes description
+ *
+ * aligned(8) class Box (unsigned int(32) boxtype, optional unsigned int(8)[16] extended_type) {
+ *    unsigned int(32) size;
+ *    unsigned int(32) type = boxtype;
+ *    if (size==1) {
+ *       unsigned int(64) largesize;
+ *    } else if (size==0) {
+ *       // boxes extends to end of file
+ *    }
+ *    if (boxtype==‘uuid’) {
+ *       unsigned int(8)[16] usertype = extended_type;
+ *    }
+ * }
+ */
+export declare class Box {
+    source: DataView;
+    boxParser: BoxParser;
+    type: string;
+    size32: number;
+    size64: number;
+    usertype: number;
+    content: DataView;
+    children: Box[];
+    /**
+     * Next byte in source buffer to be read
+     */
+    protected cursor: number;
+    /**
+     * for compatibility with old Box type
+     */
+    get id(): string;
+    /**
+     *
+     */
+    get size(): number;
+    constructor(source: DataView, boxParser: BoxParser);
+    /**
+     * Internal method to scan for children
+     */
+    protected scanForBoxes(view: DataView): Box[];
+    /**
+     * Reads given number of bytes from source buffer as a string
+     * starting from current cursor position and using provided encoding
+     * Moves cursor forward
+     */
+    protected readString(byteLength: number, encoding?: string): string;
+    /**
+     * Reads 1 byte from source buffer as an unsigned integer
+     * starting from current cursor position
+     * Moves cursor forward
+     */
+    protected readUint8(): number;
+    /**
+     * Reads 2 bytes from source buffer as an unsigned integer
+     * starting from current cursor position
+     * Moves cursor forward
+     */
+    protected readUint16(): number;
+    /**
+     * Reads 4 bytes from source buffer as an unsigned integer
+     * starting from current cursor position
+     * Moves cursor forward
+     */
+    protected readUint32(): number;
+    /**
+     * Reads 8 bytes from source buffer as an unsigned BigInt
+     * starting from current cursor position
+     * Moves cursor forward
+     */
+    protected readUint64(): bigint;
+}

package/types/providers/DashProviderNew/lib/parsers/mpeg/boxes/avc1.d.ts

@@ -0,0 +1,8 @@
+import { Box } from '../../../../../../providers/DashProviderNew/lib/parsers/mpeg/box';
+import { BoxParser } from '../../../../../../providers/DashProviderNew/lib/parsers/mpeg/BoxParser';
+/**
+ * Advance Video Coding Box
+ */
+export declare class Avc1Box extends Box {
+    constructor(source: DataView, boxParser: BoxParser);
+}

package/types/providers/DashProviderNew/lib/parsers/mpeg/boxes/equi.d.ts

@@ -0,0 +1,21 @@
+import { FullBox } from '../../../../../../providers/DashProviderNew/lib/parsers/mpeg/fullBox';
+import { type BoxParser } from '../../../../../../providers/DashProviderNew/lib/parsers/mpeg/BoxParser';
+/**
+ * aligned(8) class ProjectionDataBox(unsigned int(32) proj_type, unsigned int(8)version, unsigned int(24) flags)
+ *     extends FullBox(proj_type, version, flags) {
+ * }
+ *
+ * aligned(8) class EquirectangularProjection ProjectionDataBox(‘equi’, 0, 0) {
+ *     unsigned int(32) projection_bounds_top;
+ *     unsigned int(32) projection_bounds_bottom;
+ *     unsigned int(32) projection_bounds_left;
+ *     unsigned int(32) projection_bounds_right;
+ * }
+ */
+export declare class EquiBox extends FullBox {
+    projectionBoundsTop: number;
+    projectionBoundsBottom: number;
+    projectionBoundsLeft: number;
+    projectionBoundsRight: number;
+    constructor(source: DataView, boxParser: BoxParser);
+}

package/types/providers/DashProviderNew/lib/parsers/mpeg/boxes/ftyp.d.ts

@@ -0,0 +1,17 @@
+import { Box } from '../../../../../../providers/DashProviderNew/lib/parsers/mpeg/box';
+import { type BoxParser } from '../../../../../../providers/DashProviderNew/lib/parsers/mpeg/BoxParser';
+/**
+ * File Type Box description
+ *
+ * aligned(8) class FileTypeBox extends Box(‘ftyp’) {
+ *    unsigned int(32) major_brand;
+ *    unsigned int(32) minor_version;
+ *    unsigned int(32) compatible_brands[]; // to end of the boxes
+ * }
+ */
+export declare class FtypBox extends Box {
+    majorBrand: string;
+    minorVersion: number;
+    compatibleBrands: string[];
+    constructor(source: DataView, boxParser: BoxParser);
+}