rx-player 3.28.0-dev.2022071100 → 3.29.0-dev.2022090500

package/dist/_esm5.processed/core/decrypt/create_session.js

@@ -110,7 +110,7 @@ function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistent
          */
         function recreatePersistentSession() {
             return __awaiter(this, void 0, void 0, function () {
-                var persistentEntry, newEntry;
+                var persistentEntry, err_2, newEntry;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
@@ -122,9 +122,30 @@ function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistent
                             if (persistentEntry !== null) {
                                 persistentSessionsStore.delete(persistentEntry.sessionId);
                             }
-                            return [4 /*yield*/, loadedSessionsStore.closeSession(entry.mediaKeySession)];
+                            _a.label = 1;
                         case 1:
+                            _a.trys.push([1, 3, , 4]);
+                            return [4 /*yield*/, loadedSessionsStore.closeSession(entry.mediaKeySession)];
+                        case 2:
                             _a.sent();
+                            return [3 /*break*/, 4];
+                        case 3:
+                            err_2 = _a.sent();
+                            // From reading the EME specification in details, it seems that a
+                            // `MediaKeySession`'s ability to be closed is tightly linked to its
+                            // possession of a "sanitized session ID" set as `sessionId`.
+                            // This is never clearly stated however and I'm (Paul B.) always afraid of
+                            // breaking compatibility when it comes to EME code.
+                            // So we still try to close the `MediaKeySession` in any case, only, if it
+                            // fails and it didn't had any `sessionId` set, we just ignore the error.
+                            // Note that trying to close the `MediaKeySession` might incur some delays
+                            // in those rare cases.
+                            if (entry.mediaKeySession.sessionId !== "") {
+                                throw err_2;
+                            }
+                            loadedSessionsStore.removeSessionWithoutClosingIt(entry.mediaKeySession);
+                            return [3 /*break*/, 4];
+                        case 4:
                             if (cancelSignal.cancellationError !== null) {
                                 throw cancelSignal.cancellationError;
                             }
@@ -135,7 +156,7 @@ function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistent
                 });
             });
         }
-        var entry, storedEntry, hasLoadedSession, err_1;
+        var entry, storedEntry, hasLoadedSession, newEntry, err_1;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -158,8 +179,16 @@ function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistent
                     if (!hasLoadedSession) {
                         log.warn("DRM: No data stored for the loaded session");
                         persistentSessionsStore.delete(storedEntry.sessionId);
+                        // The EME specification is kind of implicit about it but it seems from my
+                        // understanding (Paul B.) that a MediaKeySession on wich a `load` attempt
+                        // did not succeed due to the loaded session not being found by the
+                        // browser/CDM, should neither be used anymore nor closed.
+                        // Thus, we're creating another `"persistent-license"` `MediaKeySession`
+                        // in that specific case.
+                        loadedSessionsStore.removeSessionWithoutClosingIt(entry.mediaKeySession);
+                        newEntry = loadedSessionsStore.createSession(initData, "persistent-license");
                         return [2 /*return*/, { type: "created-session" /* MediaKeySessionLoadingType.Created */,
-                                value: entry }];
+                                value: newEntry }];
                     }
                     if (hasLoadedSession && isSessionUsable(entry.mediaKeySession)) {
                         persistentSessionsStore.add(initData, initData.keyIds, entry.mediaKeySession);

package/dist/_esm5.processed/core/decrypt/utils/loaded_sessions_store.d.ts

@@ -106,6 +106,20 @@ export default class LoadedSessionsStore {
      * @returns {Promise}
      */
     closeAllSessions(): Promise<void>;
+    /**
+     * Find the given `MediaKeySession` in the `LoadedSessionsStore` and removes
+     * any reference to it without actually closing it.
+     *
+     * Returns `true` if the given `mediaKeySession` has been found and removed,
+     * `false` otherwise.
+     *
+     * Note that this may create a `MediaKeySession` leakage in the wrong
+     * conditions, cases where this method should be called should be very
+     * carefully evaluated.
+     * @param {MediaKeySession} mediaKeySession
+     * @returns {boolean}
+     */
+    removeSessionWithoutClosingIt(mediaKeySession: MediaKeySession | ICustomMediaKeySession): boolean;
     /**
      * Get the index of a stored MediaKeySession entry based on its
      * `KeySessionRecord`.

package/dist/_esm5.processed/core/decrypt/utils/loaded_sessions_store.js

@@ -62,6 +62,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import { closeSession, generateKeyRequest, loadSession, } from "../../../compat";
 import log from "../../../log";
+import assert from "../../../utils/assert";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import KeySessionRecord from "./key_session_record";
 /**
@@ -346,6 +347,30 @@ var LoadedSessionsStore = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Find the given `MediaKeySession` in the `LoadedSessionsStore` and removes
+     * any reference to it without actually closing it.
+     *
+     * Returns `true` if the given `mediaKeySession` has been found and removed,
+     * `false` otherwise.
+     *
+     * Note that this may create a `MediaKeySession` leakage in the wrong
+     * conditions, cases where this method should be called should be very
+     * carefully evaluated.
+     * @param {MediaKeySession} mediaKeySession
+     * @returns {boolean}
+     */
+    LoadedSessionsStore.prototype.removeSessionWithoutClosingIt = function (mediaKeySession) {
+        assert(mediaKeySession.sessionId === "", "Initialized `MediaKeySession`s should always be properly closed");
+        for (var i = this._storage.length - 1; i >= 0; i--) {
+            var stored = this._storage[i];
+            if (stored.mediaKeySession === mediaKeySession) {
+                this._storage.splice(i, 1);
+                return true;
+            }
+        }
+        return false;
+    };
     /**
      * Get the index of a stored MediaKeySession entry based on its
      * `KeySessionRecord`.

package/dist/_esm5.processed/core/fetchers/manifest/manifest_fetcher.d.ts

@@ -74,6 +74,13 @@ export interface IManifestFetcherSettings {
     maxRetryRegular: number | undefined;
     /** Maximum number of time a request be retried when the user is offline. */
     maxRetryOffline: number | undefined;
+    /**
+     * Timeout after which request are aborted and, depending on other options,
+     * retried.
+     * To set to `-1` for no timeout.
+     * `undefined` will lead to a default, large, timeout being used.
+     */
+    requestTimeout: number | undefined;
 }
 /**
  * Class allowing to facilitate the task of loading and parsing a Manifest.

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

@@ -54,6 +54,7 @@ import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
 import assert from "../../../utils/assert";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import { tryRequestPromiseWithBackoff, } from "../utils/try_urls_with_backoff";
@@ -106,6 +107,7 @@ var ManifestFetcher = /** @class */ (function () {
     ManifestFetcher.prototype.fetch = function (url) {
         var _this = this;
         return new Observable(function (obs) {
+            var settings = _this._settings;
             var pipelines = _this._pipelines;
             var requestUrl = url !== null && url !== void 0 ? url : _this._manifestUrl;
             /** `true` if the loading pipeline is already completely executed. */
@@ -160,12 +162,18 @@ var ManifestFetcher = /** @class */ (function () {
              * Call the loader part of the pipeline, retrying if it fails according
              * to the current settings.
              * Returns the Promise of the last attempt.
-             * @param {string | undefined}  resolverUrl
+             * @param {string | undefined} manifestUrl
              * @returns {Promise}
              */
             function callLoaderWithRetries(manifestUrl) {
                 var loadManifest = pipelines.loadManifest;
-                var callLoader = function () { return loadManifest(manifestUrl, canceller.signal); };
+                var requestTimeout = isNullOrUndefined(settings.requestTimeout) ?
+                    config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
+                    settings.requestTimeout;
+                if (requestTimeout < 0) {
+                    requestTimeout = undefined;
+                }
+                var callLoader = function () { return loadManifest(manifestUrl, { timeout: requestTimeout }, canceller.signal); };
                 return tryRequestPromiseWithBackoff(callLoader, backoffSettings, canceller.signal);
             }
         });

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

@@ -26,7 +26,7 @@ import { IBufferType } from "../../segment_buffers";
  * `options` argument, which may retry a segment request when it fails.
  *
  * @param {string} bufferType
- * @param {Object} transport
+ * @param {Object} pipeline
  * @param {Object} callbacks
  * @param {Object} options
  * @returns {Function}
@@ -123,14 +123,21 @@ export interface ISegmentFetcherOptions {
      * currently offline.
      */
     maxRetryOffline: number;
+    /**
+     * Timeout after which request are aborted and, depending on other options,
+     * retried.
+     * To set to `-1` for no timeout.
+     */
+    requestTimeout: number;
 }
 /**
  * @param {string} bufferType
  * @param {Object}
  * @returns {Object}
  */
-export declare function getSegmentFetcherOptions(bufferType: string, { maxRetryRegular, maxRetryOffline, lowLatencyMode }: {
+export declare function getSegmentFetcherOptions(bufferType: string, { maxRetryRegular, maxRetryOffline, lowLatencyMode, requestTimeout }: {
     maxRetryRegular?: number | undefined;
     maxRetryOffline?: number | undefined;
+    requestTimeout?: number | undefined;
     lowLatencyMode: boolean;
 }): ISegmentFetcherOptions;

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.js

@@ -34,12 +34,16 @@ var generateRequestID = idGenerator();
  * `options` argument, which may retry a segment request when it fails.
  *
  * @param {string} bufferType
- * @param {Object} transport
+ * @param {Object} pipeline
  * @param {Object} callbacks
  * @param {Object} options
  * @returns {Function}
  */
 export default function createSegmentFetcher(bufferType, pipeline, callbacks, options) {
+    var requestOptions = {
+        timeout: options.requestTimeout < 0 ? undefined :
+            options.requestTimeout,
+    };
     /**
      * Cache audio and video initialization segments.
      * This allows to avoid doing too many requests for what are usually very
@@ -203,7 +207,7 @@ export default function createSegmentFetcher(bufferType, pipeline, callbacks, op
              * @returns {Promise}
              */
             function callLoaderWithUrl(url, cancellationSignal) {
-                return loadSegment(url, content, cancellationSignal, loaderCallbacks);
+                return loadSegment(url, content, requestOptions, cancellationSignal, loaderCallbacks);
             }
             /**
              * Generate function allowing to parse a loaded segment.
@@ -272,13 +276,15 @@ export default function createSegmentFetcher(bufferType, pipeline, callbacks, op
  * @returns {Object}
  */
 export function getSegmentFetcherOptions(bufferType, _a) {
-    var maxRetryRegular = _a.maxRetryRegular, maxRetryOffline = _a.maxRetryOffline, lowLatencyMode = _a.lowLatencyMode;
-    var _b = config.getCurrent(), DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = _b.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _b.MAX_BACKOFF_DELAY_BASE;
+    var maxRetryRegular = _a.maxRetryRegular, maxRetryOffline = _a.maxRetryOffline, lowLatencyMode = _a.lowLatencyMode, requestTimeout = _a.requestTimeout;
+    var _b = config.getCurrent(), DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_REQUEST_TIMEOUT = _b.DEFAULT_REQUEST_TIMEOUT, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = _b.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _b.MAX_BACKOFF_DELAY_BASE;
     return { maxRetryRegular: bufferType === "image" ? 0 :
             maxRetryRegular !== null && maxRetryRegular !== void 0 ? maxRetryRegular : DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
         maxRetryOffline: maxRetryOffline !== null && maxRetryOffline !== void 0 ? maxRetryOffline : DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
         baseDelay: lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
             INITIAL_BACKOFF_DELAY_BASE.REGULAR,
         maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
-            MAX_BACKOFF_DELAY_BASE.REGULAR };
+            MAX_BACKOFF_DELAY_BASE.REGULAR,
+        requestTimeout: isNullOrUndefined(requestTimeout) ? DEFAULT_REQUEST_TIMEOUT :
+            requestTimeout };
 }

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

@@ -91,4 +91,11 @@ export interface ISegmentFetcherCreatorBackoffOptions {
     maxRetryRegular: number | undefined;
     /** Maximum number of time a request be retried when the user is offline. */
     maxRetryOffline: number | undefined;
+    /**
+     * Timeout after which request are aborted and, depending on other options,
+     * retried.
+     * To set to `-1` for no timeout.
+     * `undefined` will lead to a default, large, timeout being used.
+     */
+    requestTimeout: number | undefined;
 }

package/dist/_esm5.processed/core/init/content_time_boundaries_observer.js

@@ -17,6 +17,7 @@ import { distinctUntilChanged, ignoreElements, map, merge as observableMerge, sk
 import { MediaError } from "../../errors";
 import { fromEvent } from "../../utils/event_emitter";
 import filterMap from "../../utils/filter_map";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import createSharedReference from "../../utils/reference";
 import EVENTS from "./events_generators";
 // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
@@ -54,7 +55,7 @@ export default function ContentTimeBoundariesObserver(manifest, streams, playbac
                 "earliest time announced in the Manifest.");
             return EVENTS.warning(warning);
         }
-        else if (wantedPosition > maximumPositionCalculator.getCurrentMaximumPosition()) {
+        else if (wantedPosition > maximumPositionCalculator.getMaximumAvailablePosition()) {
             var warning = new MediaError("MEDIA_TIME_AFTER_MANIFEST", "The current position is after the latest " +
                 "time announced in the Manifest.");
             return EVENTS.warning(warning);
@@ -68,32 +69,31 @@ export default function ContentTimeBoundariesObserver(manifest, streams, playbac
      */
     var contentDuration = createSharedReference(undefined);
     var updateDurationOnManifestUpdate$ = fromEvent(manifest, "manifestUpdate").pipe(startWith(null), tap(function () {
-        if (!manifest.isDynamic) {
-            var maxPos = maximumPositionCalculator.getCurrentMaximumPosition();
-            contentDuration.setValue(maxPos);
-        }
-        else {
-            // TODO handle finished dynamic contents?
-            contentDuration.setValue(undefined);
-        }
+        var duration = manifest.isDynamic ?
+            maximumPositionCalculator.getEndingPosition() :
+            maximumPositionCalculator.getMaximumAvailablePosition();
+        contentDuration.setValue(duration);
     }), ignoreElements());
     var updateDurationAndTimeBoundsOnTrackChange$ = streams.pipe(tap(function (message) {
         if (message.type === "adaptationChange") {
+            if (!manifest.isLastPeriodKnown) {
+                return;
+            }
             var lastPeriod = manifest.periods[manifest.periods.length - 1];
             if (message.value.period.id === (lastPeriod === null || lastPeriod === void 0 ? void 0 : lastPeriod.id)) {
-                if (message.value.type === "audio") {
-                    maximumPositionCalculator
-                        .updateLastAudioAdaptation(message.value.adaptation);
-                    if (!manifest.isDynamic) {
-                        contentDuration.setValue(maximumPositionCalculator.getCurrentMaximumPosition());
+                if (message.value.type === "audio" || message.value.type === "video") {
+                    if (message.value.type === "audio") {
+                        maximumPositionCalculator
+                            .updateLastAudioAdaptation(message.value.adaptation);
                     }
-                }
-                else if (message.value.type === "video") {
-                    maximumPositionCalculator
-                        .updateLastVideoAdaptation(message.value.adaptation);
-                    if (!manifest.isDynamic) {
-                        contentDuration.setValue(maximumPositionCalculator.getCurrentMaximumPosition());
+                    else {
+                        maximumPositionCalculator
+                            .updateLastVideoAdaptation(message.value.adaptation);
                     }
+                    var newDuration = manifest.isDynamic ?
+                        maximumPositionCalculator.getMaximumAvailablePosition() :
+                        maximumPositionCalculator.getEndingPosition();
+                    contentDuration.setValue(newDuration);
                 }
             }
         }
@@ -119,7 +119,7 @@ var MaximumPositionCalculator = /** @class */ (function () {
      * If no Adaptation has been set, it should be set to `null`.
      *
      * Allows to calculate the maximum position more precizely in
-     * `getCurrentMaximumPosition`.
+     * `getMaximumAvailablePosition` and `getEndingPosition`.
      * @param {Object|null} adaptation
      */
     MaximumPositionCalculator.prototype.updateLastAudioAdaptation = function (adaptation) {
@@ -130,18 +130,18 @@ var MaximumPositionCalculator = /** @class */ (function () {
      * If no Adaptation has been set, it should be set to `null`.
      *
      * Allows to calculate the maximum position more precizely in
-     * `getCurrentMaximumPosition`.
+     * `getMaximumAvailablePosition` and `getEndingPosition`.
      * @param {Object|null} adaptation
      */
     MaximumPositionCalculator.prototype.updateLastVideoAdaptation = function (adaptation) {
         this._lastVideoAdaptation = adaptation;
     };
     /**
-     * Returns an estimate of the maximum position reachable under the current
-     * circumstances.
+     * Returns an estimate of the maximum position currently reachable (i.e.
+     * segments are available) under the current circumstances.
      * @returns {number}
      */
-    MaximumPositionCalculator.prototype.getCurrentMaximumPosition = function () {
+    MaximumPositionCalculator.prototype.getMaximumAvailablePosition = function () {
         var _a;
         if (this._manifest.isDynamic) {
             return (_a = this._manifest.getLivePosition()) !== null && _a !== void 0 ? _a : this._manifest.getMaximumSafePosition();
@@ -155,7 +155,7 @@ var MaximumPositionCalculator = /** @class */ (function () {
                 return this._manifest.getMaximumSafePosition();
             }
             else {
-                var lastVideoPosition = getLastPositionFromAdaptation(this._lastVideoAdaptation);
+                var lastVideoPosition = getLastAvailablePositionFromAdaptation(this._lastVideoAdaptation);
                 if (typeof lastVideoPosition !== "number") {
                     return this._manifest.getMaximumSafePosition();
                 }
@@ -163,15 +163,15 @@ var MaximumPositionCalculator = /** @class */ (function () {
             }
         }
         else if (this._lastVideoAdaptation === null) {
-            var lastAudioPosition = getLastPositionFromAdaptation(this._lastAudioAdaptation);
+            var lastAudioPosition = getLastAvailablePositionFromAdaptation(this._lastAudioAdaptation);
             if (typeof lastAudioPosition !== "number") {
                 return this._manifest.getMaximumSafePosition();
             }
             return lastAudioPosition;
         }
         else {
-            var lastAudioPosition = getLastPositionFromAdaptation(this._lastAudioAdaptation);
-            var lastVideoPosition = getLastPositionFromAdaptation(this._lastVideoAdaptation);
+            var lastAudioPosition = getLastAvailablePositionFromAdaptation(this._lastAudioAdaptation);
+            var lastVideoPosition = getLastAvailablePositionFromAdaptation(this._lastVideoAdaptation);
             if (typeof lastAudioPosition !== "number" ||
                 typeof lastVideoPosition !== "number") {
                 return this._manifest.getMaximumSafePosition();
@@ -181,20 +181,58 @@ var MaximumPositionCalculator = /** @class */ (function () {
             }
         }
     };
+    /**
+     * Returns an estimate of the actual ending position once
+     * the full content is available.
+     * Returns `undefined` if that could not be determined, for various reasons.
+     * @returns {number|undefined}
+     */
+    MaximumPositionCalculator.prototype.getEndingPosition = function () {
+        var _a, _b;
+        if (!this._manifest.isDynamic) {
+            return this.getMaximumAvailablePosition();
+        }
+        if (this._lastVideoAdaptation === undefined ||
+            this._lastAudioAdaptation === undefined) {
+            return undefined;
+        }
+        else if (this._lastAudioAdaptation === null) {
+            if (this._lastVideoAdaptation === null) {
+                return undefined;
+            }
+            else {
+                return (_a = getEndingPositionFromAdaptation(this._lastVideoAdaptation)) !== null && _a !== void 0 ? _a : undefined;
+            }
+        }
+        else if (this._lastVideoAdaptation === null) {
+            return (_b = getEndingPositionFromAdaptation(this._lastAudioAdaptation)) !== null && _b !== void 0 ? _b : undefined;
+        }
+        else {
+            var lastAudioPosition = getEndingPositionFromAdaptation(this._lastAudioAdaptation);
+            var lastVideoPosition = getEndingPositionFromAdaptation(this._lastVideoAdaptation);
+            if (typeof lastAudioPosition !== "number" ||
+                typeof lastVideoPosition !== "number") {
+                return undefined;
+            }
+            else {
+                return Math.min(lastAudioPosition, lastVideoPosition);
+            }
+        }
+    };
     return MaximumPositionCalculator;
 }());
 /**
- * Returns "last time of reference" from the adaptation given.
+ * Returns last currently available position from the Adaptation given.
  * `undefined` if a time could not be found.
- * Null if the Adaptation has no segments (it could be that it didn't started or
+ * `null` if the Adaptation has no segments (it could be that it didn't started or
  * that it already finished for example).
  *
- * We consider the earliest last time from every representations in the given
- * adaptation.
+ * We consider the earliest last available position from every Representation
+ * in the given Adaptation.
  * @param {Object} adaptation
  * @returns {Number|undefined|null}
  */
-function getLastPositionFromAdaptation(adaptation) {
+function getLastAvailablePositionFromAdaptation(adaptation) {
     var representations = adaptation.representations;
     var min = null;
     /**
@@ -207,18 +245,52 @@ function getLastPositionFromAdaptation(adaptation) {
     for (var i = 0; i < representations.length; i++) {
         if (representations[i].index !== lastIndex) {
             lastIndex = representations[i].index;
-            var lastPosition = representations[i].index.getLastPosition();
+            var lastPosition = representations[i].index.getLastAvailablePosition();
             if (lastPosition === undefined) { // we cannot tell
                 return undefined;
             }
             if (lastPosition !== null) {
-                min = min == null ? lastPosition :
+                min = isNullOrUndefined(min) ? lastPosition :
                     Math.min(min, lastPosition);
             }
         }
     }
-    if (min === null) { // It means that all positions were null === no segments (yet?)
-        return null;
+    return min;
+}
+/**
+ * Returns ending time from the Adaptation given, once all its segments are
+ * available.
+ * `undefined` if a time could not be found.
+ * `null` if the Adaptation has no segments (it could be that it already
+ * finished for example).
+ *
+ * We consider the earliest ending time from every Representation in the given
+ * Adaptation.
+ * @param {Object} adaptation
+ * @returns {Number|undefined|null}
+ */
+function getEndingPositionFromAdaptation(adaptation) {
+    var representations = adaptation.representations;
+    var min = null;
+    /**
+     * Some Manifest parsers use the exact same `IRepresentationIndex` reference
+     * for each Representation of a given Adaptation, because in the actual source
+     * Manifest file, indexing data is often defined at Adaptation-level.
+     * This variable allows to optimize the logic here when this is the case.
+     */
+    var lastIndex;
+    for (var i = 0; i < representations.length; i++) {
+        if (representations[i].index !== lastIndex) {
+            lastIndex = representations[i].index;
+            var lastPosition = representations[i].index.getEnd();
+            if (lastPosition === undefined) { // we cannot tell
+                return undefined;
+            }
+            if (lastPosition !== null) {
+                min = isNullOrUndefined(min) ? lastPosition :
+                    Math.min(min, lastPosition);
+            }
+        }
     }
     return min;
 }

package/dist/_esm5.processed/core/init/initialize_directfile.js

@@ -108,7 +108,7 @@ export default function initializeDirectfileContent(_a) {
      * Observable trying to avoid various stalling situations, emitting "stalled"
      * events when it cannot, as well as "unstalled" events when it get out of one.
      */
-    var stallAvoider$ = StallAvoider(playbackObserver, null, EMPTY, EMPTY);
+    var stallAvoider$ = StallAvoider(playbackObserver, null, speed, EMPTY, EMPTY);
     /**
      * Emit a "loaded" events once the initial play has been performed and the
      * media can begin playback.

package/dist/_esm5.processed/core/init/load_on_media_source.js

@@ -106,7 +106,7 @@ export default function createMediaSourceLoader(_a) {
          * Observable trying to avoid various stalling situations, emitting "stalled"
          * events when it cannot, as well as "unstalled" events when it get out of one.
          */
-        var stallAvoider$ = StallAvoider(playbackObserver, manifest, lockedStream$, discontinuityUpdate$);
+        var stallAvoider$ = StallAvoider(playbackObserver, manifest, speed, lockedStream$, discontinuityUpdate$);
         /**
          * Emit a "loaded" events once the initial play has been performed and the
          * media can begin playback.

package/dist/_esm5.processed/core/init/stall_avoider.d.ts

@@ -15,6 +15,7 @@
  */
 import { Observable } from "rxjs";
 import Manifest, { Period } from "../../manifest";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import { PlaybackObserver } from "../api";
 import { IBufferType } from "../segment_buffers";
 import { IStalledEvent, IUnstalledEvent, IWarningEvent } from "./types";
@@ -67,9 +68,10 @@ export interface IDiscontinuityTimeInfo {
  * encountered and exited.
  * @param {object} playbackObserver - emit the current playback conditions.
  * @param {Object} manifest - The Manifest of the currently-played content.
+ * @param {Object} speed - The last speed set by the user
+ * @param {Observable} lockedStream$
  * @param {Observable} discontinuityUpdate$ - Observable emitting encountered
  * discontinuities for loaded Period and buffer types.
- * @param {Function} setCurrentTime
  * @returns {Observable}
  */
-export default function StallAvoider(playbackObserver: PlaybackObserver, manifest: Manifest | null, lockedStream$: Observable<ILockedStreamEvent>, discontinuityUpdate$: Observable<IDiscontinuityEvent>): Observable<IStalledEvent | IUnstalledEvent | IWarningEvent>;
+export default function StallAvoider(playbackObserver: PlaybackObserver, manifest: Manifest | null, speed: IReadOnlySharedReference<number>, lockedStream$: Observable<ILockedStreamEvent>, discontinuityUpdate$: Observable<IDiscontinuityEvent>): Observable<IStalledEvent | IUnstalledEvent | IWarningEvent>;