rx-player 3.26.2 → 3.27.0-dev.20220317

package/dist/_esm5.processed/core/{eme → decrypt}/utils/persistent_sessions_store.js

@@ -16,12 +16,13 @@
 import log from "../../../log";
 import areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
 import { assertInterface } from "../../../utils/assert";
-import { base64ToBytes, bytesToBase64, } from "../../../utils/base64";
-import { concat } from "../../../utils/byte_parsing";
+import { bytesToBase64 } from "../../../utils/base64";
 import hashBuffer from "../../../utils/hash_buffer";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import areInitializationValuesCompatible from "./are_init_values_compatible";
+import { areKeyIdsEqual } from "./key_id_comparison";
+import SerializableBytes from "./serializable_bytes";
 /**
  * Throw if the given storage does not respect the right interface.
  * @param {Object} storage
@@ -29,37 +30,6 @@ import areInitializationValuesCompatible from "./are_init_values_compatible";
 function checkStorage(storage) {
     assertInterface(storage, { save: "function", load: "function" }, "licenseStorage");
 }
-/** Wrap initialization data and allow serialization of it into base64. */
-var InitDataContainer = /** @class */ (function () {
-    /**
-     * Create a new container, wrapping the initialization data given and allowing
-     * linearization into base64.
-     * @param {Uint8Array}
-     */
-    function InitDataContainer(initData) {
-        this.initData = initData;
-    }
-    /**
-     * Convert it to base64.
-     * `toJSON` is specially interpreted by JavaScript engines to be able to rely
-     * on it when calling `JSON.stringify` on it or any of its parent objects:
-     * https://tc39.es/ecma262/#sec-serializejsonproperty
-     * @returns {string}
-     */
-    InitDataContainer.prototype.toJSON = function () {
-        return bytesToBase64(this.initData);
-    };
-    /**
-     * Decode a base64 sequence representing an initialization data back to an
-     * Uint8Array.
-     * @param {string}
-     * @returns {Uint8Array}
-     */
-    InitDataContainer.decode = function (base64) {
-        return base64ToBytes(base64);
-    };
-    return InitDataContainer;
-}());
 /**
  * Set representing persisted licenses. Depends on a simple local-
  * storage implementation with a `save`/`load` synchronous interface
@@ -79,13 +49,14 @@ var PersistentSessionsStore = /** @class */ (function () {
         this._entries = [];
         this._storage = storage;
         try {
-            this._entries = this._storage.load();
-            if (!Array.isArray(this._entries)) {
-                this._entries = [];
+            var entries = this._storage.load();
+            if (!Array.isArray(entries)) {
+                entries = [];
             }
+            this._entries = entries;
         }
         catch (e) {
-            log.warn("EME-PSS: Could not get entries from license storage", e);
+            log.warn("DRM-PSS: Could not get entries from license storage", e);
             this.dispose();
         }
     }
@@ -106,7 +77,7 @@ var PersistentSessionsStore = /** @class */ (function () {
     };
     /**
      * Retrieve an entry based on its initialization data.
-     * @param {Uint8Array}  initData
+     * @param {Object}  initData
      * @param {string|undefined} initDataType
      * @returns {Object|null}
      */
@@ -141,9 +112,9 @@ var PersistentSessionsStore = /** @class */ (function () {
      * @param {string|undefined} initDataType
      * @param {MediaKeySession} session
      */
-    PersistentSessionsStore.prototype.add = function (initData, session) {
+    PersistentSessionsStore.prototype.add = function (initData, keyIds, session) {
         if (isNullOrUndefined(session) || !isNonEmptyString(session.sessionId)) {
-            log.warn("EME-PSS: Invalid Persisten Session given.");
+            log.warn("DRM-PSS: Invalid Persisten Session given.");
             return;
         }
         var sessionId = session.sessionId;
@@ -152,32 +123,46 @@ var PersistentSessionsStore = /** @class */ (function () {
             return;
         }
         else if (currentEntry !== null) { // currentEntry has a different sessionId
-            this.delete(initData);
+            this.delete(currentEntry.sessionId);
+        }
+        log.info("DRM-PSS: Add new session", sessionId);
+        var storedValues = prepareValuesForStore(initData.values.getFormattedValues());
+        if (keyIds === undefined) {
+            this._entries.push({ version: 3, sessionId: sessionId, values: storedValues,
+                initDataType: initData.type });
+        }
+        else {
+            this._entries.push({ version: 4, sessionId: sessionId, keyIds: keyIds.map(function (k) { return new SerializableBytes(k); }),
+                values: storedValues,
+                initDataType: initData.type });
         }
-        log.info("EME-PSS: Add new session", sessionId);
-        this._entries.push({ version: 3, sessionId: sessionId, values: this._formatValuesForStore(initData.values),
-            initDataType: initData.type });
         this._save();
     };
     /**
-     * Delete stored MediaKeySession information based on its initialization
-     * data.
+     * Delete stored MediaKeySession information based on its session id.
      * @param {Uint8Array}  initData
      * @param {string|undefined} initDataType
      */
-    PersistentSessionsStore.prototype.delete = function (initData) {
-        var index = this._getIndex(initData);
+    PersistentSessionsStore.prototype.delete = function (sessionId) {
+        var index = -1;
+        for (var i = 0; i < this._entries.length; i++) {
+            var entry_1 = this._entries[i];
+            if (entry_1.sessionId === sessionId) {
+                index = i;
+                break;
+            }
+        }
         if (index === -1) {
-            log.warn("EME-PSS: initData to delete not found.");
+            log.warn("DRM-PSS: initData to delete not found.");
             return;
         }
         var entry = this._entries[index];
-        log.warn("EME-PSS: Delete session from store", entry.sessionId);
+        log.warn("DRM-PSS: Delete session from store", entry.sessionId);
         this._entries.splice(index, 1);
         this._save();
     };
     PersistentSessionsStore.prototype.deleteOldSessions = function (sessionsToDelete) {
-        log.info("EME-PSS: Deleting last ".concat(sessionsToDelete, " sessions."));
+        log.info("DRM-PSS: Deleting last ".concat(sessionsToDelete, " sessions."));
         if (sessionsToDelete <= 0) {
             return;
         }
@@ -185,7 +170,7 @@ var PersistentSessionsStore = /** @class */ (function () {
             this._entries.splice(0, sessionsToDelete);
         }
         else {
-            log.warn("EME-PSS: Asked to remove more information that it contains", sessionsToDelete, this._entries.length);
+            log.warn("DRM-PSS: Asked to remove more information that it contains", sessionsToDelete, this._entries.length);
             this._entries = [];
         }
         this._save();
@@ -200,60 +185,103 @@ var PersistentSessionsStore = /** @class */ (function () {
     /**
      * Retrieve index of an entry.
      * Returns `-1` if not found.
-     * @param {Uint8Array}  initData
-     * @param {string|undefined} initDataType
+     * @param {Object} initData
      * @returns {number}
      */
     PersistentSessionsStore.prototype._getIndex = function (initData) {
-        var formatted = this._formatValuesForStore(initData.values);
         // Older versions of the format include a concatenation of all
         // initialization data and its hash.
-        var concatInitData = concat.apply(void 0, initData.values.map(function (i) { return i.data; }));
-        var concatInitDataHash = hashBuffer(concatInitData);
-        for (var i = 0; i < this._entries.length; i++) {
-            var entry = this._entries[i];
+        // This is only computed lazily, the first time it is needed.
+        var lazyConcatenatedData = null;
+        function getConcatenatedInitDataInfo() {
+            if (lazyConcatenatedData === null) {
+                var concatInitData = initData.values.constructRequestData();
+                lazyConcatenatedData = { initData: concatInitData,
+                    initDataHash: hashBuffer(concatInitData) };
+            }
+            return lazyConcatenatedData;
+        }
+        var _loop_1 = function (i) {
+            var entry = this_1._entries[i];
             if (entry.initDataType === initData.type) {
                 switch (entry.version) {
+                    case 4:
+                        if (initData.keyIds !== undefined) {
+                            var foundCompatible = initData.keyIds.every(function (keyId) {
+                                var keyIdB64 = bytesToBase64(keyId);
+                                for (var _i = 0, _a = entry.keyIds; _i < _a.length; _i++) {
+                                    var entryKid = _a[_i];
+                                    if (typeof entryKid === "string") {
+                                        if (keyIdB64 === entryKid) {
+                                            return true;
+                                        }
+                                    }
+                                    else if (areKeyIdsEqual(entryKid.initData, keyId)) {
+                                        return true;
+                                    }
+                                }
+                                return false;
+                            });
+                            if (foundCompatible) {
+                                return { value: i };
+                            }
+                        }
+                        else {
+                            var formatted_1 = initData.values.getFormattedValues();
+                            if (areInitializationValuesCompatible(formatted_1, entry.values)) {
+                                return { value: i };
+                            }
+                        }
+                        break;
                     case 3:
+                        var formatted = initData.values.getFormattedValues();
                         if (areInitializationValuesCompatible(formatted, entry.values)) {
-                            return i;
+                            return { value: i };
                         }
                         break;
-                    case 2:
-                        if (entry.initDataHash === concatInitDataHash) {
+                    case 2: {
+                        var _a = getConcatenatedInitDataInfo(), concatInitData = _a.initData, concatHash = _a.initDataHash;
+                        if (entry.initDataHash === concatHash) {
                             try {
                                 var decodedInitData = typeof entry.initData === "string" ?
-                                    InitDataContainer.decode(entry.initData) :
+                                    SerializableBytes.decode(entry.initData) :
                                     entry.initData.initData;
                                 if (areArraysOfNumbersEqual(decodedInitData, concatInitData)) {
-                                    return i;
+                                    return { value: i };
                                 }
                             }
                             catch (e) {
-                                log.warn("EME-PSS: Could not decode initialization data.", e);
+                                log.warn("DRM-PSS: Could not decode initialization data.", e);
                             }
                         }
                         break;
-                    case 1:
-                        if (entry.initDataHash === concatInitDataHash) {
+                    }
+                    case 1: {
+                        var _b = getConcatenatedInitDataInfo(), concatInitData = _b.initData, concatHash = _b.initDataHash;
+                        if (entry.initDataHash === concatHash) {
                             if (typeof entry.initData.length === "undefined") {
-                                // If length is undefined, it has been linearized. We could still
-                                // convert it back to an Uint8Array but this would necessitate some
-                                // ugly unreadable logic for a very very minor possibility.
-                                // Just consider that it is a match based on the hash.
-                                return i;
+                                return { value: i };
                             }
                             else if (areArraysOfNumbersEqual(entry.initData, concatInitData)) {
-                                return i;
+                                return { value: i };
                             }
                         }
                         break;
-                    default:
-                        if (entry.initData === concatInitDataHash) {
-                            return i;
+                    }
+                    default: {
+                        var concatHash = getConcatenatedInitDataInfo().initDataHash;
+                        if (entry.initData === concatHash) {
+                            return { value: i };
                         }
+                    }
                 }
             }
+        };
+        var this_1 = this;
+        for (var i = 0; i < this._entries.length; i++) {
+            var state_1 = _loop_1(i);
+            if (typeof state_1 === "object")
+                return state_1.value;
         }
         return -1;
     };
@@ -265,29 +293,23 @@ var PersistentSessionsStore = /** @class */ (function () {
             this._storage.save(this._entries);
         }
         catch (e) {
-            log.warn("EME-PSS: Could not save licenses in localStorage");
+            log.warn("DRM-PSS: Could not save licenses in localStorage");
         }
     };
-    /**
-     * Format given initializationData's values so they are ready to be stored:
-     *   - sort them by systemId, so they are faster to compare
-     *   - add hash for each initialization data encountered.
-     * @param {Array.<Object>} initialValues
-     * @returns {Array.<Object>}
-     */
-    PersistentSessionsStore.prototype._formatValuesForStore = function (initialValues) {
-        return initialValues.slice()
-            .sort(function (a, b) { return a.systemId === b.systemId ? 0 :
-            a.systemId === undefined ? 1 :
-                b.systemId === undefined ? -1 :
-                    a.systemId < b.systemId ? -1 :
-                        1; })
-            .map(function (_a) {
-            var systemId = _a.systemId, data = _a.data;
-            return ({ systemId: systemId, data: new InitDataContainer(data),
-                hash: hashBuffer(data) });
-        });
-    };
     return PersistentSessionsStore;
 }());
 export default PersistentSessionsStore;
+/**
+ * Format given initializationData's values so they are ready to be stored:
+ *   - sort them by systemId, so they are faster to compare
+ *   - add hash for each initialization data encountered.
+ * @param {Array.<Object>} initialValues
+ * @returns {Array.<Object>}
+ */
+function prepareValuesForStore(initialValues) {
+    return initialValues
+        .map(function (_a) {
+        var systemId = _a.systemId, data = _a.data, hash = _a.hash;
+        return ({ systemId: systemId, hash: hash, data: new SerializableBytes(data) });
+    });
+}

package/dist/_esm5.processed/core/{eme/utils/init_data_container.d.ts → decrypt/utils/serializable_bytes.d.ts}

@@ -13,13 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/** Wrap initialization data and allow serialization of it into base64. */
-export default class InitDataContainer {
-    /** The initData itself. */
+/** Wrap byte-based data and allow serialization of it into base64. */
+export default class SerializableBytes {
+    /**
+     * The data itself. Named `initData` for legacy reasons (cannot be changed
+     * because it has an impact on saved persistent session information.
+     */
     initData: Uint8Array;
     /**
-     * Create a new container, wrapping the initialization data given and allowing
-     * linearization into base64.
+     * Create a new `SerializableBytes`, wrapping the initialization data
+     * given and allowing serialization into base64.
      * @param {Uint8Array}
      */
     constructor(initData: Uint8Array);

package/dist/_esm5.processed/core/{eme/utils/init_data_container.js → decrypt/utils/serializable_bytes.js}

@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 import { base64ToBytes, bytesToBase64, } from "../../../utils/base64";
-/** Wrap initialization data and allow serialization of it into base64. */
-var InitDataContainer = /** @class */ (function () {
+/** Wrap byte-based data and allow serialization of it into base64. */
+var SerializableBytes = /** @class */ (function () {
     /**
-     * Create a new container, wrapping the initialization data given and allowing
-     * linearization into base64.
+     * Create a new `SerializableBytes`, wrapping the initialization data
+     * given and allowing serialization into base64.
      * @param {Uint8Array}
      */
-    function InitDataContainer(initData) {
+    function SerializableBytes(initData) {
         this.initData = initData;
     }
     /**
@@ -31,7 +31,7 @@ var InitDataContainer = /** @class */ (function () {
      * https://tc39.es/ecma262/#sec-serializejsonproperty
      * @returns {string}
      */
-    InitDataContainer.prototype.toJSON = function () {
+    SerializableBytes.prototype.toJSON = function () {
         return bytesToBase64(this.initData);
     };
     /**
@@ -40,9 +40,9 @@ var InitDataContainer = /** @class */ (function () {
      * @param {string}
      * @returns {Uint8Array}
      */
-    InitDataContainer.decode = function (base64) {
+    SerializableBytes.decode = function (base64) {
         return base64ToBytes(base64);
     };
-    return InitDataContainer;
+    return SerializableBytes;
 }());
-export default InitDataContainer;
+export default SerializableBytes;

package/dist/_esm5.processed/core/{eme → decrypt/utils}/server_certificate_store.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ICustomMediaKeys } from "../../compat";
+import { ICustomMediaKeys } from "../../../compat";
 declare const _default: {
     /**
      * Tells the ServerCertificateStore that you begin to call the APIs to set a

package/dist/_esm5.processed/core/{eme → decrypt/utils}/server_certificate_store.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import hashBuffer from "../../utils/hash_buffer";
+import hashBuffer from "../../../utils/hash_buffer";
 /**
  * Keep track of server certificate which have been set for a MediaKeys.
  * As it is impossible for a MediaKeys to have his server certificate reset

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

@@ -27,10 +27,10 @@ export interface IManifestFetcherParsedResult {
      * The time (`performance.now()`) at which the request was started (at which
      * the JavaScript call was done).
      */
-    sendingTime?: number;
+    sendingTime?: number | undefined;
     /** The time (`performance.now()`) at which the request was fully received. */
-    receivedTime?: number;
-    parsingTime?: number;
+    receivedTime?: number | undefined;
+    parsingTime?: number | undefined;
 }
 /** Emitted when a fetching or parsing minor error happened. */
 export interface IManifestFetcherWarningEvent {
@@ -51,7 +51,7 @@ export interface IManifestFetcherParserOptions {
      * If set, offset to add to `performance.now()` to obtain the current
      * server's time.
      */
-    externalClockOffset?: number;
+    externalClockOffset?: number | undefined;
     /** The previous value of the Manifest (when updating). */
     previousManifest: Manifest | null;
     /**

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

@@ -49,16 +49,15 @@ 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 PPromise from "pinkie";
 import { Observable, } from "rxjs";
 import config from "../../../config";
 import { formatError, } from "../../../errors";
 import log from "../../../log";
 import assert from "../../../utils/assert";
+import PPromise from "../../../utils/promise";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import { tryRequestPromiseWithBackoff, } from "../utils/try_urls_with_backoff";
-var DEFAULT_MAX_MANIFEST_REQUEST_RETRY = config.DEFAULT_MAX_MANIFEST_REQUEST_RETRY, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = config.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = config.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = config.MAX_BACKOFF_DELAY_BASE;
 /**
  * Class allowing to facilitate the task of loading and parsing a Manifest.
  * @class ManifestFetcher
@@ -318,7 +317,8 @@ var ManifestFetcher = /** @class */ (function () {
      * @returns {Object}
      */
     ManifestFetcher.prototype._getBackoffSetting = function (onRetry) {
-        var _a = this._settings, lowLatencyMode = _a.lowLatencyMode, ogRegular = _a.maxRetryRegular, ogOffline = _a.maxRetryOffline;
+        var _a = config.getCurrent(), DEFAULT_MAX_MANIFEST_REQUEST_RETRY = _a.DEFAULT_MAX_MANIFEST_REQUEST_RETRY, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = _a.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = _a.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _a.MAX_BACKOFF_DELAY_BASE;
+        var _b = this._settings, lowLatencyMode = _b.lowLatencyMode, ogRegular = _b.maxRetryRegular, ogOffline = _b.maxRetryOffline;
         var baseDelay = lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
             INITIAL_BACKOFF_DELAY_BASE.REGULAR;
         var maxDelay = lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :

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

@@ -130,7 +130,7 @@ export interface ISegmentFetcherOptions {
  * @returns {Object}
  */
 export declare function getSegmentFetcherOptions(bufferType: string, { maxRetryRegular, maxRetryOffline, lowLatencyMode }: {
-    maxRetryRegular?: number;
-    maxRetryOffline?: number;
+    maxRetryRegular?: number | undefined;
+    maxRetryOffline?: number | undefined;
     lowLatencyMode: boolean;
 }): ISegmentFetcherOptions;

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

@@ -26,7 +26,6 @@ import objectAssign from "../../../utils/object_assign";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import { tryURLsWithBackoff } from "../utils/try_urls_with_backoff";
-var DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = config.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = config.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = config.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = config.MAX_BACKOFF_DELAY_BASE;
 var generateRequestID = idGenerator();
 /**
  * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
@@ -76,7 +75,8 @@ export default function createSegmentFetcher(bufferType, pipeline, callbacks, op
             /**
              * If the request succeeded, set to the corresponding
              * `IChunkCompleteInformation` object.
-             * If the request failed or was cancelled, set to `null`.
+             * For any other completion cases: if the request either failed, was
+             * cancelled or just if no request was needed, set to `null`.
              *
              * Stays to `undefined` when the request is still pending.
              */
@@ -162,6 +162,9 @@ export default function createSegmentFetcher(bufferType, pipeline, callbacks, op
                     requestInfo = res.resultData;
                     sendNetworkMetricsIfAvailable();
                 }
+                else {
+                    requestInfo = null;
+                }
                 if (!canceller.isUsed) {
                     // The current Observable could have been canceled as a result of one
                     // of the previous `next` calls. In that case, we don't want to send
@@ -267,6 +270,7 @@ export default function createSegmentFetcher(bufferType, pipeline, callbacks, op
  */
 export function getSegmentFetcherOptions(bufferType, _a) {
     var maxRetryRegular = _a.maxRetryRegular, maxRetryOffline = _a.maxRetryOffline, lowLatencyMode = _a.lowLatencyMode;
+    var _b = config.getCurrent(), DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = _b.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _b.MAX_BACKOFF_DELAY_BASE;
     return { maxRetryRegular: bufferType === "image" ? 0 :
             maxRetryRegular !== null && maxRetryRegular !== void 0 ? maxRetryRegular : DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
         maxRetryOffline: maxRetryOffline !== null && maxRetryOffline !== void 0 ? maxRetryOffline : DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,

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

@@ -17,7 +17,6 @@ import config from "../../../config";
 import applyPrioritizerToSegmentFetcher from "./prioritized_segment_fetcher";
 import ObservablePrioritizer from "./prioritizer";
 import createSegmentFetcher, { getSegmentFetcherOptions, } from "./segment_fetcher";
-var MIN_CANCELABLE_PRIORITY = config.MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_LEVEL = config.MAX_HIGH_PRIORITY_LEVEL;
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.
@@ -53,6 +52,7 @@ var SegmentFetcherCreator = /** @class */ (function () {
      * @param {Object} transport
      */
     function SegmentFetcherCreator(transport, options) {
+        var _a = config.getCurrent(), MIN_CANCELABLE_PRIORITY = _a.MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_LEVEL = _a.MAX_HIGH_PRIORITY_LEVEL;
         this._transport = transport;
         this._prioritizer = new ObservablePrioritizer({
             prioritySteps: { high: MAX_HIGH_PRIORITY_LEVEL,

package/dist/_esm5.processed/core/fetchers/utils/try_urls_with_backoff.js

@@ -49,12 +49,12 @@ 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 PPromise from "pinkie";
 import { isOffline } from "../../../compat";
 import { CustomLoaderError, isKnownError, NetworkErrorTypes, RequestError, } from "../../../errors";
 import log from "../../../log";
 import cancellableSleep from "../../../utils/cancellable_sleep";
 import getFuzzedDelay from "../../../utils/get_fuzzed_delay";
+import PPromise from "../../../utils/promise";
 import TaskCanceller from "../../../utils/task_canceller";
 /**
  * Called on a loader error.

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

@@ -15,7 +15,6 @@
  */
 import config from "../../config";
 import log from "../../log";
-var DEFAULT_LIVE_GAP = config.DEFAULT_LIVE_GAP;
 /**
  * Returns the calculated initial time for the content described by the given
  * Manifest:
@@ -76,6 +75,7 @@ export default function getInitialTime(manifest, lowLatencyMode, startAt) {
         var suggestedPresentationDelay = manifest.suggestedPresentationDelay, clockOffset = manifest.clockOffset;
         var maximumPosition = manifest.getMaximumPosition();
         var liveTime = void 0;
+        var DEFAULT_LIVE_GAP = config.getCurrent().DEFAULT_LIVE_GAP;
         if (clockOffset == null) {
             log.info("Init: no clock offset found for a live content, " +
                 "starting close to maximum available position");

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

@@ -20,7 +20,7 @@
 import { Observable } from "rxjs";
 import { IReadOnlySharedReference } from "../../utils/reference";
 import { PlaybackObserver } from "../api";
-import { IKeySystemOption } from "../eme";
+import { IKeySystemOption } from "../decrypt";
 import { IInitialTimeOptions } from "./get_initial_time";
 import { IDirectfileEvent } from "./types";
 export interface IDirectFileOptions {
@@ -29,8 +29,8 @@ export interface IDirectFileOptions {
     mediaElement: HTMLMediaElement;
     playbackObserver: PlaybackObserver;
     speed: IReadOnlySharedReference<number>;
-    startAt?: IInitialTimeOptions;
-    url?: string;
+    startAt?: IInitialTimeOptions | undefined;
+    url?: string | undefined;
 }
 /**
  * Launch a content in "Directfile mode".

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

@@ -21,12 +21,17 @@ import { EMPTY, filter, ignoreElements, merge as observableMerge, mergeMap, swit
 import { clearElementSrc, setElementSrc$, } from "../../compat";
 import log from "../../log";
 import deferSubscriptions from "../../utils/defer_subscriptions";
-import createEMEManager from "./create_eme_manager";
 import emitLoadedEvent from "./emit_loaded_event";
 import initialSeekAndPlay from "./initial_seek_and_play";
+import linkDrmAndContent from "./link_drm_and_content";
 import StallAvoider from "./stall_avoider";
 import throwOnMediaError from "./throw_on_media_error";
 import updatePlaybackRate from "./update_playback_rate";
+// NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+// first type parameter as `any` instead of the perfectly fine `unknown`,
+// leading to linter issues, as it forbids the usage of `any`.
+// This is why we're disabling the eslint rule.
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
 /**
  * calculate initial time as a position in seconds.
  * @param {HTMLMediaElement} mediaElement
@@ -86,9 +91,8 @@ export default function initializeDirectfileContent(_a) {
     log.debug("Init: Initial time calculated:", initialTime);
     var seekAndPlay$ = initialSeekAndPlay({ mediaElement: mediaElement, playbackObserver: playbackObserver, startTime: initialTime,
         mustAutoPlay: autoPlay }).seekAndPlay$;
-    // Create EME Manager, an observable which will manage every EME-related
-    // issue.
-    var emeManager$ = linkURL$.pipe(mergeMap(function () { return createEMEManager(mediaElement, keySystems, EMPTY); }), deferSubscriptions(), share());
+    /** Initialize decryption capabilities and the HTMLMediaElement's src attribute. */
+    var drmEvents$ = linkDrmAndContent(mediaElement, keySystems, EMPTY, linkURL$).pipe(deferSubscriptions(), share());
     // Translate errors coming from the media element into RxPlayer errors
     // through a throwing Observable.
     var mediaError$ = throwOnMediaError(mediaElement);
@@ -96,11 +100,6 @@ export default function initializeDirectfileContent(_a) {
     // Set the speed set by the user on the media element while pausing a
     // little longer while the buffer is empty.
     var playbackRate$ = updatePlaybackRate(mediaElement, speed, observation$)
-        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
-        // first type parameter as `any` instead of the perfectly fine `unknown`,
-        // leading to linter issues, as it forbids the usage of `any`.
-        // This is why we're disabling the eslint rule.
-        /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
         .pipe(ignoreElements());
     /**
      * Observable trying to avoid various stalling situations, emitting "stalled"
@@ -112,17 +111,12 @@ export default function initializeDirectfileContent(_a) {
      * media can begin playback.
      * Also emits warning events if issues arise when doing so.
      */
-    var loadingEvts$ = emeManager$.pipe(filter(function isEMEReady(evt) {
-        if (evt.type === "created-media-keys") {
-            evt.value.canAttachMediaKeys.setValue(true);
-            return true;
-        }
-        return evt.type === "eme-disabled" || evt.type === "attached-media-keys";
-    }), take(1), mergeMap(function () { return seekAndPlay$; }), switchMap(function (evt) {
+    var loadingEvts$ = drmEvents$.pipe(filter(function (evt) { return evt.type === "decryption-ready" ||
+        evt.type === "decryption-disabled"; }), take(1), mergeMap(function () { return seekAndPlay$; }), switchMap(function (evt) {
         if (evt.type === "warning") {
             return observableOf(evt);
         }
         return emitLoadedEvent(observation$, mediaElement, null, true);
     }));
-    return observableMerge(loadingEvts$, emeManager$, mediaError$, playbackRate$, stallAvoider$);
+    return observableMerge(loadingEvts$, drmEvents$.pipe(ignoreElements()), mediaError$, playbackRate$, stallAvoider$);
 }