rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/core/api/clock.d.ts

@@ -1,129 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * This file defines a global clock for the RxPlayer.
- *
- * Each clock tick also pass information about the current state of the
- * media element to sub-parts of the player.
- */
-import { Observable } from "rxjs";
-/** "Event" that triggered the clock tick. */
-export declare type IClockMediaEventType = 
-/** First clock tick automatically emitted. */
-"init" | // set once on first emit
-/** Regularly emitted clock tick when no event happened in a long time. */
-"timeupdate" | 
-/** On the HTML5 event with the same name */
-"canplay" | 
-/** On the HTML5 event with the same name */
-"canplaythrough" | // HTML5 Event
-/** On the HTML5 event with the same name */
-"play" | 
-/** On the HTML5 event with the same name */
-"seeking" | 
-/** On the HTML5 event with the same name */
-"seeked" | 
-/** On the HTML5 event with the same name */
-"stalled" | 
-/** On the HTML5 event with the same name */
-"loadedmetadata" | 
-/** On the HTML5 event with the same name */
-"ratechange" | 
-/** An internal seek happens */
-"internal-seeking";
-/** Information recuperated on the media element on each clock tick. */
-interface IMediaInfos {
-    /** Gap between `currentTime` and the next position with un-buffered data. */
-    bufferGap: number;
-    /** Value of `buffered` (buffered ranges) for the media element. */
-    buffered: TimeRanges;
-    /** The buffered range we are currently playing. */
-    currentRange: {
-        start: number;
-        end: number;
-    } | null;
-    /** `currentTime` (position) set on the media element at the time of the tick. */
-    position: number;
-    /** Current `duration` set on the media element. */
-    duration: number;
-    /** Current `ended` set on the media element. */
-    ended: boolean;
-    /** Current `paused` set on the media element. */
-    paused: boolean;
-    /** Current `playbackRate` set on the media element. */
-    playbackRate: number;
-    /** Current `readyState` value on the media element. */
-    readyState: number;
-    /** Current `seeking` value on the mediaElement. */
-    seeking: boolean;
-    /** Event that triggered this clock tick. */
-    event: IClockMediaEventType;
-}
-/** Describes when the player is "stalled" and what event started that status. */
-export interface IStalledStatus {
-    /** What started the player to stall. */
-    reason: "seeking" | // Building buffer after seeking
-    "not-ready" | // Building buffer after low readyState
-    "internal-seek" | // Building buffer after a seek happened inside the player
-    "buffering";
-    /** `performance.now` at the time the stalling happened. */
-    timestamp: number;
-    /**
-     * Position, in seconds, at which data is awaited.
-     * If `null` the player is stalled but not because it is awaiting future data.
-     */
-    position: number | null;
-}
-/** Information emitted on each clock tick. */
-export interface IClockTick extends IMediaInfos {
-    /** Set if the player is stalled, `null` if not. */
-    stalled: IStalledStatus | null;
-    getCurrentTime: () => number;
-}
-/** Handle time relative information */
-export interface IClockHandler {
-    clock$: Observable<IClockTick>;
-    setCurrentTime: (time: number) => void;
-}
-export interface IClockOptions {
-    withMediaSource: boolean;
-    lowLatencyMode: boolean;
-}
-/**
- * Timings observable.
- *
- * This Observable samples snapshots of player's current state:
- *   * time position
- *   * playback rate
- *   * current buffered range
- *   * gap with current buffered range ending
- *   * media duration
- *
- * In addition to sampling, this Observable also reacts to "seeking" and "play"
- * events.
- *
- * Observable is shared for performance reason: reduces the number of event
- * listeners and intervals/timeouts but also limit access to the media element
- * properties and gap calculations.
- *
- * The sampling is manual instead of based on "timeupdate" to reduce the
- * number of events.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} options
- * @returns {Observable}
- */
-declare function createClock(mediaElement: HTMLMediaElement, options: IClockOptions): IClockHandler;
-export default createClock;

package/dist/_esm5.processed/core/api/clock.js

@@ -1,335 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
-/**
- * This file defines a global clock for the RxPlayer.
- *
- * Each clock tick also pass information about the current state of the
- * media element to sub-parts of the player.
- */
-import { defer as observableDefer, fromEvent as observableFromEvent, interval as observableInterval, merge as observableMerge, } from "rxjs";
-import { map, mapTo, shareReplay, startWith, } from "rxjs/operators";
-import config from "../../config";
-import log from "../../log";
-import objectAssign from "../../utils/object_assign";
-import { getRange } from "../../utils/ranges";
-var SAMPLING_INTERVAL_MEDIASOURCE = config.SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY = config.SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE = config.SAMPLING_INTERVAL_NO_MEDIASOURCE, RESUME_GAP_AFTER_SEEKING = config.RESUME_GAP_AFTER_SEEKING, RESUME_GAP_AFTER_NOT_ENOUGH_DATA = config.RESUME_GAP_AFTER_NOT_ENOUGH_DATA, RESUME_GAP_AFTER_BUFFERING = config.RESUME_GAP_AFTER_BUFFERING, STALL_GAP = config.STALL_GAP;
-/**
- * HTMLMediaElement Events for which timings are calculated and emitted.
- * @type {Array.<string>}
- */
-var SCANNED_MEDIA_ELEMENTS_EVENTS = ["canplay",
-    "play",
-    "seeking",
-    "seeked",
-    "loadedmetadata",
-    "ratechange"];
-/**
- * Returns the amount of time in seconds the buffer should have ahead of the
- * current position before resuming playback. Based on the infos of the stall.
- * Waiting time differs between a "seeking" stall and a buffering stall.
- * @param {Object|null} stalled
- * @param {Boolean} lowLatencyMode
- * @returns {Number}
- */
-function getResumeGap(stalled, lowLatencyMode) {
-    if (stalled === null) {
-        return 0;
-    }
-    var suffix = lowLatencyMode ? "LOW_LATENCY" :
-        "DEFAULT";
-    switch (stalled.reason) {
-        case "seeking":
-        case "internal-seek":
-            return RESUME_GAP_AFTER_SEEKING[suffix];
-        case "not-ready":
-            return RESUME_GAP_AFTER_NOT_ENOUGH_DATA[suffix];
-        case "buffering":
-            return RESUME_GAP_AFTER_BUFFERING[suffix];
-    }
-}
-/**
- * @param {Object} currentRange
- * @param {Number} duration
- * @param {Boolean} lowLatencyMode
- * @returns {Boolean}
- */
-function hasLoadedUntilTheEnd(currentRange, duration, lowLatencyMode) {
-    var suffix = lowLatencyMode ? "LOW_LATENCY" :
-        "DEFAULT";
-    return currentRange !== null &&
-        (duration - currentRange.end) <= STALL_GAP[suffix];
-}
-/**
- * Generate a basic timings object from the media element and the eventName
- * which triggered the request.
- * @param {HTMLMediaElement} mediaElement
- * @param {string} event
- * @returns {Object}
- */
-function getMediaInfos(mediaElement, event) {
-    var buffered = mediaElement.buffered, currentTime = mediaElement.currentTime, duration = mediaElement.duration, ended = mediaElement.ended, paused = mediaElement.paused, playbackRate = mediaElement.playbackRate, readyState = mediaElement.readyState, seeking = mediaElement.seeking;
-    var currentRange = getRange(buffered, currentTime);
-    return { bufferGap: currentRange !== null ? currentRange.end - currentTime :
-            // TODO null/0 would probably be
-            // more appropriate
-            Infinity,
-        buffered: buffered,
-        currentRange: currentRange,
-        position: currentTime,
-        duration: duration,
-        ended: ended,
-        paused: paused,
-        playbackRate: playbackRate,
-        readyState: readyState,
-        seeking: seeking,
-        event: event };
-}
-/**
- * Infer stalled status of the media based on:
- *   - the return of the function getMediaInfos
- *   - the previous timings object.
- *
- * @param {Object} prevTimings - Previous timings object. See function to know
- * the different properties needed.
- * @param {Object} currentTimings - Current timings object. This does not need
- * to have every single infos, see function to know which properties are needed.
- * @param {Object} options
- * @returns {Object|null}
- */
-function getStalledStatus(prevTimings, currentTimings, _a) {
-    var withMediaSource = _a.withMediaSource, lowLatencyMode = _a.lowLatencyMode;
-    var currentEvt = currentTimings.event, currentTime = currentTimings.position, bufferGap = currentTimings.bufferGap, currentRange = currentTimings.currentRange, duration = currentTimings.duration, paused = currentTimings.paused, readyState = currentTimings.readyState, ended = currentTimings.ended;
-    var prevStalled = prevTimings.stalled, prevEvt = prevTimings.event, prevTime = prevTimings.position;
-    var fullyLoaded = hasLoadedUntilTheEnd(currentRange, duration, lowLatencyMode);
-    var canStall = (readyState >= 1 &&
-        currentEvt !== "loadedmetadata" &&
-        prevStalled === null &&
-        !(fullyLoaded || ended));
-    var stalledPosition = null;
-    var shouldStall;
-    var shouldUnstall;
-    var stallGap = lowLatencyMode ? STALL_GAP.LOW_LATENCY :
-        STALL_GAP.DEFAULT;
-    if (withMediaSource) {
-        if (canStall) {
-            if (bufferGap <= stallGap) {
-                shouldStall = true;
-                stalledPosition = currentTime + bufferGap;
-            }
-            else if (bufferGap === Infinity) {
-                shouldStall = true;
-                stalledPosition = currentTime;
-            }
-            else if (readyState === 1) {
-                shouldStall = true;
-            }
-        }
-        else if (prevStalled !== null) {
-            var resumeGap = getResumeGap(prevStalled, lowLatencyMode);
-            if (shouldStall !== true && prevStalled !== null && readyState > 1 &&
-                (fullyLoaded || ended || (bufferGap < Infinity && bufferGap > resumeGap))) {
-                shouldUnstall = true;
-            }
-            else if (bufferGap === Infinity || bufferGap <= resumeGap) {
-                stalledPosition = bufferGap === Infinity ? currentTime :
-                    currentTime + bufferGap;
-            }
-        }
-    }
-    // when using a direct file, the media will stall and unstall on its
-    // own, so we only try to detect when the media timestamp has not changed
-    // between two consecutive timeupdates
-    else {
-        if (canStall &&
-            (!paused && currentEvt === "timeupdate" &&
-                prevEvt === "timeupdate" && currentTime === prevTime ||
-                currentEvt === "seeking" && bufferGap === Infinity)) {
-            shouldStall = true;
-        }
-        else if (prevStalled !== null &&
-            (currentEvt !== "seeking" && currentTime !== prevTime ||
-                currentEvt === "canplay" ||
-                bufferGap < Infinity &&
-                    (bufferGap > getResumeGap(prevStalled, lowLatencyMode) ||
-                        fullyLoaded || ended))) {
-            shouldUnstall = true;
-        }
-    }
-    if (shouldUnstall === true) {
-        return null;
-    }
-    else if (shouldStall === true || prevStalled !== null) {
-        var reason = void 0;
-        if (currentEvt === "seeking" ||
-            prevStalled !== null && prevStalled.reason === "seeking") {
-            reason = "seeking";
-        }
-        else if (currentTimings.seeking &&
-            ((currentEvt === "internal-seeking") ||
-                (prevStalled !== null && prevStalled.reason === "internal-seek"))) {
-            reason = "internal-seek";
-        }
-        else if (currentTimings.seeking) {
-            reason = "seeking";
-        }
-        else if (readyState === 1) {
-            reason = "not-ready";
-        }
-        else {
-            reason = "buffering";
-        }
-        if (prevStalled !== null && prevStalled.reason === reason) {
-            return { reason: prevStalled.reason,
-                timestamp: prevStalled.timestamp,
-                position: stalledPosition };
-        }
-        return { reason: reason,
-            timestamp: performance.now(),
-            position: stalledPosition };
-    }
-    return null;
-}
-/**
- * Timings observable.
- *
- * This Observable samples snapshots of player's current state:
- *   * time position
- *   * playback rate
- *   * current buffered range
- *   * gap with current buffered range ending
- *   * media duration
- *
- * In addition to sampling, this Observable also reacts to "seeking" and "play"
- * events.
- *
- * Observable is shared for performance reason: reduces the number of event
- * listeners and intervals/timeouts but also limit access to the media element
- * properties and gap calculations.
- *
- * The sampling is manual instead of based on "timeupdate" to reduce the
- * number of events.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} options
- * @returns {Observable}
- */
-function createClock(mediaElement, options) {
-    // Allow us to identify seek performed internally by the player.
-    var internalSeekingComingCounter = 0;
-    function setCurrentTime(time) {
-        mediaElement.currentTime = time;
-        internalSeekingComingCounter += 1;
-    }
-    var clock$ = observableDefer(function () {
-        var lastTimings = objectAssign(getMediaInfos(mediaElement, "init"), { stalled: null, getCurrentTime: function () { return mediaElement.currentTime; } });
-        function getCurrentClockTick(event) {
-            var tmpEvt = event;
-            if (tmpEvt === "seeking" && internalSeekingComingCounter > 0) {
-                tmpEvt = "internal-seeking";
-                internalSeekingComingCounter -= 1;
-            }
-            var mediaTimings = getMediaInfos(mediaElement, tmpEvt);
-            var stalledState = getStalledStatus(lastTimings, mediaTimings, options);
-            var timings = objectAssign({}, { stalled: stalledState,
-                getCurrentTime: function () { return mediaElement.currentTime; } }, mediaTimings);
-            log.debug("API: current media element state", timings);
-            return timings;
-        }
-        var eventObs = SCANNED_MEDIA_ELEMENTS_EVENTS.map(function (eventName) {
-            return observableFromEvent(mediaElement, eventName)
-                .pipe(mapTo(eventName));
-        });
-        var interval = options.lowLatencyMode ? SAMPLING_INTERVAL_LOW_LATENCY :
-            options.withMediaSource ? SAMPLING_INTERVAL_MEDIASOURCE :
-                SAMPLING_INTERVAL_NO_MEDIASOURCE;
-        var interval$ = observableInterval(interval)
-            .pipe(mapTo("timeupdate"));
-        return observableMerge.apply(void 0, __spreadArray([interval$], eventObs)).pipe(map(function (event) {
-            lastTimings = getCurrentClockTick(event);
-            if (log.getLevel() === "DEBUG") {
-                log.debug("API: current playback timeline:\n" +
-                    prettyPrintBuffered(lastTimings.buffered, lastTimings.position), "\n" + event);
-            }
-            return lastTimings;
-        }), startWith(lastTimings));
-    }).pipe(
-    // Always emit the last tick when already subscribed
-    shareReplay({ bufferSize: 1, refCount: true }));
-    return { clock$: clock$, setCurrentTime: setCurrentTime };
-}
-/**
- * Pretty print a TimeRanges Object, to see the current content of it in a
- * one-liner string.
- *
- * @example
- * This function is called by giving it directly the TimeRanges, such as:
- * ```js
- * prettyPrintBuffered(document.getElementsByTagName("video")[0].buffered);
- * ```
- *
- * Let's consider this possible return:
- *
- * ```
- * 0.00|==29.95==|29.95 ~30.05~ 60.00|==29.86==|89.86
- *          ^14
- * ```
- * This means that our video element has 29.95 seconds of buffer between 0 and
- * 29.95 seconds.
- * Then 30.05 seconds where no buffer is found.
- * Then 29.86 seconds of buffer between 60.00 and 89.86 seconds.
- *
- * A caret on the second line indicates the current time we're at.
- * The number coming after it is the current time.
- * @param {TimeRanges} buffered
- * @param {number} currentTime
- * @returns {string}
- */
-function prettyPrintBuffered(buffered, currentTime) {
-    var str = "";
-    var currentTimeStr = "";
-    for (var i = 0; i < buffered.length; i++) {
-        var start = buffered.start(i);
-        var end = buffered.end(i);
-        var fixedStart = start.toFixed(2);
-        var fixedEnd = end.toFixed(2);
-        var fixedDuration = (end - start).toFixed(2);
-        var newIntervalStr = fixedStart + "|==" + fixedDuration + "==|" + fixedEnd;
-        str += newIntervalStr;
-        if (currentTimeStr.length === 0 && end > currentTime) {
-            var padBefore = str.length - Math.floor(newIntervalStr.length / 2);
-            currentTimeStr = " ".repeat(padBefore) + ("^" + currentTime);
-        }
-        if (i < buffered.length - 1) {
-            var nextStart = buffered.start(i + 1);
-            var fixedDiff = (nextStart - end).toFixed(2);
-            var holeStr = " ~" + fixedDiff + "~ ";
-            str += holeStr;
-            if (currentTimeStr.length === 0 && currentTime < nextStart) {
-                var padBefore = str.length - Math.floor(holeStr.length / 2);
-                currentTimeStr = " ".repeat(padBefore) + ("^" + currentTime);
-            }
-        }
-    }
-    if (currentTimeStr.length === 0) {
-        currentTimeStr = " ".repeat(str.length) + ("^" + currentTime);
-    }
-    return str + "\n" + currentTimeStr;
-}
-export default createClock;

package/dist/_esm5.processed/core/fetchers/manifest/get_manifest_backoff_options.js

@@ -1,38 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import config from "../../../config";
-var DEFAULT_MAX_MANIFEST_REQUEST_RETRY = config.DEFAULT_MAX_MANIFEST_REQUEST_RETRY, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = config.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = config.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = config.MAX_BACKOFF_DELAY_BASE;
-/**
- * Parse config to replace missing manifest backoff options.
- * @param {Object} backoffOptions
- * @returns {Object}
- */
-export default function getManifestBackoffOptions(_a) {
-    var maxRetryRegular = _a.maxRetryRegular, maxRetryOffline = _a.maxRetryOffline, lowLatencyMode = _a.lowLatencyMode;
-    var baseDelay = lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
-        INITIAL_BACKOFF_DELAY_BASE.REGULAR;
-    var maxDelay = lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
-        MAX_BACKOFF_DELAY_BASE.REGULAR;
-    return {
-        baseDelay: baseDelay,
-        maxDelay: maxDelay,
-        maxRetryRegular: maxRetryRegular !== undefined ? maxRetryRegular :
-            DEFAULT_MAX_MANIFEST_REQUEST_RETRY,
-        maxRetryOffline: maxRetryOffline !== undefined ?
-            maxRetryOffline :
-            DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
-    };
-}

package/dist/_esm5.processed/core/fetchers/segment/create_segment_loader.d.ts

@@ -1,98 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Observable } from "rxjs";
-import { ICustomError } from "../../../errors";
-import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
-import { ILoaderDataLoadedValue, ILoaderProgressEvent, ISegmentLoaderArguments, ISegmentLoaderEvent as ITransportSegmentLoaderEvent } from "../../../transports";
-import { IABRMetricsEvent } from "../../abr";
-import { IBackoffOptions } from "../utils/try_urls_with_backoff";
-/** An Error happened while loading (usually a request error). */
-export interface ISegmentLoaderWarning {
-    type: "warning";
-    value: ICustomError;
-}
-/** The request begins to be done. */
-export interface ISegmentLoaderRequest {
-    type: "request";
-    value: ISegmentLoaderArguments;
-}
-/** The whole segment's data (not only a chunk) is available. */
-export interface ISegmentLoaderData<T> {
-    type: "data";
-    value: {
-        responseData: T;
-    };
-}
-/**
- * A chunk of the data is available.
- * You will receive every chunk through such events until a
- * ISegmentLoaderChunkComplete event is received.
- */
-export interface ISegmentLoaderChunk {
-    type: "chunk";
-    value: {
-        responseData: null | ArrayBuffer | Uint8Array;
-    };
-}
-/** The data has been entirely sent through "chunk" events. */
-export interface ISegmentLoaderChunkComplete {
-    type: "chunk-complete";
-    value: null;
-}
-/**
- * Every events the segment loader emits.
- * Type parameters: T: Argument given to the loader
- *                  U: ResponseType of the request
- */
-export declare type ISegmentLoaderEvent<T> = ISegmentLoaderData<T> | ISegmentLoaderRequest | ILoaderProgressEvent | ISegmentLoaderWarning | ISegmentLoaderChunk | ISegmentLoaderChunkComplete | IABRMetricsEvent;
-/** Cache implementation to avoid re-requesting segment */
-export interface ISegmentLoaderCache<T> {
-    /** Add a segment to the cache. */
-    add: (obj: ISegmentLoaderContent, arg: ILoaderDataLoadedValue<T>) => void;
-    /** Retrieve a segment from the cache */
-    get: (obj: ISegmentLoaderContent) => ILoaderDataLoadedValue<T> | null;
-}
-/** Abstraction to load a segment in the current transport protocol. */
-export declare type ISegmentPipelineLoader<T> = (x: ISegmentLoaderArguments) => Observable<ITransportSegmentLoaderEvent<T>>;
-/** Content used by the segment loader as a context to load a new segment. */
-export interface ISegmentLoaderContent {
-    manifest: Manifest;
-    period: Period;
-    adaptation: Adaptation;
-    representation: Representation;
-    segment: ISegment;
-}
-/**
- * Returns a function allowing to load any wanted segment.
- *
- * The function returned takes in argument information about the wanted segment
- * and returns an Observable which will emit various events related to the
- * segment request (see ISegmentLoaderEvent).
- *
- * This observable will throw if, following the options given, the request and
- * possible retry all failed.
- *
- * This observable will complete after emitting all the segment's data.
- *
- * Type parameters:
- *   - T: type of the data emitted
- *
- * @param {Function} loader
- * @param {Object | undefined} cache
- * @param {Object} options
- * @returns {Function}
- */
-export default function createSegmentLoader<T>(loader: ISegmentPipelineLoader<T>, cache: ISegmentLoaderCache<T> | undefined, backoffOptions: IBackoffOptions): (x: ISegmentLoaderContent) => Observable<ISegmentLoaderEvent<T>>;