rx-player 4.0.0-beta.2 → 4.0.0-worker.2023091900

package/.eslintrc.js

@@ -328,6 +328,15 @@ module.exports = {
     "prefer-template": "off",
     "no-restricted-properties": [
       "error",
+      {
+        "object": "performance",
+        "property": "now",
+        "message": "Avoid using `performance.now` directly as timestamps may be different in the worker and the main thread. Please use the `getMonotonicTimeStamp` util instead.",
+      },
+      {
+        "object": "window",
+        "message": "`window` doesn't work in Node.JS and only works when JavaScript is running in the main thread. Please import `globalScope` instead.",
+      },
       {
         "object": "Object",
         "property": "assign",

package/CHANGELOG.md

@@ -1,6 +1,30 @@
 # Changelog
 
-## v4.0.0-beta.2 (2023-03-08)
+## v4.0.0-worker.2023091900 (2023-09-19)
+
+### Changes
+
+  - On `MediaError` objects, replace `trackInfo` prop by `tracksInfo` to group similar errors
+
+### Features
+
+  - Add `MULTI_THREAD` experimental feature to be able to run the RxPlayer's main logic in a WebWorker for efficiency reasons
+  - `addFeatures` is now available in any build of the RxPlayer
+  - The `representationFilter` `loadVideo` option can now be defined as a string to be usable in the new "multithreading" mode
+
+### Bug fixes
+
+  - DRM: Fix decipherability reporting by correcting seemsDecipherable to decipherable
+
+### Other improvements
+
+  - `newAvailablePeriods` events are now lazily sent when the Period begins to be considered [#1265]
+  - TTML: put saner values for extent and origins when weird ones are found
+  - Fix small memory leak when going through the `"RELOADING"` state
+  - The `HTML_TEXT_BUFFER` and `NATIVE_TEXT_BUFFER` now do not need to be imported as it is explicitely done when importing respectively HTML and native text tracks parsers (both have been undocumented)
+
+
+## v4.0.0-beta.2 (2023-06-27)
 
 ### Changes
 

package/CONTRIBUTING.md

@@ -12,23 +12,53 @@ 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.
+
+This import restriction should be enforced by our code linter, you may also know
+which features are accessible through the `features` object by looking at that
+type's documentation.
+
+### Multithreading
+
+Some parts of the code are intented to be runnable in a WebWorker. In that
+environment some API, more specifically DOM-related API, are not available
+directly (if some interaction with the DOM is needed, it will have to go through
+an asynchronous `postMessage` round-trip).
+
+Whether the code needs to be runnable or not in a WebWorker is generally
+documented in the `README.md` of concerned directories.
 
 
 
@@ -53,8 +83,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/FILES.md

@@ -119,6 +119,21 @@ Defines a common `Manifest` class, regardless of the streaming technology (DASH,
 HSS...). This class is then used by the rest of the RxPlayer, to allow
 interaction with it without considering the underlying technology used.
 
+### `src/mse/`: MSE abstractions
+
+Abstraction over Media Source Extensions API, which are the browser API allowing
+to buffer media.
+
+This allows to provide a common API to the rest of the RxPlayer's code
+regardless of the environment (e.g. in a WebWorker without MSE API or in an
+environment with MSE API).
+
+### `src/multithread/`: Multithread-specific code
+
+Global code specific to the multithreaded "flavor" of the RxPlayer.
+
+That is, an RxPlayer instance which can rely on a WebWorker to perform its main
+operations allowing to compete less with the UI for CPU resources.
 
 ### `src/transports/`: Streaming protocols implementation
 

package/VERSION

@@ -1 +1 @@
-4.0.0-beta.2
+4.0.0-worker.2023091900

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

@@ -143,7 +143,6 @@ export interface ICompatPictureInPictureWindow extends EventTarget {
     width: number;
     height: number;
 }
-/** MediaSource implementation, including vendored implementations. */
 declare const MediaSource_: typeof MediaSource | undefined;
 /** List an HTMLMediaElement's possible values for its readyState property. */
 declare const READY_STATES: {

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

@@ -14,15 +14,16 @@
  * limitations under the License.
  */
 import isNullOrUndefined from "../utils/is_null_or_undefined";
-import isNode from "./is_node";
-var win = isNode ? undefined :
-    window;
+import globalScope from "./global_scope";
+/* eslint-disable */
 /** MediaSource implementation, including vendored implementations. */
-var MediaSource_ = win === undefined ? undefined :
-    !isNullOrUndefined(win.MediaSource) ? win.MediaSource :
-        !isNullOrUndefined(win.MozMediaSource) ? win.MozMediaSource :
-            !isNullOrUndefined(win.WebKitMediaSource) ? win.WebKitMediaSource :
-                win.MSMediaSource;
+var gs = globalScope;
+var MediaSource_ = gs === undefined ? undefined :
+    !isNullOrUndefined(gs.MediaSource) ? gs.MediaSource :
+        !isNullOrUndefined(gs.MozMediaSource) ? gs.MozMediaSource :
+            !isNullOrUndefined(gs.WebKitMediaSource) ? gs.WebKitMediaSource :
+                gs.MSMediaSource;
+/* eslint-enable */
 /** List an HTMLMediaElement's possible values for its readyState property. */
 var READY_STATES = { HAVE_NOTHING: 0,
     HAVE_METADATA: 1,

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

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import globalScope from "./global_scope";
 import isNode from "./is_node";
 /** Edge Chromium, regardless of the device */
 var isEdgeChromium = false;
@@ -46,7 +47,7 @@ var isPlayStation5 = false;
         return;
     }
     // 1 - Find out browser between IE/Edge Legacy/Edge Chromium/Firefox/Safari
-    if (typeof window.MSInputMethodContext !== "undefined" &&
+    if (typeof globalScope.MSInputMethodContext !== "undefined" &&
         typeof document.documentMode !== "undefined") {
         isIE11 = true;
         isIEOrEdge = true;
@@ -66,8 +67,8 @@ var isPlayStation5 = false;
         /iPad|iPhone|iPod/.test(navigator.platform)) {
         isSafariMobile = true;
     }
-    else if (Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") >= 0 ||
-        ((_b = (_a = window.safari) === null || _a === void 0 ? void 0 : _a.pushNotification) === null || _b === void 0 ? void 0 : _b.toString()) ===
+    else if (Object.prototype.toString.call(globalScope.HTMLElement).indexOf("Constructor") >= 0 ||
+        ((_b = (_a = globalScope.safari) === null || _a === void 0 ? void 0 : _a.pushNotification) === null || _b === void 0 ? void 0 : _b.toString()) ===
             "[object SafariRemoteNotification]") {
         isSafariDesktop = true;
     }

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,19 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNode from "../../is_node";
+import wrapInPromise from "../../../utils/wrapInPromise";
+import globalScope from "../../global_scope";
 var MozMediaKeysConstructor;
-if (!isNode) {
-    var MozMediaKeys = window.MozMediaKeys;
-    if (MozMediaKeys !== undefined &&
-        MozMediaKeys.prototype !== undefined &&
-        typeof MozMediaKeys.isTypeSupported === "function" &&
-        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-        typeof MozMediaKeys.prototype.createSession === "function"
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-    ) {
-        MozMediaKeysConstructor = MozMediaKeys;
-    }
+var MozMediaKeys = globalScope.MozMediaKeys;
+if (MozMediaKeys !== undefined &&
+    MozMediaKeys.prototype !== undefined &&
+    typeof MozMediaKeys.isTypeSupported === "function" &&
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    typeof MozMediaKeys.prototype.createSession === "function"
+/* eslint-enable @typescript-eslint/no-unsafe-member-access */
+) {
+    MozMediaKeysConstructor = MozMediaKeys;
 }
 export { MozMediaKeysConstructor };
 export default function getMozMediaKeysCallbacks() {
@@ -45,11 +44,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/ms_media_keys_constructor.js

@@ -13,18 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNode from "../../is_node";
+import globalScope from "../../global_scope";
 var MSMediaKeysConstructor;
-if (!isNode) {
-    var MSMediaKeys = window.MSMediaKeys;
-    if (MSMediaKeys !== undefined &&
-        MSMediaKeys.prototype !== undefined &&
-        typeof MSMediaKeys.isTypeSupported === "function" &&
-        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-        typeof MSMediaKeys.prototype.createSession === "function"
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-    ) {
-        MSMediaKeysConstructor = MSMediaKeys;
-    }
+var MSMediaKeys = globalScope.MSMediaKeys;
+if (MSMediaKeys !== undefined &&
+    MSMediaKeys.prototype !== undefined &&
+    typeof MSMediaKeys.isTypeSupported === "function" &&
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    typeof MSMediaKeys.prototype.createSession === "function"
+/* eslint-enable @typescript-eslint/no-unsafe-member-access */
+) {
+    MSMediaKeysConstructor = MSMediaKeys;
 }
 export { MSMediaKeysConstructor };

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

@@ -24,18 +24,18 @@ export interface IOldWebkitHTMLMediaElement extends HTMLVideoElement {
  * @param {HTMLMediaElement} element
  * @returns {Boolean}
  */
-export declare function isOldWebkitMediaElement(element: HTMLMediaElement | IOldWebkitHTMLMediaElement): element is IOldWebkitHTMLMediaElement;
+export declare function isOldWebkitMediaElement(element: unknown): element is IOldWebkitHTMLMediaElement;
 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.
@@ -39,8 +40,7 @@ import { utf8ToStr } from "../../../utils/string_parsing";
  * @returns {Boolean}
  */
 export function isOldWebkitMediaElement(element) {
-    return typeof element
-        .webkitGenerateKeyRequest === "function";
+    return typeof (element === null || element === void 0 ? void 0 : element.webkitGenerateKeyRequest) === "function";
 }
 /**
  * MediaKeySession implementation for older versions of WebKit relying on APIs
@@ -138,10 +138,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 +175,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>;
 }