rx-player 3.29.0-dev.2022090500 → 3.29.0-dev.2022091600

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

@@ -100,6 +100,7 @@ import createOrLoadSession from "./create_or_load_session";
 import initMediaKeys from "./init_media_keys";
 import SessionEventsListener, { BlacklistedSessionError, } from "./session_events_listener";
 import setServerCertificate from "./set_server_certificate";
+import { DecommissionedSessionError } from "./utils/check_key_statuses";
 import cleanOldStoredPersistentInfo from "./utils/clean_old_stored_persistent_info";
 import getDrmSystemId from "./utils/get_drm_system_id";
 import InitDataValuesContainer from "./utils/init_data_values_container";
@@ -351,7 +352,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                             .reduce(function (acc, kid) { return "".concat(acc, ", ").concat(bytesToHex(kid)); }, "");
                                         log.debug("DRM: Blacklisting new key ids", hexKids);
                                     }
-                                    updateDecipherability(initializationData.content.manifest, [], keyIds);
+                                    updateDecipherability(initializationData.content.manifest, [], keyIds, []);
                                 }
                                 return [2 /*return*/];
                             }
@@ -380,7 +381,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                                 createdSess.keyStatuses.blacklisted.push(innerKid);
                                             }
                                         }
-                                        updateDecipherability(initializationData.content.manifest, createdSess.keyStatuses.whitelisted, createdSess.keyStatuses.blacklisted);
+                                        updateDecipherability(initializationData.content.manifest, createdSess.keyStatuses.whitelisted, createdSess.keyStatuses.blacklisted, []);
                                         return [2 /*return*/];
                                     }
                                 }
@@ -428,7 +429,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                         _this.trigger("warning", evt.value);
                                         return;
                                 }
-                                var linkedKeys = getKeyIdsLinkedToSession(initializationData, sessionInfo.record, options.singleLicensePer, sessionInfo.source === "created-session" /* MediaKeySessionLoadingType.Created */, evt.value.whitelistedKeyIds, evt.value.blacklistedKeyIDs);
+                                var linkedKeys = getKeyIdsLinkedToSession(initializationData, sessionInfo.record, options.singleLicensePer, sessionInfo.source === "created-session" /* MediaKeySessionLoadingType.Created */, evt.value.whitelistedKeyIds, evt.value.blacklistedKeyIds);
                                 sessionInfo.record.associateKeyIds(linkedKeys.whitelisted);
                                 sessionInfo.record.associateKeyIds(linkedKeys.blacklisted);
                                 sessionInfo.keyStatuses = { whitelisted: linkedKeys.whitelisted,
@@ -443,11 +444,36 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                     isSessionPersisted = true;
                                 }
                                 if (initializationData.content !== undefined) {
-                                    updateDecipherability(initializationData.content.manifest, linkedKeys.whitelisted, linkedKeys.blacklisted);
+                                    updateDecipherability(initializationData.content.manifest, linkedKeys.whitelisted, linkedKeys.blacklisted, []);
                                 }
                                 _this._unlockInitDataQueue();
                             },
                             error: function (err) {
+                                var _a;
+                                if (err instanceof DecommissionedSessionError) {
+                                    log.warn("DRM: A session's closing condition has been triggered");
+                                    _this._lockInitDataQueue();
+                                    var indexOf = _this._currentSessions.indexOf(sessionInfo);
+                                    if (indexOf >= 0) {
+                                        _this._currentSessions.splice(indexOf);
+                                    }
+                                    if (initializationData.content !== undefined) {
+                                        updateDecipherability(initializationData.content.manifest, [], [], sessionInfo.record.getAssociatedKeyIds());
+                                    }
+                                    (_a = stores.persistentSessionsStore) === null || _a === void 0 ? void 0 : _a.delete(mediaKeySession.sessionId);
+                                    stores.loadedSessionsStore.closeSession(mediaKeySession)
+                                        .catch(function (e) {
+                                        var closeError = e instanceof Error ? e :
+                                            "unknown error";
+                                        log.warn("DRM: failed to close expired session", closeError);
+                                    })
+                                        .then(function () { return _this._unlockInitDataQueue(); })
+                                        .catch(function (retryError) { return _this._onFatalError(retryError); });
+                                    if (!_this._isStopped()) {
+                                        _this.trigger("warning", err.reason);
+                                    }
+                                    return;
+                                }
                                 if (!(err instanceof BlacklistedSessionError)) {
                                     _this._onFatalError(err);
                                     return;
@@ -559,7 +585,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                 }
                 log.info("DRM: Current initialization data is linked to blacklisted keys. " +
                     "Marking Representations as not decipherable");
-                updateDecipherability(initializationData.content.manifest, [], initializationData.keyIds);
+                updateDecipherability(initializationData.content.manifest, [], initializationData.keyIds, []);
                 return true;
             }
         }
@@ -586,13 +612,23 @@ var ContentDecryptor = /** @class */ (function (_super) {
         }
         return false;
     };
+    /**
+     * Callback that should be called if an error that made the current
+     * `ContentDecryptor` instance unusable arised.
+     * This callbacks takes care of resetting state and sending the right events.
+     *
+     * Once called, no further actions should be taken.
+     *
+     * @param {*} err - The error object which describes the issue. Will be
+     * formatted and sent in an "error" event.
+     */
     ContentDecryptor.prototype._onFatalError = function (err) {
         if (this._canceller.isUsed) {
             return;
         }
         var formattedErr = err instanceof Error ?
             err :
-            new OtherError("NONE", "Unknown encryption error");
+            new OtherError("NONE", "Unknown decryption error");
         this.error = formattedErr;
         this._initDataQueue.length = 0;
         this._stateData = { state: ContentDecryptorState.Error,
@@ -615,6 +651,10 @@ var ContentDecryptor = /** @class */ (function (_super) {
         return this._stateData.state === ContentDecryptorState.Disposed ||
             this._stateData.state === ContentDecryptorState.Error;
     };
+    /**
+     * Start processing the next initialization data of the `_initDataQueue` if it
+     * isn't lock.
+     */
     ContentDecryptor.prototype._processCurrentInitDataQueue = function () {
         while (this._stateData.isInitDataQueueLocked === false) {
             var initData = this._initDataQueue.shift();
@@ -624,11 +664,23 @@ var ContentDecryptor = /** @class */ (function (_super) {
             this.onInitializationData(initData);
         }
     };
+    /**
+     * Lock new initialization data (from the `_initDataQueue`) from being
+     * processed until `_unlockInitDataQueue` is called.
+     *
+     * You may want to call this method when performing operations which may have
+     * an impact on the handling of other initialization data.
+     */
     ContentDecryptor.prototype._lockInitDataQueue = function () {
         if (this._stateData.isInitDataQueueLocked === false) {
             this._stateData.isInitDataQueueLocked = true;
         }
     };
+    /**
+     * Unlock `_initDataQueue` and start processing the first element.
+     *
+     * Should have no effect if the `_initDataQueue` was not locked.
+     */
     ContentDecryptor.prototype._unlockInitDataQueue = function () {
         if (this._stateData.isMediaKeysAttached !== true) {
             log.error("DRM: Trying to unlock in the wrong state");
@@ -651,7 +703,25 @@ function canCreatePersistentSession(mediaKeySystemAccess) {
     return sessionTypes !== undefined &&
         arrayIncludes(sessionTypes, "persistent-license");
 }
-function updateDecipherability(manifest, whitelistedKeyIds, blacklistedKeyIDs) {
+/**
+ * Change the decipherability of Representations which have their key id in one
+ * of the given Arrays:
+ *
+ *   - Those who have a key id listed in `whitelistedKeyIds` will have their
+ *     decipherability updated to `true`
+ *
+ *   - Those who have a key id listed in `blacklistedKeyIds` will have their
+ *     decipherability updated to `false`
+ *
+ *   - Those who have a key id listed in `delistedKeyIds` will have their
+ *     decipherability updated to `undefined`.
+ *
+ * @param {Object} manifest
+ * @param {Array.<Uint8Array>} whitelistedKeyIds
+ * @param {Array.<Uint8Array>} blacklistedKeyIds
+ * @param {Array.<Uint8Array>} delistedKeyIds
+ */
+function updateDecipherability(manifest, whitelistedKeyIds, blacklistedKeyIds, delistedKeyIds) {
     manifest.updateRepresentationsDeciperability(function (representation) {
         if (representation.contentProtections === undefined) {
             return representation.decipherable;
@@ -660,8 +730,8 @@ function updateDecipherability(manifest, whitelistedKeyIds, blacklistedKeyIDs) {
         if (contentKIDs !== undefined) {
             for (var i = 0; i < contentKIDs.length; i++) {
                 var elt = contentKIDs[i];
-                for (var j = 0; j < blacklistedKeyIDs.length; j++) {
-                    if (areKeyIdsEqual(blacklistedKeyIDs[j], elt.keyId)) {
+                for (var j = 0; j < blacklistedKeyIds.length; j++) {
+                    if (areKeyIdsEqual(blacklistedKeyIds[j], elt.keyId)) {
                         return false;
                     }
                 }
@@ -670,11 +740,22 @@ function updateDecipherability(manifest, whitelistedKeyIds, blacklistedKeyIDs) {
                         return true;
                     }
                 }
+                for (var j = 0; j < delistedKeyIds.length; j++) {
+                    if (areKeyIdsEqual(delistedKeyIds[j], elt.keyId)) {
+                        return undefined;
+                    }
+                }
             }
         }
         return representation.decipherable;
     });
 }
+/**
+ * Update decipherability to `false` to any Representation which is linked to
+ * the given initialization data.
+ * @param {Object} manifest
+ * @param {Object} initData
+ */
 function blackListProtectionData(manifest, initData) {
     manifest.updateRepresentationsDeciperability(function (representation) {
         var _a, _b;
@@ -874,6 +955,12 @@ function getKeyIdsLinkedToSession(initializationData, keySessionRecord, singleLi
         /** associatedKeyIds starts with the whitelisted one. */
         blacklisted: associatedKeyIds.slice(usableKeyIds.length) };
 }
+/**
+ * Push all kei ids in the given `set` and add it to the `arr` Array only if it
+ * isn't already present in it.
+ * @param {Set.<Uint8Array>} set
+ * @param {Array.<Uint8Array>} arr
+ */
 function mergeKeyIdSetIntoArray(set, arr) {
     var setArr = Array.from(set.values());
     var _loop_4 = function (kid) {
@@ -887,6 +974,11 @@ function mergeKeyIdSetIntoArray(set, arr) {
         _loop_4(kid);
     }
 }
+/**
+ * Add to the given `set` all key ids found in the given `Period`.
+ * @param {Set.<Uint8Array>} set
+ * @param {Object} period
+ */
 function addKeyIdsFromPeriod(set, period) {
     for (var _i = 0, _a = period.getAdaptations(); _i < _a.length; _i++) {
         var adaptation = _a[_i];

package/dist/_esm5.processed/core/decrypt/session_events_listener.d.ts

@@ -38,17 +38,8 @@ export declare class BlacklistedSessionError extends Error {
  */
 export default function SessionEventsListener(session: MediaKeySession | ICustomMediaKeySession, keySystemOptions: IKeySystemOption, keySystem: string): Observable<IEMEWarningEvent | IKeysUpdateEvent>;
 /**
- * Some key ids have updated their status.
- *
- * We put them in two different list:
- *
- *   - `blacklistedKeyIDs`: Those key ids won't be used for decryption and the
- *     corresponding media it decrypts should not be pushed to the buffer
- *     Note that a blacklisted key id can become whitelisted in the future.
- *
- *   - `whitelistedKeyIds`: Those key ids were found and their corresponding
- *     keys are now being considered for decryption.
- *     Note that a whitelisted key id can become blacklisted in the future.
+ * Some key ids related to the current MediaKeySession have updated their
+ * statuses.
  *
  * Note that each `IKeysUpdateEvent` is independent of any other.
  *
@@ -56,7 +47,7 @@ export default function SessionEventsListener(session: MediaKeySession | ICustom
  * one, as it can for example be linked to a whole other decryption session.
  *
  * However, if a key id is encountered in both an older and a newer
- * `IKeysUpdateEvent`, only the older status should be considered.
+ * `IKeysUpdateEvent`, only the newer, updated, status should be considered.
  */
 export interface IKeysUpdateEvent {
     type: "keys-update";
@@ -65,13 +56,19 @@ export interface IKeysUpdateEvent {
 /** Information on key ids linked to a MediaKeySession. */
 export interface IKeyUpdateValue {
     /**
-     * The list of key ids that are blacklisted.
-     * As such, their corresponding keys won't be used by that session, despite
-     * the fact that they were part of the pushed license.
+     * The list of key ids linked to the corresponding MediaKeySession that are
+     * now "blacklisted", i.e. the decryption keys they are linked to are blocked
+     * from ever being used anymore.
+     *
+     * Blacklisted key ids correspond to keys linked to a MediaKeySession that
+     * cannot and should not be used, due to various reasons, which mainly involve
+     * unmet output restrictions and CDM internal errors linked to that key.
+     *
+     * Content linked to key ids in `blacklistedKeyIds` should be refrained from
+     * being used.
      *
-     * Reasons for blacklisting a keys depend on options, but mainly involve unmet
-     * output restrictions and CDM internal errors linked to that key id.
+     * Note that a key id may only be blacklisted temporarily.
      */
-    blacklistedKeyIDs: Uint8Array[];
+    blacklistedKeyIds: Uint8Array[];
     whitelistedKeyIds: Uint8Array[];
 }

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

@@ -148,12 +148,13 @@ function getKeyStatusesEvents(session, options, keySystem) {
         if (session.keyStatuses.size === 0) {
             return EMPTY;
         }
-        var _a = checkKeyStatuses(session, options, keySystem), warnings = _a.warnings, blacklistedKeyIDs = _a.blacklistedKeyIDs, whitelistedKeyIds = _a.whitelistedKeyIds;
-        var warnings$ = warnings.length > 0 ? observableOf.apply(void 0, warnings) :
-            EMPTY;
+        var _a = checkKeyStatuses(session, options, keySystem), warning = _a.warning, blacklistedKeyIds = _a.blacklistedKeyIds, whitelistedKeyIds = _a.whitelistedKeyIds;
         var keysUpdate$ = observableOf({ type: "keys-update",
-            value: { whitelistedKeyIds: whitelistedKeyIds, blacklistedKeyIDs: blacklistedKeyIDs } });
-        return observableConcat(warnings$, keysUpdate$);
+            value: { whitelistedKeyIds: whitelistedKeyIds, blacklistedKeyIds: blacklistedKeyIds } });
+        if (warning !== undefined) {
+            return observableConcat(observableOf({ type: "warning", value: warning }), keysUpdate$);
+        }
+        return keysUpdate$;
     });
 }
 /**
@@ -196,8 +197,9 @@ function updateSessionWithMessage(session, message) {
     ignoreElements());
 }
 /**
- * @param {MediaKeySession}
- * @param {Object} keySystem
+ * @param {MediaKeySession} session
+ * @param {Object} keySystemOptions
+ * @param {string} keySystem
  * @param {Event} keyStatusesEvent
  * @returns {Observable}
  */

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

@@ -14,29 +14,26 @@
  * limitations under the License.
  */
 import { ICustomMediaKeySession } from "../../../compat";
-import { IEMEWarningEvent } from "../types";
-export interface IKeyStatusesCheckingOptions {
+import { EncryptedMediaError } from "../../../errors";
+import { IKeySystemOption, IPlayerError } from "../../../public_types";
+/**
+ * Error thrown when the MediaKeySession has to be closed due to a trigger
+ * specified by user configuration.
+ * Such MediaKeySession should be closed immediately and may be re-created if
+ * needed again.
+ * @class DecommissionedSessionError
+ * @extends Error
+ */
+export declare class DecommissionedSessionError extends Error {
+    reason: IPlayerError;
     /**
-     * If explicitely set to `false`, we won't throw on error when a used license
-     * is expired.
+     * Creates a new `DecommissionedSessionError`.
+     * @param {Error} reason - Error that led to the decision to close the
+     * current MediaKeySession. Should be used for reporting purposes.
      */
-    throwOnLicenseExpiration?: boolean;
-    /** Avoid throwing when invalid key statuses are encountered. */
-    fallbackOn?: {
-        /**
-         * If set to `true`, we won't throw when an "internal-error" key status is
-         * encountered but just add a warning and the corresponding key id to the list
-         * of blacklisted key ids.
-         */
-        keyInternalError?: boolean;
-        /**
-         * If set to `true`, we won't throw when an "output-restricted" key status is
-         * encountered but just add a warning and the corresponding key id to the list
-         * of blacklisted key ids.
-         */
-        keyOutputRestricted?: boolean;
-    };
+    constructor(reason: IPlayerError);
 }
+export declare type IKeyStatusesCheckingOptions = Pick<IKeySystemOption, "throwOnLicenseExpiration" | "fallbackOn" | "onKeyExpiration">;
 /**
  * Look at the current key statuses in the sessions and construct the
  * appropriate warnings, whitelisted and blacklisted key ids.
@@ -49,7 +46,7 @@ export interface IKeyStatusesCheckingOptions {
  * @returns {Object} - Warnings to send, whitelisted and blacklisted key ids.
  */
 export default function checkKeyStatuses(session: MediaKeySession | ICustomMediaKeySession, options: IKeyStatusesCheckingOptions, keySystem: string): {
-    warnings: IEMEWarningEvent[];
-    blacklistedKeyIDs: Uint8Array[];
+    warning: EncryptedMediaError | undefined;
+    blacklistedKeyIds: Uint8Array[];
     whitelistedKeyIds: Uint8Array[];
 };

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

@@ -13,10 +13,60 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 /* eslint-disable-next-line max-len */
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
+import assertUnreachable from "../../../utils/assert_unreachable";
 import { bytesToHex } from "../../../utils/string_parsing";
+/**
+ * Error thrown when the MediaKeySession has to be closed due to a trigger
+ * specified by user configuration.
+ * Such MediaKeySession should be closed immediately and may be re-created if
+ * needed again.
+ * @class DecommissionedSessionError
+ * @extends Error
+ */
+var DecommissionedSessionError = /** @class */ (function (_super) {
+    __extends(DecommissionedSessionError, _super);
+    /**
+     * Creates a new `DecommissionedSessionError`.
+     * @param {Error} reason - Error that led to the decision to close the
+     * current MediaKeySession. Should be used for reporting purposes.
+     */
+    function DecommissionedSessionError(reason) {
+        var _this = _super.call(this) || this;
+        // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
+        Object.setPrototypeOf(_this, DecommissionedSessionError.prototype);
+        _this.reason = reason;
+        return _this;
+    }
+    return DecommissionedSessionError;
+}(Error));
+export { DecommissionedSessionError };
 var KEY_STATUSES = { EXPIRED: "expired",
     INTERNAL_ERROR: "internal-error",
     OUTPUT_RESTRICTED: "output-restricted" };
@@ -32,10 +82,10 @@ var KEY_STATUSES = { EXPIRED: "expired",
  * @returns {Object} - Warnings to send, whitelisted and blacklisted key ids.
  */
 export default function checkKeyStatuses(session, options, keySystem) {
-    var warnings = [];
-    var blacklistedKeyIDs = [];
+    var _a = options.fallbackOn, fallbackOn = _a === void 0 ? {} : _a, throwOnLicenseExpiration = options.throwOnLicenseExpiration, onKeyExpiration = options.onKeyExpiration;
+    var blacklistedKeyIds = [];
     var whitelistedKeyIds = [];
-    var _a = options.fallbackOn, fallbackOn = _a === void 0 ? {} : _a, throwOnLicenseExpiration = options.throwOnLicenseExpiration;
+    var badKeyStatuses = [];
     session.keyStatuses.forEach(function (_arg1, _arg2) {
         // Hack present because the order of the arguments has changed in spec
         // and is not the same between some versions of Edge and Chrome.
@@ -44,32 +94,49 @@ export default function checkKeyStatuses(session, options, keySystem) {
                 [_arg2, _arg1]);
         })(), keyStatus = _a[0], keyStatusKeyId = _a[1];
         var keyId = getUUIDKidFromKeyStatusKID(keySystem, new Uint8Array(keyStatusKeyId));
+        var keyStatusObj = { keyId: keyId.buffer, keyStatus: keyStatus };
         switch (keyStatus) {
             case KEY_STATUSES.EXPIRED: {
-                var error = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "A decryption key expired (".concat(bytesToHex(keyId), ")"));
-                if (throwOnLicenseExpiration !== false) {
+                var error = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "A decryption key expired (".concat(bytesToHex(keyId), ")"), { keyStatuses: __spreadArray([keyStatusObj], badKeyStatuses, true) });
+                if (onKeyExpiration === "error" ||
+                    (onKeyExpiration === undefined && throwOnLicenseExpiration === false)) {
                     throw error;
                 }
-                warnings.push({ type: "warning", value: error });
-                whitelistedKeyIds.push(keyId);
+                switch (onKeyExpiration) {
+                    case "close-session":
+                        throw new DecommissionedSessionError(error);
+                    case "fallback":
+                        blacklistedKeyIds.push(keyId);
+                        break;
+                    default:
+                        // I weirdly stopped relying on switch-cases here due to some TypeScript
+                        // issue, not checking properly `case undefined` (bug?)
+                        if (onKeyExpiration === "continue" || onKeyExpiration === undefined) {
+                            whitelistedKeyIds.push(keyId);
+                        }
+                        else {
+                            // Compile-time check throwing when not all possible cases are handled
+                            assertUnreachable(onKeyExpiration);
+                        }
+                        break;
+                }
+                badKeyStatuses.push(keyStatusObj);
                 break;
             }
             case KEY_STATUSES.INTERNAL_ERROR: {
-                var error = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "A \"".concat(keyStatus, "\" status has been encountered (").concat(bytesToHex(keyId), ")"));
                 if (fallbackOn.keyInternalError !== true) {
-                    throw error;
+                    throw new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "A \"".concat(keyStatus, "\" status has been encountered (").concat(bytesToHex(keyId), ")"), { keyStatuses: __spreadArray([keyStatusObj], badKeyStatuses, true) });
                 }
-                warnings.push({ type: "warning", value: error });
-                blacklistedKeyIDs.push(keyId);
+                badKeyStatuses.push(keyStatusObj);
+                blacklistedKeyIds.push(keyId);
                 break;
             }
             case KEY_STATUSES.OUTPUT_RESTRICTED: {
-                var error = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "A \"".concat(keyStatus, "\" status has been encountered (").concat(bytesToHex(keyId), ")"));
                 if (fallbackOn.keyOutputRestricted !== true) {
-                    throw error;
+                    throw new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "A \"".concat(keyStatus, "\" status has been encountered (").concat(bytesToHex(keyId), ")"), { keyStatuses: __spreadArray([keyStatusObj], badKeyStatuses, true) });
                 }
-                warnings.push({ type: "warning", value: error });
-                blacklistedKeyIDs.push(keyId);
+                badKeyStatuses.push(keyStatusObj);
+                blacklistedKeyIds.push(keyId);
                 break;
             }
             default:
@@ -77,5 +144,9 @@ export default function checkKeyStatuses(session, options, keySystem) {
                 break;
         }
     });
-    return { warnings: warnings, blacklistedKeyIDs: blacklistedKeyIDs, whitelistedKeyIds: whitelistedKeyIds };
+    var warning;
+    if (badKeyStatuses.length > 0) {
+        warning = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "One or several problematic key statuses have been encountered", { keyStatuses: badKeyStatuses });
+    }
+    return { warning: warning, blacklistedKeyIds: blacklistedKeyIds, whitelistedKeyIds: whitelistedKeyIds };
 }

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

@@ -72,8 +72,7 @@ export default class PersistentSessionsStore {
     add(initData: IProcessedProtectionData, keyIds: Uint8Array[] | undefined, session: MediaKeySession | ICustomMediaKeySession): void;
     /**
      * Delete stored MediaKeySession information based on its session id.
-     * @param {Uint8Array}  initData
-     * @param {string|undefined} initDataType
+     * @param {string} sessionId
      */
     delete(sessionId: string): void;
     deleteOldSessions(sessionsToDelete: number): void;

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

@@ -148,8 +148,7 @@ var PersistentSessionsStore = /** @class */ (function () {
     };
     /**
      * Delete stored MediaKeySession information based on its session id.
-     * @param {Uint8Array}  initData
-     * @param {string|undefined} initDataType
+     * @param {string} sessionId
      */
     PersistentSessionsStore.prototype.delete = function (sessionId) {
         var index = -1;

package/dist/_esm5.processed/core/fetchers/index.d.ts

@@ -14,5 +14,5 @@
  * limitations under the License.
  */
 import ManifestFetcher, { IManifestFetcherParsedResult, IManifestFetcherParserOptions, IManifestFetcherWarningEvent } from "./manifest";
-import SegmentFetcherCreator, { IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherCreatorBackoffOptions, ISegmentFetcherEvent, ISegmentFetcherRetry } from "./segment";
-export { ManifestFetcher, SegmentFetcherCreator, IManifestFetcherParserOptions, IManifestFetcherParsedResult, IManifestFetcherWarningEvent, IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent, ISegmentFetcherEvent, ISegmentFetcherCreatorBackoffOptions, ISegmentFetcherChunkEvent, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherRetry, };
+import SegmentFetcherCreator, { IPrioritizedSegmentFetcher, ISegmentFetcherCreatorBackoffOptions } from "./segment";
+export { ManifestFetcher, SegmentFetcherCreator, IManifestFetcherParserOptions, IManifestFetcherParsedResult, IManifestFetcherWarningEvent, IPrioritizedSegmentFetcher, ISegmentFetcherCreatorBackoffOptions, };

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent } from "./prioritized_segment_fetcher";
-import { ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherEvent, ISegmentFetcherRetry } from "./segment_fetcher";
+import { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
 import SegmentFetcherCreator, { ISegmentFetcherCreatorBackoffOptions } from "./segment_fetcher_creator";
 export default SegmentFetcherCreator;
-export { IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherEvent, ISegmentFetcherRetry, ISegmentFetcherCreatorBackoffOptions, };
+export { IPrioritizedSegmentFetcher, ISegmentFetcherCreatorBackoffOptions, };

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

@@ -13,26 +13,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import ObservablePrioritizer, { IEndedTaskEvent, IInterruptedTaskEvent } from "./prioritizer";
-import { ISegmentFetcher, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherRetry, ISegmentLoaderContent } from "./segment_fetcher";
+import { CancellationSignal } from "../../../utils/task_canceller";
+import { ISegmentFetcher, ISegmentFetcherCallbacks, ISegmentLoaderContent } from "./segment_fetcher";
+import TaskPrioritizer, { ITaskPrioritizerCallbacks } from "./task_prioritizer";
 /**
  * This function basically put in relation:
  *   - an `ISegmentFetcher`, which will be used to perform the segment requests
- *   - a prioritizer, which will handle the priority of a segment request
+ *   - a `TaskPrioritizer`, which will handle the priority of a segment request
  *
  * and returns functions to fetch segments with a given priority.
  * @param {Object} prioritizer
  * @param {Object} fetcher
  * @returns {Object}
  */
-export default function applyPrioritizerToSegmentFetcher<TSegmentDataType>(prioritizer: ObservablePrioritizer<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>, fetcher: ISegmentFetcher<TSegmentDataType>): IPrioritizedSegmentFetcher<TSegmentDataType>;
+export default function applyPrioritizerToSegmentFetcher<TSegmentDataType>(prioritizer: TaskPrioritizer<void>, fetcher: ISegmentFetcher<TSegmentDataType>): IPrioritizedSegmentFetcher<TSegmentDataType>;
 /** Oject returned by `applyPrioritizerToSegmentFetcher`. */
 export interface IPrioritizedSegmentFetcher<TSegmentDataType> {
     /** Create a new request for a segment with a given priority. */
-    createRequest: (content: ISegmentLoaderContent, priority?: number) => Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>;
+    createRequest: (content: ISegmentLoaderContent, priority: number, callbacks: IPrioritizedSegmentFetcherCallbacks<TSegmentDataType>, cancellationSignal: CancellationSignal) => Promise<void>;
     /** Update priority of a request created through `createRequest`. */
-    updatePriority: (observable: Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>, priority: number) => void;
+    updatePriority: (task: Promise<void>, priority: number) => void;
 }
-/** Event sent by a `IPrioritizedSegmentFetcher`. */
-export declare type IPrioritizedSegmentFetcherEvent<TSegmentDataType> = ISegmentFetcherChunkEvent<TSegmentDataType> | ISegmentFetcherChunkCompleteEvent | ISegmentFetcherRetry | IInterruptedTaskEvent | IEndedTaskEvent;
+/** Callbacks awaited by `applyPrioritizerToSegmentFetcher`. */
+export declare type IPrioritizedSegmentFetcherCallbacks<TSegmentDataType> = ISegmentFetcherCallbacks<TSegmentDataType> & ITaskPrioritizerCallbacks;