rx-player 3.28.0 → 3.28.1-dev.2022083000

package/.github/workflows/checks.yml

@@ -54,27 +54,29 @@ jobs:
     - run: node tests/integration/run.js --bchromehl
     - run: npm run test:memory
 
-  integration_windows:
+  # Windows seems to be a lot less stable for some reason.
+  # TODO debug?
+  # integration_windows:
 
-    runs-on: windows-latest
+  #   runs-on: windows-latest
 
-    strategy:
-      matrix:
-        node-version: [16.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+  #   strategy:
+  #     matrix:
+  #       node-version: [16.x]
+  #       # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm install
-    # Firefox seems to have issue with integration tests on GitHub actions only
-    # TODO to check
-    - run: node tests/integration/run.js --bchromehl
-    - run: npm run test:memory
+  #   steps:
+  #   - uses: actions/checkout@v2
+  #   - name: Use Node.js ${{ matrix.node-version }}
+  #     uses: actions/setup-node@v2
+  #     with:
+  #       node-version: ${{ matrix.node-version }}
+  #       cache: 'npm'
+  #   - run: npm install
+  #   # Firefox seems to have issue with integration tests on GitHub actions only
+  #   # TODO to check
+  #   - run: node tests/integration/run.js --bchromehl
+  #   - run: npm run test:memory
 
   # MacOS seems to be a lot less stable for some reason.
   # TODO debug?

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## v3.28.1-dev.2022083000 (2022-08-30)
+
+### Bug fixes
+
+  - DRM: When using persistent licenses, create new MediaKeySession when `load` resolves with `false`, instead of relying the same, to fix issues with such persistent sessions [#1139]
+
+### Other improvements
+
+  - In the experimental "local" transport, add `incomingRanges` property to signal the time ranges of remaining data, allowing better discontinuity handling and duration estimates for sill-loading dowloaded contents [#1151]
+
 ## v3.28.0 (2022-07-12)
 
 ### Features
@@ -25,6 +35,7 @@
 ### Other improvements
 
   - TTML: Add support for percent based thickness for textOutline in TTML Subtitles [#1108]
+  - Improve TypeScript's language servers auto import feature with the RxPlayer by better redirecting to the exported type [#1126]
   - If seeking after the last potential position, load last segments before ending [#1097]
   - The duration set on the media element is now only relative to the current chosen tracks (it was previously relative to all potential track). This allows to seek later when switching e.g. to a longer video track [#1102]
   - Errors coming from an HTMLMediaElement now have the browser's error message if it exists [#1112]

package/VERSION

@@ -1 +1 @@
-3.28.0
+3.28.1-dev.2022083000

package/dist/_esm5.processed/compat/eme/load_session.d.ts

@@ -18,14 +18,13 @@ import { ICustomMediaKeySession } from "./custom_media_keys";
  * Load a persistent session, based on its `sessionId`, on the given
  * MediaKeySession.
  *
- * Returns an Observable which emits:
- *   - true if the persistent MediaKeySession was found and loaded
- *   - false if no persistent MediaKeySession was found with that `sessionId`.
- * Then completes.
+ * Returns a Promise which resolves with:
+ *   - `true` if the persistent MediaKeySession was found and loaded
+ *   - `false` if no persistent MediaKeySession was found with that `sessionId`.
  *
- * The Observable throws if anything goes wrong in the process.
+ * The Promise rejects if anything goes wrong in the process.
  * @param {MediaKeySession} session
  * @param {string} sessionId
- * @returns {Observable}
+ * @returns {Promise.<boolean>}
  */
 export default function loadSession(session: MediaKeySession | ICustomMediaKeySession, sessionId: string): Promise<boolean>;

package/dist/_esm5.processed/compat/eme/load_session.js

@@ -55,15 +55,14 @@ var EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
  * Load a persistent session, based on its `sessionId`, on the given
  * MediaKeySession.
  *
- * Returns an Observable which emits:
- *   - true if the persistent MediaKeySession was found and loaded
- *   - false if no persistent MediaKeySession was found with that `sessionId`.
- * Then completes.
+ * Returns a Promise which resolves with:
+ *   - `true` if the persistent MediaKeySession was found and loaded
+ *   - `false` if no persistent MediaKeySession was found with that `sessionId`.
  *
- * The Observable throws if anything goes wrong in the process.
+ * The Promise rejects if anything goes wrong in the process.
  * @param {MediaKeySession} session
  * @param {string} sessionId
- * @returns {Observable}
+ * @returns {Promise.<boolean>}
  */
 export default function loadSession(session, sessionId) {
     return __awaiter(this, void 0, void 0, function () {

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

@@ -88,7 +88,7 @@ var Player = /** @class */ (function (_super) {
         // Workaround to support Firefox autoplay on FF 42.
         // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
         videoElement.preload = "auto";
-        _this.version = /* PLAYER_VERSION */ "3.28.0";
+        _this.version = /* PLAYER_VERSION */ "3.28.1-dev.2022083000";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -2295,5 +2295,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.28.0";
+Player.version = /* PLAYER_VERSION */ "3.28.1-dev.2022083000";
 export default Player;

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/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}

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

@@ -34,7 +34,7 @@ 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}

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/stream/representation/check_for_discontinuity.js

@@ -75,23 +75,35 @@ export default function checkForDiscontinuity(content, checkedRange, nextSegment
         // and no segment will fill in that hole
         (nextSegmentStart === null ||
             nextBufferedSegment.infos.segment.end <= nextSegmentStart)) {
+        var discontinuityEnd = nextBufferedSegment.bufferedStart;
+        if (!hasFinishedLoading &&
+            representation.index.awaitSegmentBetween(checkedRange.start, discontinuityEnd) !== false) {
+            return null;
+        }
         log.debug("RS: current discontinuity encountered", adaptation.type, nextBufferedSegment.bufferedStart);
         return { start: undefined,
-            end: nextBufferedSegment.bufferedStart };
+            end: discontinuityEnd };
     }
     // Check if there's a discontinuity BETWEEN segments of the current range
     var nextHoleIdx = getIndexOfFirstDiscontinuityBetweenChunks(bufferedSegments, checkedRange, nextBufferedInRangeIdx + 1);
     // If there was a hole between two consecutives segments, and if this hole
     // comes before the next segment to load, there is a discontinuity (that hole!)
-    if (nextHoleIdx !== null &&
-        (nextSegmentStart === null ||
-            bufferedSegments[nextHoleIdx].infos.segment.end <= nextSegmentStart)) {
-        var start = bufferedSegments[nextHoleIdx - 1].bufferedEnd;
-        var end = bufferedSegments[nextHoleIdx].bufferedStart;
-        log.debug("RS: future discontinuity encountered", adaptation.type, start, end);
-        return { start: start, end: end };
+    if (nextHoleIdx !== null) {
+        var segmentInfoBeforeHole = bufferedSegments[nextHoleIdx - 1];
+        var segmentInfoAfterHole = bufferedSegments[nextHoleIdx];
+        if (nextSegmentStart === null ||
+            segmentInfoAfterHole.infos.segment.end <= nextSegmentStart) {
+            if (!hasFinishedLoading && representation.index
+                .awaitSegmentBetween(segmentInfoBeforeHole.infos.segment.end, segmentInfoAfterHole.infos.segment.time) !== false) {
+                return null;
+            }
+            var start = segmentInfoBeforeHole.bufferedEnd;
+            var end = segmentInfoAfterHole.bufferedStart;
+            log.debug("RS: future discontinuity encountered", adaptation.type, start, end);
+            return { start: start, end: end };
+        }
     }
-    else if (nextSegmentStart === null) {
+    if (nextSegmentStart === null) {
         // If no hole between segments and no segment to load, check for a
         // discontinuity at the end of the Period
         if (hasFinishedLoading && period.end !== undefined) { // Period is finished

package/dist/_esm5.processed/core/stream/representation/get_buffer_status.js

@@ -64,38 +64,30 @@ export default function getBufferStatus(content, initialWantedTime, playbackObse
      * `true` if the current `RepresentationStream` has loaded all the
      * needed segments for this Representation until the end of the Period.
      */
-    var hasFinishedLoading = neededRange.hasReachedPeriodEnd &&
+    var hasFinishedLoading = representation.index.isInitialized() &&
+        representation.index.isFinished() &&
+        neededRange.hasReachedPeriodEnd &&
         prioritizedNeededSegments.length === 0 &&
         segmentsOnHold.length === 0;
-    var imminentDiscontinuity;
-    if (!representation.index.isInitialized() ||
-        // TODO better handle contents not chronologically generated
-        (!representation.index.areSegmentsChronologicallyGenerated() &&
-            !hasFinishedLoading)) {
-        // We might be missing information about future segments
-        imminentDiscontinuity = null;
+    /**
+     * Start time in seconds of the next available not-yet pushed segment.
+     * `null` if no segment is wanted for the current wanted range.
+     */
+    var nextSegmentStart = null;
+    if (segmentsBeingPushed.length > 0) {
+        nextSegmentStart = Math.min.apply(Math, segmentsBeingPushed.map(function (info) { return info.segment.time; }));
     }
-    else {
-        /**
-         * Start time in seconds of the next available not-yet pushed segment.
-         * `null` if no segment is wanted for the current wanted range.
-         */
-        var nextSegmentStart = null;
-        if (segmentsBeingPushed.length > 0) {
-            nextSegmentStart = Math.min.apply(Math, segmentsBeingPushed.map(function (info) { return info.segment.time; }));
-        }
-        if (segmentsOnHold.length > 0) {
-            nextSegmentStart = nextSegmentStart !== null ?
-                Math.min(nextSegmentStart, segmentsOnHold[0].time) :
-                segmentsOnHold[0].time;
-        }
-        if (prioritizedNeededSegments.length > 0) {
-            nextSegmentStart = nextSegmentStart !== null ?
-                Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time) :
-                prioritizedNeededSegments[0].segment.time;
-        }
-        imminentDiscontinuity = checkForDiscontinuity(content, neededRange, nextSegmentStart, hasFinishedLoading, bufferedSegments);
+    if (segmentsOnHold.length > 0) {
+        nextSegmentStart = nextSegmentStart !== null ?
+            Math.min(nextSegmentStart, segmentsOnHold[0].time) :
+            segmentsOnHold[0].time;
+    }
+    if (prioritizedNeededSegments.length > 0) {
+        nextSegmentStart = nextSegmentStart !== null ?
+            Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time) :
+            prioritizedNeededSegments[0].segment.time;
     }
+    var imminentDiscontinuity = checkForDiscontinuity(content, neededRange, nextSegmentStart, hasFinishedLoading, bufferedSegments);
     return { imminentDiscontinuity: imminentDiscontinuity, hasFinishedLoading: hasFinishedLoading, neededSegments: prioritizedNeededSegments, isBufferFull: isBufferFull, shouldRefreshManifest: shouldRefreshManifest };
 }
 /**
@@ -111,7 +103,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
     var _a;
     var wantedStartPosition;
     var manifest = content.manifest, period = content.period, representation = content.representation;
-    var lastIndexPosition = representation.index.getLastPosition();
+    var lastIndexPosition = representation.index.getLastAvailablePosition();
     var representationIndex = representation.index;
     // There is an exception for when the current initially wanted time is already
     // after the last position with segments AND when we're playing the absolute