rx-player 3.31.1-dev.2023070500 → 3.32.0-dev.2023092900

package/CHANGELOG.md

@@ -1,15 +1,38 @@
 # Changelog
 
-## v3.31.1-dev.2023070500 (2023-07-05)
+## v3.32.0-dev.2023092900 (2023-09-29)
+
+### Features
+
+  - DASH: add optional `isSpatialAudio` boolean property to Representation returned by `getAvailableAudioTracks`, `getAudioTrack`, corresponding events, and `trackInfo` optional property of `MediaError` objects to signal Dolby Atmos techology [#1275]
+  - `LOCAL`: add `isSpatialAudio` property to Representation of the experiment `"local"` transport (used for offline playback) [#1275]
+  - `addFeatures` static method is now available on all RxPlayer builds. It was previously only in the minimal (`rx-player/minimal` import path) [#1287]
+  - The `NATIVE_TEXT_BUFFER`, `HTML_TEXT_BUFFER` and `IMAGE_BUFFER` features are now totally optional [#1287, #1293]
 
 ### Bug fixes
 
+  - Fix `setVideoBitrate` and `setAudioBitrate` API which may have led to a higher quality than wanted in the default `"seamless"` `manualBitrateSwitchingMode` if our buffer-based adaptive logic decided to  [#1267, #1271]
   - On the PlayStation 5, only switch to the `"LOADED"` state once the HTMLMediaElement's `readyState` of `4` has been reached, as it seems to switch to `3` too soon there [#1257]
+  - DASH: Fix potential track duplication if more than two `AdaptationSet` have an `adaptation-set-switching` `<SupplementalProperty>` between one another [#1279]
+  - DASH-WASM: availabilityTimeOffset is actually a floating number [#1278]
 
 ### Other improvements
 
   - Do not load the last text segment if the current position goes after it as it is unnecessary [#1256]
+  - Implement better `NetworkError` messages [#1274]
   - Set a better error message for when no `keySystems` option is set when playing an encrypted content
+  - Fix very small memory leak when reloading a content [#1286]
+  - TTML: put saner values for extent and origins when weird ones are found
+  - Re-check for segments to load immediately after the manifest has been refreshed [#1282]
+  - When "fallbacking" an undecipherable Representation, now empty the whole buffer if we can't make out where content was in the buffer [#1283]
+  - DRM: Reload when playback is unexpectedly frozen with encrypted but only decipherable data in the buffer [#1236]
+  - Improve segment start detection in buffer when there's unknown data buffered before it [#1284]
+  - DRM: Selection of alternative EME API like those used on IE11 or Safari has been refactored to facilitate future developments [#1261]
+
+### Deprecated
+
+  - Deprecate the `manifestUpdateUrl` `loadVideo` option as it doesn't seem used anymore [#1288]
+  - Deprecate the `NATIVE_TEXT_BUFFER`, `HTML_TEXT_BUFFER` and `IMAGE_BUFFER` features as they are now unneeded [#1287, #1293]
 
 
 ## v3.31.0 (2023-06-14)

package/CONTRIBUTING.md

@@ -12,23 +12,39 @@ Those have to follow the conventions defined below.
 
 
 
-## Reading the current code
+## Important code concepts
 
-Even if we hope the current code is straightforward, readable and commented
-enough we can still admit that going blind into the codebase can be hard at
-first as this is a pretty big technical project on a specific matter.
+### Code documentation
 
-We thus encourage you to rely on the architecture documentation you can usually
-find alongside the code, in `README.md` files.
-You can for example start by reading `src/README.md`, to have a clearer idea
-of the general code architecture of the player.
+We try to put `README.md` files inside every significant directories inside
+`/src` to provide a global architecture documentation of that directory
+specifically.
+
+You can try to start understanding a piece of RxPlayer code by navigating
+to that file. Understand that the documented behavior may be out of date
+(in which case you're welcome to update it or open an issue) though even in
+that case, it is a good starting point to understand the directory's role.
+Likewise, don't forget to update it if a change you made to the code
+necessitates a documentation change.
 
 Also, for a more exhaustive approach to the documentation of the project's file
 organization, you can look at [`FILES.md`](./FILES.md).
 
-The code of the RxPlayer being heavily modularized, you should not need to read
-the whole documentation to be ready, only the parts you want to update
-(hopefully!).
+### When renaming or deleting functions, classes or variables
+
+When Refactoring/Renaming, make sure to grep any of the renamed class / function
+/ variable's name as they may also be referenced in documentation and code
+comments. Same thing for a directory or file name.
+
+If the name is hard to grep (e.g. the name is too generic and thus has too many
+false positives), you can generally reduce the area to comments in the same file
+and documentation files in the same directory.
+
+### `features` object
+
+Some files should not be imported directly but only be accessed by going through
+the `features` object exported at `/src/features`. This is to reduce bundle size
+when an application doesn't need all of the RxPlayer's features.
 
 
 
@@ -53,8 +69,6 @@ directory) by calling `npm run lint:tests`.
 
 ### Types
 
-#### General TypeScript rules
-
 We try to be as strict as possible with types:
 
   - the `any` type should be avoided

package/VERSION

@@ -1 +1 @@
-3.31.1-dev.2023070500
+3.32.0-dev.2023092900

package/dist/_esm5.processed/compat/eme/custom_media_keys/ie11_media_keys.d.ts

@@ -19,13 +19,13 @@ declare class IE11CustomMediaKeys implements ICustomMediaKeys {
     private _videoElement?;
     private _mediaKeys?;
     constructor(keyType: string);
-    _setVideo(videoElement: HTMLMediaElement): void;
+    _setVideo(videoElement: HTMLMediaElement): Promise<unknown>;
     createSession(): ICustomMediaKeySession;
     setServerCertificate(): Promise<void>;
 }
 export default function getIE11MediaKeysCallbacks(): {
     isTypeSupported: (keyType: string) => boolean;
     createCustomMediaKeys: (keyType: string) => IE11CustomMediaKeys;
-    setMediaKeys: (elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => void;
+    setMediaKeys: (elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => Promise<unknown>;
 };
 export { MSMediaKeysConstructor };

package/dist/_esm5.processed/compat/eme/custom_media_keys/ie11_media_keys.js

@@ -30,6 +30,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 import EventEmitter from "../../../utils/event_emitter";
 import TaskCanceller from "../../../utils/task_canceller";
+import wrapInPromise from "../../../utils/wrapInPromise";
 import * as events from "../../event_listeners";
 import { MSMediaKeysConstructor, } from "./ms_media_keys_constructor";
 var IE11MediaKeySession = /** @class */ (function (_super) {
@@ -115,10 +116,13 @@ var IE11CustomMediaKeys = /** @class */ (function () {
         this._mediaKeys = new MSMediaKeysConstructor(keyType);
     }
     IE11CustomMediaKeys.prototype._setVideo = function (videoElement) {
-        this._videoElement = videoElement;
-        if (this._videoElement.msSetMediaKeys !== undefined) {
-            return this._videoElement.msSetMediaKeys(this._mediaKeys);
-        }
+        var _this = this;
+        return wrapInPromise(function () {
+            _this._videoElement = videoElement;
+            if (_this._videoElement.msSetMediaKeys !== undefined) {
+                _this._videoElement.msSetMediaKeys(_this._mediaKeys);
+            }
+        });
     };
     IE11CustomMediaKeys.prototype.createSession = function ( /* sessionType */) {
         if (this._videoElement === undefined || this._mediaKeys === undefined) {
@@ -149,7 +153,7 @@ export default function getIE11MediaKeysCallbacks() {
             // msSetMediaKeys only accepts native MSMediaKeys as argument.
             // Calling it with null or undefined will raise an exception.
             // There is no way to unset the mediakeys in that case, so return here.
-            return;
+            return Promise.resolve(undefined);
         }
         if (!(mediaKeys instanceof IE11CustomMediaKeys)) {
             throw new Error("Custom setMediaKeys is supposed to be called " +

package/dist/_esm5.processed/compat/eme/custom_media_keys/index.d.ts

@@ -1,28 +1,7 @@
-/**
- * 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 CustomMediaKeySystemAccess from "./../custom_key_system_access";
+import getIE11MediaKeysCallbacks, { MSMediaKeysConstructor } from "./ie11_media_keys";
+import getMozMediaKeysCallbacks, { MozMediaKeysConstructor } from "./moz_media_keys_constructor";
+import getOldKitWebKitMediaKeyCallbacks, { isOldWebkitMediaElement } from "./old_webkit_media_keys";
 import { ICustomMediaKeys, ICustomMediaKeySession } from "./types";
-/** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
-type ICompatRequestMediaKeySystemAccessFn = (keyType: string, config: MediaKeySystemConfiguration[]) => Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
-declare let requestMediaKeySystemAccess: ICompatRequestMediaKeySystemAccessFn | null;
-/**
- * Set the given MediaKeys on the given HTMLMediaElement.
- * Emits null when done then complete.
- * @param {HTMLMediaElement} elt
- * @param {Object} mediaKeys
- */
-declare let setMediaKeys: ((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => unknown);
-export { requestMediaKeySystemAccess, setMediaKeys, ICustomMediaKeys, ICustomMediaKeySession, };
+import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
+import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
+export { getIE11MediaKeysCallbacks, MSMediaKeysConstructor, getMozMediaKeysCallbacks, MozMediaKeysConstructor, getOldKitWebKitMediaKeyCallbacks, isOldWebkitMediaElement, ICustomMediaKeys, ICustomMediaKeySession, getWebKitMediaKeysCallbacks, WebKitMediaKeysConstructor, };

package/dist/_esm5.processed/compat/eme/custom_media_keys/index.js

@@ -1,159 +1,6 @@
-/**
- * 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 { MediaError } from "../../../errors";
-import assert from "../../../utils/assert";
-import { isIE11 } from "../../browser_detection";
-import isNode from "../../is_node";
-import shouldFavourCustomSafariEME from "../../should_favour_custom_safari_EME";
-import CustomMediaKeySystemAccess from "./../custom_key_system_access";
 import getIE11MediaKeysCallbacks, { MSMediaKeysConstructor, } from "./ie11_media_keys";
 import getMozMediaKeysCallbacks, { MozMediaKeysConstructor, } from "./moz_media_keys_constructor";
 import getOldKitWebKitMediaKeyCallbacks, { isOldWebkitMediaElement, } from "./old_webkit_media_keys";
 import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
-var requestMediaKeySystemAccess = null;
-/**
- * Set the given MediaKeys on the given HTMLMediaElement.
- * Emits null when done then complete.
- * @param {HTMLMediaElement} elt
- * @param {Object} mediaKeys
- */
-var setMediaKeys = function defaultSetMediaKeys(mediaElement, mediaKeys) {
-    var elt = mediaElement;
-    /* eslint-disable @typescript-eslint/unbound-method */
-    if (typeof elt.setMediaKeys === "function") {
-        return elt.setMediaKeys(mediaKeys);
-    }
-    /* eslint-enable @typescript-eslint/unbound-method */
-    // If we get in the following code, it means that no compat case has been
-    // found and no standard setMediaKeys API exists. This case is particulary
-    // rare. We will try to call each API with native media keys.
-    if (typeof elt.webkitSetMediaKeys === "function") {
-        return elt.webkitSetMediaKeys(mediaKeys);
-    }
-    if (typeof elt.mozSetMediaKeys === "function") {
-        return elt.mozSetMediaKeys(mediaKeys);
-    }
-    if (typeof elt.msSetMediaKeys === "function" && mediaKeys !== null) {
-        return elt.msSetMediaKeys(mediaKeys);
-    }
-};
-/**
- * Since Safari 12.1, EME APIs are available without webkit prefix.
- * However, it seems that since fairplay CDM implementation within the browser is not
- * standard with EME w3c current spec, the requestMediaKeySystemAccess API doesn't resolve
- * positively, even if the drm (fairplay in most cases) is supported.
- *
- * Therefore, we prefer not to use requestMediaKeySystemAccess on Safari when webkit API
- * is available.
- */
-if (isNode ||
-    (navigator.requestMediaKeySystemAccess != null && !shouldFavourCustomSafariEME())) {
-    requestMediaKeySystemAccess = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return navigator.requestMediaKeySystemAccess.apply(navigator, args);
-    };
-}
-else {
-    var isTypeSupported_1;
-    var createCustomMediaKeys_1;
-    // This is for Chrome with unprefixed EME api
-    if (isOldWebkitMediaElement(HTMLVideoElement.prototype)) {
-        var callbacks = getOldKitWebKitMediaKeyCallbacks();
-        isTypeSupported_1 = callbacks.isTypeSupported;
-        createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        setMediaKeys = callbacks.setMediaKeys;
-        // This is for WebKit with prefixed EME api
-    }
-    else if (WebKitMediaKeysConstructor !== undefined) {
-        var callbacks = getWebKitMediaKeysCallbacks();
-        isTypeSupported_1 = callbacks.isTypeSupported;
-        createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        setMediaKeys = callbacks.setMediaKeys;
-    }
-    else if (isIE11 && MSMediaKeysConstructor !== undefined) {
-        var callbacks = getIE11MediaKeysCallbacks();
-        isTypeSupported_1 = callbacks.isTypeSupported;
-        createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        setMediaKeys = callbacks.setMediaKeys;
-    }
-    else if (MozMediaKeysConstructor !== undefined) {
-        var callbacks = getMozMediaKeysCallbacks();
-        isTypeSupported_1 = callbacks.isTypeSupported;
-        createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        setMediaKeys = callbacks.setMediaKeys;
-    }
-    else {
-        var MK_1 = window.MediaKeys;
-        var checkForStandardMediaKeys_1 = function () {
-            if (MK_1 === undefined) {
-                throw new MediaError("MEDIA_KEYS_NOT_SUPPORTED", "No `MediaKeys` implementation found " +
-                    "in the current browser.");
-            }
-            if (typeof MK_1.isTypeSupported === "undefined") {
-                var message = "This browser seems to be unable to play encrypted contents " +
-                    "currently. Note: Some browsers do not allow decryption " +
-                    "in some situations, like when not using HTTPS.";
-                throw new Error(message);
-            }
-        };
-        isTypeSupported_1 = function (keyType) {
-            checkForStandardMediaKeys_1();
-            assert(typeof MK_1.isTypeSupported === "function");
-            return MK_1.isTypeSupported(keyType);
-        };
-        createCustomMediaKeys_1 = function (keyType) {
-            checkForStandardMediaKeys_1();
-            return new MK_1(keyType);
-        };
-    }
-    requestMediaKeySystemAccess = function (keyType, keySystemConfigurations) {
-        if (!isTypeSupported_1(keyType)) {
-            return Promise.reject(new Error("Unsupported key type"));
-        }
-        for (var i = 0; i < keySystemConfigurations.length; i++) {
-            var keySystemConfiguration = keySystemConfigurations[i];
-            var videoCapabilities = keySystemConfiguration.videoCapabilities, audioCapabilities = keySystemConfiguration.audioCapabilities, initDataTypes = keySystemConfiguration.initDataTypes, distinctiveIdentifier = keySystemConfiguration.distinctiveIdentifier;
-            var supported = true;
-            supported = supported &&
-                (initDataTypes == null ||
-                    initDataTypes.some(function (idt) { return idt === "cenc"; }));
-            supported = supported && (distinctiveIdentifier !== "required");
-            if (supported) {
-                var keySystemConfigurationResponse = {
-                    initDataTypes: ["cenc"],
-                    distinctiveIdentifier: "not-allowed",
-                    persistentState: "required",
-                    sessionTypes: ["temporary", "persistent-license"],
-                };
-                if (videoCapabilities !== undefined) {
-                    keySystemConfigurationResponse.videoCapabilities = videoCapabilities;
-                }
-                if (audioCapabilities !== undefined) {
-                    keySystemConfigurationResponse.audioCapabilities = audioCapabilities;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                var customMediaKeys = createCustomMediaKeys_1(keyType);
-                return Promise.resolve(new CustomMediaKeySystemAccess(keyType, customMediaKeys, keySystemConfigurationResponse));
-            }
-        }
-        return Promise.reject(new Error("Unsupported configuration"));
-    };
-}
-export { requestMediaKeySystemAccess, setMediaKeys, };
+export { getIE11MediaKeysCallbacks, MSMediaKeysConstructor, getMozMediaKeysCallbacks, MozMediaKeysConstructor, getOldKitWebKitMediaKeyCallbacks, isOldWebkitMediaElement, getWebKitMediaKeysCallbacks, WebKitMediaKeysConstructor, };

package/dist/_esm5.processed/compat/eme/custom_media_keys/moz_media_keys_constructor.d.ts

@@ -23,5 +23,5 @@ export { MozMediaKeysConstructor };
 export default function getMozMediaKeysCallbacks(): {
     isTypeSupported: (keyType: string) => boolean;
     createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
-    setMediaKeys: (elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => void;
+    setMediaKeys: (elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => Promise<unknown>;
 };

package/dist/_esm5.processed/compat/eme/custom_media_keys/moz_media_keys_constructor.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import wrapInPromise from "../../../utils/wrapInPromise";
 import isNode from "../../is_node";
 var MozMediaKeysConstructor;
 if (!isNode) {
@@ -45,11 +46,14 @@ export default function getMozMediaKeysCallbacks() {
         return new MozMediaKeysConstructor(keyType);
     };
     var setMediaKeys = function (mediaElement, mediaKeys) {
-        var elt = mediaElement;
-        if (elt.mozSetMediaKeys === undefined || typeof elt.mozSetMediaKeys !== "function") {
-            throw new Error("Can't set video on MozMediaKeys.");
-        }
-        return elt.mozSetMediaKeys(mediaKeys);
+        return wrapInPromise(function () {
+            var elt = mediaElement;
+            if (elt.mozSetMediaKeys === undefined ||
+                typeof elt.mozSetMediaKeys !== "function") {
+                throw new Error("Can't set video on MozMediaKeys.");
+            }
+            return elt.mozSetMediaKeys(mediaKeys);
+        });
     };
     return {
         isTypeSupported: isTypeSupported,

package/dist/_esm5.processed/compat/eme/custom_media_keys/old_webkit_media_keys.d.ts

@@ -29,13 +29,13 @@ declare class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
     private readonly _keySystem;
     private _videoElement?;
     constructor(keySystem: string);
-    _setVideo(videoElement: IOldWebkitHTMLMediaElement | HTMLMediaElement): void;
+    _setVideo(videoElement: IOldWebkitHTMLMediaElement | HTMLMediaElement): Promise<unknown>;
     createSession(): ICustomMediaKeySession;
     setServerCertificate(): Promise<void>;
 }
 export default function getOldWebKitMediaKeysCallbacks(): {
     isTypeSupported: (keyType: string) => boolean;
     createCustomMediaKeys: (keyType: string) => OldWebKitCustomMediaKeys;
-    setMediaKeys: (elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => void;
+    setMediaKeys: (elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => Promise<unknown>;
 };
 export {};

package/dist/_esm5.processed/compat/eme/custom_media_keys/old_webkit_media_keys.js

@@ -32,6 +32,7 @@ import { base64ToBytes } from "../../../utils/base64";
 import EventEmitter from "../../../utils/event_emitter";
 import noop from "../../../utils/noop";
 import { utf8ToStr } from "../../../utils/string_parsing";
+import wrapInPromise from "../../../utils/wrapInPromise";
 /**
  * Returns true if the given media element has old webkit methods
  * corresponding to the IOldWebkitHTMLMediaElement interface.
@@ -138,10 +139,13 @@ var OldWebKitCustomMediaKeys = /** @class */ (function () {
         this._keySystem = keySystem;
     }
     OldWebKitCustomMediaKeys.prototype._setVideo = function (videoElement) {
-        if (!isOldWebkitMediaElement(videoElement)) {
-            throw new Error("Video not attached to the MediaKeys");
-        }
-        this._videoElement = videoElement;
+        var _this = this;
+        return wrapInPromise(function () {
+            if (!isOldWebkitMediaElement(videoElement)) {
+                throw new Error("Video not attached to the MediaKeys");
+            }
+            _this._videoElement = videoElement;
+        });
     };
     OldWebKitCustomMediaKeys.prototype.createSession = function ( /* sessionType */) {
         if (this._videoElement == null) {
@@ -172,7 +176,7 @@ export default function getOldWebKitMediaKeysCallbacks() {
     var createCustomMediaKeys = function (keyType) { return new OldWebKitCustomMediaKeys(keyType); };
     var setMediaKeys = function (elt, mediaKeys) {
         if (mediaKeys === null) {
-            return;
+            return Promise.resolve(undefined);
         }
         if (!(mediaKeys instanceof OldWebKitCustomMediaKeys)) {
             throw new Error("Custom setMediaKeys is supposed to be called " +

package/dist/_esm5.processed/compat/eme/custom_media_keys/types.d.ts

@@ -28,7 +28,7 @@ export interface ICustomMediaKeySession extends IEventEmitter<IMediaKeySessionEv
     remove(): Promise<void>;
 }
 export interface ICustomMediaKeys {
-    _setVideo: (vid: HTMLMediaElement) => void;
+    _setVideo: (vid: HTMLMediaElement) => Promise<unknown>;
     createSession(sessionType?: MediaKeySessionType): ICustomMediaKeySession;
     setServerCertificate(setServerCertificate: BufferSource): Promise<void>;
 }

package/dist/_esm5.processed/compat/eme/custom_media_keys/webkit_media_keys.d.ts

@@ -25,13 +25,13 @@ declare class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
     private _serverCertificate?;
     private _keyType;
     constructor(keyType: string);
-    _setVideo(videoElement: HTMLMediaElement): void;
+    _setVideo(videoElement: HTMLMediaElement): Promise<unknown>;
     createSession(): ICustomMediaKeySession;
     setServerCertificate(serverCertificate: Uint8Array): Promise<void>;
 }
 export default function getWebKitMediaKeysCallbacks(): {
     isTypeSupported: (keyType: string) => boolean;
     createCustomMediaKeys: (keyType: string) => WebKitCustomMediaKeys;
-    setMediaKeys: (elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => void;
+    setMediaKeys: (elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => Promise<unknown>;
 };
 export {};

package/dist/_esm5.processed/compat/eme/custom_media_keys/webkit_media_keys.js

@@ -30,6 +30,8 @@ var __extends = (this && this.__extends) || (function () {
 })();
 import EventEmitter from "../../../utils/event_emitter";
 import noop from "../../../utils/noop";
+import startsWith from "../../../utils/starts_with";
+import wrapInPromise from "../../../utils/wrapInPromise";
 import getWebKitFairplayInitData from "../get_webkit_fairplay_initdata";
 import { WebKitMediaKeysConstructor, } from "./webkit_media_keys_constructor";
 /**
@@ -38,21 +40,23 @@ import { WebKitMediaKeysConstructor, } from "./webkit_media_keys_constructor";
  * @returns {boolean}
  */
 function isFairplayKeyType(keyType) {
-    return keyType === "com.apple.fps.1_0" ||
-        keyType === "com.apple.fps.2_0";
+    return startsWith(keyType, "com.apple.fps");
 }
 /**
  * Set media keys on video element using native HTMLMediaElement
  * setMediaKeys from WebKit.
  * @param {HTMLMediaElement} videoElement
  * @param {Object|null} mediaKeys
+ * @returns {Promise}
  */
 function setWebKitMediaKeys(videoElement, mediaKeys) {
     var elt = videoElement;
-    if (elt.webkitSetMediaKeys === undefined) {
-        throw new Error("No webKitMediaKeys API.");
-    }
-    return elt.webkitSetMediaKeys(mediaKeys);
+    return wrapInPromise(function () {
+        if (elt.webkitSetMediaKeys === undefined) {
+            throw new Error("No webKitMediaKeys API.");
+        }
+        elt.webkitSetMediaKeys(mediaKeys);
+    });
 }
 /**
  * On Safari browsers (>= 9), there are specific webkit prefixed APIs for cyphered

package/dist/_esm5.processed/compat/eme/eme-api-implementation.d.ts

@@ -0,0 +1,78 @@
+import { CancellationSignal } from "../../utils/task_canceller";
+import { IEventTargetLike } from "../event_listeners";
+import CustomMediaKeySystemAccess from "./custom_key_system_access";
+import { ICustomMediaKeys } from "./custom_media_keys/types";
+/**
+ * Automatically detect and set which EME implementation should be used in the
+ * current platform.
+ *
+ * You can call `getEmeApiImplementation` for a different implementation.
+ */
+declare const defaultEmeImplementation: IEmeApiImplementation;
+export default defaultEmeImplementation;
+/**
+ * Generic interface harmonizing the structure of the different EME API
+ * implementations the RxPlayer could use.
+ */
+export interface IEmeApiImplementation {
+    /**
+     * API implementing the `navigator.requestMediaKeySystemAccess` static method
+     * from EME.
+     * @param {string} keyType - Key system name, as a reverse domain name.
+     * @param {Array.<MediaKeySystemMediaCapability>} Wanted configurations, from
+     * the most wanted to the least.
+     * @returns {Promise}
+     */
+    requestMediaKeySystemAccess: (keyType: string, config: MediaKeySystemConfiguration[]) => Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+    /**
+     * API allowing to listen for `"encrypted"` events, presumably sent by the
+     * HTMLMediaElement on which encrypted content is pushed.
+     * @param {EventTarget} The element on which the event will be listened to.
+     * Generally it is the HTMLMediaElement.
+     * @param {Function} listener - The event listener on which that event's
+     * payload will be dispatched.
+     * @param {Object} cancelSignal - The event listener will be removed once that
+     * `CancellationSignal` emits.
+     */
+    onEncrypted: (target: IEventTargetLike, listener: (evt: unknown) => void, cancelSignal: CancellationSignal) => void;
+    /**
+     * API allowing to attach a `MediaKeys` instance (or an `ICustomMediaKeys`) to
+     * the HTMLMediaElement so it can start decoding.
+     * @param {HTMLMediaElement} The HTMLMediaElement on which the content plays.
+     * @param {MediaKeys} mediaKeys - The MediaKeys instance to attach.
+     * @returns {Promise} - That promise resolves if the `MediaKeys` instance was
+     * attached to the `HTMLMediaElement` with success, or rejects on the opposite
+     * scenario.
+     */
+    setMediaKeys: (mediaElement: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => Promise<unknown>;
+    /**
+     * String describing the currently used EME implementation:
+     *
+     *   - "standard": regular EME implementation
+     *
+     *   - "webkit": The webkit-prefixed variant of the EME API
+     *
+     *   - "older-webkit": An even older webkit-prefixed variant of the EME API
+     *
+     *   - "ms": The ms-prefixed variant of the EME API
+     *
+     *   - "moz": The moz-prefixed variant of the EME API
+     *
+     *   - "unknown": An unidentified variant of the EME API
+     */
+    implementation: "standard" | "webkit" | "older-webkit" | "ms" | "moz" | "unknown";
+}
+/**
+ * Union of all the different value the preferred EME API type can be set to:
+ *
+ *   - "auto": The implementation will be chosen automatically based on what
+ *     we've most confidence on on the current device.
+ *
+ *   - "standard": If present, the standard EME API will be given precedence
+ *     over custom and browser-specific ones.
+ *
+ *   - "webkit": The webkit-prefixed variant of the EME API will be given
+ *     precedence over any other one if present.
+ *
+ */
+export type IPreferredEmeApiType = "auto" | "standard" | "webkit";