rx-player 3.27.0-dev.2022032100 → 3.27.0

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

@@ -37,7 +37,7 @@ export default class LoadedSessionsStore {
     constructor(mediaKeys: MediaKeys | ICustomMediaKeys);
     /**
      * Create a new MediaKeySession and store it in this store.
-     * @param {Object} initializationData
+     * @param {Object} initData
      * @param {string} sessionType
      * @returns {Object}
      */
@@ -55,6 +55,32 @@ export default class LoadedSessionsStore {
      * @returns {Object|null}
      */
     reuse(initializationData: IProcessedProtectionData): IStoredSessionEntry | null;
+    /**
+     * Get `LoadedSessionsStore`'s entry for a given MediaKeySession.
+     * Returns `null` if the given MediaKeySession is not stored in the
+     * `LoadedSessionsStore`.
+     * @param {MediaKeySession} mediaKeySession
+     * @returns {Object|null}
+     */
+    getEntryForSession(mediaKeySession: MediaKeySession | ICustomMediaKeySession): IStoredSessionEntry | null;
+    /**
+     * Generate a license request on the given MediaKeySession, while indicating
+     * to the LoadedSessionsStore that a license-request is pending so
+     * session-closing orders are properly scheduled after it is done.
+     * @param {Object} mediaKeySession
+     * @param {string} initializationDataType - Initialization data type given
+     * e.g. by the "encrypted" event for the corresponding request.
+     * @param {Uint8Array} initializationData - Initialization data given e.g. by
+     * the "encrypted" event for the corresponding request.
+     * @returns {Promise}
+     */
+    generateLicenseRequest(mediaKeySession: MediaKeySession | ICustomMediaKeySession, initializationDataType: string | undefined, initializationData: Uint8Array): Promise<unknown>;
+    /**
+     * @param {Object} mediaKeySession
+     * @param {string} sessionId
+     * @returns {Promise}
+     */
+    loadPersistentSession(mediaKeySession: MediaKeySession | ICustomMediaKeySession, sessionId: string): Promise<boolean>;
     /**
      * Close a MediaKeySession and remove its related stored information from the
      * `LoadedSessionsStore`.
@@ -80,7 +106,23 @@ export default class LoadedSessionsStore {
      * @returns {Promise}
      */
     closeAllSessions(): Promise<void>;
+    /**
+     * Get the index of a stored MediaKeySession entry based on its
+     * `KeySessionRecord`.
+     * Returns -1 if not found.
+     * @param {Object} record
+     * @returns {number}
+     */
     private getIndex;
+    /**
+     * Prepare the closure of a `MediaKeySession` stored as an entry of the
+     * `LoadedSessionsStore`.
+     * Allows to postpone the closure action if another MediaKeySession action
+     * is already pending.
+     * @param {Object} entry
+     * @returns {Promise.<boolean>}
+     */
+    private _closeEntry;
 }
 /** Information linked to a `MediaKeySession` created by the `LoadedSessionsStore`. */
 export interface IStoredSessionEntry {
@@ -105,4 +147,55 @@ export interface IStoredSessionEntry {
      * which the MediaKeySession was created.
      */
     sessionType: MediaKeySessionType;
+    /**
+     * Set to `true` while a `generateRequest` call is pending.
+     * This information might be useful as it is one of the operation we have to
+     * wait for before closing a MediaKeySession.
+     */
+    isGeneratingRequest: boolean;
+    /**
+     * Set to `true` while a `load` call is pending.
+     * This information might be useful as it is one of the operation we have to
+     * wait for before closing a MediaKeySession.
+     */
+    isLoadingPersistentSession: boolean;
+    /**
+     * The status of a potential `MediaKeySession`'s close request.
+     * Closing a MediaKeySession could be made complex as it normally cannot
+     * happen until `generateRequest` or `load` has been called.
+     *
+     * To avoid problems while still staying compatible to the most devices
+     * possible - which may have strange implementation of the specification -
+     * we're adding the `closingStatus` property allowing to perform multiple
+     * type of interaction while a close operation is either pending or is
+     * awaited.
+     */
+    closingStatus: 
+    /** Status when the MediaKeySession is currently being closed. */
+    {
+        type: "pending";
+    } | 
+    /** Status when the MediaKeySession has been closed. */
+    {
+        type: "done";
+    } | 
+    /** Status when the MediaKeySession failed to close. */
+    {
+        type: "failed";
+    } | 
+    /**
+     * Status when a close order has been received for this MediaKeySession
+     * while some sensitive operation (examples are `generateRequest` and `load`
+     * calls).
+     * The `LoadedSessionsStore` should call `start` once it has finished those
+     * operations.
+     */
+    {
+        type: "awaiting";
+        start: () => void;
+    } | 
+    /** Status when the MediaKeySession failed to close. */
+    {
+        type: "none";
+    };
 }

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

@@ -13,6 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -49,9 +60,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-import { closeSession, } from "../../../compat";
-import { onKeyMessage$, onKeyStatusesChange$, } from "../../../compat/event_listeners";
-import config from "../../../config";
+import { closeSession, generateKeyRequest, loadSession, } from "../../../compat";
 import log from "../../../log";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import KeySessionRecord from "./key_session_record";
@@ -75,7 +84,7 @@ var LoadedSessionsStore = /** @class */ (function () {
     }
     /**
      * Create a new MediaKeySession and store it in this store.
-     * @param {Object} initializationData
+     * @param {Object} initData
      * @param {string} sessionType
      * @returns {Object}
      */
@@ -83,7 +92,9 @@ var LoadedSessionsStore = /** @class */ (function () {
         var _this = this;
         var keySessionRecord = new KeySessionRecord(initData);
         var mediaKeySession = this._mediaKeys.createSession(sessionType);
-        var entry = { mediaKeySession: mediaKeySession, sessionType: sessionType, keySessionRecord: keySessionRecord };
+        var entry = { mediaKeySession: mediaKeySession, sessionType: sessionType, keySessionRecord: keySessionRecord, isGeneratingRequest: false,
+            isLoadingPersistentSession: false,
+            closingStatus: { type: "none" } };
         if (!isNullOrUndefined(mediaKeySession.closed)) {
             mediaKeySession.closed
                 .then(function () {
@@ -99,7 +110,7 @@ var LoadedSessionsStore = /** @class */ (function () {
             });
         }
         log.debug("DRM-LSS: Add MediaKeySession", entry.sessionType);
-        this._storage.push({ keySessionRecord: keySessionRecord, mediaKeySession: mediaKeySession, sessionType: sessionType });
+        this._storage.push(__assign({}, entry));
         return entry;
     };
     /**
@@ -120,23 +131,41 @@ var LoadedSessionsStore = /** @class */ (function () {
             if (stored.keySessionRecord.isCompatibleWith(initializationData)) {
                 this._storage.splice(i, 1);
                 this._storage.push(stored);
-                return { keySessionRecord: stored.keySessionRecord,
-                    mediaKeySession: stored.mediaKeySession,
-                    sessionType: stored.sessionType };
+                return __assign({}, stored);
             }
         }
         return null;
     };
     /**
-     * Close a MediaKeySession and remove its related stored information from the
+     * Get `LoadedSessionsStore`'s entry for a given MediaKeySession.
+     * Returns `null` if the given MediaKeySession is not stored in the
      * `LoadedSessionsStore`.
-     * Emit when done.
+     * @param {MediaKeySession} mediaKeySession
+     * @returns {Object|null}
+     */
+    LoadedSessionsStore.prototype.getEntryForSession = function (mediaKeySession) {
+        for (var i = this._storage.length - 1; i >= 0; i--) {
+            var stored = this._storage[i];
+            if (stored.mediaKeySession === mediaKeySession) {
+                return __assign({}, stored);
+            }
+        }
+        return null;
+    };
+    /**
+     * Generate a license request on the given MediaKeySession, while indicating
+     * to the LoadedSessionsStore that a license-request is pending so
+     * session-closing orders are properly scheduled after it is done.
      * @param {Object} mediaKeySession
+     * @param {string} initializationDataType - Initialization data type given
+     * e.g. by the "encrypted" event for the corresponding request.
+     * @param {Uint8Array} initializationData - Initialization data given e.g. by
+     * the "encrypted" event for the corresponding request.
      * @returns {Promise}
      */
-    LoadedSessionsStore.prototype.closeSession = function (mediaKeySession) {
+    LoadedSessionsStore.prototype.generateLicenseRequest = function (mediaKeySession, initializationDataType, initializationData) {
         return __awaiter(this, void 0, void 0, function () {
-            var entry, _i, _a, stored;
+            var entry, _i, _a, stored, err_1;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -148,18 +177,132 @@ var LoadedSessionsStore = /** @class */ (function () {
                             }
                         }
                         if (entry === undefined) {
-                            log.warn("DRM-LSS: No MediaKeySession found with " +
+                            log.error("DRM-LSS: generateRequest error. No MediaKeySession found with " +
                                 "the given initData and initDataType");
-                            return [2 /*return*/, Promise.resolve(false)];
+                            return [2 /*return*/, generateKeyRequest(mediaKeySession, initializationDataType, initializationData)];
                         }
-                        return [4 /*yield*/, safelyCloseMediaKeySession(entry.mediaKeySession)];
+                        entry.isGeneratingRequest = true;
+                        // Note the `as string` is needed due to TypeScript not understanding that
+                        // the `closingStatus` might change in the next checks
+                        if (entry.closingStatus.type !== "none") {
+                            throw new Error("The `MediaKeySession` is being closed.");
+                        }
+                        _b.label = 1;
                     case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, generateKeyRequest(mediaKeySession, initializationDataType, initializationData)];
+                    case 2:
                         _b.sent();
-                        return [2 /*return*/, Promise.resolve(true)];
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _b.sent();
+                        if (entry === undefined) {
+                            throw err_1;
+                        }
+                        entry.isGeneratingRequest = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        throw err_1;
+                    case 4:
+                        if (entry === undefined) {
+                            return [2 /*return*/, undefined];
+                        }
+                        entry.isGeneratingRequest = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        return [2 /*return*/];
                 }
             });
         });
     };
+    /**
+     * @param {Object} mediaKeySession
+     * @param {string} sessionId
+     * @returns {Promise}
+     */
+    LoadedSessionsStore.prototype.loadPersistentSession = function (mediaKeySession, sessionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entry, _i, _a, stored, ret, err_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        for (_i = 0, _a = this._storage; _i < _a.length; _i++) {
+                            stored = _a[_i];
+                            if (stored.mediaKeySession === mediaKeySession) {
+                                entry = stored;
+                                break;
+                            }
+                        }
+                        if (entry === undefined) {
+                            log.error("DRM-LSS: loadPersistentSession error. No MediaKeySession found with " +
+                                "the given initData and initDataType");
+                            return [2 /*return*/, loadSession(mediaKeySession, sessionId)];
+                        }
+                        entry.isLoadingPersistentSession = true;
+                        // Note the `as string` is needed due to TypeScript not understanding that
+                        // the `closingStatus` might change in the next checks
+                        if (entry.closingStatus.type !== "none") {
+                            throw new Error("The `MediaKeySession` is being closed.");
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, loadSession(mediaKeySession, sessionId)];
+                    case 2:
+                        ret = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_2 = _b.sent();
+                        if (entry === undefined) {
+                            throw err_2;
+                        }
+                        entry.isLoadingPersistentSession = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        throw err_2;
+                    case 4:
+                        if (entry === undefined) {
+                            return [2 /*return*/, ret];
+                        }
+                        entry.isLoadingPersistentSession = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        return [2 /*return*/, ret];
+                }
+            });
+        });
+    };
+    /**
+     * Close a MediaKeySession and remove its related stored information from the
+     * `LoadedSessionsStore`.
+     * Emit when done.
+     * @param {Object} mediaKeySession
+     * @returns {Promise}
+     */
+    LoadedSessionsStore.prototype.closeSession = function (mediaKeySession) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entry, _i, _a, stored;
+            return __generator(this, function (_b) {
+                for (_i = 0, _a = this._storage; _i < _a.length; _i++) {
+                    stored = _a[_i];
+                    if (stored.mediaKeySession === mediaKeySession) {
+                        entry = stored;
+                        break;
+                    }
+                }
+                if (entry === undefined) {
+                    log.warn("DRM-LSS: No MediaKeySession found with " +
+                        "the given initData and initDataType");
+                    return [2 /*return*/, Promise.resolve(false)];
+                }
+                return [2 /*return*/, this._closeEntry(entry)];
+            });
+        });
+    };
     /**
      * Returns the number of stored MediaKeySessions in this LoadedSessionsStore.
      * @returns {number}
@@ -183,6 +326,7 @@ var LoadedSessionsStore = /** @class */ (function () {
     LoadedSessionsStore.prototype.closeAllSessions = function () {
         return __awaiter(this, void 0, void 0, function () {
             var allEntries, closingProms;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -193,7 +337,7 @@ var LoadedSessionsStore = /** @class */ (function () {
                         // process of removing
                         this._storage = [];
                         closingProms = allEntries
-                            .map(function (entry) { return safelyCloseMediaKeySession(entry.mediaKeySession); });
+                            .map(function (entry) { return _this._closeEntry(entry); });
                         return [4 /*yield*/, Promise.all(closingProms)];
                     case 1:
                         _a.sent();
@@ -202,6 +346,13 @@ var LoadedSessionsStore = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Get the index of a stored MediaKeySession entry based on its
+     * `KeySessionRecord`.
+     * Returns -1 if not found.
+     * @param {Object} record
+     * @returns {number}
+     */
     LoadedSessionsStore.prototype.getIndex = function (record) {
         for (var i = 0; i < this._storage.length; i++) {
             var stored = this._storage[i];
@@ -211,92 +362,82 @@ var LoadedSessionsStore = /** @class */ (function () {
         }
         return -1;
     };
+    /**
+     * Prepare the closure of a `MediaKeySession` stored as an entry of the
+     * `LoadedSessionsStore`.
+     * Allows to postpone the closure action if another MediaKeySession action
+     * is already pending.
+     * @param {Object} entry
+     * @returns {Promise.<boolean>}
+     */
+    LoadedSessionsStore.prototype._closeEntry = function (entry) {
+        return __awaiter(this, void 0, void 0, function () {
+            var mediaKeySession;
+            return __generator(this, function (_a) {
+                mediaKeySession = entry.mediaKeySession;
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        if (entry !== undefined &&
+                            (entry.isLoadingPersistentSession || entry.isGeneratingRequest)) {
+                            entry.closingStatus = { type: "awaiting",
+                                start: tryClosingEntryAndResolve };
+                        }
+                        else {
+                            tryClosingEntryAndResolve();
+                        }
+                        function tryClosingEntryAndResolve() {
+                            if (entry !== undefined) {
+                                entry.closingStatus = { type: "pending" };
+                            }
+                            safelyCloseMediaKeySession(mediaKeySession)
+                                .then(function () {
+                                if (entry !== undefined) {
+                                    entry.closingStatus = { type: "done" };
+                                }
+                                resolve(true);
+                            })
+                                .catch(function (err) {
+                                if (entry !== undefined) {
+                                    entry.closingStatus = { type: "failed" };
+                                }
+                                reject(err);
+                            });
+                        }
+                    })];
+            });
+        });
+    };
     return LoadedSessionsStore;
 }());
 export default LoadedSessionsStore;
 /**
- * Close a MediaKeySession with multiple attempts if needed and do not throw if
- * this action throws an error.
+ * Close a MediaKeySession and just log an error if it fails (while resolving).
  * Emits then complete when done.
  * @param {MediaKeySession} mediaKeySession
  * @returns {Observable}
  */
 function safelyCloseMediaKeySession(mediaKeySession) {
-    return recursivelyTryToCloseMediaKeySession(0);
-    /**
-     * Perform a new attempt at closing the MediaKeySession.
-     * If this operation fails due to a not-"callable" (an EME term)
-     * MediaKeySession, retry based on either a timer or on MediaKeySession
-     * events, whichever comes first.
-     * Emits then complete when done.
-     * @param {number} retryNb - The attempt number starting at 0.
-     * @returns {Observable}
-     */
-    function recursivelyTryToCloseMediaKeySession(retryNb) {
-        return __awaiter(this, void 0, void 0, function () {
-            var err_1, _a, EME_SESSION_CLOSING_MAX_RETRY, EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY, nextRetryNb, delay_1, ksChangeSub_1, ksChangeProm, ksMsgSub_1, ksMsgProm, sleepTimer_1, sleepProm;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        log.debug("DRM: Trying to close a MediaKeySession", mediaKeySession.sessionId, retryNb);
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 3, , 5]);
-                        return [4 /*yield*/, closeSession(mediaKeySession)];
-                    case 2:
-                        _b.sent();
-                        log.debug("DRM: Succeeded to close MediaKeySession");
-                        return [2 /*return*/, undefined];
-                    case 3:
-                        err_1 = _b.sent();
-                        // Unitialized MediaKeySession may not close properly until their
-                        // corresponding `generateRequest` or `load` call are handled by the
-                        // browser.
-                        // In that case the EME specification tells us that the browser is
-                        // supposed to reject the `close` call with an InvalidStateError.
-                        if (!(err_1 instanceof Error) || err_1.name !== "InvalidStateError" ||
-                            mediaKeySession.sessionId !== "") {
-                            return [2 /*return*/, failToCloseSession(err_1)];
-                        }
-                        _a = config.getCurrent(), EME_SESSION_CLOSING_MAX_RETRY = _a.EME_SESSION_CLOSING_MAX_RETRY, EME_SESSION_CLOSING_INITIAL_DELAY = _a.EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY = _a.EME_SESSION_CLOSING_MAX_DELAY;
-                        nextRetryNb = retryNb + 1;
-                        if (nextRetryNb > EME_SESSION_CLOSING_MAX_RETRY) {
-                            return [2 /*return*/, failToCloseSession(err_1)];
-                        }
-                        delay_1 = Math.min(Math.pow(2, retryNb) * EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY);
-                        log.warn("DRM: attempt to close a mediaKeySession failed, " +
-                            "scheduling retry...", delay_1);
-                        ksChangeProm = new Promise(function (res) {
-                            ksChangeSub_1 = onKeyStatusesChange$(mediaKeySession).subscribe(res);
-                        });
-                        ksMsgProm = new Promise(function (res) {
-                            ksMsgSub_1 = onKeyMessage$(mediaKeySession).subscribe(res);
-                        });
-                        sleepProm = new Promise(function (res) {
-                            sleepTimer_1 = window.setTimeout(res, delay_1);
-                        });
-                        return [4 /*yield*/, Promise.race([ksChangeProm, ksMsgProm, sleepProm])];
-                    case 4:
-                        _b.sent();
-                        ksChangeSub_1 === null || ksChangeSub_1 === void 0 ? void 0 : ksChangeSub_1.unsubscribe();
-                        ksMsgSub_1 === null || ksMsgSub_1 === void 0 ? void 0 : ksMsgSub_1.unsubscribe();
-                        clearTimeout(sleepTimer_1);
-                        return [2 /*return*/, recursivelyTryToCloseMediaKeySession(nextRetryNb)];
-                    case 5: return [2 /*return*/];
-                }
-            });
+    return __awaiter(this, void 0, void 0, function () {
+        var err_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    log.debug("DRM: Trying to close a MediaKeySession", mediaKeySession.sessionId);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, closeSession(mediaKeySession)];
+                case 2:
+                    _a.sent();
+                    log.debug("DRM: Succeeded to close MediaKeySession");
+                    return [2 /*return*/];
+                case 3:
+                    err_3 = _a.sent();
+                    log.error("DRM: Could not close MediaKeySession: " +
+                        (err_3 instanceof Error ? err_3.toString() :
+                            "Unknown error"));
+                    return [2 /*return*/];
+                case 4: return [2 /*return*/];
+            }
         });
-    }
-    /**
-     * Log error anouncing that we could not close the MediaKeySession and emits
-     * then complete through Observable.
-     * TODO Emit warning?
-     * @returns {Observable}
-     */
-    function failToCloseSession(err) {
-        log.error("DRM: Could not close MediaKeySession: " +
-            (err instanceof Error ? err.toString() :
-                "Unknown error"));
-        return Promise.resolve(null);
-    }
+    });
 }

package/dist/_esm5.processed/core/segment_buffers/garbage_collector.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, concatAll, EMPTY, from as observableFrom, ignoreElements, mergeMap, } from "rxjs";
+import { combineLatest as observableCombineLatest, concatAll, EMPTY, from as observableFrom, ignoreElements, mergeMap, of as observableOf, } from "rxjs";
 import log from "../../log";
 import { getInnerAndOuterTimeRanges } from "../../utils/ranges";
 /**
@@ -105,6 +105,9 @@ function clearBuffer(segmentBuffer, position, maxBufferBehind, maxBufferAhead) {
     collectBufferAhead();
     var clean$ = observableFrom(cleanedupRanges.map(function (range) {
         log.debug("GC: cleaning range from SegmentBuffer", range);
+        if (range.start >= range.end) {
+            return observableOf(null);
+        }
         return segmentBuffer.removeBuffer(range.start, range.end);
     })).pipe(concatAll(), 
     // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.js

@@ -240,7 +240,8 @@ export default function StreamOrchestrator(content, playbackObserver, abrManager
             destroyStreams$.next();
             return observableConcat.apply(void 0, __spreadArray(__spreadArray([], rangesToClean.map(function (_a) {
                 var start = _a.start, end = _a.end;
-                return segmentBuffer.removeBuffer(start, end).pipe(ignoreElements());
+                return start >= end ? EMPTY :
+                    segmentBuffer.removeBuffer(start, end).pipe(ignoreElements());
             }), false), [playbackObserver.observe(true).pipe(take(1), mergeMap(function (observation) {
                     return observableConcat(observableOf(EVENTS.needsDecipherabilityFlush(observation.position, !observation.isPaused, observation.duration)), observableDefer(function () {
                         var lastPosition = observation.position +

package/dist/_esm5.processed/core/stream/period/period_stream.js

@@ -63,9 +63,15 @@ export default function PeriodStream(_a) {
                 if (SegmentBuffersStore.isNative(bufferType)) {
                     return reloadAfterSwitch(period, bufferType, playbackObserver, 0);
                 }
-                cleanBuffer$ = segmentBufferStatus.value
-                    .removeBuffer(period.start, period.end == null ? Infinity :
-                    period.end);
+                if (period.end === undefined) {
+                    cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start, Infinity);
+                }
+                else if (period.end <= period.start) {
+                    cleanBuffer$ = observableOf(null);
+                }
+                else {
+                    cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start, period.end);
+                }
             }
             else {
                 if (segmentBufferStatus.type === "uninitialized") {

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

@@ -16,7 +16,7 @@
 /**
  * This file allows any Stream to push data to a SegmentBuffer.
  */
-import { catchError, concat as observableConcat, mergeMap, ignoreElements, } from "rxjs";
+import { catchError, concat as observableConcat, mergeMap, ignoreElements, take, } from "rxjs";
 import { MediaError } from "../../../errors";
 import forceGarbageCollection from "./force_garbage_collection";
 /**
@@ -38,10 +38,11 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                 "An unknown error happened when pushing content";
             throw new MediaError("BUFFER_APPEND_ERROR", reason);
         }
-        return playbackObserver.observe(true).pipe(mergeMap(function (observation) {
+        return playbackObserver.observe(true).pipe(take(1), mergeMap(function (observation) {
             var currentPos = observation.position + observation.wantedTimeOffset;
             return observableConcat(forceGarbageCollection(currentPos, segmentBuffer).pipe(ignoreElements()), append$).pipe(catchError(function (forcedGCError) {
-                var reason = forcedGCError instanceof Error ? forcedGCError.toString() :
+                var reason = forcedGCError instanceof Error ?
+                    forcedGCError.toString() :
                     "Could not clean the buffer";
                 throw new MediaError("BUFFER_FULL_ERROR", reason);
             }));

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concatAll, defer as observableDefer, from as observableFrom, } from "rxjs";
+import { concatAll, defer as observableDefer, from as observableFrom, of as observableOf, } from "rxjs";
 import config from "../../../config";
 import log from "../../../log";
 import { getInnerAndOuterTimeRanges } from "../../../utils/ranges";
@@ -41,7 +41,8 @@ export default function forceGarbageCollection(currentPosition, bufferingQueue)
         log.debug("Stream: GC cleaning", cleanedupRanges);
         return observableFrom(cleanedupRanges.map(function (_a) {
             var start = _a.start, end = _a.end;
-            return bufferingQueue.removeBuffer(start, end);
+            return start >= end ? observableOf(null) :
+                bufferingQueue.removeBuffer(start, end);
         })).pipe(concatAll());
     });
 }

package/dist/_esm5.processed/core/stream/representation/get_buffer_status.d.ts

@@ -43,8 +43,8 @@ export interface IBufferStatus {
      */
     shouldRefreshManifest: boolean;
     /**
-     * If 'true', the buffer memory is saturated before being able to download
-     * at least MIN_REQUIRED_BUFFER_AHEAD ( default : 10sec )
+     * If 'true', the buffer memory is saturated, thus we may have issues loading
+     * new segments.
      */
     isBufferFull: boolean;
 }