rx-player 4.0.0-beta.2 → 4.0.0-beta.3

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,143 +14,122 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import EventEmitter from "../../../utils/event_emitter";
-import TaskCanceller from "../../../utils/task_canceller";
-import * as events from "../../event_listeners";
-import { MSMediaKeysConstructor, } from "./ms_media_keys_constructor";
-var IE11MediaKeySession = /** @class */ (function (_super) {
-    __extends(IE11MediaKeySession, _super);
-    function IE11MediaKeySession(mk) {
-        var _this = _super.call(this) || this;
-        _this.expiration = NaN;
-        _this.keyStatuses = new Map();
-        _this._mk = mk;
-        _this._sessionClosingCanceller = new TaskCanceller();
-        _this.closed = new Promise(function (resolve) {
-            _this._sessionClosingCanceller.signal.register(function () { return resolve(); });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MSMediaKeysConstructor = void 0;
+const event_emitter_1 = require("../../../utils/event_emitter");
+const task_canceller_1 = require("../../../utils/task_canceller");
+const wrapInPromise_1 = require("../../../utils/wrapInPromise");
+const events = require("../../event_listeners");
+const ms_media_keys_constructor_1 = require("./ms_media_keys_constructor");
+Object.defineProperty(exports, "MSMediaKeysConstructor", { enumerable: true, get: function () { return ms_media_keys_constructor_1.MSMediaKeysConstructor; } });
+class IE11MediaKeySession extends event_emitter_1.default {
+    constructor(mk) {
+        super();
+        this.expiration = NaN;
+        this.keyStatuses = new Map();
+        this._mk = mk;
+        this._sessionClosingCanceller = new task_canceller_1.default();
+        this.closed = new Promise((resolve) => {
+            this._sessionClosingCanceller.signal.register(() => resolve());
         });
-        _this.update = function (license) {
-            return new Promise(function (resolve, reject) {
-                if (_this._ss === undefined) {
+        this.update = (license) => {
+            return new Promise((resolve, reject) => {
+                if (this._ss === undefined) {
                     return reject("MediaKeySession not set.");
                 }
                 try {
-                    resolve(_this._ss.update(license, ""));
+                    resolve(this._ss.update(license, ""));
                 }
                 catch (err) {
                     reject(err);
                 }
             });
         };
-        return _this;
     }
-    IE11MediaKeySession.prototype.generateRequest = function (_initDataType, initData) {
-        var _this = this;
-        return new Promise(function (resolve) {
-            var initDataU8 = initData instanceof Uint8Array ? initData :
+    generateRequest(_initDataType, initData) {
+        return new Promise((resolve) => {
+            const initDataU8 = initData instanceof Uint8Array ? initData :
                 initData instanceof ArrayBuffer ? new Uint8Array(initData) :
                     new Uint8Array(initData.buffer);
-            _this._ss = _this._mk.createSession("video/mp4", initDataU8);
-            events.onKeyMessage(_this._ss, function (evt) {
+            this._ss = this._mk.createSession("video/mp4", initDataU8);
+            events.onKeyMessage(this._ss, (evt) => {
                 var _a;
-                _this.trigger((_a = evt.type) !== null && _a !== void 0 ? _a : "message", evt);
-            }, _this._sessionClosingCanceller.signal);
-            events.onKeyAdded(_this._ss, function (evt) {
+                this.trigger((_a = evt.type) !== null && _a !== void 0 ? _a : "message", evt);
+            }, this._sessionClosingCanceller.signal);
+            events.onKeyAdded(this._ss, (evt) => {
                 var _a;
-                _this.trigger((_a = evt.type) !== null && _a !== void 0 ? _a : "keyadded", evt);
-            }, _this._sessionClosingCanceller.signal);
-            events.onKeyError(_this._ss, function (evt) {
+                this.trigger((_a = evt.type) !== null && _a !== void 0 ? _a : "keyadded", evt);
+            }, this._sessionClosingCanceller.signal);
+            events.onKeyError(this._ss, (evt) => {
                 var _a;
-                _this.trigger((_a = evt.type) !== null && _a !== void 0 ? _a : "keyerror", evt);
-            }, _this._sessionClosingCanceller.signal);
+                this.trigger((_a = evt.type) !== null && _a !== void 0 ? _a : "keyerror", evt);
+            }, this._sessionClosingCanceller.signal);
             resolve();
         });
-    };
-    IE11MediaKeySession.prototype.close = function () {
-        var _this = this;
-        return new Promise(function (resolve) {
-            if (_this._ss != null) {
-                _this._ss.close();
-                _this._ss = undefined;
+    }
+    close() {
+        return new Promise((resolve) => {
+            if (this._ss != null) {
+                this._ss.close();
+                this._ss = undefined;
             }
-            _this._sessionClosingCanceller.cancel();
+            this._sessionClosingCanceller.cancel();
             resolve();
         });
-    };
-    IE11MediaKeySession.prototype.load = function () {
+    }
+    load() {
         return Promise.resolve(false);
-    };
-    IE11MediaKeySession.prototype.remove = function () {
+    }
+    remove() {
         return Promise.resolve();
-    };
-    Object.defineProperty(IE11MediaKeySession.prototype, "sessionId", {
-        get: function () {
-            var _a, _b;
-            return (_b = (_a = this._ss) === null || _a === void 0 ? void 0 : _a.sessionId) !== null && _b !== void 0 ? _b : "";
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return IE11MediaKeySession;
-}(EventEmitter));
-var IE11CustomMediaKeys = /** @class */ (function () {
-    function IE11CustomMediaKeys(keyType) {
-        if (MSMediaKeysConstructor === undefined) {
+    }
+    get sessionId() {
+        var _a, _b;
+        return (_b = (_a = this._ss) === null || _a === void 0 ? void 0 : _a.sessionId) !== null && _b !== void 0 ? _b : "";
+    }
+}
+class IE11CustomMediaKeys {
+    constructor(keyType) {
+        if (ms_media_keys_constructor_1.MSMediaKeysConstructor === undefined) {
             throw new Error("No MSMediaKeys API.");
         }
-        this._mediaKeys = new MSMediaKeysConstructor(keyType);
+        this._mediaKeys = new ms_media_keys_constructor_1.MSMediaKeysConstructor(keyType);
     }
-    IE11CustomMediaKeys.prototype._setVideo = function (videoElement) {
-        this._videoElement = videoElement;
-        if (this._videoElement.msSetMediaKeys !== undefined) {
-            return this._videoElement.msSetMediaKeys(this._mediaKeys);
-        }
-    };
-    IE11CustomMediaKeys.prototype.createSession = function ( /* sessionType */) {
+    _setVideo(videoElement) {
+        return (0, wrapInPromise_1.default)(() => {
+            this._videoElement = videoElement;
+            if (this._videoElement.msSetMediaKeys !== undefined) {
+                this._videoElement.msSetMediaKeys(this._mediaKeys);
+            }
+        });
+    }
+    createSession( /* sessionType */) {
         if (this._videoElement === undefined || this._mediaKeys === undefined) {
             throw new Error("Video not attached to the MediaKeys");
         }
         return new IE11MediaKeySession(this._mediaKeys);
-    };
-    IE11CustomMediaKeys.prototype.setServerCertificate = function () {
+    }
+    setServerCertificate() {
         throw new Error("Server certificate is not implemented in your browser");
-    };
-    return IE11CustomMediaKeys;
-}());
-export default function getIE11MediaKeysCallbacks() {
-    var isTypeSupported = function (keySystem, type) {
-        if (MSMediaKeysConstructor === undefined) {
+    }
+}
+function getIE11MediaKeysCallbacks() {
+    const isTypeSupported = (keySystem, type) => {
+        if (ms_media_keys_constructor_1.MSMediaKeysConstructor === undefined) {
             throw new Error("No MSMediaKeys API.");
         }
         if (type !== undefined) {
-            return MSMediaKeysConstructor.isTypeSupported(keySystem, type);
+            return ms_media_keys_constructor_1.MSMediaKeysConstructor.isTypeSupported(keySystem, type);
         }
-        return MSMediaKeysConstructor.isTypeSupported(keySystem);
-    };
-    var createCustomMediaKeys = function (keyType) {
-        return new IE11CustomMediaKeys(keyType);
+        return ms_media_keys_constructor_1.MSMediaKeysConstructor.isTypeSupported(keySystem);
     };
-    var setMediaKeys = function (elt, mediaKeys) {
+    const createCustomMediaKeys = (keyType) => new IE11CustomMediaKeys(keyType);
+    const setMediaKeys = (elt, mediaKeys) => {
         if (mediaKeys === null) {
             // 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 " +
@@ -158,9 +138,9 @@ export default function getIE11MediaKeysCallbacks() {
         return mediaKeys._setVideo(elt);
     };
     return {
-        isTypeSupported: isTypeSupported,
-        createCustomMediaKeys: createCustomMediaKeys,
-        setMediaKeys: setMediaKeys,
+        isTypeSupported,
+        createCustomMediaKeys,
+        setMediaKeys,
     };
 }
-export { MSMediaKeysConstructor };
+exports.default = getIE11MediaKeysCallbacks;

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,16 @@
-/**
- * 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, };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebKitMediaKeysConstructor = exports.getWebKitMediaKeysCallbacks = exports.isOldWebkitMediaElement = exports.getOldKitWebKitMediaKeyCallbacks = exports.MozMediaKeysConstructor = exports.getMozMediaKeysCallbacks = exports.MSMediaKeysConstructor = exports.getIE11MediaKeysCallbacks = void 0;
+const ie11_media_keys_1 = require("./ie11_media_keys");
+exports.getIE11MediaKeysCallbacks = ie11_media_keys_1.default;
+Object.defineProperty(exports, "MSMediaKeysConstructor", { enumerable: true, get: function () { return ie11_media_keys_1.MSMediaKeysConstructor; } });
+const moz_media_keys_constructor_1 = require("./moz_media_keys_constructor");
+exports.getMozMediaKeysCallbacks = moz_media_keys_constructor_1.default;
+Object.defineProperty(exports, "MozMediaKeysConstructor", { enumerable: true, get: function () { return moz_media_keys_constructor_1.MozMediaKeysConstructor; } });
+const old_webkit_media_keys_1 = require("./old_webkit_media_keys");
+exports.getOldKitWebKitMediaKeyCallbacks = old_webkit_media_keys_1.default;
+Object.defineProperty(exports, "isOldWebkitMediaElement", { enumerable: true, get: function () { return old_webkit_media_keys_1.isOldWebkitMediaElement; } });
+const webkit_media_keys_1 = require("./webkit_media_keys");
+exports.getWebKitMediaKeysCallbacks = webkit_media_keys_1.default;
+const webkit_media_keys_constructor_1 = require("./webkit_media_keys_constructor");
+Object.defineProperty(exports, "WebKitMediaKeysConstructor", { enumerable: true, get: function () { return webkit_media_keys_constructor_1.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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,23 +14,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNode from "../../is_node";
-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;
-    }
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MozMediaKeysConstructor = void 0;
+const wrapInPromise_1 = require("../../../utils/wrapInPromise");
+const global_scope_1 = require("../../global_scope");
+let MozMediaKeysConstructor;
+const { MozMediaKeys } = global_scope_1.default;
+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 */
+) {
+    exports.MozMediaKeysConstructor = MozMediaKeysConstructor = MozMediaKeys;
 }
-export { MozMediaKeysConstructor };
-export default function getMozMediaKeysCallbacks() {
-    var isTypeSupported = function (keySystem, type) {
+function getMozMediaKeysCallbacks() {
+    const isTypeSupported = (keySystem, type) => {
         if (MozMediaKeysConstructor === undefined) {
             throw new Error("No MozMediaKeys API.");
         }
@@ -38,22 +39,26 @@ export default function getMozMediaKeysCallbacks() {
         }
         return MozMediaKeysConstructor.isTypeSupported(keySystem);
     };
-    var createCustomMediaKeys = function (keyType) {
+    const createCustomMediaKeys = (keyType) => {
         if (MozMediaKeysConstructor === undefined) {
             throw new Error("No MozMediaKeys API.");
         }
         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);
+    const setMediaKeys = (mediaElement, mediaKeys) => {
+        return (0, wrapInPromise_1.default)(() => {
+            const 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,
-        createCustomMediaKeys: createCustomMediaKeys,
-        setMediaKeys: setMediaKeys,
+        isTypeSupported,
+        createCustomMediaKeys,
+        setMediaKeys,
     };
 }
+exports.default = getMozMediaKeysCallbacks;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,18 +14,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNode from "../../is_node";
-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;
-    }
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MSMediaKeysConstructor = void 0;
+const global_scope_1 = require("../../global_scope");
+let MSMediaKeysConstructor;
+const { MSMediaKeys } = global_scope_1.default;
+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 */
+) {
+    exports.MSMediaKeysConstructor = MSMediaKeysConstructor = MSMediaKeys;
 }
-export { MSMediaKeysConstructor };

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 {};