rx-player 3.33.2 → 3.33.3

package/VERSION

@@ -1 +1 @@
-3.33.2
+3.33.3

package/dist/_esm5.processed/compat/can_rely_on_request_media_key_system_access.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * This functions tells if the RxPlayer can trust the browser when it has
+ * successfully granted the MediaKeySystemAccess with
+ * `navigator.requestMediaKeySystemAccess(keySystem)` function, or if it should do
+ * some additional testing to confirm that the `keySystem` is supported on the device.
+ *
+ * This behavior has been experienced on the following device:
+ *
+ * On a Microsoft Surface with Edge v.124:
+ * - Althought `requestMediaKeySystemAccess` resolve correctly with the keySystem
+ *   "com.microsoft.playready.recommendation.3000", generating a request with
+ *   `generateRequest` throws an error: "NotSupportedError: Failed to execute
+ *   'generateRequest' on 'MediaKeySession': Failed to create MF PR CdmSession".
+ *   In this particular case, the work-around was to consider
+ *   recommendation.3000 as not supported and try another keySystem.
+ * @param keySystem - The key system in use.
+ * @returns {boolean}
+ */
+export declare function canRelyOnRequestMediaKeySystemAccess(keySystem: string): boolean;

package/dist/_esm5.processed/compat/can_rely_on_request_media_key_system_access.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { isEdgeChromium } from "./browser_detection";
+/**
+ * This functions tells if the RxPlayer can trust the browser when it has
+ * successfully granted the MediaKeySystemAccess with
+ * `navigator.requestMediaKeySystemAccess(keySystem)` function, or if it should do
+ * some additional testing to confirm that the `keySystem` is supported on the device.
+ *
+ * This behavior has been experienced on the following device:
+ *
+ * On a Microsoft Surface with Edge v.124:
+ * - Althought `requestMediaKeySystemAccess` resolve correctly with the keySystem
+ *   "com.microsoft.playready.recommendation.3000", generating a request with
+ *   `generateRequest` throws an error: "NotSupportedError: Failed to execute
+ *   'generateRequest' on 'MediaKeySession': Failed to create MF PR CdmSession".
+ *   In this particular case, the work-around was to consider
+ *   recommendation.3000 as not supported and try another keySystem.
+ * @param keySystem - The key system in use.
+ * @returns {boolean}
+ */
+export function canRelyOnRequestMediaKeySystemAccess(keySystem) {
+    if (isEdgeChromium && keySystem.indexOf("playready") !== -1) {
+        return false;
+    }
+    return true;
+}

package/dist/_esm5.processed/compat/generate_init_data.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The PlayReadyHeader sample that will be used to test if the CDM is supported.
+ * The KID does not matter because no content will be played, it's only to check if
+ * the CDM is capable of creating a session and generating a request.
+ */
+export declare const DUMMY_PLAY_READY_HEADER = "<WRMHEADER xmlns=\"http://schemas.microsoft.com/DRM/2007/03/PlayReadyHeader\" version=\"4.0.0.0\"><DATA><PROTECTINFO><KEYLEN>16</KEYLEN><ALGID>AESCTR</ALGID></PROTECTINFO><KID>ckB07BNLskeUq0qd83fTbA==</KID><DS_ID>yYIPDBca1kmMfL60IsfgAQ==</DS_ID><CUSTOMATTRIBUTES xmlns=\"\"><encryptionref>312_4024_2018127108</encryptionref></CUSTOMATTRIBUTES><CHECKSUM>U/tsUYRgMzw=</CHECKSUM></DATA></WRMHEADER>";
+/**
+ * Generate the "cenc" init data for playready from the PlayreadyHeader string.
+ * @param {string} playreadyHeader - String representing the PlayreadyHeader XML.
+ * @returns {Uint8Array} The init data generated for that PlayreadyHeader.
+ * @see https://learn.microsoft.com/en-us/playready/specifications/playready-hea
+ * der-specification
+ */
+export declare function generatePlayReadyInitData(playreadyHeader: string): Uint8Array;

package/dist/_esm5.processed/compat/generate_init_data.js

@@ -0,0 +1,61 @@
+import { itole4, itobe4, itole2, concat } from "../utils/byte_parsing";
+import { strToUtf8, strToUtf16LE, hexToBytes } from "../utils/string_parsing";
+/**
+ * The PlayReadyHeader sample that will be used to test if the CDM is supported.
+ * The KID does not matter because no content will be played, it's only to check if
+ * the CDM is capable of creating a session and generating a request.
+ */
+export var DUMMY_PLAY_READY_HEADER = 
+/* eslint-disable-next-line max-len */
+"<WRMHEADER xmlns=\"http://schemas.microsoft.com/DRM/2007/03/PlayReadyHeader\" version=\"4.0.0.0\"><DATA><PROTECTINFO><KEYLEN>16</KEYLEN><ALGID>AESCTR</ALGID></PROTECTINFO><KID>ckB07BNLskeUq0qd83fTbA==</KID><DS_ID>yYIPDBca1kmMfL60IsfgAQ==</DS_ID><CUSTOMATTRIBUTES xmlns=\"\"><encryptionref>312_4024_2018127108</encryptionref></CUSTOMATTRIBUTES><CHECKSUM>U/tsUYRgMzw=</CHECKSUM></DATA></WRMHEADER>";
+/**
+ * Generate the "cenc" init data for playready from the PlayreadyHeader string.
+ * @param {string} playreadyHeader - String representing the PlayreadyHeader XML.
+ * @returns {Uint8Array} The init data generated for that PlayreadyHeader.
+ * @see https://learn.microsoft.com/en-us/playready/specifications/playready-hea
+ * der-specification
+ */
+export function generatePlayReadyInitData(playreadyHeader) {
+    var recordValueEncoded = strToUtf16LE(playreadyHeader);
+    var recordLength = itole2(recordValueEncoded.length);
+    // RecordType: 0x0001	Indicates that the record contains a PlayReady Header (PRH).
+    var recordType = new Uint8Array([1, 0]);
+    var numberOfObjects = new Uint8Array([1, 0]); // 1 PlayReady object
+    /* playReadyObjectLength equals = X bytes for record + 2 bytes for record length,
+    + 2 bytes for record types + 2 bytes for number of object  */
+    var playReadyObjectLength = itole4(recordValueEncoded.length + 6);
+    var playReadyObject = concat(playReadyObjectLength, // 4 bytes for the Playready object length
+    numberOfObjects, // 2 bytes for the number of PlayReady objects
+    recordType, // 2 bytes for record type
+    recordLength, // 2 bytes for record length
+    recordValueEncoded // X bytes for record value
+    );
+    /**  the systemId is define at https://dashif.org/identifiers/content_protection/ */
+    var playreadySystemId = hexToBytes("9a04f07998404286ab92e65be0885f95");
+    return generateInitData(playReadyObject, playreadySystemId);
+}
+/**
+ * Generate the "cenc" initData given the data and the systemId to use.
+ * Note this will generate an initData for version 0 of pssh.
+ * @param data - The data that is contained inside the pssh.
+ * @param systemId - The systemId to use.
+ * @returns
+ */
+function generateInitData(data, systemId) {
+    var psshBoxName = strToUtf8("pssh");
+    var versionAndFlags = new Uint8Array([0, 0, 0, 0]); // pssh version 0
+    var sizeOfData = itobe4(data.length);
+    var psshSize = itobe4(4 /* pssh size */ +
+        4 /* pssh box */ +
+        4 /* version and flags */ +
+        16 /* systemId */ +
+        4 /* size of data */ +
+        data.length /* data */);
+    return concat(psshSize, // 4 bytes for the pssh size
+    psshBoxName, // 4 bytes for the pssh box
+    versionAndFlags, // 4 bytes for version and flags
+    systemId, // 16 bytes for the systemId
+    sizeOfData, // 4 bytes for the data size
+    data // X bytes for data
+    );
+}

package/dist/_esm5.processed/compat/may_media_element_fail_on_undecipherable_data.d.ts

@@ -0,0 +1,16 @@
+/**
+ * We noticed that the PlayStation 5 may have the HTMLMediaElement on which the
+ * content is played stop on a `MEDIA_ERR_DECODE` error if it encounters
+ * encrypted media data whose key is not usable due to policy restrictions (the
+ * most usual issue being non-respect of HDCP restrictions).
+ *
+ * This is not an usual behavior, other platforms just do not attempt to decode
+ * the encrypted media data and stall the playback instead (which is a much
+ * preferable behavior for us as we have some advanced mechanism to restart
+ * playback when this happens).
+ *
+ * Consequently, we have to specifically consider platforms with that
+ * fail-on-undecipherable-data issue, to perform a work-around in that case.
+ */
+declare const mayMediaElementFailOnUndecipherableData: boolean;
+export default mayMediaElementFailOnUndecipherableData;

package/dist/_esm5.processed/compat/may_media_element_fail_on_undecipherable_data.js

@@ -0,0 +1,17 @@
+import { isPlayStation5 } from "./browser_detection";
+/**
+ * We noticed that the PlayStation 5 may have the HTMLMediaElement on which the
+ * content is played stop on a `MEDIA_ERR_DECODE` error if it encounters
+ * encrypted media data whose key is not usable due to policy restrictions (the
+ * most usual issue being non-respect of HDCP restrictions).
+ *
+ * This is not an usual behavior, other platforms just do not attempt to decode
+ * the encrypted media data and stall the playback instead (which is a much
+ * preferable behavior for us as we have some advanced mechanism to restart
+ * playback when this happens).
+ *
+ * Consequently, we have to specifically consider platforms with that
+ * fail-on-undecipherable-data issue, to perform a work-around in that case.
+ */
+var mayMediaElementFailOnUndecipherableData = isPlayStation5;
+export default mayMediaElementFailOnUndecipherableData;

package/dist/_esm5.processed/compat/should_wait_for_data_before_loaded.d.ts

@@ -21,4 +21,4 @@
  * @param {Boolean} isDirectfile
  * @returns {Boolean}
  */
-export default function shouldWaitForDataBeforeLoaded(isDirectfile: boolean, mustPlayInline: boolean): boolean;
+export default function shouldWaitForDataBeforeLoaded(isDirectfile: boolean): boolean;

package/dist/_esm5.processed/compat/should_wait_for_data_before_loaded.js

@@ -22,9 +22,11 @@ import { isSafariMobile } from "./browser_detection";
  * @param {Boolean} isDirectfile
  * @returns {Boolean}
  */
-export default function shouldWaitForDataBeforeLoaded(isDirectfile, mustPlayInline) {
+export default function shouldWaitForDataBeforeLoaded(isDirectfile) {
     if (isDirectfile && isSafariMobile) {
-        return mustPlayInline;
+        return false;
+    }
+    else {
+        return true;
     }
-    return true;
 }

package/dist/_esm5.processed/config.d.ts

@@ -121,6 +121,8 @@ declare class ConfigHandler {
         UNFREEZING_SEEK_DELAY: number;
         FREEZING_STALLED_DELAY: number;
         UNFREEZING_DELTA_POSITION: number;
+        SEGMENT_SYNCHRONIZATION_DELAY: number;
+        MISSING_DATA_TRIGGER_SYNC_DELAY: number;
         MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT: number;
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE: number;
         MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE: number;

package/dist/_esm5.processed/core/adaptive/adaptive_representation_selector.js

@@ -222,7 +222,7 @@ function getEstimateReference(_a, stopAllEstimates) {
                 var manualRepresentation = selectOptimalRepresentation(representations, manualBitrateVal, 0, Infinity);
                 return {
                     representation: manualRepresentation,
-                    bitrate: undefined,
+                    bitrate: undefined, // Bitrate estimation is deactivated here
                     knownStableBitrate: undefined,
                     manual: true,
                     urgent: true, // a manual bitrate switch should happen immediately

package/dist/_esm5.processed/core/api/debug/buffer_graph.js

@@ -4,9 +4,9 @@ var COLORS = [
     "#fed766",
     "#4dd248",
     "#a22c28",
-    "#556b2f",
-    "#add8e6",
-    "#90ee90",
+    "#556b2f", // darkolivegreen
+    "#add8e6", // lightblue
+    "#90ee90", // lightgreen
     "#444444",
     "#40bfc1",
     "#57557e",

package/dist/_esm5.processed/core/api/public_api.d.ts

@@ -30,6 +30,12 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
     static version: string;
     /** Current version of the RxPlayer.  */
     readonly version: string;
+    /**
+     * Store all video elements currently in use by an RxPlayer instance.
+     * This is used to check that a video element is not shared between multiple instances.
+     * Use of a WeakSet ensure the object is garbage collected if it's not used anymore.
+     */
+    private static _priv_currentlyUsedVideoElements;
     /**
      * Media element attached to the RxPlayer.
      * Set to `null` when the RxPlayer is disposed.
@@ -132,6 +138,17 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * @param {Array.<Object>} featureList - Features wanted.
      */
     static addFeatures(featureList: IFeature[]): void;
+    /**
+     * Register the video element to the set of elements currently in use.
+     * @param videoElement the video element to register.
+     * @throws Error - Throws if the element is already used by another player instance.
+     */
+    private static _priv_registerVideoElement;
+    /**
+     * Deregister the video element of the set of elements currently in use.
+     * @param videoElement the video element to deregister.
+     */
+    static _priv_deregisterVideoElement(videoElement: HTMLMediaElement): void;
     /**
      * @constructor
      * @param {Object} options

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

@@ -88,10 +88,11 @@ var Player = /** @class */ (function (_super) {
         // Workaround to support Firefox autoplay on FF 42.
         // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
         videoElement.preload = "auto";
-        _this.version = /* PLAYER_VERSION */ "3.33.2";
+        _this.version = /* PLAYER_VERSION */ "3.33.3";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
+        Player._priv_registerVideoElement(_this.videoElement);
         var destroyCanceller = new TaskCanceller();
         _this._destroyCanceller = destroyCanceller;
         _this._priv_pictureInPictureRef = getPictureOnPictureStateRef(videoElement, destroyCanceller.signal);
@@ -218,6 +219,37 @@ var Player = /** @class */ (function (_super) {
     Player.addFeatures = function (featureList) {
         addFeatures(featureList);
     };
+    /**
+     * Register the video element to the set of elements currently in use.
+     * @param videoElement the video element to register.
+     * @throws Error - Throws if the element is already used by another player instance.
+     */
+    Player._priv_registerVideoElement = function (videoElement) {
+        if (Player._priv_currentlyUsedVideoElements.has(videoElement)) {
+            var errorMessage = "The video element is already attached to another RxPlayer instance." +
+                "\nMake sure to dispose the previous instance with player.dispose() " +
+                "before creating a new player instance attaching that video element.";
+            // eslint-disable-next-line no-console
+            console.warn(errorMessage);
+            /*
+             * TODO: for next major version 5.0: this need to throw an error instead
+             * of just logging this was not done for minor version as it could be
+             * considerated a breaking change.
+             *
+             * throw new Error(errorMessage);
+             */
+        }
+        Player._priv_currentlyUsedVideoElements.add(videoElement);
+    };
+    /**
+     * Deregister the video element of the set of elements currently in use.
+     * @param videoElement the video element to deregister.
+     */
+    Player._priv_deregisterVideoElement = function (videoElement) {
+        if (Player._priv_currentlyUsedVideoElements.has(videoElement)) {
+            Player._priv_currentlyUsedVideoElements.delete(videoElement);
+        }
+    };
     /**
      * Register a new callback for a player event event.
      *
@@ -253,6 +285,7 @@ var Player = /** @class */ (function (_super) {
         // free resources linked to the loaded content
         this.stop();
         if (this.videoElement !== null) {
+            Player._priv_deregisterVideoElement(this.videoElement);
             // free resources used for decryption management
             disposeDecryptionResources(this.videoElement)
                 .catch(function (err) {
@@ -2470,7 +2503,13 @@ var Player = /** @class */ (function (_super) {
         });
         return mediaElementTrackChoiceManager;
     };
+    /**
+     * Store all video elements currently in use by an RxPlayer instance.
+     * This is used to check that a video element is not shared between multiple instances.
+     * Use of a WeakSet ensure the object is garbage collected if it's not used anymore.
+     */
+    Player._priv_currentlyUsedVideoElements = new WeakSet();
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.33.2";
+Player.version = /* PLAYER_VERSION */ "3.33.3";
 export default Player;

package/dist/_esm5.processed/core/api/tracks_management/media_element_track_choice_manager.js

@@ -64,20 +64,20 @@ function createAudioTracks(audioTracks) {
     var languagesOccurences = {};
     for (var i = 0; i < audioTracks.length; i++) {
         var audioTrack = audioTracks[i];
-        var language = audioTrack.language === "" ? "nolang" :
-            audioTrack.language;
+        var language = audioTrack.language === "" ? "nolang" : audioTrack.language;
         var occurences = (_a = languagesOccurences[language]) !== null && _a !== void 0 ? _a : 1;
-        var id = "gen_audio_" +
-            language +
-            "_" +
-            occurences.toString();
+        var id = "gen_audio_" + language + "_" + occurences.toString();
         languagesOccurences[language] = occurences + 1;
-        var track = { language: audioTrack.language, id: id, normalized: normalizeLanguage(audioTrack.language),
+        var track = {
+            language: audioTrack.language,
+            id: id,
+            normalized: normalizeLanguage(audioTrack.language),
             audioDescription: audioTrack.kind === "descriptions" ||
                 // Safari seem to prefer the non-standard singular
                 // version, funnily enough
                 audioTrack.kind === "description",
-            representations: [] };
+            representations: [],
+        };
         newAudioTracks.push({ track: track, nativeTrack: audioTrack });
     }
     return newAudioTracks;
@@ -93,23 +93,23 @@ function createTextTracks(textTracks) {
     var languagesOccurences = {};
     for (var i = 0; i < textTracks.length; i++) {
         var textTrack = textTracks[i];
-        var language = textTrack.language === "" ? "nolang" :
-            textTrack.language;
+        var language = textTrack.language === "" ? "nolang" : textTrack.language;
         var occurences = (_a = languagesOccurences[language]) !== null && _a !== void 0 ? _a : 1;
-        var id = "gen_text_" +
-            language +
-            "_" +
-            occurences.toString();
+        var id = "gen_text_" + language + "_" + occurences.toString();
         languagesOccurences[language] = occurences + 1;
         // Safari seems to be indicating that the subtitles track is a forced
         // subtitles track by setting the `kind` attribute to `"forced"`.
         // As of now (2023-04-04), this is not standard.
         // @see https://github.com/whatwg/html/issues/4472
-        var forced = textTrack.kind === "forced" ?
-            true :
-            undefined;
-        var track = { language: textTrack.language, forced: forced, label: textTrack.label, id: id, normalized: normalizeLanguage(textTrack.language),
-            closedCaption: textTrack.kind === "captions" };
+        var forced = textTrack.kind === "forced" ? true : undefined;
+        var track = {
+            language: textTrack.language,
+            forced: forced,
+            label: textTrack.label,
+            id: id,
+            normalized: normalizeLanguage(textTrack.language),
+            closedCaption: textTrack.kind === "captions",
+        };
         newTextTracks.push({ track: track, nativeTrack: textTrack });
     }
     return newTextTracks;
@@ -125,13 +125,9 @@ function createVideoTracks(videoTracks) {
     var languagesOccurences = {};
     for (var i = 0; i < videoTracks.length; i++) {
         var videoTrack = videoTracks[i];
-        var language = videoTrack.language === "" ? "nolang" :
-            videoTrack.language;
+        var language = videoTrack.language === "" ? "nolang" : videoTrack.language;
         var occurences = (_a = languagesOccurences[language]) !== null && _a !== void 0 ? _a : 1;
-        var id = "gen_video_" +
-            language +
-            "_" +
-            occurences.toString();
+        var id = "gen_video_" + language + "_" + occurences.toString();
         languagesOccurences[language] = occurences + 1;
         newVideoTracks.push({ track: { id: id, representations: [] },
             nativeTrack: videoTrack });

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

@@ -77,12 +77,12 @@ export function disableMediaKeys(mediaElement) {
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function attachMediaKeys(mediaElement, _a, cancelSignal) {
-    var emeImplementation = _a.emeImplementation, keySystemOptions = _a.keySystemOptions, loadedSessionsStore = _a.loadedSessionsStore, mediaKeySystemAccess = _a.mediaKeySystemAccess, mediaKeys = _a.mediaKeys;
-    return __awaiter(this, void 0, void 0, function () {
+export default function attachMediaKeys(mediaElement_1, _a, cancelSignal_1) {
+    return __awaiter(this, arguments, void 0, function (mediaElement, _b, cancelSignal) {
         var previousState, closeAllSessions;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var emeImplementation = _b.emeImplementation, keySystemOptions = _b.keySystemOptions, loadedSessionsStore = _b.loadedSessionsStore, mediaKeySystemAccess = _b.mediaKeySystemAccess, mediaKeys = _b.mediaKeys;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     previousState = MediaKeysInfosStore.getState(mediaElement);
                     closeAllSessions = previousState !== null &&
@@ -91,7 +91,7 @@ export default function attachMediaKeys(mediaElement, _a, cancelSignal) {
                         Promise.resolve();
                     return [4 /*yield*/, closeAllSessions];
                 case 1:
-                    _b.sent();
+                    _c.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()) {

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

@@ -46,3 +46,13 @@ export type IFoundMediaKeySystemAccessEvent = IReuseMediaKeySystemAccessEvent |
  * @returns {Promise.<Object>}
  */
 export default function getMediaKeySystemAccess(mediaElement: HTMLMediaElement, keySystemsConfigs: IKeySystemOption[], cancelSignal: CancellationSignal): Promise<IFoundMediaKeySystemAccessEvent>;
+/**
+ * Test a key system configuration, resolves with the MediaKeySystemAccess
+ * or reject if the key system is unsupported.
+ * @param {string} keyType - The KeySystem string to test
+ * (ex: com.microsoft.playready.recommendation)
+ * @param {Array.<MediaKeySystemMediaCapability>} keySystemConfigurations -
+ * Configurations for this keySystem
+ * @returns Promise resolving with the MediaKeySystemAccess. Rejects if unsupported.
+ */
+export declare function testKeySystem(keyType: string, keySystemConfigurations: MediaKeySystemConfiguration[]): Promise<MediaKeySystemAccess | import("../../compat/eme/custom_key_system_access").default>;

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

@@ -61,7 +61,9 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { shouldRenewMediaKeySystemAccess, } from "../../compat";
+import { canRelyOnRequestMediaKeySystemAccess, } from "../../compat/can_rely_on_request_media_key_system_access";
 import eme from "../../compat/eme";
+import { generatePlayReadyInitData, DUMMY_PLAY_READY_HEADER, } from "../../compat/generate_init_data";
 import config from "../../config";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
@@ -311,7 +313,7 @@ export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs,
                         _b.label = 1;
                     case 1:
                         _b.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, eme.requestMediaKeySystemAccess(keyType, keySystemConfigurations)];
+                        return [4 /*yield*/, testKeySystem(keyType, keySystemConfigurations)];
                     case 2:
                         keySystemAccess = _b.sent();
                         log.info("DRM: Found compatible keysystem", keyType, index + 1);
@@ -331,3 +333,42 @@ export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs,
         });
     }
 }
+/**
+ * Test a key system configuration, resolves with the MediaKeySystemAccess
+ * or reject if the key system is unsupported.
+ * @param {string} keyType - The KeySystem string to test
+ * (ex: com.microsoft.playready.recommendation)
+ * @param {Array.<MediaKeySystemMediaCapability>} keySystemConfigurations -
+ * Configurations for this keySystem
+ * @returns Promise resolving with the MediaKeySystemAccess. Rejects if unsupported.
+ */
+export function testKeySystem(keyType, keySystemConfigurations) {
+    return __awaiter(this, void 0, void 0, function () {
+        var keySystemAccess, mediaKeys, session, initData, err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, eme.requestMediaKeySystemAccess(keyType, keySystemConfigurations)];
+                case 1:
+                    keySystemAccess = _a.sent();
+                    if (!!canRelyOnRequestMediaKeySystemAccess(keyType)) return [3 /*break*/, 6];
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 5, , 6]);
+                    return [4 /*yield*/, keySystemAccess.createMediaKeys()];
+                case 3:
+                    mediaKeys = _a.sent();
+                    session = mediaKeys.createSession();
+                    initData = generatePlayReadyInitData(DUMMY_PLAY_READY_HEADER);
+                    return [4 /*yield*/, session.generateRequest("cenc", initData)];
+                case 4:
+                    _a.sent();
+                    return [3 /*break*/, 6];
+                case 5:
+                    err_1 = _a.sent();
+                    log.debug("DRM: KeySystemAccess was granted but it is not usable");
+                    throw err_1;
+                case 6: return [2 /*return*/, keySystemAccess];
+            }
+        });
+    });
+}

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

@@ -360,7 +360,7 @@ function updateSessionWithMessage(session, message) {
 var BlacklistedSessionError = /** @class */ (function (_super) {
     __extends(BlacklistedSessionError, _super);
     function BlacklistedSessionError(sessionError) {
-        var _this = _super.call(this) || this;
+        var _this = _super.call(this, sessionError.message) || this;
         // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
         Object.setPrototypeOf(_this, BlacklistedSessionError.prototype);
         _this.sessionError = sessionError;
@@ -377,7 +377,7 @@ export { BlacklistedSessionError };
 var GetLicenseTimeoutError = /** @class */ (function (_super) {
     __extends(GetLicenseTimeoutError, _super);
     function GetLicenseTimeoutError(message) {
-        var _this = _super.call(this) || this;
+        var _this = _super.call(this, message) || this;
         // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
         Object.setPrototypeOf(_this, BlacklistedSessionError.prototype);
         _this.message = message;

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

@@ -182,7 +182,6 @@ var ManifestFetcher = /** @class */ (function (_super) {
      * @returns {Promise}
      */
     ManifestFetcher.prototype._fetchManifest = function (url) {
-        var _a;
         return __awaiter(this, void 0, void 0, function () {
             /**
              * Call the resolver part of the pipeline, retrying if it fails according
@@ -218,6 +217,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
             }
             var cancelSignal, settings, pipelines, requestUrl, backoffSettings, loadingPromise, response_1, err_1;
             var _this = this;
+            var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -277,7 +277,6 @@ var ManifestFetcher = /** @class */ (function (_super) {
      * @returns {Promise}
      */
     ManifestFetcher.prototype._parseLoadedManifest = function (loaded, parserOptions, requestUrl) {
-        var _a;
         return __awaiter(this, void 0, void 0, function () {
             /**
              * Perform a request with the same retry mechanisms and error handling
@@ -334,6 +333,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
             }
             var parsingTimeStart, cancelSignal, trigger, sendingTime, receivedTime, backoffSettings, originalUrl, opts, res, manifest, err_2, formattedError;
             var _this = this;
+            var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:

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

@@ -109,7 +109,6 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
      * @returns {Promise}
      */
     return function fetchSegment(content, fetcherCallbacks, cancellationSignal) {
-        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function () {
             function onCancellation() {
                 var _a;
@@ -190,6 +189,7 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
                 }
             }
             var segmentIdString, requestId, requestInfo, parsedChunks, segmentDurationAcc, metricsSent, loaderCallbacks, cached, res, loadedData, err_1;
+            var _a, _b, _c;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0: