rx-player 3.27.0-dev.2022032100 → 3.27.0

package/dist/rx-player.js

@@ -624,18 +624,25 @@ var OldWebkitMediaKeySession = /*#__PURE__*/function (_EventEmitter) {
     _this.sessionId = "";
     _this._closeSession = noop/* default */.Z; // Just here to make TypeScript happy
 
-    _this.closed = new Promise(function (resolve) {
-      _this._closeSession = resolve;
-    });
     _this.keyStatuses = new Map();
     _this.expiration = NaN;
 
-    _this._onSessionRelatedEvent = function (evt) {
+    var onSessionRelatedEvent = function onSessionRelatedEvent(evt) {
       _this.trigger(evt.type, evt);
     };
 
+    _this.closed = new Promise(function (resolve) {
+      _this._closeSession = function () {
+        ["keymessage", "message", "keyadded", "ready", "keyerror", "error"].forEach(function (evt) {
+          mediaElement.removeEventListener(evt, onSessionRelatedEvent);
+          mediaElement.removeEventListener("webkit" + evt, onSessionRelatedEvent);
+        });
+        resolve();
+      };
+    });
     ["keymessage", "message", "keyadded", "ready", "keyerror", "error"].forEach(function (evt) {
-      return mediaElement.addEventListener(evt, _this._onSessionRelatedEvent);
+      mediaElement.addEventListener(evt, onSessionRelatedEvent);
+      mediaElement.addEventListener("webkit" + evt, onSessionRelatedEvent);
     });
     return _this;
   }
@@ -692,8 +699,6 @@ var OldWebkitMediaKeySession = /*#__PURE__*/function (_EventEmitter) {
     var _this4 = this;
 
     return new Promise(function (resolve) {
-      _this4._unbindSession();
-
       _this4._closeSession();
 
       resolve();
@@ -715,14 +720,6 @@ var OldWebkitMediaKeySession = /*#__PURE__*/function (_EventEmitter) {
     return Promise.resolve();
   };
 
-  _proto._unbindSession = function _unbindSession() {
-    var _this5 = this;
-
-    ["keymessage", "message", "keyadded", "ready", "keyerror", "error"].forEach(function (evt) {
-      return _this5._vid.removeEventListener(evt, _this5._onSessionRelatedEvent);
-    });
-  };
-
   return OldWebkitMediaKeySession;
 }(event_emitter/* default */.Z);
 
@@ -941,11 +938,6 @@ var WebkitMediaKeySession = /*#__PURE__*/function (_EventEmitter) {
     });
     _this.keyStatuses = new Map();
     _this.expiration = NaN;
-
-    _this._onEvent = function (evt) {
-      _this.trigger(evt.type, evt);
-    };
-
     return _this;
   }
 
@@ -961,9 +953,20 @@ var WebkitMediaKeySession = /*#__PURE__*/function (_EventEmitter) {
       }
 
       try {
+        var uInt8Arraylicense;
+
+        if (license instanceof ArrayBuffer) {
+          uInt8Arraylicense = new Uint8Array(license);
+        } else if (license instanceof Uint8Array) {
+          uInt8Arraylicense = license;
+        } else {
+          uInt8Arraylicense = new Uint8Array(license.buffer);
+        }
         /* eslint-disable @typescript-eslint/no-unsafe-member-access */
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        resolve(_this2._nativeSession.update(license));
+
+
+        resolve(_this2._nativeSession.update(uInt8Arraylicense));
         /* eslint-enable @typescript-eslint/no-unsafe-member-access */
       } catch (err) {
         reject(err);
@@ -1047,6 +1050,10 @@ var WebkitMediaKeySession = /*#__PURE__*/function (_EventEmitter) {
 
     this._unbindSession(); // If previous session was linked
 
+
+    var onEvent = function onEvent(evt) {
+      _this5.trigger(evt.type, evt);
+    };
     /* eslint-disable @typescript-eslint/no-unsafe-call */
 
     /* eslint-disable @typescript-eslint/no-unsafe-member-access */
@@ -1055,12 +1062,14 @@ var WebkitMediaKeySession = /*#__PURE__*/function (_EventEmitter) {
 
 
     ["keymessage", "message", "keyadded", "ready", "keyerror", "error"].forEach(function (evt) {
-      return session.addEventListener(evt, _this5._onEvent);
+      session.addEventListener(evt, onEvent);
+      session.addEventListener("webkit" + evt, onEvent);
     });
 
     this._unbindSession = function () {
       ["keymessage", "message", "keyadded", "ready", "keyerror", "error"].forEach(function (evt) {
-        return session.removeEventListener(evt, _this5._onEvent);
+        session.removeEventListener(evt, onEvent);
+        session.removeEventListener("webkit" + evt, onEvent);
       });
     };
     /* eslint-disable @typescript-eslint/no-unsafe-return */
@@ -3216,36 +3225,6 @@ var DEFAULT_CONFIG = {
    */
   EME_MAX_STORED_PERSISTENT_SESSION_INFORMATION: 1000,
 
-  /**
-   * Attempts to closing a MediaKeySession can fail, most likely because the
-   * MediaKeySession was not initialized yet.
-   * When we consider that we're in one of these case, we will retry to close it.
-   *
-   * To avoid going into an infinite loop of retry, this number indicates a
-   * maximum number of attemps we're going to make (`0` meaning no retry at all,
-   * `1` only one retry and so on).
-   */
-  EME_SESSION_CLOSING_MAX_RETRY: 5,
-
-  /**
-   * When closing a MediaKeySession failed due to the reasons explained for the
-   * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-   * triggers) choose to wait a delay raising exponentially at each retry before
-   * that new attempt.
-   * This value indicates the initial value for this delay, in milliseconds.
-   */
-  EME_SESSION_CLOSING_INITIAL_DELAY: 100,
-
-  /**
-   * When closing a MediaKeySession failed due to the reasons explained for the
-   * `EME_SESSION_CLOSING_MAX_RETRY` config property, we may (among other
-   * triggers) choose to wait a delay raising exponentially at each retry before
-   * that new attempt.
-   * This value indicates the maximum possible value for this delay, in
-   * milliseconds.
-   */
-  EME_SESSION_CLOSING_MAX_DELAY: 1000,
-
   /**
    * After loading a persistent MediaKeySession, the RxPlayer needs to ensure
    * that its keys still allow to decrypt a content.
@@ -3388,18 +3367,11 @@ var DEFAULT_CONFIG = {
    */
   BUFFERED_HISTORY_MAXIMUM_ENTRIES: 200,
 
-  /**
-   * Minimum buffer (in seconds) we should have, regardless of memory
-   * constraints
-   */
-  MIN_BUFFER_LENGTH: 5,
-
   /**
    * Minimum buffer in seconds ahead relative to current time
-   * we should be able to download
-   * Before trying to agressively free up memory
+   * we should be able to download, even in cases of saturated memory.
    */
-  MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP: 10,
+  MIN_BUFFER_AHEAD: 5,
 
   /**
    * Distance in seconds behind the current position
@@ -4722,146 +4694,6 @@ function getInitData(encryptedEvent) {
     values: values
   };
 }
-// EXTERNAL MODULE: ./src/parsers/containers/isobmff/get_box.ts
-var get_box = __webpack_require__(2297);
-;// CONCATENATED MODULE: ./src/compat/eme/generate_key_request.ts
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-
-
-/**
- * Modify "initialization data" sent to a `generateKeyRequest` EME call to
- * improve the player's browser compatibility:
- *
- *   1. some browsers/CDM have problems when the CENC PSSH box is the first
- *      encountered PSSH box in the initialization data (for the moment just
- *      Edge was noted with this behavior).
- *      We found however that it works on every browser when the CENC pssh
- *      box(es) is/are the last box(es) encountered.
- *
- *      To that end, we move CENC pssh boxes at the end of the initialization
- *      data in this function.
- *
- *   2. Some poorly encoded/packaged contents communicate both a CENC with a
- *      pssh version of 0 and one with a version of 1. We found out that this is
- *      not always well handled on some devices/browsers (on Edge and some other
- *      embedded devices that shall remain nameless for now!).
- *
- *      Here this function will filter out CENC pssh with a version different to
- *      1 when one(s) with a version of 1 is/are already present.
- *
- * If the initData is unrecognized or if a CENC PSSH is not found, this function
- * throws.
- * @param {Uint8Array} initData - Initialization data you want to patch
- * @returns {Uint8Array} - Initialization data, patched
- */
-
-function patchInitData(initData) {
-  log/* default.info */.Z.info("Compat: Trying to move CENC PSSH from init data at the end of it.");
-  var foundCencV1 = false;
-  var concatenatedCencs = new Uint8Array();
-  var resInitData = new Uint8Array();
-  var offset = 0;
-
-  while (offset < initData.length) {
-    if (initData.length < offset + 8 || (0,byte_parsing/* be4toi */.pX)(initData, offset + 4) !== PSSH_TO_INTEGER) {
-      log/* default.warn */.Z.warn("Compat: unrecognized initialization data. Cannot patch it.");
-      throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
-    }
-
-    var len = (0,byte_parsing/* be4toi */.pX)(new Uint8Array(initData), offset);
-
-    if (offset + len > initData.length) {
-      log/* default.warn */.Z.warn("Compat: unrecognized initialization data. Cannot patch it.");
-      throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
-    }
-
-    var currentPSSH = initData.subarray(offset, offset + len); // yep
-
-    if (initData[offset + 12] === 0x10 && initData[offset + 13] === 0x77 && initData[offset + 14] === 0xEF && initData[offset + 15] === 0xEC && initData[offset + 16] === 0xC0 && initData[offset + 17] === 0xB2 && initData[offset + 18] === 0x4D && initData[offset + 19] === 0x02 && initData[offset + 20] === 0xAC && initData[offset + 21] === 0xE3 && initData[offset + 22] === 0x3C && initData[offset + 23] === 0x1E && initData[offset + 24] === 0x52 && initData[offset + 25] === 0xE2 && initData[offset + 26] === 0xFB && initData[offset + 27] === 0x4B) {
-      var cencOffsets = (0,get_box/* getNextBoxOffsets */.Xj)(currentPSSH);
-      var version = cencOffsets === null ? undefined : currentPSSH[cencOffsets[1]];
-      log/* default.info */.Z.info("Compat: CENC PSSH found with version", version);
-
-      if (version === undefined) {
-        log/* default.warn */.Z.warn("Compat: could not read version of CENC PSSH");
-      } else if (foundCencV1 === (version === 1)) {
-        // Either `concatenatedCencs` only contains v1 or does not contain any
-        concatenatedCencs = (0,byte_parsing/* concat */.zo)(concatenatedCencs, currentPSSH);
-      } else if (version === 1) {
-        log/* default.warn */.Z.warn("Compat: cenc version 1 encountered, " + "removing every other cenc pssh box.");
-        concatenatedCencs = currentPSSH;
-        foundCencV1 = true;
-      } else {
-        log/* default.warn */.Z.warn("Compat: filtering out cenc pssh box with wrong version", version);
-      }
-    } else {
-      resInitData = (0,byte_parsing/* concat */.zo)(resInitData, currentPSSH);
-    }
-
-    offset += len;
-  }
-
-  if (offset !== initData.length) {
-    log/* default.warn */.Z.warn("Compat: unrecognized initialization data. Cannot patch it.");
-    throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
-  }
-
-  return (0,byte_parsing/* concat */.zo)(resInitData, concatenatedCencs);
-}
-/**
- * Generate a request from session.
- * @param {MediaKeySession} session - MediaKeySession on which the request will
- * be done.
- * @param {Uint8Array} initData - Initialization data given e.g. by the
- * "encrypted" event for the corresponding request.
- * @param {string} initDataType - Initialization data type given e.g. by the
- * "encrypted" event for the corresponding request.
- * @param {string} sessionType - Type of session you want to generate. Consult
- * EME Specification for more information on session types.
- * @returns {Promise} - Emit when done. Errors if fails.
- */
-
-function generateKeyRequest(session, initializationDataType, initializationData) {
-  log/* default.debug */.Z.debug("Compat: Calling generateRequest on the MediaKeySession");
-  var patchedInit;
-
-  try {
-    patchedInit = patchInitData(initializationData);
-  } catch (_e) {
-    patchedInit = initializationData;
-  }
-
-  var initDataType = initializationDataType !== null && initializationDataType !== void 0 ? initializationDataType : "";
-  return session.generateRequest(initDataType, patchedInit)["catch"](function (error) {
-    if (initDataType !== "" || !(error instanceof TypeError)) {
-      throw error;
-    } // On newer EME versions of the specification, the initialization data
-    // type given to generateRequest cannot be an empty string (it returns
-    // a rejected promise with a TypeError in that case).
-    // Retry with a default "cenc" value for initialization data type if
-    // we're in that condition.
-
-
-    log/* default.warn */.Z.warn("Compat: error while calling `generateRequest` with an empty " + "initialization data type. Retrying with a default \"cenc\" value.", error);
-    return session.generateRequest("cenc", patchedInit);
-  });
-}
 // EXTERNAL MODULE: ./src/compat/event_listeners.ts + 6 modules
 var event_listeners = __webpack_require__(4804);
 // EXTERNAL MODULE: ./src/config.ts + 2 modules
@@ -4979,92 +4811,6 @@ function _attachMediaKeys() {
   }));
   return _attachMediaKeys.apply(this, arguments);
 }
-;// CONCATENATED MODULE: ./src/compat/eme/load_session.ts
-
-
-
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-var 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.
- *
- * The Observable throws if anything goes wrong in the process.
- * @param {MediaKeySession} session
- * @param {string} sessionId
- * @returns {Observable}
- */
-
-function loadSession(_x, _x2) {
-  return _loadSession.apply(this, arguments);
-}
-
-function _loadSession() {
-  _loadSession = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee(session, sessionId) {
-    var isLoaded;
-    return regenerator_default().wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            log/* default.info */.Z.info("Compat/DRM: Load persisted session", sessionId);
-            _context.next = 3;
-            return session.load(sessionId);
-
-          case 3:
-            isLoaded = _context.sent;
-
-            if (!(!isLoaded || session.keyStatuses.size > 0)) {
-              _context.next = 6;
-              break;
-            }
-
-            return _context.abrupt("return", isLoaded);
-
-          case 6:
-            return _context.abrupt("return", new Promise(function (resolve) {
-              session.addEventListener("keystatuseschange", resolveWithLoadedStatus);
-              var timeout = setTimeout(resolveWithLoadedStatus, EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES);
-
-              function resolveWithLoadedStatus() {
-                cleanUp();
-                resolve(isLoaded);
-              }
-
-              function cleanUp() {
-                clearTimeout(timeout);
-                session.removeEventListener("keystatuseschange", resolveWithLoadedStatus);
-              }
-            }));
-
-          case 7:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-  return _loadSession.apply(this, arguments);
-}
 ;// CONCATENATED MODULE: ./src/core/decrypt/utils/is_session_usable.ts
 /**
  * Copyright 2015 CANAL+ Group
@@ -5141,7 +4887,6 @@ function isSessionUsable(loadedSession) {
  */
 
 
-
 /**
  * Create a new Session or load a persistent one on the given MediaKeys,
  * according to wanted settings and what is currently stored.
@@ -5155,10 +4900,11 @@ function isSessionUsable(loadedSession) {
  * @param {Object} stores
  * @param {Object} initData
  * @param {string} wantedSessionType
+ * @param {Object} cancelSignal
  * @returns {Promise}
  */
 
-function createSession(stores, initData, wantedSessionType) {
+function createSession(stores, initData, wantedSessionType, cancelSignal) {
   var loadedSessionsStore = stores.loadedSessionsStore,
       persistentSessionsStore = stores.persistentSessionsStore;
 
@@ -5169,7 +4915,7 @@ function createSession(stores, initData, wantedSessionType) {
     return createTemporarySession(loadedSessionsStore, initData);
   }
 
-  return createAndTryToRetrievePersistentSession(loadedSessionsStore, persistentSessionsStore, initData);
+  return createAndTryToRetrievePersistentSession(loadedSessionsStore, persistentSessionsStore, initData, cancelSignal);
 }
 /**
  * Create a new temporary MediaKeySession linked to the given initData and
@@ -5195,16 +4941,17 @@ function createTemporarySession(loadedSessionsStore, initData) {
  * @param {Object} loadedSessionsStore
  * @param {Object} persistentSessionsStore
  * @param {Object} initData
+ * @param {Object} cancelSignal
  * @returns {Promise}
  */
 
 
-function createAndTryToRetrievePersistentSession(_x, _x2, _x3) {
+function createAndTryToRetrievePersistentSession(_x, _x2, _x3, _x4) {
   return _createAndTryToRetrievePersistentSession.apply(this, arguments);
 }
 
 function _createAndTryToRetrievePersistentSession() {
-  _createAndTryToRetrievePersistentSession = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee2(loadedSessionsStore, persistentSessionsStore, initData) {
+  _createAndTryToRetrievePersistentSession = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee2(loadedSessionsStore, persistentSessionsStore, initData, cancelSignal) {
     var entry, storedEntry, hasLoadedSession, recreatePersistentSession, _recreatePersistentSession;
 
     return regenerator_default().wrap(function _callee2$(_context2) {
@@ -5218,6 +4965,14 @@ function _createAndTryToRetrievePersistentSession() {
                   while (1) {
                     switch (_context.prev = _context.next) {
                       case 0:
+                        if (!(cancelSignal.cancellationError !== null)) {
+                          _context.next = 2;
+                          break;
+                        }
+
+                        throw cancelSignal.cancellationError;
+
+                      case 2:
                         log/* default.info */.Z.info("DRM: Removing previous persistent session.");
                         persistentEntry = persistentSessionsStore.get(initData);
 
@@ -5225,10 +4980,18 @@ function _createAndTryToRetrievePersistentSession() {
                           persistentSessionsStore["delete"](persistentEntry.sessionId);
                         }
 
-                        _context.next = 5;
+                        _context.next = 7;
                         return loadedSessionsStore.closeSession(entry.mediaKeySession);
 
-                      case 5:
+                      case 7:
+                        if (!(cancelSignal.cancellationError !== null)) {
+                          _context.next = 9;
+                          break;
+                        }
+
+                        throw cancelSignal.cancellationError;
+
+                      case 9:
                         newEntry = loadedSessionsStore.createSession(initData, "persistent-license");
                         return _context.abrupt("return", {
                           type: "created-session"
@@ -5237,7 +5000,7 @@ function _createAndTryToRetrievePersistentSession() {
                           value: newEntry
                         });
 
-                      case 7:
+                      case 11:
                       case "end":
                         return _context.stop();
                     }
@@ -5251,12 +5014,20 @@ function _createAndTryToRetrievePersistentSession() {
               return _recreatePersistentSession.apply(this, arguments);
             };
 
+            if (!(cancelSignal.cancellationError !== null)) {
+              _context2.next = 4;
+              break;
+            }
+
+            throw cancelSignal.cancellationError;
+
+          case 4:
             log/* default.info */.Z.info("DRM: Creating persistent MediaKeySession");
             entry = loadedSessionsStore.createSession(initData, "persistent-license");
             storedEntry = persistentSessionsStore.getAndReuse(initData);
 
             if (!(storedEntry === null)) {
-              _context2.next = 7;
+              _context2.next = 9;
               break;
             }
 
@@ -5267,16 +5038,16 @@ function _createAndTryToRetrievePersistentSession() {
               value: entry
             });
 
-          case 7:
-            _context2.prev = 7;
-            _context2.next = 10;
-            return loadSession(entry.mediaKeySession, storedEntry.sessionId);
+          case 9:
+            _context2.prev = 9;
+            _context2.next = 12;
+            return loadedSessionsStore.loadPersistentSession(entry.mediaKeySession, storedEntry.sessionId);
 
-          case 10:
+          case 12:
             hasLoadedSession = _context2.sent;
 
             if (hasLoadedSession) {
-              _context2.next = 15;
+              _context2.next = 17;
               break;
             }
 
@@ -5289,9 +5060,9 @@ function _createAndTryToRetrievePersistentSession() {
               value: entry
             });
 
-          case 15:
+          case 17:
             if (!(hasLoadedSession && isSessionUsable(entry.mediaKeySession))) {
-              _context2.next = 19;
+              _context2.next = 21;
               break;
             }
 
@@ -5304,23 +5075,23 @@ function _createAndTryToRetrievePersistentSession() {
               value: entry
             });
 
-          case 19:
+          case 21:
             // Unusable persistent session: recreate a new session from scratch.
             log/* default.warn */.Z.warn("DRM: Previous persistent session not usable anymore.");
             return _context2.abrupt("return", recreatePersistentSession());
 
-          case 23:
-            _context2.prev = 23;
-            _context2.t0 = _context2["catch"](7);
+          case 25:
+            _context2.prev = 25;
+            _context2.t0 = _context2["catch"](9);
             log/* default.warn */.Z.warn("DRM: Unable to load persistent session: " + (_context2.t0 instanceof Error ? _context2.t0.toString() : "Unknown Error"));
             return _context2.abrupt("return", recreatePersistentSession());
 
-          case 27:
+          case 29:
           case "end":
             return _context2.stop();
         }
       }
-    }, _callee2, null, [[7, 23]]);
+    }, _callee2, null, [[9, 25]]);
   }));
   return _createAndTryToRetrievePersistentSession.apply(this, arguments);
 }
@@ -5516,7 +5287,7 @@ function _createOrLoadSession() {
 
           case 20:
             _context.next = 22;
-            return createSession(stores, initializationData, wantedSessionType);
+            return createSession(stores, initializationData, wantedSessionType, cancelSignal);
 
           case 22:
             evt = _context.sent;
@@ -5915,6 +5686,230 @@ function getMediaKeySystemAccess(mediaElement, keySystemsConfigs, cancelSignal)
     return _recursivelyTestKeySystems.apply(this, arguments);
   }
 }
+// EXTERNAL MODULE: ./src/parsers/containers/isobmff/get_box.ts
+var get_box = __webpack_require__(2297);
+;// CONCATENATED MODULE: ./src/compat/eme/generate_key_request.ts
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+
+/**
+ * Modify "initialization data" sent to a `generateKeyRequest` EME call to
+ * improve the player's browser compatibility:
+ *
+ *   1. some browsers/CDM have problems when the CENC PSSH box is the first
+ *      encountered PSSH box in the initialization data (for the moment just
+ *      Edge was noted with this behavior).
+ *      We found however that it works on every browser when the CENC pssh
+ *      box(es) is/are the last box(es) encountered.
+ *
+ *      To that end, we move CENC pssh boxes at the end of the initialization
+ *      data in this function.
+ *
+ *   2. Some poorly encoded/packaged contents communicate both a CENC with a
+ *      pssh version of 0 and one with a version of 1. We found out that this is
+ *      not always well handled on some devices/browsers (on Edge and some other
+ *      embedded devices that shall remain nameless for now!).
+ *
+ *      Here this function will filter out CENC pssh with a version different to
+ *      1 when one(s) with a version of 1 is/are already present.
+ *
+ * If the initData is unrecognized or if a CENC PSSH is not found, this function
+ * throws.
+ * @param {Uint8Array} initData - Initialization data you want to patch
+ * @returns {Uint8Array} - Initialization data, patched
+ */
+
+function patchInitData(initData) {
+  log/* default.info */.Z.info("Compat: Trying to move CENC PSSH from init data at the end of it.");
+  var foundCencV1 = false;
+  var concatenatedCencs = new Uint8Array();
+  var resInitData = new Uint8Array();
+  var offset = 0;
+
+  while (offset < initData.length) {
+    if (initData.length < offset + 8 || (0,byte_parsing/* be4toi */.pX)(initData, offset + 4) !== PSSH_TO_INTEGER) {
+      log/* default.warn */.Z.warn("Compat: unrecognized initialization data. Cannot patch it.");
+      throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
+    }
+
+    var len = (0,byte_parsing/* be4toi */.pX)(new Uint8Array(initData), offset);
+
+    if (offset + len > initData.length) {
+      log/* default.warn */.Z.warn("Compat: unrecognized initialization data. Cannot patch it.");
+      throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
+    }
+
+    var currentPSSH = initData.subarray(offset, offset + len); // yep
+
+    if (initData[offset + 12] === 0x10 && initData[offset + 13] === 0x77 && initData[offset + 14] === 0xEF && initData[offset + 15] === 0xEC && initData[offset + 16] === 0xC0 && initData[offset + 17] === 0xB2 && initData[offset + 18] === 0x4D && initData[offset + 19] === 0x02 && initData[offset + 20] === 0xAC && initData[offset + 21] === 0xE3 && initData[offset + 22] === 0x3C && initData[offset + 23] === 0x1E && initData[offset + 24] === 0x52 && initData[offset + 25] === 0xE2 && initData[offset + 26] === 0xFB && initData[offset + 27] === 0x4B) {
+      var cencOffsets = (0,get_box/* getNextBoxOffsets */.Xj)(currentPSSH);
+      var version = cencOffsets === null ? undefined : currentPSSH[cencOffsets[1]];
+      log/* default.info */.Z.info("Compat: CENC PSSH found with version", version);
+
+      if (version === undefined) {
+        log/* default.warn */.Z.warn("Compat: could not read version of CENC PSSH");
+      } else if (foundCencV1 === (version === 1)) {
+        // Either `concatenatedCencs` only contains v1 or does not contain any
+        concatenatedCencs = (0,byte_parsing/* concat */.zo)(concatenatedCencs, currentPSSH);
+      } else if (version === 1) {
+        log/* default.warn */.Z.warn("Compat: cenc version 1 encountered, " + "removing every other cenc pssh box.");
+        concatenatedCencs = currentPSSH;
+        foundCencV1 = true;
+      } else {
+        log/* default.warn */.Z.warn("Compat: filtering out cenc pssh box with wrong version", version);
+      }
+    } else {
+      resInitData = (0,byte_parsing/* concat */.zo)(resInitData, currentPSSH);
+    }
+
+    offset += len;
+  }
+
+  if (offset !== initData.length) {
+    log/* default.warn */.Z.warn("Compat: unrecognized initialization data. Cannot patch it.");
+    throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
+  }
+
+  return (0,byte_parsing/* concat */.zo)(resInitData, concatenatedCencs);
+}
+/**
+ * Generate a request from session.
+ * @param {MediaKeySession} session - MediaKeySession on which the request will
+ * be done.
+ * @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} - Emit when done. Errors if fails.
+ */
+
+function generateKeyRequest(session, initializationDataType, initializationData) {
+  log/* default.debug */.Z.debug("Compat: Calling generateRequest on the MediaKeySession");
+  var patchedInit;
+
+  try {
+    patchedInit = patchInitData(initializationData);
+  } catch (_e) {
+    patchedInit = initializationData;
+  }
+
+  var initDataType = initializationDataType !== null && initializationDataType !== void 0 ? initializationDataType : "";
+  return session.generateRequest(initDataType, patchedInit)["catch"](function (error) {
+    if (initDataType !== "" || !(error instanceof TypeError)) {
+      throw error;
+    } // On newer EME versions of the specification, the initialization data
+    // type given to generateRequest cannot be an empty string (it returns
+    // a rejected promise with a TypeError in that case).
+    // Retry with a default "cenc" value for initialization data type if
+    // we're in that condition.
+
+
+    log/* default.warn */.Z.warn("Compat: error while calling `generateRequest` with an empty " + "initialization data type. Retrying with a default \"cenc\" value.", error);
+    return session.generateRequest("cenc", patchedInit);
+  });
+}
+;// CONCATENATED MODULE: ./src/compat/eme/load_session.ts
+
+
+
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var 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.
+ *
+ * The Observable throws if anything goes wrong in the process.
+ * @param {MediaKeySession} session
+ * @param {string} sessionId
+ * @returns {Observable}
+ */
+
+function loadSession(_x, _x2) {
+  return _loadSession.apply(this, arguments);
+}
+
+function _loadSession() {
+  _loadSession = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee(session, sessionId) {
+    var isLoaded;
+    return regenerator_default().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            log/* default.info */.Z.info("Compat/DRM: Load persisted session", sessionId);
+            _context.next = 3;
+            return session.load(sessionId);
+
+          case 3:
+            isLoaded = _context.sent;
+
+            if (!(!isLoaded || session.keyStatuses.size > 0)) {
+              _context.next = 6;
+              break;
+            }
+
+            return _context.abrupt("return", isLoaded);
+
+          case 6:
+            return _context.abrupt("return", new Promise(function (resolve) {
+              session.addEventListener("keystatuseschange", resolveWithLoadedStatus);
+              var timeout = setTimeout(resolveWithLoadedStatus, EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES);
+
+              function resolveWithLoadedStatus() {
+                cleanUp();
+                resolve(isLoaded);
+              }
+
+              function cleanUp() {
+                clearTimeout(timeout);
+                session.removeEventListener("keystatuseschange", resolveWithLoadedStatus);
+              }
+            }));
+
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _loadSession.apply(this, arguments);
+}
 // EXTERNAL MODULE: ./src/utils/cancellable_sleep.ts
 var cancellable_sleep = __webpack_require__(7864);
 ;// CONCATENATED MODULE: ./src/compat/eme/close_session.ts
@@ -6411,8 +6406,6 @@ function loaded_sessions_store_arrayLikeToArray(arr, len) { if (len == null || l
 
 
 
-
-
 /**
  * Create and store MediaKeySessions linked to a single MediaKeys
  * instance.
@@ -6434,7 +6427,7 @@ var LoadedSessionsStore = /*#__PURE__*/function () {
   }
   /**
    * Create a new MediaKeySession and store it in this store.
-   * @param {Object} initializationData
+   * @param {Object} initData
    * @param {string} sessionType
    * @returns {Object}
    */
@@ -6452,7 +6445,12 @@ var LoadedSessionsStore = /*#__PURE__*/function () {
     var entry = {
       mediaKeySession: mediaKeySession,
       sessionType: sessionType,
-      keySessionRecord: keySessionRecord
+      keySessionRecord: keySessionRecord,
+      isGeneratingRequest: false,
+      isLoadingPersistentSession: false,
+      closingStatus: {
+        type: "none"
+      }
     };
 
     if (!(0,is_null_or_undefined/* default */.Z)(mediaKeySession.closed)) {
@@ -6470,11 +6468,7 @@ var LoadedSessionsStore = /*#__PURE__*/function () {
 
     log/* default.debug */.Z.debug("DRM-LSS: Add MediaKeySession", entry.sessionType);
 
-    this._storage.push({
-      keySessionRecord: keySessionRecord,
-      mediaKeySession: mediaKeySession,
-      sessionType: sessionType
-    });
+    this._storage.push(Object.assign({}, entry));
 
     return entry;
   }
@@ -6501,29 +6495,49 @@ var LoadedSessionsStore = /*#__PURE__*/function () {
 
         this._storage.push(stored);
 
-        return {
-          keySessionRecord: stored.keySessionRecord,
-          mediaKeySession: stored.mediaKeySession,
-          sessionType: stored.sessionType
-        };
+        return Object.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}
+   */
+  ;
+
+  _proto.getEntryForSession = function getEntryForSession(mediaKeySession) {
+    for (var i = this._storage.length - 1; i >= 0; i--) {
+      var stored = this._storage[i];
+
+      if (stored.mediaKeySession === mediaKeySession) {
+        return Object.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}
    */
   ;
 
-  _proto.closeSession =
+  _proto.generateLicenseRequest =
   /*#__PURE__*/
   function () {
-    var _closeSession = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee(mediaKeySession) {
+    var _generateLicenseRequest = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee(mediaKeySession, initializationDataType, initializationData) {
       var entry, _iterator, _step, stored;
 
       return regenerator_default().wrap(function _callee$(_context) {
@@ -6558,25 +6572,260 @@ var LoadedSessionsStore = /*#__PURE__*/function () {
                 break;
               }
 
-              log/* default.warn */.Z.warn("DRM-LSS: No MediaKeySession found with " + "the given initData and initDataType");
-              return _context.abrupt("return", Promise.resolve(false));
+              log/* default.error */.Z.error("DRM-LSS: generateRequest error. No MediaKeySession found with " + "the given initData and initDataType");
+              return _context.abrupt("return", generateKeyRequest(mediaKeySession, initializationDataType, initializationData));
 
             case 11:
-              _context.next = 13;
-              return 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
 
-            case 13:
-              return _context.abrupt("return", Promise.resolve(true));
+              if (!(entry.closingStatus.type !== "none")) {
+                _context.next = 14;
+                break;
+              }
+
+              throw new Error("The `MediaKeySession` is being closed.");
 
             case 14:
+              _context.prev = 14;
+              _context.next = 17;
+              return generateKeyRequest(mediaKeySession, initializationDataType, initializationData);
+
+            case 17:
+              _context.next = 26;
+              break;
+
+            case 19:
+              _context.prev = 19;
+              _context.t0 = _context["catch"](14);
+
+              if (!(entry === undefined)) {
+                _context.next = 23;
+                break;
+              }
+
+              throw _context.t0;
+
+            case 23:
+              entry.isGeneratingRequest = false;
+
+              if (entry.closingStatus.type === "awaiting") {
+                entry.closingStatus.start();
+              }
+
+              throw _context.t0;
+
+            case 26:
+              if (!(entry === undefined)) {
+                _context.next = 28;
+                break;
+              }
+
+              return _context.abrupt("return", undefined);
+
+            case 28:
+              entry.isGeneratingRequest = false;
+
+              if (entry.closingStatus.type === "awaiting") {
+                entry.closingStatus.start();
+              }
+
+            case 30:
             case "end":
               return _context.stop();
           }
         }
-      }, _callee, this);
+      }, _callee, this, [[14, 19]]);
+    }));
+
+    function generateLicenseRequest(_x, _x2, _x3) {
+      return _generateLicenseRequest.apply(this, arguments);
+    }
+
+    return generateLicenseRequest;
+  }()
+  /**
+   * @param {Object} mediaKeySession
+   * @param {string} sessionId
+   * @returns {Promise}
+   */
+  ;
+
+  _proto.loadPersistentSession =
+  /*#__PURE__*/
+  function () {
+    var _loadPersistentSession = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee2(mediaKeySession, sessionId) {
+      var entry, _iterator2, _step2, stored, ret;
+
+      return regenerator_default().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _iterator2 = loaded_sessions_store_createForOfIteratorHelperLoose(this._storage);
+
+            case 1:
+              if ((_step2 = _iterator2()).done) {
+                _context2.next = 8;
+                break;
+              }
+
+              stored = _step2.value;
+
+              if (!(stored.mediaKeySession === mediaKeySession)) {
+                _context2.next = 6;
+                break;
+              }
+
+              entry = stored;
+              return _context2.abrupt("break", 8);
+
+            case 6:
+              _context2.next = 1;
+              break;
+
+            case 8:
+              if (!(entry === undefined)) {
+                _context2.next = 11;
+                break;
+              }
+
+              log/* default.error */.Z.error("DRM-LSS: loadPersistentSession error. No MediaKeySession found with " + "the given initData and initDataType");
+              return _context2.abrupt("return", loadSession(mediaKeySession, sessionId));
+
+            case 11:
+              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")) {
+                _context2.next = 14;
+                break;
+              }
+
+              throw new Error("The `MediaKeySession` is being closed.");
+
+            case 14:
+              _context2.prev = 14;
+              _context2.next = 17;
+              return loadSession(mediaKeySession, sessionId);
+
+            case 17:
+              ret = _context2.sent;
+              _context2.next = 27;
+              break;
+
+            case 20:
+              _context2.prev = 20;
+              _context2.t0 = _context2["catch"](14);
+
+              if (!(entry === undefined)) {
+                _context2.next = 24;
+                break;
+              }
+
+              throw _context2.t0;
+
+            case 24:
+              entry.isLoadingPersistentSession = false;
+
+              if (entry.closingStatus.type === "awaiting") {
+                entry.closingStatus.start();
+              }
+
+              throw _context2.t0;
+
+            case 27:
+              if (!(entry === undefined)) {
+                _context2.next = 29;
+                break;
+              }
+
+              return _context2.abrupt("return", ret);
+
+            case 29:
+              entry.isLoadingPersistentSession = false;
+
+              if (entry.closingStatus.type === "awaiting") {
+                entry.closingStatus.start();
+              }
+
+              return _context2.abrupt("return", ret);
+
+            case 32:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this, [[14, 20]]);
     }));
 
-    function closeSession(_x) {
+    function loadPersistentSession(_x4, _x5) {
+      return _loadPersistentSession.apply(this, arguments);
+    }
+
+    return loadPersistentSession;
+  }()
+  /**
+   * Close a MediaKeySession and remove its related stored information from the
+   * `LoadedSessionsStore`.
+   * Emit when done.
+   * @param {Object} mediaKeySession
+   * @returns {Promise}
+   */
+  ;
+
+  _proto.closeSession =
+  /*#__PURE__*/
+  function () {
+    var _closeSession = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee3(mediaKeySession) {
+      var entry, _iterator3, _step3, stored;
+
+      return regenerator_default().wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              _iterator3 = loaded_sessions_store_createForOfIteratorHelperLoose(this._storage);
+
+            case 1:
+              if ((_step3 = _iterator3()).done) {
+                _context3.next = 8;
+                break;
+              }
+
+              stored = _step3.value;
+
+              if (!(stored.mediaKeySession === mediaKeySession)) {
+                _context3.next = 6;
+                break;
+              }
+
+              entry = stored;
+              return _context3.abrupt("break", 8);
+
+            case 6:
+              _context3.next = 1;
+              break;
+
+            case 8:
+              if (!(entry === undefined)) {
+                _context3.next = 11;
+                break;
+              }
+
+              log/* default.warn */.Z.warn("DRM-LSS: No MediaKeySession found with " + "the given initData and initDataType");
+              return _context3.abrupt("return", Promise.resolve(false));
+
+            case 11:
+              return _context3.abrupt("return", this._closeEntry(entry));
+
+            case 12:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    }));
+
+    function closeSession(_x6) {
       return _closeSession.apply(this, arguments);
     }
 
@@ -6611,11 +6860,13 @@ var LoadedSessionsStore = /*#__PURE__*/function () {
   _proto.closeAllSessions =
   /*#__PURE__*/
   function () {
-    var _closeAllSessions = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee2() {
+    var _closeAllSessions = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee4() {
+      var _this2 = this;
+
       var allEntries, closingProms;
-      return regenerator_default().wrap(function _callee2$(_context2) {
+      return regenerator_default().wrap(function _callee4$(_context4) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context4.prev = _context4.next) {
             case 0:
               allEntries = this._storage;
               log/* default.debug */.Z.debug("DRM-LSS: Closing all current MediaKeySessions", allEntries.length); // re-initialize the storage, so that new interactions with the
@@ -6624,17 +6875,17 @@ var LoadedSessionsStore = /*#__PURE__*/function () {
 
               this._storage = [];
               closingProms = allEntries.map(function (entry) {
-                return safelyCloseMediaKeySession(entry.mediaKeySession);
+                return _this2._closeEntry(entry);
               });
-              _context2.next = 6;
+              _context4.next = 6;
               return Promise.all(closingProms);
 
             case 6:
             case "end":
-              return _context2.stop();
+              return _context4.stop();
           }
         }
-      }, _callee2, this);
+      }, _callee4, this);
     }));
 
     function closeAllSessions() {
@@ -6642,7 +6893,15 @@ var LoadedSessionsStore = /*#__PURE__*/function () {
     }
 
     return closeAllSessions;
-  }();
+  }()
+  /**
+   * Get the index of a stored MediaKeySession entry based on its
+   * `KeySessionRecord`.
+   * Returns -1 if not found.
+   * @param {Object} record
+   * @returns {number}
+   */
+  ;
 
   _proto.getIndex = function getIndex(record) {
     for (var i = 0; i < this._storage.length; i++) {
@@ -6654,122 +6913,124 @@ var LoadedSessionsStore = /*#__PURE__*/function () {
     }
 
     return -1;
-  };
-
-  return LoadedSessionsStore;
-}();
-/**
- * Close a MediaKeySession with multiple attempts if needed and do not throw if
- * this action throws an error.
- * 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(_x2) {
-    return _recursivelyTryToCloseMediaKeySession.apply(this, arguments);
   }
   /**
-   * Log error anouncing that we could not close the MediaKeySession and emits
-   * then complete through Observable.
-   * TODO Emit warning?
-   * @returns {Observable}
+   * 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>}
    */
+  ;
 
-
-  function _recursivelyTryToCloseMediaKeySession() {
-    _recursivelyTryToCloseMediaKeySession = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee3(retryNb) {
-      var _config$getCurrent, EME_SESSION_CLOSING_MAX_RETRY, EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY, nextRetryNb, delay, ksChangeSub, ksChangeProm, ksMsgSub, ksMsgProm, sleepTimer, sleepProm;
-
-      return regenerator_default().wrap(function _callee3$(_context3) {
+  _proto._closeEntry =
+  /*#__PURE__*/
+  function () {
+    var _closeEntry2 = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee5(entry) {
+      var mediaKeySession;
+      return regenerator_default().wrap(function _callee5$(_context5) {
         while (1) {
-          switch (_context3.prev = _context3.next) {
+          switch (_context5.prev = _context5.next) {
             case 0:
-              log/* default.debug */.Z.debug("DRM: Trying to close a MediaKeySession", mediaKeySession.sessionId, retryNb);
-              _context3.prev = 1;
-              _context3.next = 4;
-              return closeSession(mediaKeySession);
+              mediaKeySession = entry.mediaKeySession;
+              return _context5.abrupt("return", new Promise(function (resolve, reject) {
+                if (entry !== undefined && (entry.isLoadingPersistentSession || entry.isGeneratingRequest)) {
+                  entry.closingStatus = {
+                    type: "awaiting",
+                    start: tryClosingEntryAndResolve
+                  };
+                } else {
+                  tryClosingEntryAndResolve();
+                }
 
-            case 4:
-              log/* default.debug */.Z.debug("DRM: Succeeded to close MediaKeySession");
-              return _context3.abrupt("return", undefined);
+                function tryClosingEntryAndResolve() {
+                  if (entry !== undefined) {
+                    entry.closingStatus = {
+                      type: "pending"
+                    };
+                  }
 
-            case 8:
-              _context3.prev = 8;
-              _context3.t0 = _context3["catch"](1);
+                  safelyCloseMediaKeySession(mediaKeySession).then(function () {
+                    if (entry !== undefined) {
+                      entry.closingStatus = {
+                        type: "done"
+                      };
+                    }
 
-              if (!(!(_context3.t0 instanceof Error) || _context3.t0.name !== "InvalidStateError" || mediaKeySession.sessionId !== "")) {
-                _context3.next = 12;
-                break;
-              }
+                    resolve(true);
+                  })["catch"](function (err) {
+                    if (entry !== undefined) {
+                      entry.closingStatus = {
+                        type: "failed"
+                      };
+                    }
 
-              return _context3.abrupt("return", failToCloseSession(_context3.t0));
+                    reject(err);
+                  });
+                }
+              }));
 
-            case 12:
-              _config$getCurrent = config/* default.getCurrent */.Z.getCurrent(), EME_SESSION_CLOSING_MAX_RETRY = _config$getCurrent.EME_SESSION_CLOSING_MAX_RETRY, EME_SESSION_CLOSING_INITIAL_DELAY = _config$getCurrent.EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY = _config$getCurrent.EME_SESSION_CLOSING_MAX_DELAY; // We will retry either:
-              //   - when an event indicates that the MediaKeySession is
-              //     initialized (`callable` is the proper EME term here)
-              //   - after a delay, raising exponentially
+            case 2:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5);
+    }));
 
-              nextRetryNb = retryNb + 1;
+    function _closeEntry(_x7) {
+      return _closeEntry2.apply(this, arguments);
+    }
 
-              if (!(nextRetryNb > EME_SESSION_CLOSING_MAX_RETRY)) {
-                _context3.next = 16;
-                break;
-              }
+    return _closeEntry;
+  }();
 
-              return _context3.abrupt("return", failToCloseSession(_context3.t0));
+  return LoadedSessionsStore;
+}();
+/**
+ * Close a MediaKeySession and just log an error if it fails (while resolving).
+ * Emits then complete when done.
+ * @param {MediaKeySession} mediaKeySession
+ * @returns {Observable}
+ */
 
-            case 16:
-              delay = Math.min(Math.pow(2, retryNb) * EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY);
-              log/* default.warn */.Z.warn("DRM: attempt to close a mediaKeySession failed, " + "scheduling retry...", delay);
-              ksChangeProm = new Promise(function (res) {
-                ksChangeSub = (0,event_listeners/* onKeyStatusesChange$ */.eX)(mediaKeySession).subscribe(res);
-              });
-              ksMsgProm = new Promise(function (res) {
-                ksMsgSub = (0,event_listeners/* onKeyMessage$ */.GJ)(mediaKeySession).subscribe(res);
-              });
-              sleepProm = new Promise(function (res) {
-                sleepTimer = window.setTimeout(res, delay);
-              });
-              _context3.next = 23;
-              return Promise.race([ksChangeProm, ksMsgProm, sleepProm]);
 
-            case 23:
-              ksChangeSub === null || ksChangeSub === void 0 ? void 0 : ksChangeSub.unsubscribe();
-              ksMsgSub === null || ksMsgSub === void 0 ? void 0 : ksMsgSub.unsubscribe();
-              clearTimeout(sleepTimer);
-              return _context3.abrupt("return", recursivelyTryToCloseMediaKeySession(nextRetryNb));
 
-            case 27:
-            case "end":
-              return _context3.stop();
-          }
-        }
-      }, _callee3, null, [[1, 8]]);
-    }));
-    return _recursivelyTryToCloseMediaKeySession.apply(this, arguments);
-  }
 
-  function failToCloseSession(err) {
-    log/* default.error */.Z.error("DRM: Could not close MediaKeySession: " + (err instanceof Error ? err.toString() : "Unknown error"));
-    return Promise.resolve(null);
-  }
+function safelyCloseMediaKeySession(_x8) {
+  return _safelyCloseMediaKeySession.apply(this, arguments);
+}
+
+function _safelyCloseMediaKeySession() {
+  _safelyCloseMediaKeySession = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee6(mediaKeySession) {
+    return regenerator_default().wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            log/* default.debug */.Z.debug("DRM: Trying to close a MediaKeySession", mediaKeySession.sessionId);
+            _context6.prev = 1;
+            _context6.next = 4;
+            return closeSession(mediaKeySession);
+
+          case 4:
+            log/* default.debug */.Z.debug("DRM: Succeeded to close MediaKeySession");
+            return _context6.abrupt("return");
+
+          case 8:
+            _context6.prev = 8;
+            _context6.t0 = _context6["catch"](1);
+            log/* default.error */.Z.error("DRM: Could not close MediaKeySession: " + (_context6.t0 instanceof Error ? _context6.t0.toString() : "Unknown error"));
+            return _context6.abrupt("return");
+
+          case 12:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6, null, [[1, 8]]);
+  }));
+  return _safelyCloseMediaKeySession.apply(this, arguments);
 }
 // EXTERNAL MODULE: ./src/utils/assert.ts
 var assert = __webpack_require__(811);
@@ -9088,7 +9349,7 @@ var ContentDecryptor = /*#__PURE__*/function (_EventEmitter) {
     var _processInitializationData2 = (0,asyncToGenerator/* default */.Z)( /*#__PURE__*/regenerator_default().mark(function _callee2(initializationData, mediaKeysData) {
       var _this4 = this;
 
-      var mediaKeySystemAccess, stores, options, firstCreatedSession, keyIds, hexKids, period, createdSessions, periodKeys, _iterator, _step, createdSess, periodKeysArr, _i, _periodKeysArr, kid, _iterator2, _step2, innerKid, wantedSessionType, _config$getCurrent, EME_DEFAULT_MAX_SIMULTANEOUS_MEDIA_KEY_SESSIONS, EME_MAX_STORED_PERSISTENT_SESSION_INFORMATION, maxSessionCacheSize, sessionRes, sessionInfo, _sessionRes$value, mediaKeySession, sessionType, isSessionPersisted, sub, requestData;
+      var mediaKeySystemAccess, stores, options, firstCreatedSession, keyIds, hexKids, period, createdSessions, periodKeys, _iterator, _step, createdSess, periodKeysArr, _i, _periodKeysArr, kid, _iterator2, _step2, innerKid, wantedSessionType, _config$getCurrent, EME_DEFAULT_MAX_SIMULTANEOUS_MEDIA_KEY_SESSIONS, EME_MAX_STORED_PERSISTENT_SESSION_INFORMATION, maxSessionCacheSize, sessionRes, sessionInfo, _sessionRes$value, mediaKeySession, sessionType, isSessionPersisted, sub, requestData, entry, indexInCurrent;
 
       return regenerator_default().wrap(function _callee2$(_context2) {
         while (1) {
@@ -9350,28 +9611,47 @@ var ContentDecryptor = /*#__PURE__*/function (_EventEmitter) {
               if (!(sessionRes.type === "created-session"
               /* Created */
               )) {
-                _context2.next = 63;
+                _context2.next = 68;
                 break;
               }
 
               requestData = initializationData.values.constructRequestData();
               _context2.prev = 55;
               _context2.next = 58;
-              return generateKeyRequest(mediaKeySession, initializationData.type, requestData);
+              return stores.loadedSessionsStore.generateLicenseRequest(mediaKeySession, initializationData.type, requestData);
 
             case 58:
-              _context2.next = 63;
+              _context2.next = 68;
               break;
 
             case 60:
               _context2.prev = 60;
               _context2.t0 = _context2["catch"](55);
+              // First check that the error was not due to the MediaKeySession closing
+              // or being closed
+              entry = stores.loadedSessionsStore.getEntryForSession(mediaKeySession);
+
+              if (!(entry === null || entry.closingStatus.type !== "none")) {
+                _context2.next = 67;
+                break;
+              }
+
+              // MediaKeySession closing/closed: Just remove from handled list and abort.
+              indexInCurrent = this._currentSessions.indexOf(sessionInfo);
+
+              if (indexInCurrent >= 0) {
+                this._currentSessions.splice(indexInCurrent, 1);
+              }
+
+              return _context2.abrupt("return", Promise.resolve());
+
+            case 67:
               throw new encrypted_media_error/* default */.Z("KEY_GENERATE_REQUEST_ERROR", _context2.t0 instanceof Error ? _context2.t0.toString() : "Unknown error");
 
-            case 63:
+            case 68:
               return _context2.abrupt("return", Promise.resolve());
 
-            case 64:
+            case 69:
             case "end":
               return _context2.stop();
           }
@@ -31620,60 +31900,61 @@ var check_isobmff_integrity = __webpack_require__(4460);
 
 function addSegmentIntegrityChecks(segmentLoader) {
   return function (url, content, initialCancelSignal, callbacks) {
-    return new Promise(function (res, rej) {
-      var canceller = new task_canceller/* default */.ZP();
-      var unregisterCancelLstnr = initialCancelSignal.register(function onCheckCancellation(err) {
-        canceller.cancel();
-        rej(err);
-      });
-      /**
-       * If the data's seems to be corrupted, cancel the loading task and reject
-       * with an `INTEGRITY_ERROR` error.
-       * @param {*} data
-       */
-
-      function cancelAndRejectOnBadIntegrity(data) {
-        if (!(data instanceof Array) && !(data instanceof Uint8Array) || inferSegmentContainer(content.adaptation.type, content.representation) !== "mp4") {
-          return;
-        }
-
-        try {
-          (0,check_isobmff_integrity/* default */.Z)(new Uint8Array(data), content.segment.isInit);
-        } catch (err) {
-          unregisterCancelLstnr();
-          canceller.cancel();
-          rej(err);
-        }
-      }
+    return new Promise(function (resolve, reject) {
+      var requestCanceller = new task_canceller/* default */.ZP({
+        cancelOn: initialCancelSignal
+      }); // Reject the `CancellationError` when `requestCanceller`'s signal emits
+      // `stopRejectingOnCancel` here is a function allowing to stop this mechanism
 
-      segmentLoader(url, content, canceller.signal, Object.assign(Object.assign({}, callbacks), {
+      var stopRejectingOnCancel = requestCanceller.signal.register(reject);
+      segmentLoader(url, content, requestCanceller.signal, Object.assign(Object.assign({}, callbacks), {
         onNewChunk: function onNewChunk(data) {
-          cancelAndRejectOnBadIntegrity(data);
-
-          if (!canceller.isUsed) {
+          try {
+            trowOnIntegrityError(data);
             callbacks.onNewChunk(data);
+          } catch (err) {
+            // Do not reject with a `CancellationError` after cancelling the request
+            stopRejectingOnCancel(); // Cancel the request
+
+            requestCanceller.cancel(); // Reject with thrown error
+
+            reject(err);
           }
         }
       })).then(function (info) {
-        if (canceller.isUsed) {
+        if (requestCanceller.isUsed) {
           return;
         }
 
-        unregisterCancelLstnr();
+        stopRejectingOnCancel();
 
         if (info.resultType === "segment-loaded") {
-          cancelAndRejectOnBadIntegrity(info.resultData.responseData);
+          try {
+            trowOnIntegrityError(info.resultData.responseData);
+          } catch (err) {
+            reject(err);
+            return;
+          }
         }
 
-        res(info);
+        resolve(info);
       }, function (error) {
-        // The segmentLoader's cancellations cases are all handled here
-        if (!task_canceller/* default.isCancellationError */.ZP.isCancellationError(error)) {
-          unregisterCancelLstnr();
-          rej(error);
-        }
+        stopRejectingOnCancel();
+        reject(error);
       });
     });
+    /**
+     * If the data's seems to be corrupted, throws an `INTEGRITY_ERROR` error.
+     * @param {*} data
+     */
+
+    function trowOnIntegrityError(data) {
+      if (!(data instanceof ArrayBuffer) && !(data instanceof Uint8Array) || inferSegmentContainer(content.adaptation.type, content.representation) !== "mp4") {
+        return;
+      }
+
+      (0,check_isobmff_integrity/* default */.Z)(new Uint8Array(data), content.segment.isInit);
+    }
   };
 }
 // EXTERNAL MODULE: ./src/utils/byte_parsing.ts
@@ -40190,8 +40471,7 @@ function isTimeInTimeRanges(ranges, time) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "$": function() { return /* binding */ createSharedReference; }
 /* harmony export */ });
-/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1480);
-/* harmony import */ var _log__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3887);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1480);
 function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
@@ -40214,7 +40494,6 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
  * limitations under the License.
  */
 
-
 /**
  * Create an `ISharedReference` object encapsulating the mutable `initialValue`
  * value of type T.
@@ -40261,7 +40540,6 @@ function createSharedReference(initialValue) {
     setValue: function setValue(newVal) {
       if (isFinished) {
         if (false) {} else {
-          _log__WEBPACK_IMPORTED_MODULE_0__/* ["default"].error */ .Z.error("Finished shared references cannot be updated");
           return;
         }
       }
@@ -40300,7 +40578,7 @@ function createSharedReference(initialValue) {
      * @returns {Observable}
      */
     asObservable: function asObservable(skipCurrentValue) {
-      return new rxjs__WEBPACK_IMPORTED_MODULE_1__/* .Observable */ .y(function (obs) {
+      return new rxjs__WEBPACK_IMPORTED_MODULE_0__/* .Observable */ .y(function (obs) {
         if (skipCurrentValue !== true) {
           obs.next(value);
         }
@@ -41464,8 +41742,11 @@ var TaskCanceller = /*#__PURE__*/function () {
    * Creates a new `TaskCanceller`, with its own `CancellationSignal` created
    * as its `signal` provide.
    * You can then pass this property to async task you wish to be cancellable.
+   * @param {Object|undefined} options
    */
-  function TaskCanceller() {
+  function TaskCanceller(options) {
+    var _this = this;
+
     var _createCancellationFu = createCancellationFunctions(),
         trigger = _createCancellationFu[0],
         register = _createCancellationFu[1];
@@ -41473,6 +41754,13 @@ var TaskCanceller = /*#__PURE__*/function () {
     this.isUsed = false;
     this._trigger = trigger;
     this.signal = new CancellationSignal(register);
+
+    if ((options === null || options === void 0 ? void 0 : options.cancelOn) !== undefined) {
+      var unregisterParent = options.cancelOn.register(function () {
+        _this.cancel();
+      });
+      this.signal.register(unregisterParent);
+    }
   }
   /**
    * "Trigger" the `TaskCanceller`, notify through its associated
@@ -41530,17 +41818,17 @@ var CancellationSignal = /*#__PURE__*/function () {
    * cancelled.
    */
   function CancellationSignal(registerToSource) {
-    var _this = this;
+    var _this2 = this;
 
     this.isCancelled = false;
     this.cancellationError = null;
     this._listeners = [];
     registerToSource(function (cancellationError) {
-      _this.cancellationError = cancellationError;
-      _this.isCancelled = true;
+      _this2.cancellationError = cancellationError;
+      _this2.isCancelled = true;
 
-      while (_this._listeners.length > 0) {
-        var listener = _this._listeners.splice(_this._listeners.length - 1, 1)[0];
+      while (_this2._listeners.length > 0) {
+        var listener = _this2._listeners.splice(_this2._listeners.length - 1, 1)[0];
 
         listener(cancellationError);
       }
@@ -41572,7 +41860,7 @@ var CancellationSignal = /*#__PURE__*/function () {
   var _proto2 = CancellationSignal.prototype;
 
   _proto2.register = function register(fn) {
-    var _this2 = this;
+    var _this3 = this;
 
     if (this.isCancelled) {
       (0,_assert__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(this.cancellationError !== null);
@@ -41582,7 +41870,7 @@ var CancellationSignal = /*#__PURE__*/function () {
     this._listeners.push(fn);
 
     return function () {
-      return _this2.deregister(fn);
+      return _this3.deregister(fn);
     };
   }
   /**
@@ -41625,14 +41913,14 @@ var CancellationError = /*#__PURE__*/function (_Error) {
    * @param {string} message
    */
   function CancellationError() {
-    var _this3;
+    var _this4;
 
-    _this3 = _Error.call(this) || this; // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
+    _this4 = _Error.call(this) || this; // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
 
-    Object.setPrototypeOf((0,_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(_this3), CancellationError.prototype);
-    _this3.name = "CancellationError";
-    _this3.message = "This task was cancelled.";
-    return _this3;
+    Object.setPrototypeOf((0,_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(_this4), CancellationError.prototype);
+    _this4.name = "CancellationError";
+    _this4.message = "This task was cancelled.";
+    return _this4;
   }
 
   return CancellationError;
@@ -46277,6 +46565,54 @@ function skipWhile(predicate) {
 var take = __webpack_require__(4727);
 // EXTERNAL MODULE: ./src/compat/event_listeners.ts + 6 modules
 var event_listeners = __webpack_require__(4804);
+;// CONCATENATED MODULE: ./src/compat/get_start_date.ts
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Calculating a live-offseted media position necessitate to obtain first an
+ * offset, and then adding that offset to the wanted position.
+ *
+ * That offset is in most case present inside the Manifest file, yet in cases
+ * without it or without a Manifest, such as the "directfile" mode, the RxPlayer
+ * won't know that offset.
+ *
+ * Thankfully Safari declares a `getStartDate` method allowing to obtain that
+ * offset when available. This logic is mainly useful when playing HLS contents
+ * in directfile mode on Safari.
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {number|undefined}
+ */
+function getStartDate(mediaElement) {
+  var _mediaElement = mediaElement;
+
+  if (typeof _mediaElement.getStartDate === "function") {
+    var startDate = _mediaElement.getStartDate();
+
+    if (typeof startDate === "object" && startDate !== null) {
+      var startDateNum = +startDate;
+
+      if (!isNaN(startDateNum)) {
+        return startDateNum / 1000;
+      }
+    } else if (typeof startDate === "number" && !isNaN(startDate)) {
+      return startDate;
+    }
+  }
+}
 ;// CONCATENATED MODULE: ./src/compat/fullscreen.ts
 /**
  * Copyright 2015 CANAL+ Group
@@ -52318,6 +52654,11 @@ function clearBuffer(segmentBuffer, position, maxBufferBehind, maxBufferAhead) {
   collectBufferAhead();
   var clean$ = (0,from/* from */.D)(cleanedupRanges.map(function (range) {
     log/* default.debug */.Z.debug("GC: cleaning range from SegmentBuffer", range);
+
+    if (range.start >= range.end) {
+      return (0,of.of)(null);
+    }
+
     return segmentBuffer.removeBuffer(range.start, range.end);
   })).pipe((0,concatAll/* concatAll */.u)(), // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
   // first type parameter as `any` instead of the perfectly fine `unknown`,
@@ -53052,9 +53393,7 @@ function getNeededSegments(_ref) {
       segmentsBeingPushed = _ref.segmentsBeingPushed,
       maxBufferSize = _ref.maxBufferSize;
   var representation = content.representation;
-  var availableBufferSize = getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxBufferSize); // Current buffer length in seconds
-
-  var bufferLength = getBufferLength(bufferedSegments, segmentsBeingPushed);
+  var availableBufferSize = getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxBufferSize);
   var availableSegmentsForRange = representation.index.getSegments(neededRange.start, neededRange.end - neededRange.start); // Remove from `bufferedSegments` any segments we would prefer to replace:
   //   - segments in the wrong track / bad quality
   //   - garbage-collected segments
@@ -53091,10 +53430,9 @@ function getNeededSegments(_ref) {
 
   var _config$getCurrent = config/* default.getCurrent */.Z.getCurrent(),
       MINIMUM_SEGMENT_SIZE = _config$getCurrent.MINIMUM_SEGMENT_SIZE,
-      MIN_BUFFER_LENGTH = _config$getCurrent.MIN_BUFFER_LENGTH,
-      MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP = _config$getCurrent.MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP;
+      MIN_BUFFER_AHEAD = _config$getCurrent.MIN_BUFFER_AHEAD;
 
-  var isMemorySaturated = false;
+  var shouldStopLoadingSegments = false;
   /**
    * Epsilon compensating for rounding errors when comparing the start and end
    * time of multiple segments.
@@ -53102,7 +53440,8 @@ function getNeededSegments(_ref) {
 
   var ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
   var isBufferFull = false;
-  var neededSegments = availableSegmentsForRange.filter(function (segment) {
+  var segmentsOnHold = [];
+  var segmentsToLoad = availableSegmentsForRange.filter(function (segment) {
     var contentObject = (0,object_assign/* default */.Z)({
       segment: segment
     }, content); // First, check that the segment is not already being pushed
@@ -53125,17 +53464,8 @@ function getNeededSegments(_ref) {
       return true; // never skip initialization segments
     }
 
-    if (isMemorySaturated) {
-      // If we are so saturated in memory
-      // That we cannot download atleast till
-      // NeededRange.Start ( current position ) + a CONST
-      // Then the buffer is full
-      if (time < neededRange.start + MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP) {
-        isBufferFull = true;
-      }
-    }
-
-    if (isMemorySaturated && bufferLength > MIN_BUFFER_LENGTH) {
+    if (shouldStopLoadingSegments) {
+      segmentsOnHold.push(segment);
       return false;
     }
 
@@ -53184,32 +53514,42 @@ function getNeededSegments(_ref) {
           return false; // already downloaded
         }
       }
+    }
+
+    var estimatedSegmentSize = duration * content.representation.bitrate / 8000;
+
+    if (availableBufferSize - estimatedSegmentSize < 0) {
+      isBufferFull = true;
+
+      if (time > neededRange.start + MIN_BUFFER_AHEAD) {
+        shouldStopLoadingSegments = true;
+        segmentsOnHold.push(segment);
+        return false;
+      }
     } // check if there is an hole in place of the segment currently
 
 
     for (var _i = 0; _i < segmentsToKeep.length; _i++) {
-      var _completeSeg = segmentsToKeep[_i];
+      var _completeSeg = segmentsToKeep[_i]; // For the first already-loaded segment, take the first one ending after
+      // this one' s start
 
-      if (_completeSeg.end > time) {
-        // `true` if `completeSeg` starts too far after `time`
-        return _completeSeg.start > time + ROUNDING_ERROR || // `true` if `completeSeg` ends too soon before `end`
-        getLastContiguousSegment(segmentsToKeep, _i).end < end - ROUNDING_ERROR;
-      }
-    }
+      if (_completeSeg.end + ROUNDING_ERROR > time) {
+        var shouldLoad = _completeSeg.start > time + ROUNDING_ERROR || getLastContiguousSegment(segmentsToKeep, _i).end < end - ROUNDING_ERROR;
 
-    var estimatedSegmentSize = duration * content.representation.bitrate / 8000;
+        if (shouldLoad) {
+          availableBufferSize -= estimatedSegmentSize;
+        }
 
-    if (availableBufferSize - estimatedSegmentSize < 0 && bufferLength > MIN_BUFFER_LENGTH) {
-      isMemorySaturated = true;
-      return false;
+        return shouldLoad;
+      }
     }
 
     availableBufferSize -= estimatedSegmentSize;
-    bufferLength += duration;
     return true;
   });
   return {
-    neededSegments: neededSegments,
+    segmentsToLoad: segmentsToLoad,
+    segmentsOnHold: segmentsOnHold,
     isBufferFull: isBufferFull
   };
 }
@@ -53232,29 +53572,12 @@ function getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxVideoB
   }, 0);
   return bufferedSegments.reduce(function (size, chunk) {
     if (chunk.chunkSize !== undefined) {
-      return size - chunk.chunkSize / 8000;
+      return size - chunk.chunkSize / 1000;
     } else {
       return size;
     }
   }, availableBufferSize);
 }
-/**
- * Compute the length of the buffer in seconds
- * @param bufferedSegments
- * @param segmentsBeingPushed
- * @returns bufferLength in seconds
- */
-
-
-function getBufferLength(bufferedSegments, segmentsBeingPushed) {
-  var bufferLength = bufferedSegments.reduce(function (length, segment) {
-    return length + (segment.end - segment.start);
-  }, 0);
-  var bufferBeingPushed = segmentsBeingPushed.reduce(function (length, segment) {
-    return length + segment.segment.duration;
-  }, 0);
-  return bufferLength + bufferBeingPushed;
-}
 /**
  * From the given array of buffered chunks (`bufferedSegments`) returns the last
  * buffered chunk contiguous with the one at the `startIndex` index given.
@@ -53628,10 +53951,11 @@ function getBufferStatus(content, wantedStartPosition, playbackObserver, fastSwi
     segmentsBeingPushed: segmentsBeingPushed,
     maxBufferSize: maxBufferSize
   }),
-      neededSegments = _getNeededSegments.neededSegments,
+      segmentsToLoad = _getNeededSegments.segmentsToLoad,
+      segmentsOnHold = _getNeededSegments.segmentsOnHold,
       isBufferFull = _getNeededSegments.isBufferFull;
 
-  var prioritizedNeededSegments = neededSegments.map(function (segment) {
+  var prioritizedNeededSegments = segmentsToLoad.map(function (segment) {
     return {
       priority: getSegmentPriority(segment.time, wantedStartPosition),
       segment: segment
@@ -53645,7 +53969,7 @@ function getBufferStatus(content, wantedStartPosition, playbackObserver, fastSwi
   var hasFinishedLoading;
   var lastPosition = representation.index.getLastPosition();
 
-  if (!representation.index.isInitialized() || period.end === undefined || prioritizedNeededSegments.length > 0) {
+  if (!representation.index.isInitialized() || period.end === undefined || prioritizedNeededSegments.length > 0 || segmentsOnHold.length > 0) {
     hasFinishedLoading = false;
   } else {
     if (lastPosition === undefined) {
@@ -53686,6 +54010,10 @@ function getBufferStatus(content, wantedStartPosition, playbackObserver, fastSwi
       }));
     }
 
+    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;
     }
@@ -53783,7 +54111,7 @@ function forceGarbageCollection(currentPosition, bufferingQueue) {
     return (0,from/* from */.D)(cleanedupRanges.map(function (_ref) {
       var start = _ref.start,
           end = _ref.end;
-      return bufferingQueue.removeBuffer(start, end);
+      return start >= end ? (0,of.of)(null) : bufferingQueue.removeBuffer(start, end);
     })).pipe((0,concatAll/* concatAll */.u)());
   });
 }
@@ -53882,7 +54210,7 @@ function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos) {
       throw new media_error/* default */.Z("BUFFER_APPEND_ERROR", reason);
     }
 
-    return playbackObserver.observe(true).pipe((0,mergeMap/* mergeMap */.z)(function (observation) {
+    return playbackObserver.observe(true).pipe((0,take/* take */.q)(1), (0,mergeMap/* mergeMap */.z)(function (observation) {
       var currentPos = observation.position + observation.wantedTimeOffset;
       return (0,concat/* concat */.z)(forceGarbageCollection(currentPos, segmentBuffer).pipe((0,ignoreElements/* ignoreElements */.l)()), append$).pipe((0,catchError/* catchError */.K)(function (forcedGCError) {
         var reason = forcedGCError instanceof Error ? forcedGCError.toString() : "Could not clean the buffer";
@@ -54241,8 +54569,11 @@ function RepresentationStream(_ref) {
 
     if (status.isBufferFull) {
       var gcedPosition = Math.max(0, wantedStartPosition - UPTO_CURRENT_POSITION_CLEANUP);
-      bufferRemoval = segmentBuffer.removeBuffer(0, gcedPosition) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      .pipe((0,ignoreElements/* ignoreElements */.l)());
+
+      if (gcedPosition > 0) {
+        bufferRemoval = segmentBuffer.removeBuffer(0, gcedPosition) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        .pipe((0,ignoreElements/* ignoreElements */.l)());
+      }
     }
 
     return status.shouldRefreshManifest ? (0,concat/* concat */.z)((0,of.of)(stream_events_generators/* default.needsManifestRefresh */.Z.needsManifestRefresh()), bufferStatusEvt, bufferRemoval) : (0,concat/* concat */.z)(bufferStatusEvt, bufferRemoval);
@@ -55226,7 +55557,13 @@ function PeriodStream(_ref) {
           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$ = (0,of.of)(null);
+        } else {
+          cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start, period.end);
+        }
       } else {
         if (segmentBufferStatus.type === "uninitialized") {
           segmentBuffersStore.disableSegmentBuffer(bufferType);
@@ -55949,7 +56286,7 @@ function StreamOrchestrator(content, playbackObserver, abrManager, segmentBuffer
       return concat/* concat.apply */.z.apply(void 0, rangesToClean.map(function (_ref4) {
         var start = _ref4.start,
             end = _ref4.end;
-        return segmentBuffer.removeBuffer(start, end).pipe((0,ignoreElements/* ignoreElements */.l)());
+        return start >= end ? empty/* EMPTY */.E : segmentBuffer.removeBuffer(start, end).pipe((0,ignoreElements/* ignoreElements */.l)());
       }).concat([playbackObserver.observe(true).pipe((0,take/* take */.q)(1), (0,mergeMap/* mergeMap */.z)(function (observation) {
         return (0,concat/* concat */.z)((0,of.of)(stream_events_generators/* default.needsDecipherabilityFlush */.Z.needsDecipherabilityFlush(observation.position, !observation.isPaused, observation.duration)), (0,defer/* defer */.P)(function () {
           var lastPosition = observation.position + observation.wantedTimeOffset;
@@ -60153,7 +60490,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
     videoElement.preload = "auto";
     _this.version =
     /* PLAYER_VERSION */
-    "3.27.0-dev.2022032100";
+    "3.27.0";
     _this.log = log/* default */.Z;
     _this.state = "STOPPED";
     _this.videoElement = videoElement;
@@ -61045,25 +61382,8 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
         manifest = _this$_priv_contentIn4.manifest;
 
     if (isDirectFile) {
-      // Calculating the "wall-clock time" necessitate to obtain first an offset,
-      // and then adding that offset to the HTMLMediaElement's current position.
-      // That offset is in most case present inside the Manifest file, yet in
-      // directfile mode, the RxPlayer won't parse that file, the browser does it.
-      //
-      // Thankfully Safari declares a `getStartDate` method allowing to obtain
-      // that offset when available. This logic is thus mainly useful when
-      // playing HLS contents in directfile mode on Safari.
-      var mediaElement = this.videoElement;
-
-      if (typeof mediaElement.getStartDate === "function") {
-        var startDate = mediaElement.getStartDate();
-
-        if (typeof startDate === "number" && !isNaN(startDate)) {
-          return startDate + mediaElement.currentTime;
-        }
-      }
-
-      return mediaElement.currentTime;
+      var startDate = getStartDate(this.videoElement);
+      return (startDate !== null && startDate !== void 0 ? startDate : 0) + this.videoElement.currentTime;
     }
 
     if (manifest !== null) {
@@ -61371,6 +61691,8 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
   ;
 
   _proto.seekTo = function seekTo(time) {
+    var _a;
+
     if (this.videoElement === null) {
       throw new Error("Disposed player");
     }
@@ -61400,7 +61722,19 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
       } else if (!(0,is_null_or_undefined/* default */.Z)(timeObj.position)) {
         positionWanted = timeObj.position;
       } else if (!(0,is_null_or_undefined/* default */.Z)(timeObj.wallClockTime)) {
-        positionWanted = isDirectFile || manifest === null ? timeObj.wallClockTime : timeObj.wallClockTime - (manifest.availabilityStartTime !== undefined ? manifest.availabilityStartTime : 0);
+        if (manifest !== null) {
+          positionWanted = timeObj.wallClockTime - ((_a = manifest.availabilityStartTime) !== null && _a !== void 0 ? _a : 0);
+        } else if (isDirectFile && this.videoElement !== null) {
+          var startDate = getStartDate(this.videoElement);
+
+          if (startDate !== undefined) {
+            positionWanted = timeObj.wallClockTime - startDate;
+          }
+        }
+
+        if (positionWanted === undefined) {
+          positionWanted = timeObj.wallClockTime;
+        }
       } else {
         throw new Error("invalid time object. You must set one of the " + "following properties: \"relative\", \"position\" or " + "\"wallClockTime\"");
       }
@@ -62892,6 +63226,12 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
       var ast = (_a = manifest.availabilityStartTime) !== null && _a !== void 0 ? _a : 0;
       positionData.wallClockTime = observation.position + ast;
       positionData.liveGap = maximumPosition - observation.position;
+    } else if (isDirectFile && this.videoElement !== null) {
+      var startDate = getStartDate(this.videoElement);
+
+      if (startDate !== undefined) {
+        positionData.wallClockTime = startDate + observation.position;
+      }
     }
 
     this.trigger("positionUpdate", positionData);
@@ -62982,7 +63322,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
 
 Player.version =
 /* PLAYER_VERSION */
-"3.27.0-dev.2022032100";
+"3.27.0";
 /* harmony default export */ var public_api = (Player);
 ;// CONCATENATED MODULE: ./src/core/api/index.ts
 /**