@vkontakte/videoplayer-core 2.0.131-dev.20b944d3.0 → 2.0.131-dev.45e99145.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.131-dev.20b944d3.0",
+  "version": "2.0.131-dev.45e99145.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.59-dev.5cf7a4be.0",
+    "@vkontakte/videoplayer-shared": "1.0.59-dev.3ed4b6b9.0",
     "hls.js": "~1.4.7"
   }
 }

package/types/player/Player.d.ts

@@ -1,14 +1,11 @@
 import { IOptionalTuningConfig } from '../utils/tuningConfig';
-import { IError, ILogEntry, Seconds, Subject, ValueSubject, QualityLimits, VideoQuality, ITracer } from '@vkontakte/videoplayer-shared';
+import { IError, ILogEntry, Seconds, Subject, ValueSubject, QualityLimits, VideoQuality } from '@vkontakte/videoplayer-shared';
 import { ChromecastState, HttpConnectionType, IAudioStream, IConfig, ICueSettings, IExternalTextTrack, IPlayer, ISeekRequest, ISources, ITextTrack, IVideoStream, PlaybackRate, PlaybackState, PredefinedQualityLimits, StartEnd, Surface, VideoFormat } from './types';
 export default class Player implements IPlayer {
     private subscription;
     private domContainer;
     private providerContainer?;
     private chromecastInitializer;
-    private logger;
-    private tracer;
-    private abrLogger;
     private config;
     private tuning;
     private throughputEstimator;
@@ -110,10 +107,9 @@ export default class Player implements IPlayer {
         element$: ValueSubject<HTMLVideoElement | undefined>;
         tuningConfigName$: ValueSubject<string[]>;
         enableDebugTelemetry$: ValueSubject<boolean>;
-        dumpTelemetry: (receiver: (value: Record<string, any>) => void) => void;
         getCurrentTime$: ValueSubject<null>;
     };
-    constructor(tuning?: IOptionalTuningConfig, tracer?: ITracer);
+    constructor(tuning?: IOptionalTuningConfig);
     initVideo(config: IConfig): IPlayer;
     destroy(): void;
     prepare(): IPlayer;
@@ -180,7 +176,6 @@ export default class Player implements IPlayer {
      */
     releaseCamera(): this;
     getExactTime(): Seconds;
-    getAllLogs(): ILogEntry[];
     private getScene3D;
     private setIntrinsicVideoSize;
     private initDesiredStateSubscriptions;
@@ -188,9 +183,7 @@ export default class Player implements IPlayer {
     private initChromecastSubscription;
     private initStartingVideoTrack;
     private setStartingVideoTrack;
-    private initLogs;
     private initDebugTelemetry;
-    private initTracerSubscription;
     private initWakeLock;
     private setVideoTrackIdByQuality;
     private getActiveLiveDelay;

package/types/player/types.d.ts

@@ -62,10 +62,6 @@ export interface IPlayer {
      * Может быть точнее, чем `info.position$` в промежутках между timeupdate
      */
     getExactTime(): number;
-    /**
-     * Возвращает все логи с момента инициализации плеера
-     */
-    getAllLogs(): ILogEntry[];
     experimental: {
         /**
          * Элемент, который сейчас вставлен в container.
@@ -74,7 +70,6 @@ export interface IPlayer {
         element$: IValueObservable<HTMLVideoElement | undefined>;
         tuningConfigName$: IValueSubject<string[]>;
         enableDebugTelemetry$: IValueSubject<boolean>;
-        dumpTelemetry: (receiver: (value: Record<string, any>) => void) => void;
         /** функция вычисления текущей позиции проигрывания из под провадера (если расчет нестандартный) */
         getCurrentTime$: IValueSubject<(() => number) | null>;
     };

package/types/providers/ChromecastProvider/ChromecastInitializer/index.d.ts

@@ -1,12 +1,9 @@
-import { ISubject, IValueSubject, ILogger, IError } from '@vkontakte/videoplayer-shared';
+import { ISubject, IValueSubject, IError } from '@vkontakte/videoplayer-shared';
 import { ChromecastState } from '../../../player/types';
 import { IChromecastConnection, IChromecastInitializer } from './types';
 interface IParams {
     receiverApplicationId?: string;
     isDisabled?: boolean;
-    dependencies: {
-        logger: ILogger;
-    };
 }
 export declare class ChromecastInitializer implements IChromecastInitializer {
     readonly connection$: IValueSubject<IChromecastConnection | undefined>;
@@ -15,7 +12,6 @@ export declare class ChromecastInitializer implements IChromecastInitializer {
     contentId?: string;
     private readonly realCastState$;
     private readonly subscription;
-    private readonly log;
     private readonly params;
     private isDestroyed;
     constructor(params: IParams);

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

@@ -11,7 +11,6 @@ export default class ChromecastProvider implements IProvider {
     private loadMediaTimeoutSubscription;
     private videoState;
     private params;
-    private log;
     constructor(params: IParams);
     destroy(): void;
     private subscribe;
@@ -27,7 +26,6 @@ export default class ChromecastProvider implements IProvider {
     private createMediaInfo;
     private createLoadRequest;
     private loadMedia;
-    private logRemoteEvent;
     private syncPlayback;
 }
 export {};

package/types/providers/DashLiveProvider/DashLiveProvider.d.ts

@@ -22,7 +22,6 @@ export default class DashLiveProvider implements IProvider {
     private maxSeekBackTime$;
     private zeroTime$;
     private liveOffset;
-    private log;
     private params;
     constructor(params: Params);
     destroy(): void;

package/types/providers/DashLiveProvider/utils/FilesFetcher.d.ts

@@ -9,8 +9,7 @@ export default class FilesFetcher {
     private TIMEOUT;
     private BITRATE_ESTIMATOR;
     private MAX_PARALLEL_REQUESTS;
-    private logger;
-    constructor(RETRY_COUNT: number, TIMEOUT: number, BITRATE_ESTIMATOR: any, MAX_PARALLEL_REQUESTS: number, logger: (...args: any[]) => void);
+    constructor(RETRY_COUNT: number, TIMEOUT: number, BITRATE_ESTIMATOR: any, MAX_PARALLEL_REQUESTS: number);
     private limitCompleteCount;
     private _sendRequest;
     private _getParallelRequestCount;

package/types/providers/DashLiveProvider/utils/LiveDashPlayer.d.ts

@@ -19,7 +19,6 @@ interface IParams {
         manifestRetryMaxInterval: number;
         manifestRetryMaxCount: number;
     };
-    logger: (...args: any[]) => void;
 }
 type AutoQualityLimits = {
     max?: number;

package/types/providers/DashLiveProvider/utils/ThroughputEstimator.d.ts

@@ -15,12 +15,9 @@
  * active time = (1.1 - 1.0) + (0.5 - 0.2) = 0.4
  * throughput = total size / active time = 6500 bytes/sec
  */
-type ILogger = (...args: any[]) => void;
 export default class ThroughputEstimator {
     private intervals;
     private currentRate;
-    private logger;
-    constructor(logger: ILogger);
     private _updateRate;
     private _createInterval;
     private _doMergeIntervals;
@@ -30,4 +27,3 @@ export default class ThroughputEstimator {
     addInterval(timeStart: number, timeEnd: number, bytes: number): boolean;
     getBitRate(): number;
 }
-export {};

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

@@ -3,7 +3,7 @@ import { CommonInit, IProviderSubscriptionInfo, ProviderState, Representation, S
 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 { ISubscription, Milliseconds } from '@vkontakte/videoplayer-shared';
 import { Player } from './lib/player';
 import { Scene3D } from '../../utils/3d/Scene3D';
 import DroppedFramesManager from '../../providers/utils/HTMLVideoElement/DroppedFramesManager';
@@ -20,7 +20,6 @@ export default abstract class BaseDashProvider implements IProvider {
     protected video: HTMLVideoElement;
     protected player: Player;
     protected params: IParams;
-    protected tracer: ITracer;
     protected textTracksManager: TextTrackManager;
     protected droppedFramesManager: DroppedFramesManager;
     protected stallsManager: StallsManager;
@@ -41,6 +40,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

@@ -1,6 +1,6 @@
 import { HttpConnectionType } from '../../../player/types';
 import type ThroughputEstimator from '../../../utils/ThroughputEstimator';
-import { Byte, IValueSubject, Milliseconds, IRange, Subject, ITracer, IError } from '@vkontakte/videoplayer-shared';
+import { Byte, IValueSubject, Milliseconds, IRange, Subject, IError } from '@vkontakte/videoplayer-shared';
 import { CommonInit, GenericContainerParser, Segment, SegmentReference } from './types';
 export declare enum RangeMethod {
     HEADER = 0,
@@ -10,7 +10,6 @@ export interface IParams {
     throughputEstimator?: ThroughputEstimator;
     requestQuic: boolean;
     compatibilityMode?: boolean;
-    tracer: ITracer;
     useEnableSubtitlesParam?: boolean;
 }
 export type Priority = 'high' | 'low' | 'auto';
@@ -35,17 +34,16 @@ export type RepresentationFetchResult = {
 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 subscription;
     private compatibilityMode;
     private useEnableSubtitlesParam;
-    constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam }: IParams);
+    private readonly subscription;
+    constructor({ throughputEstimator, requestQuic, compatibilityMode, useEnableSubtitlesParam }: IParams);
     private onHeadersReceived;
     fetchManifest: (param_0: string) => Promise<string | null | undefined>;
     fetch: (param_0: string, param_1: FetchParams) => Promise<ArrayBuffer | null | undefined>;
@@ -54,5 +52,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

@@ -3,7 +3,7 @@ import { CommonInit, LiveStreamStatus, Manifest, Representation, StreamKind, Tex
 import StateMachine from '../../../utils/StateMachine/StateMachine';
 import type ThroughputEstimator from '../../../utils/ThroughputEstimator';
 import { ITuningConfig } from '../../../utils/tuningConfig';
-import { IError, ISubject, ITracer, IValueSubject, Milliseconds, Subject } from '@vkontakte/videoplayer-shared';
+import { IError, ISubject, IValueSubject, Milliseconds, Subject } from '@vkontakte/videoplayer-shared';
 export declare enum State {
     NONE = "none",
     MANIFEST_READY = "manifest_ready",
@@ -14,7 +14,6 @@ export interface Params {
     throughputEstimator: ThroughputEstimator;
     tuning: ITuningConfig;
     compatibilityMode?: boolean;
-    tracer: ITracer;
 }
 export declare class Player {
     private element;
@@ -22,7 +21,6 @@ export declare class Player {
     private source;
     private manifest;
     private tuning;
-    private tracer;
     private videoBufferManager;
     private audioBufferManager;
     private bufferManagers;
@@ -68,6 +66,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>;
@@ -83,7 +82,6 @@ export declare class Player {
     getStreams(): Manifest['streams'] | undefined;
     setPreloadOnly(preloadOnly: boolean): void;
     destroy(): void;
-    private initTracerSubscription;
     private isManualDecreasePlaybackInLive;
     private normolizeLiveOffset;
     private tick;

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;