rx-player 3.30.0-dev.2023020100 → 3.30.0-dev.2023030200

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

@@ -28,13 +28,13 @@ import createSharedReference from "../../utils/reference";
  * remove all listeners this function has registered.
  */
 export function emitSeekEvents(mediaElement, playbackObserver, onSeeking, onSeeked, cancelSignal) {
-    if (cancelSignal.isCancelled || mediaElement === null) {
+    if (cancelSignal.isCancelled() || mediaElement === null) {
         return;
     }
     var wasSeeking = playbackObserver.getReference().getValue().seeking;
     if (wasSeeking) {
         onSeeking();
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
             return;
         }
     }
@@ -54,7 +54,7 @@ export function constructPlayerStateReference(initializer, mediaElement, playbac
     initializer.addEventListener("loaded", function () {
         if (playerStateRef.getValue() === "LOADING" /* PLAYER_STATES.LOADING */) {
             playerStateRef.setValue("LOADED" /* PLAYER_STATES.LOADED */);
-            if (!cancelSignal.isCancelled) {
+            if (!cancelSignal.isCancelled()) {
                 var newState = getLoadedContentState(mediaElement, null);
                 if (newState !== "PAUSED" /* PLAYER_STATES.PAUSED */) {
                     playerStateRef.setValue(newState);

package/dist/_esm5.processed/core/decrypt/__tests__/__global__/utils.d.ts

@@ -17,7 +17,7 @@
 import { IEncryptedEventData } from "../../../../compat/eme";
 import EventEmitter from "../../../../utils/event_emitter";
 /** Default MediaKeySystemAccess configuration used by the RxPlayer. */
-export declare const defaultKSConfig: {
+export declare const defaultKSConfig: ({
     audioCapabilities: {
         contentType: string;
     }[];
@@ -28,12 +28,19 @@ export declare const defaultKSConfig: {
     videoCapabilities: {
         contentType: string;
     }[];
-}[];
+} | {
+    audioCapabilities: undefined;
+    distinctiveIdentifier: "optional";
+    initDataTypes: readonly ["cenc"];
+    persistentState: "optional";
+    sessionTypes: readonly ["temporary"];
+    videoCapabilities: undefined;
+})[];
 /**
  * Default "com.microsoft.playready.recommendation" MediaKeySystemAccess
  * configuration used by the RxPlayer.
  */
-export declare const defaultPRRecommendationKSConfig: {
+export declare const defaultPRRecommendationKSConfig: ({
     audioCapabilities: {
         robustness: string;
         contentType: string;
@@ -46,22 +53,34 @@ export declare const defaultPRRecommendationKSConfig: {
         robustness: string;
         contentType: string;
     }[];
-}[];
+} | {
+    audioCapabilities: undefined;
+    distinctiveIdentifier: "optional";
+    initDataTypes: readonly ["cenc"];
+    persistentState: "optional";
+    sessionTypes: readonly ["temporary"];
+    videoCapabilities: undefined;
+})[];
 /** Default Widevine MediaKeySystemAccess configuration used by the RxPlayer. */
-export declare const defaultWidevineConfig: {
+export declare const defaultWidevineConfig: ({
     audioCapabilities: {
         contentType: string;
-        robustness: string;
     }[];
+    distinctiveIdentifier: "optional";
+    initDataTypes: readonly ["cenc"];
+    persistentState: "optional";
+    sessionTypes: readonly ["temporary"];
     videoCapabilities: {
         contentType: string;
-        robustness: string;
     }[];
+} | {
+    audioCapabilities: undefined;
     distinctiveIdentifier: "optional";
     initDataTypes: readonly ["cenc"];
     persistentState: "optional";
     sessionTypes: readonly ["temporary"];
-}[];
+    videoCapabilities: undefined;
+})[];
 /**
  * Custom implementation of an EME-compliant MediaKeyStatusMap.
  * @class MediaKeyStatusMapImpl
@@ -119,17 +138,17 @@ export declare function requestMediaKeySystemAccessImpl(keySystem: string, confi
  * Mock functions coming from the compat directory.
  */
 export declare function mockCompat(exportedFunctions?: {}): {
-    mockEvents: Record<string, jest.Mock<any, any>>;
+    mockEvents: Record<string, jest.Mock<any, any, any>>;
     eventTriggers: {
         triggerEncrypted(elt: HTMLMediaElement, value: unknown): void;
         triggerKeyMessage(session: MediaKeySessionImpl, value: unknown): void;
         triggerKeyError(session: MediaKeySessionImpl, value: unknown): void;
         triggerKeyStatusesChange(session: MediaKeySessionImpl, value: unknown): void;
     };
-    mockRequestMediaKeySystemAccess: jest.Mock<Promise<MediaKeySystemAccessImpl>, [keySystem: string, config: MediaKeySystemConfiguration[]]>;
-    mockGetInitData: jest.Mock<IEncryptedEventData, [encryptedEvent: IEncryptedEventData]>;
-    mockSetMediaKeys: jest.Mock<any, any>;
-    mockGenerateKeyRequest: jest.Mock<Promise<void>, [mks: MediaKeySessionImpl, initializationDataType: any, initializationData: any]>;
+    mockRequestMediaKeySystemAccess: jest.Mock<Promise<MediaKeySystemAccessImpl>, [keySystem: string, config: MediaKeySystemConfiguration[]], any>;
+    mockGetInitData: jest.Mock<IEncryptedEventData, [encryptedEvent: IEncryptedEventData], any>;
+    mockSetMediaKeys: jest.Mock<any, any, any>;
+    mockGenerateKeyRequest: jest.Mock<Promise<void>, [mks: MediaKeySessionImpl, initializationDataType: any, initializationData: any], any>;
 };
 /**
  * Check that the ContentDecryptor, when called with those arguments, throws.

package/dist/_esm5.processed/core/decrypt/__tests__/__global__/utils.js

@@ -44,7 +44,8 @@ import EventEmitter from "../../../../utils/event_emitter";
 import flatMap from "../../../../utils/flat_map";
 import { strToUtf8, utf8ToStr, } from "../../../../utils/string_parsing";
 /** Default MediaKeySystemAccess configuration used by the RxPlayer. */
-export var defaultKSConfig = [{
+export var defaultKSConfig = [
+    {
         audioCapabilities: [{ contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
             { contentType: "audio/webm;codecs=opus" }],
         distinctiveIdentifier: "optional",
@@ -54,12 +55,22 @@ export var defaultKSConfig = [{
         videoCapabilities: [{ contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
             { contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
             { contentType: "video/webm;codecs=\"vp8\"" }],
-    }];
+    },
+    {
+        audioCapabilities: undefined,
+        distinctiveIdentifier: "optional",
+        initDataTypes: ["cenc"],
+        persistentState: "optional",
+        sessionTypes: ["temporary"],
+        videoCapabilities: undefined,
+    },
+];
 /**
  * Default "com.microsoft.playready.recommendation" MediaKeySystemAccess
  * configuration used by the RxPlayer.
  */
-export var defaultPRRecommendationKSConfig = [{
+export var defaultPRRecommendationKSConfig = [
+    {
         audioCapabilities: [{ robustness: "3000",
                 contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
             { robustness: "3000",
@@ -84,7 +95,16 @@ export var defaultPRRecommendationKSConfig = [{
                 contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
             { robustness: "2000",
                 contentType: "video/webm;codecs=\"vp8\"" }],
-    }];
+    },
+    {
+        audioCapabilities: undefined,
+        distinctiveIdentifier: "optional",
+        initDataTypes: ["cenc"],
+        persistentState: "optional",
+        sessionTypes: ["temporary"],
+        videoCapabilities: undefined,
+    },
+];
 /** Default Widevine MediaKeySystemAccess configuration used by the RxPlayer. */
 export var defaultWidevineConfig = (function () {
     var ROBUSTNESSES = ["HW_SECURE_ALL",
@@ -101,9 +121,10 @@ export var defaultWidevineConfig = (function () {
         return [{ contentType: "audio/mp4;codecs=\"mp4a.40.2\"", robustness: robustness },
             { contentType: "audio/webm;codecs=opus", robustness: robustness }];
     });
-    return defaultKSConfig.map(function (conf) {
-        return __assign(__assign({}, conf), { audioCapabilities: audioCapabilities, videoCapabilities: videoCapabilities });
-    });
+    return [
+        __assign(__assign({}, defaultKSConfig[0]), { audioCapabilities: audioCapabilities, videoCapabilities: videoCapabilities }),
+        defaultKSConfig[1],
+    ];
 })();
 /**
  * Custom implementation of an EME-compliant MediaKeyStatusMap.

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

@@ -87,7 +87,7 @@ export default function attachMediaKeys(mediaElement, _a, cancelSignal) {
                     _b.sent();
                     // If this task has been cancelled while we were closing previous sessions,
                     // stop now (and thus avoid setting the new media keys);
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         throw cancelSignal.cancellationError;
                     }
                     MediaKeysInfosStore.setState(mediaElement, { keySystemOptions: keySystemOptions, mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, loadedSessionsStore: loadedSessionsStore });

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

@@ -614,7 +614,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
      * formatted and sent in an "error" event.
      */
     ContentDecryptor.prototype._onFatalError = function (err) {
-        if (this._canceller.isUsed) {
+        if (this._canceller.isUsed()) {
             return;
         }
         var formattedErr = err instanceof Error ?

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

@@ -13,6 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -130,7 +141,7 @@ function buildKeySystemConfigurations(ksName, ksType, keySystem) {
     if (keySystem.distinctiveIdentifierRequired === true) {
         distinctiveIdentifier = "required";
     }
-    var _a = config.getCurrent(), EME_DEFAULT_WIDEVINE_ROBUSTNESSES = _a.EME_DEFAULT_WIDEVINE_ROBUSTNESSES, EME_DEFAULT_PLAYREADY_ROBUSTNESSES = _a.EME_DEFAULT_PLAYREADY_ROBUSTNESSES;
+    var _a = config.getCurrent(), EME_DEFAULT_AUDIO_CODECS = _a.EME_DEFAULT_AUDIO_CODECS, EME_DEFAULT_VIDEO_CODECS = _a.EME_DEFAULT_VIDEO_CODECS, EME_DEFAULT_WIDEVINE_ROBUSTNESSES = _a.EME_DEFAULT_WIDEVINE_ROBUSTNESSES, EME_DEFAULT_PLAYREADY_ROBUSTNESSES = _a.EME_DEFAULT_PLAYREADY_ROBUSTNESSES;
     // Set robustness, in order of consideration:
     //   1. the user specified its own robustnesses
     //   2. a "widevine" key system is used, in that case set the default widevine
@@ -180,34 +191,32 @@ function buildKeySystemConfigurations(ksName, ksType, keySystem) {
     // https://storage.googleapis.com/wvdocs/Chrome_EME_Changes_and_Best_Practices.pdf
     // https://www.w3.org/TR/encrypted-media/#get-supported-configuration-and-consent
     var videoCapabilities = flatMap(videoRobustnesses, function (robustness) {
-        return ["video/mp4;codecs=\"avc1.4d401e\"",
-            "video/mp4;codecs=\"avc1.42e01e\"",
-            "video/webm;codecs=\"vp8\""].map(function (contentType) {
-            return robustness !== undefined ? { contentType: contentType, robustness: robustness } :
-                { contentType: contentType };
+        return EME_DEFAULT_VIDEO_CODECS.map(function (contentType) {
+            return robustness === undefined ? { contentType: contentType } :
+                { contentType: contentType, robustness: robustness };
         });
     });
     var audioCapabilities = flatMap(audioRobustnesses, function (robustness) {
-        return ["audio/mp4;codecs=\"mp4a.40.2\"",
-            "audio/webm;codecs=opus"].map(function (contentType) {
-            return robustness !== undefined ? { contentType: contentType, robustness: robustness } :
-                { contentType: contentType };
+        return EME_DEFAULT_AUDIO_CODECS.map(function (contentType) {
+            return robustness === undefined ? { contentType: contentType } :
+                { contentType: contentType, robustness: robustness };
         });
     });
-    // TODO Re-test with a set contentType but an undefined robustness on the
-    // STBs on which this problem was found.
-    //
-    // add another with no {audio,video}Capabilities for some legacy browsers.
-    // As of today's spec, this should return NotSupported but the first
-    // candidate configuration should be good, so we should have no downside
-    // doing that.
-    // initDataTypes: ["cenc"],
-    // videoCapabilities: undefined,
-    // audioCapabilities: undefined,
-    // distinctiveIdentifier,
-    // persistentState,
-    // sessionTypes,
-    return [{ initDataTypes: ["cenc"], videoCapabilities: videoCapabilities, audioCapabilities: audioCapabilities, distinctiveIdentifier: distinctiveIdentifier, persistentState: persistentState, sessionTypes: sessionTypes }];
+    var wantedMediaKeySystemConfiguration = {
+        initDataTypes: ["cenc"],
+        videoCapabilities: videoCapabilities,
+        audioCapabilities: audioCapabilities,
+        distinctiveIdentifier: distinctiveIdentifier,
+        persistentState: persistentState,
+        sessionTypes: sessionTypes,
+    };
+    return [
+        wantedMediaKeySystemConfiguration,
+        // Some legacy implementations have issues with `audioCapabilities` and
+        // `videoCapabilities`, so we're including a supplementary
+        // `MediaKeySystemConfiguration` without those properties.
+        __assign(__assign({}, wantedMediaKeySystemConfiguration), { audioCapabilities: undefined, videoCapabilities: undefined }),
+    ];
 }
 /**
  * Try to find a compatible key system from the keySystems array given.

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

@@ -86,12 +86,13 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
     log.info("DRM: Binding session events", session.sessionId);
     var _a = keySystemOptions.getLicenseConfig, getLicenseConfig = _a === void 0 ? {} : _a;
     /** Allows to manually cancel everything the `SessionEventsListener` is doing. */
-    var manualCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var manualCanceller = new TaskCanceller();
+    manualCanceller.linkToSignal(cancelSignal);
     if (!isNullOrUndefined(session.closed)) {
         session.closed
             .then(function () { return manualCanceller.cancel(); })
             .catch(function (err) {
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
                 return;
             }
             manualCanceller.cancel();
@@ -104,8 +105,8 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
     }, manualCanceller.signal);
     onKeyStatusesChange(session, function (keyStatusesEvent) {
         handleKeyStatusesChangeEvent(keyStatusesEvent).catch(function (error) {
-            if (cancelSignal.isCancelled ||
-                (manualCanceller.isUsed && error instanceof CancellationSignal)) {
+            if (cancelSignal.isCancelled() ||
+                (manualCanceller.isUsed() && error instanceof CancellationSignal)) {
                 return;
             }
             manualCanceller.cancel();
@@ -122,7 +123,7 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
         var backoffOptions = getLicenseBackoffOptions(getLicenseConfig.retry);
         retryPromiseWithBackoff(function () { return runGetLicense(message, messageType); }, backoffOptions, manualCanceller.signal)
             .then(function (licenseObject) {
-            if (manualCanceller.isUsed) {
+            if (manualCanceller.isUsed()) {
                 return Promise.resolve();
             }
             if (isNullOrUndefined(licenseObject)) {
@@ -133,7 +134,7 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
             }
         })
             .catch(function (err) {
-            if (manualCanceller.isUsed) {
+            if (manualCanceller.isUsed()) {
                 return;
             }
             manualCanceller.cancel();
@@ -150,6 +151,8 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
             callbacks.onError(formattedError);
         });
     }, manualCanceller.signal);
+    checkAndHandleCurrentKeyStatuses();
+    return;
     /**
      * @param {Event} keyStatusesEvent
      * @returns {Promise}
@@ -162,7 +165,7 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
                     return __generator(this, function (_a) {
                         switch (_a.label) {
                             case 0:
-                                if (manualCanceller.isUsed) {
+                                if (manualCanceller.isUsed()) {
                                     return [2 /*return*/];
                                 }
                                 if (!(typeof keySystemOptions.onKeyStatusesChange === "function")) return [3 /*break*/, 7];
@@ -173,13 +176,13 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
                                 return [4 /*yield*/, keySystemOptions.onKeyStatusesChange(keyStatusesEvent, session)];
                             case 2:
                                 ret = _a.sent();
-                                if (manualCanceller.isUsed) {
+                                if (manualCanceller.isUsed()) {
                                     return [2 /*return*/];
                                 }
                                 return [3 /*break*/, 4];
                             case 3:
                                 error_1 = _a.sent();
-                                if (cancelSignal.isCancelled) {
+                                if (cancelSignal.isCancelled()) {
                                     return [2 /*return*/];
                                 }
                                 err = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "Unknown `onKeyStatusesChange` error");
@@ -201,32 +204,13 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
                     });
                 });
             }
-            /**
-             * Check current MediaKeyStatus for each key in the given MediaKeySession and:
-             *   - throw if at least one status is a non-recoverable error
-             *   - call warning callback for recoverable errors
-             *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
-             */
-            function handleKeyStatusEvent() {
-                if (manualCanceller.isUsed || session.keyStatuses.size === 0) {
-                    return;
-                }
-                var _a = checkKeyStatuses(session, keySystemOptions, keySystem), warning = _a.warning, blacklistedKeyIds = _a.blacklistedKeyIds, whitelistedKeyIds = _a.whitelistedKeyIds;
-                if (warning !== undefined) {
-                    callbacks.onWarning(warning);
-                    if (manualCanceller.isUsed) {
-                        return;
-                    }
-                }
-                callbacks.onKeyUpdate({ whitelistedKeyIds: whitelistedKeyIds, blacklistedKeyIds: blacklistedKeyIds });
-            }
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         log.info("DRM: keystatuseschange event received", session.sessionId);
                         return [4 /*yield*/, Promise.all([
                                 runOnKeyStatusesChangeCallback(),
-                                Promise.resolve(handleKeyStatusEvent()),
+                                Promise.resolve(checkAndHandleCurrentKeyStatuses()),
                             ])];
                     case 1:
                         _a.sent();
@@ -235,36 +219,56 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
             });
         });
     }
+    /**
+     * Check current MediaKeyStatus for each key in the given MediaKeySession and:
+     *   - throw if at least one status is a non-recoverable error
+     *   - call warning callback for recoverable errors
+     *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
+     */
+    function checkAndHandleCurrentKeyStatuses() {
+        if (manualCanceller.isUsed() || session.keyStatuses.size === 0) {
+            return;
+        }
+        var _a = checkKeyStatuses(session, keySystemOptions, keySystem), warning = _a.warning, blacklistedKeyIds = _a.blacklistedKeyIds, whitelistedKeyIds = _a.whitelistedKeyIds;
+        if (warning !== undefined) {
+            callbacks.onWarning(warning);
+            if (manualCanceller.isUsed()) {
+                return;
+            }
+        }
+        callbacks.onKeyUpdate({ whitelistedKeyIds: whitelistedKeyIds, blacklistedKeyIds: blacklistedKeyIds });
+    }
     function runGetLicense(message, messageType) {
+        var timeoutId;
         return new Promise(function (res, rej) {
-            log.debug("DRM: Calling `getLicense`", messageType);
-            var getLicense = keySystemOptions.getLicense(message, messageType);
-            var getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
-                10 * 1000 :
-                getLicenseConfig.timeout;
-            var timeoutId;
-            if (getLicenseTimeout >= 0) {
-                timeoutId = setTimeout(function () {
-                    rej(new GetLicenseTimeoutError("\"getLicense\" timeout exceeded (".concat(getLicenseTimeout, " ms)")));
-                }, getLicenseTimeout);
-            }
             try {
-                Promise.resolve(getLicense).then(function (val) {
-                    clearTimeoutIfOne();
-                    res(val);
-                }, function (err) {
-                    clearTimeoutIfOne();
-                    rej(err);
-                });
+                log.debug("DRM: Calling `getLicense`", messageType);
+                var getLicense = keySystemOptions.getLicense(message, messageType);
+                var getLicenseTimeout_1 = isNullOrUndefined(getLicenseConfig.timeout) ?
+                    10 * 1000 :
+                    getLicenseConfig.timeout;
+                if (getLicenseTimeout_1 >= 0) {
+                    timeoutId = setTimeout(function () {
+                        rej(new GetLicenseTimeoutError("\"getLicense\" timeout exceeded (".concat(getLicenseTimeout_1, " ms)")));
+                    }, getLicenseTimeout_1);
+                }
+                Promise.resolve(getLicense)
+                    .then(clearTimeoutAndResolve, clearTimeoutAndReject);
             }
             catch (err) {
-                clearTimeoutIfOne();
-                rej(err);
+                clearTimeoutAndReject(err);
             }
-            function clearTimeoutIfOne() {
+            function clearTimeoutAndResolve(data) {
                 if (timeoutId !== undefined) {
                     clearTimeout(timeoutId);
                 }
+                res(data);
+            }
+            function clearTimeoutAndReject(err) {
+                if (timeoutId !== undefined) {
+                    clearTimeout(timeoutId);
+                }
+                rej(err);
             }
         });
     }

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

@@ -40,6 +40,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 /* eslint-disable-next-line max-len */
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
+import log from "../../../log";
 import assertUnreachable from "../../../utils/assert_unreachable";
 import { bytesToHex } from "../../../utils/string_parsing";
 /**
@@ -95,6 +96,9 @@ export default function checkKeyStatuses(session, options, keySystem) {
         })(), keyStatus = _a[0], keyStatusKeyId = _a[1];
         var keyId = getUUIDKidFromKeyStatusKID(keySystem, new Uint8Array(keyStatusKeyId));
         var keyStatusObj = { keyId: keyId.buffer, keyStatus: keyStatus };
+        if (log.hasLevel("DEBUG")) {
+            log.debug("DRM: key status update (".concat(bytesToHex(keyId), "): ").concat(keyStatus));
+        }
         switch (keyStatus) {
             case KEY_STATUSES.EXPIRED: {
                 var error = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "A decryption key expired (".concat(bytesToHex(keyId), ")"), { keyStatuses: __spreadArray([keyStatusObj], badKeyStatuses, true) });

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

@@ -14,17 +14,20 @@
  * limitations under the License.
  */
 import { ICdnMetadata } from "../../parsers/manifest";
-import { IPlayerError } from "../../public_types";
 import EventEmitter from "../../utils/event_emitter";
 import { CancellationSignal } from "../../utils/task_canceller";
 /**
- * Class signaling the priority between multiple CDN available for any given
- * resource.
+ * Class storing and signaling the priority between multiple CDN available for
+ * any given resource.
  *
- * This class might perform requests and schedule timeouts by itself to keep its
- * internal list of CDN priority up-to-date.
- * When it is not needed anymore, you should call the `dispose` method to clear
- * all resources.
+ * This class was first created to implement the complexities behind
+ * Content Steering features, though its handling hasn't been added yet as we
+ * wait for its specification to be both standardized and relied on in the wild.
+ * In the meantime, it acts as an abstraction for the simple concept of
+ * avoiding to request a CDN for any segment when an issue is encountered with
+ * one (e.g. HTTP 500 statuses) and several CDN exist for a given resource. It
+ * should be noted that this is also one of the planified features of the
+ * Content Steering specification.
  *
  * @class CdnPrioritizer
  */
@@ -92,7 +95,13 @@ export default class CdnPrioritizer extends EventEmitter<ICdnPrioritizerEvents>
      */
     private _removeIndexFromDowngradeList;
 }
+/** Events sent by a `CdnPrioritizer` */
 export interface ICdnPrioritizerEvents {
-    warnings: IPlayerError[];
+    /**
+     * The priority of one or several CDN changed.
+     *
+     * You might want to re-check if a CDN should still be used when this event
+     * is triggered.
+     */
     priorityChange: null;
 }

package/dist/_esm5.processed/core/fetchers/cdn_prioritizer.js

@@ -32,13 +32,17 @@ import config from "../../config";
 import arrayFindIndex from "../../utils/array_find_index";
 import EventEmitter from "../../utils/event_emitter";
 /**
- * Class signaling the priority between multiple CDN available for any given
- * resource.
+ * Class storing and signaling the priority between multiple CDN available for
+ * any given resource.
  *
- * This class might perform requests and schedule timeouts by itself to keep its
- * internal list of CDN priority up-to-date.
- * When it is not needed anymore, you should call the `dispose` method to clear
- * all resources.
+ * This class was first created to implement the complexities behind
+ * Content Steering features, though its handling hasn't been added yet as we
+ * wait for its specification to be both standardized and relied on in the wild.
+ * In the meantime, it acts as an abstraction for the simple concept of
+ * avoiding to request a CDN for any segment when an issue is encountered with
+ * one (e.g. HTTP 500 statuses) and several CDN exist for a given resource. It
+ * should be noted that this is also one of the planified features of the
+ * Content Steering specification.
  *
  * @class CdnPrioritizer
  */

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

@@ -145,7 +145,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
         manifestProm
             .then(function (val) {
             _this.trigger("manifestReady", val.manifest);
-            if (!_this._canceller.isUsed) {
+            if (!_this._canceller.isUsed()) {
                 _this._recursivelyRefreshManifest(val.manifest, val);
             }
         })
@@ -311,7 +311,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
             function onWarnings(warnings) {
                 for (var _i = 0, warnings_1 = warnings; _i < warnings_1.length; _i++) {
                     var warning = warnings_1[_i];
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return;
                     }
                     var formattedError = formatError(warning, {
@@ -430,7 +430,8 @@ var ManifestFetcher = /** @class */ (function (_super) {
          * be effectively considered.
          * `nextRefreshCanceller` will allow to cancel every other when one is triggered.
          */
-        var nextRefreshCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+        var nextRefreshCanceller = new TaskCanceller();
+        nextRefreshCanceller.linkToSignal(this._canceller.signal);
         /* Function to manually schedule a Manifest refresh */
         this.scheduleManualRefresh = function (settings) {
             var enablePartialRefresh = settings.enablePartialRefresh, delay = settings.delay, canUseUnsafeMode = settings.canUseUnsafeMode;
@@ -603,7 +604,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
         });
     };
     ManifestFetcher.prototype._onFatalError = function (err) {
-        if (this._canceller.isUsed) {
+        if (this._canceller.isUsed()) {
             return;
         }
         this.trigger("error", err);

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

@@ -26,10 +26,22 @@ import CdnPrioritizer from "../cdn_prioritizer";
  * An `ISegmentFetcher` also implements a retry mechanism, based on the given
  * `options` argument, which may retry a segment request when it fails.
  *
- * @param {string} bufferType
- * @param {Object} pipeline
- * @param {Object} lifecycleCallbacks
- * @param {Object} options
+ * @param {string} bufferType - Type of  buffer concerned (e.g. `"audio"`,
+ * `"video"`, `"text" etc.)
+ * @param {Object} pipeline - The transport-specific logic allowing to load
+ * segments of the given buffer type and transport protocol (e.g. DASH).
+ * @param {Object|null} cdnPrioritizer - Abstraction allowing to synchronize,
+ * update and keep track of the priorization of the CDN to use to load any given
+ * segment, in cases where multiple ones are available.
+ *
+ * Can be set to `null` in which case a minimal priorization logic will be used
+ * instead.
+ * @param {Object} lifecycleCallbacks - Callbacks that can be registered to be
+ * informed when new requests are made, ended, new metrics are available etc.
+ * This should be mainly useful to implement an adaptive logic relying on those
+ * metrics and events.
+ * @param {Object} options - Various tweaking options allowing to configure the
+ * behavior of the returned `ISegmentFetcher`.
  * @returns {Function}
  */
 export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(bufferType: IBufferType, pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>, cdnPrioritizer: CdnPrioritizer | null, lifecycleCallbacks: ISegmentFetcherLifecycleCallbacks, options: ISegmentFetcherOptions): ISegmentFetcher<TSegmentDataType>;
@@ -59,10 +71,15 @@ export interface ISegmentFetcherCallbacks<TSegmentDataType> {
     /**
      * Callback called when all decodable chunks of the loaded segment have been
      * communicated through the `onChunk` callback.
+     *
+     * This callback is called before the corresponding `ISegmentFetcher`'s
+     * returned Promise is resolved.
      */
     onAllChunksReceived(): void;
     /**
-     * Callback called when the segment request has to restart from scratch. */
+     * Callback called when the segment request has to restart from scratch, e.g.
+     * due to a request error.
+     */
     onRetry(error: IPlayerError): void;
 }
 /** Content used by the segment loader as a context to load a new segment. */