rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,34 +14,20 @@
  * 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 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";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_emitter_1 = require("../../../utils/event_emitter");
+const noop_1 = require("../../../utils/noop");
+const starts_with_1 = require("../../../utils/starts_with");
+const wrapInPromise_1 = require("../../../utils/wrapInPromise");
+const get_webkit_fairplay_initdata_1 = require("../get_webkit_fairplay_initdata");
+const webkit_media_keys_constructor_1 = require("./webkit_media_keys_constructor");
 /**
  * Check if keyType is for fairplay DRM
  * @param {string} keyType
  * @returns {boolean}
  */
 function isFairplayKeyType(keyType) {
-    return startsWith(keyType, "com.apple.fps");
+    return (0, starts_with_1.default)(keyType, "com.apple.fps");
 }
 /**
  * Set media keys on video element using native HTMLMediaElement
@@ -50,8 +37,8 @@ function isFairplayKeyType(keyType) {
  * @returns {Promise}
  */
 function setWebKitMediaKeys(videoElement, mediaKeys) {
-    var elt = videoElement;
-    return wrapInPromise(function () {
+    const elt = videoElement;
+    return (0, wrapInPromise_1.default)(() => {
         if (elt.webkitSetMediaKeys === undefined) {
             throw new Error("No webKitMediaKeys API.");
         }
@@ -66,38 +53,35 @@ function setWebKitMediaKeys(videoElement, mediaKeys) {
  * This class implements a standard EME API polyfill that wraps webkit prefixed Safari
  * EME custom APIs.
  */
-var WebkitMediaKeySession = /** @class */ (function (_super) {
-    __extends(WebkitMediaKeySession, _super);
+class WebkitMediaKeySession extends event_emitter_1.default {
     /**
      * @param {HTMLMediaElement} mediaElement
      * @param {string} keyType
      * @param {Uint8Array | undefined} serverCertificate
      */
-    function WebkitMediaKeySession(mediaElement, keyType, serverCertificate) {
-        var _this = _super.call(this) || this;
-        _this._serverCertificate = serverCertificate;
-        _this._videoElement = mediaElement;
-        _this._keyType = keyType;
-        _this._unbindSession = noop;
-        _this._closeSession = noop; // Just here to make TypeScript happy
-        _this.closed = new Promise(function (resolve) {
-            _this._closeSession = resolve;
+    constructor(mediaElement, keyType, serverCertificate) {
+        super();
+        this._serverCertificate = serverCertificate;
+        this._videoElement = mediaElement;
+        this._keyType = keyType;
+        this._unbindSession = noop_1.default;
+        this._closeSession = noop_1.default; // Just here to make TypeScript happy
+        this.closed = new Promise((resolve) => {
+            this._closeSession = resolve;
         });
-        _this.keyStatuses = new Map();
-        _this.expiration = NaN;
-        return _this;
+        this.keyStatuses = new Map();
+        this.expiration = NaN;
     }
-    WebkitMediaKeySession.prototype.update = function (license) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
+    update(license) {
+        return new Promise((resolve, reject) => {
             /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-            if (_this._nativeSession === undefined ||
-                _this._nativeSession.update === undefined ||
-                typeof _this._nativeSession.update !== "function") {
+            if (this._nativeSession === undefined ||
+                this._nativeSession.update === undefined ||
+                typeof this._nativeSession.update !== "function") {
                 return reject("Unavailable WebKit key session.");
             }
             try {
-                var uInt8Arraylicense = void 0;
+                let uInt8Arraylicense;
                 if (license instanceof ArrayBuffer) {
                     uInt8Arraylicense = new Uint8Array(license);
                 }
@@ -109,7 +93,7 @@ var WebkitMediaKeySession = /** @class */ (function (_super) {
                 }
                 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-                resolve(_this._nativeSession.update(uInt8Arraylicense));
+                resolve(this._nativeSession.update(uInt8Arraylicense));
                 /* eslint-enable @typescript-eslint/no-unsafe-member-access */
             }
             catch (err) {
@@ -117,132 +101,121 @@ var WebkitMediaKeySession = /** @class */ (function (_super) {
             }
             /* eslint-enable @typescript-eslint/no-unsafe-member-access */
         });
-    };
-    WebkitMediaKeySession.prototype.generateRequest = function (_initDataType, initData) {
-        var _this = this;
-        return new Promise(function (resolve) {
+    }
+    generateRequest(_initDataType, initData) {
+        return new Promise((resolve) => {
             var _a;
-            var elt = _this._videoElement;
+            const elt = this._videoElement;
             if (((_a = elt.webkitKeys) === null || _a === void 0 ? void 0 : _a.createSession) === undefined) {
                 throw new Error("No WebKitMediaKeys API.");
             }
-            var formattedInitData;
-            if (isFairplayKeyType(_this._keyType)) {
-                if (_this._serverCertificate === undefined) {
+            let formattedInitData;
+            if (isFairplayKeyType(this._keyType)) {
+                if (this._serverCertificate === undefined) {
                     throw new Error("A server certificate is needed for creating fairplay session.");
                 }
-                formattedInitData = getWebKitFairplayInitData(initData, _this._serverCertificate);
+                formattedInitData = (0, get_webkit_fairplay_initdata_1.default)(initData, this._serverCertificate);
             }
             else {
                 formattedInitData = initData;
             }
-            var keySession = elt.webkitKeys.createSession("video/mp4", formattedInitData);
+            const keySession = elt.webkitKeys.createSession("video/mp4", formattedInitData);
             if (keySession === undefined || keySession === null) {
                 throw new Error("Impossible to get the key sessions");
             }
-            _this._listenEvent(keySession);
+            this._listenEvent(keySession);
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            _this._nativeSession = keySession;
+            this._nativeSession = keySession;
             resolve();
         });
-    };
-    WebkitMediaKeySession.prototype.close = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            _this._unbindSession();
-            _this._closeSession();
-            if (_this._nativeSession === undefined) {
+    }
+    close() {
+        return new Promise((resolve, reject) => {
+            this._unbindSession();
+            this._closeSession();
+            if (this._nativeSession === undefined) {
                 reject("No session to close.");
                 return;
             }
             /* eslint-disable @typescript-eslint/no-floating-promises */
-            _this._nativeSession.close();
+            this._nativeSession.close();
             /* eslint-enable @typescript-eslint/no-floating-promises */
             resolve();
         });
-    };
-    WebkitMediaKeySession.prototype.load = function () {
+    }
+    load() {
         return Promise.resolve(false);
-    };
-    WebkitMediaKeySession.prototype.remove = function () {
+    }
+    remove() {
         return Promise.resolve();
-    };
-    Object.defineProperty(WebkitMediaKeySession.prototype, "sessionId", {
-        get: function () {
-            var _a, _b;
-            /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-            /* eslint-disable @typescript-eslint/no-unsafe-return */
-            return (_b = (_a = this._nativeSession) === null || _a === void 0 ? void 0 : _a.sessionId) !== null && _b !== void 0 ? _b : "";
-            /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-            /* eslint-enable @typescript-eslint/no-unsafe-return */
-        },
-        enumerable: false,
-        configurable: true
-    });
-    WebkitMediaKeySession.prototype._listenEvent = function (session) {
-        var _this = this;
+    }
+    get sessionId() {
+        var _a, _b;
+        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+        /* eslint-disable @typescript-eslint/no-unsafe-return */
+        return (_b = (_a = this._nativeSession) === null || _a === void 0 ? void 0 : _a.sessionId) !== null && _b !== void 0 ? _b : "";
+        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+        /* eslint-enable @typescript-eslint/no-unsafe-return */
+    }
+    _listenEvent(session) {
         this._unbindSession(); // If previous session was linked
-        var onEvent = function (evt) {
-            _this.trigger(evt.type, evt);
+        const onEvent = (evt) => {
+            this.trigger(evt.type, evt);
         };
         /* eslint-disable @typescript-eslint/no-unsafe-call */
         /* eslint-disable @typescript-eslint/no-unsafe-member-access */
         /* eslint-disable @typescript-eslint/no-unsafe-return */
         ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-            .forEach(function (evt) {
+            .forEach(evt => {
             session.addEventListener(evt, onEvent);
-            session.addEventListener("webkit".concat(evt), onEvent);
+            session.addEventListener(`webkit${evt}`, onEvent);
         });
-        this._unbindSession = function () {
+        this._unbindSession = () => {
             ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-                .forEach(function (evt) {
+                .forEach(evt => {
                 session.removeEventListener(evt, onEvent);
-                session.removeEventListener("webkit".concat(evt), onEvent);
+                session.removeEventListener(`webkit${evt}`, onEvent);
             });
         };
         /* eslint-disable @typescript-eslint/no-unsafe-return */
         /* eslint-disable @typescript-eslint/no-unsafe-member-access */
         /* eslint-enable @typescript-eslint/no-unsafe-call */
-    };
-    return WebkitMediaKeySession;
-}(EventEmitter));
-var WebKitCustomMediaKeys = /** @class */ (function () {
-    function WebKitCustomMediaKeys(keyType) {
-        if (WebKitMediaKeysConstructor === undefined) {
+    }
+}
+class WebKitCustomMediaKeys {
+    constructor(keyType) {
+        if (webkit_media_keys_constructor_1.WebKitMediaKeysConstructor === undefined) {
             throw new Error("No WebKitMediaKeys API.");
         }
         this._keyType = keyType;
-        this._mediaKeys = new WebKitMediaKeysConstructor(keyType);
+        this._mediaKeys = new webkit_media_keys_constructor_1.WebKitMediaKeysConstructor(keyType);
     }
-    WebKitCustomMediaKeys.prototype._setVideo = function (videoElement) {
+    _setVideo(videoElement) {
         this._videoElement = videoElement;
         if (this._videoElement === undefined) {
             throw new Error("Video not attached to the MediaKeys");
         }
         return setWebKitMediaKeys(this._videoElement, this._mediaKeys);
-    };
-    WebKitCustomMediaKeys.prototype.createSession = function ( /* sessionType */) {
+    }
+    createSession( /* sessionType */) {
         if (this._videoElement === undefined ||
             this._mediaKeys === undefined) {
             throw new Error("Video not attached to the MediaKeys");
         }
         return new WebkitMediaKeySession(this._videoElement, this._keyType, this._serverCertificate);
-    };
-    WebKitCustomMediaKeys.prototype.setServerCertificate = function (serverCertificate) {
+    }
+    setServerCertificate(serverCertificate) {
         this._serverCertificate = serverCertificate;
         return Promise.resolve();
-    };
-    return WebKitCustomMediaKeys;
-}());
-export default function getWebKitMediaKeysCallbacks() {
-    if (WebKitMediaKeysConstructor === undefined) {
+    }
+}
+function getWebKitMediaKeysCallbacks() {
+    if (webkit_media_keys_constructor_1.WebKitMediaKeysConstructor === undefined) {
         throw new Error("No WebKitMediaKeys API.");
     }
-    var isTypeSupported = WebKitMediaKeysConstructor.isTypeSupported;
-    var createCustomMediaKeys = function (keyType) {
-        return new WebKitCustomMediaKeys(keyType);
-    };
-    var setMediaKeys = function (elt, mediaKeys) {
+    const isTypeSupported = webkit_media_keys_constructor_1.WebKitMediaKeysConstructor.isTypeSupported;
+    const createCustomMediaKeys = (keyType) => new WebKitCustomMediaKeys(keyType);
+    const setMediaKeys = (elt, mediaKeys) => {
         if (mediaKeys === null) {
             return setWebKitMediaKeys(elt, mediaKeys);
         }
@@ -253,8 +226,9 @@ export default function getWebKitMediaKeysCallbacks() {
         return mediaKeys._setVideo(elt);
     };
     return {
-        isTypeSupported: isTypeSupported,
-        createCustomMediaKeys: createCustomMediaKeys,
-        setMediaKeys: setMediaKeys,
+        isTypeSupported,
+        createCustomMediaKeys,
+        setMediaKeys,
     };
 }
+exports.default = getWebKitMediaKeysCallbacks;

package/dist/_esm5.processed/compat/eme/custom_media_keys/webkit_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 globalScope from "../../global_scope";
-var WebKitMediaKeysConstructor;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebKitMediaKeysConstructor = void 0;
+const global_scope_1 = require("../../global_scope");
+let WebKitMediaKeysConstructor;
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-var WebKitMediaKeys = globalScope.WebKitMediaKeys;
+const { WebKitMediaKeys } = global_scope_1.default;
 if (WebKitMediaKeys !== undefined &&
     typeof WebKitMediaKeys.isTypeSupported === "function" &&
     typeof WebKitMediaKeys.prototype.createSession === "function" &&
     typeof HTMLMediaElement.prototype
         .webkitSetMediaKeys === "function") {
-    WebKitMediaKeysConstructor = WebKitMediaKeys;
+    exports.WebKitMediaKeysConstructor = WebKitMediaKeysConstructor = WebKitMediaKeys;
 }
-/* eslint-enable @typescript-eslint/no-unsafe-assignment */
-/* eslint-enable @typescript-eslint/no-unsafe-member-access */
-export { WebKitMediaKeysConstructor, };

package/dist/_esm5.processed/compat/eme/eme-api-implementation.js

@@ -1,25 +1,27 @@
-import { MediaError } from "../../errors";
-import assert from "../../utils/assert";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import { isIE11 } from "../browser_detection";
-import { createCompatibleEventListener } from "../event_listeners";
-import globalScope from "../global_scope";
-import isNode from "../is_node";
-import shouldFavourCustomSafariEME from "../should_favour_custom_safari_EME";
-import CustomMediaKeySystemAccess from "./custom_key_system_access";
-import getIE11MediaKeysCallbacks, { MSMediaKeysConstructor, } from "./custom_media_keys/ie11_media_keys";
-import getMozMediaKeysCallbacks, { MozMediaKeysConstructor, } from "./custom_media_keys/moz_media_keys_constructor";
-import getOldKitWebKitMediaKeyCallbacks, { isOldWebkitMediaElement, } from "./custom_media_keys/old_webkit_media_keys";
-import getWebKitMediaKeysCallbacks from "./custom_media_keys/webkit_media_keys";
-import { WebKitMediaKeysConstructor, } from "./custom_media_keys/webkit_media_keys_constructor";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../errors");
+const assert_1 = require("../../utils/assert");
+const is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+const browser_detection_1 = require("../browser_detection");
+const event_listeners_1 = require("../event_listeners");
+const global_scope_1 = require("../global_scope");
+const is_node_1 = require("../is_node");
+const should_favour_custom_safari_EME_1 = require("../should_favour_custom_safari_EME");
+const custom_key_system_access_1 = require("./custom_key_system_access");
+const ie11_media_keys_1 = require("./custom_media_keys/ie11_media_keys");
+const moz_media_keys_constructor_1 = require("./custom_media_keys/moz_media_keys_constructor");
+const old_webkit_media_keys_1 = require("./custom_media_keys/old_webkit_media_keys");
+const webkit_media_keys_1 = require("./custom_media_keys/webkit_media_keys");
+const webkit_media_keys_constructor_1 = require("./custom_media_keys/webkit_media_keys_constructor");
 /**
  * Automatically detect and set which EME implementation should be used in the
  * current platform.
  *
  * You can call `getEmeApiImplementation` for a different implementation.
  */
-var defaultEmeImplementation = getEmeApiImplementation("auto");
-export default defaultEmeImplementation;
+const defaultEmeImplementation = getEmeApiImplementation("auto");
+exports.default = defaultEmeImplementation;
 /**
  * Returns the current EME implementation based on what's present on the device
  * and the given preference.
@@ -28,113 +30,107 @@ export default defaultEmeImplementation;
  * @returns {Object}
  */
 function getEmeApiImplementation(preferredApiType) {
-    var requestMediaKeySystemAccess;
-    var onEncrypted;
-    var setMediaKeys = defaultSetMediaKeys;
-    var implementation;
+    let requestMediaKeySystemAccess;
+    let onEncrypted;
+    let setMediaKeys = defaultSetMediaKeys;
+    let implementation;
     if ((preferredApiType === "standard" ||
-        (preferredApiType === "auto" && !shouldFavourCustomSafariEME())) &&
+        (preferredApiType === "auto" && !(0, should_favour_custom_safari_EME_1.default)())) &&
         (
         // eslint-disable-next-line @typescript-eslint/unbound-method
-        isNode || !isNullOrUndefined(navigator.requestMediaKeySystemAccess))) {
-        requestMediaKeySystemAccess = function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return navigator.requestMediaKeySystemAccess.apply(navigator, args);
-        };
-        onEncrypted = createCompatibleEventListener(["encrypted"]);
+        is_node_1.default || !(0, is_null_or_undefined_1.default)(navigator.requestMediaKeySystemAccess))) {
+        requestMediaKeySystemAccess = (...args) => navigator.requestMediaKeySystemAccess(...args);
+        onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["encrypted"]);
         implementation = "standard";
     }
     else {
-        var isTypeSupported_1;
-        var createCustomMediaKeys_1;
-        if (preferredApiType === "webkit" && WebKitMediaKeysConstructor !== undefined) {
-            onEncrypted = createCompatibleEventListener(["needkey"]);
-            var callbacks = getWebKitMediaKeysCallbacks();
-            isTypeSupported_1 = callbacks.isTypeSupported;
-            createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
+        let isTypeSupported;
+        let createCustomMediaKeys;
+        if (preferredApiType === "webkit" && webkit_media_keys_constructor_1.WebKitMediaKeysConstructor !== undefined) {
+            onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["needkey"]);
+            const callbacks = (0, webkit_media_keys_1.default)();
+            isTypeSupported = callbacks.isTypeSupported;
+            createCustomMediaKeys = callbacks.createCustomMediaKeys;
             setMediaKeys = callbacks.setMediaKeys;
             implementation = "webkit";
         }
         else {
             // This is for Chrome with unprefixed EME api
-            if (isOldWebkitMediaElement(HTMLVideoElement.prototype)) {
-                onEncrypted = createCompatibleEventListener(["needkey"]);
-                var callbacks = getOldKitWebKitMediaKeyCallbacks();
-                isTypeSupported_1 = callbacks.isTypeSupported;
-                createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
+            if ((0, old_webkit_media_keys_1.isOldWebkitMediaElement)(HTMLVideoElement.prototype)) {
+                onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["needkey"]);
+                const callbacks = (0, old_webkit_media_keys_1.default)();
+                isTypeSupported = callbacks.isTypeSupported;
+                createCustomMediaKeys = callbacks.createCustomMediaKeys;
                 setMediaKeys = callbacks.setMediaKeys;
                 implementation = "older-webkit";
                 // This is for WebKit with prefixed EME api
             }
-            else if (WebKitMediaKeysConstructor !== undefined) {
-                onEncrypted = createCompatibleEventListener(["needkey"]);
-                var callbacks = getWebKitMediaKeysCallbacks();
-                isTypeSupported_1 = callbacks.isTypeSupported;
-                createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
+            else if (webkit_media_keys_constructor_1.WebKitMediaKeysConstructor !== undefined) {
+                onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["needkey"]);
+                const callbacks = (0, webkit_media_keys_1.default)();
+                isTypeSupported = callbacks.isTypeSupported;
+                createCustomMediaKeys = callbacks.createCustomMediaKeys;
                 setMediaKeys = callbacks.setMediaKeys;
                 implementation = "webkit";
             }
-            else if (isIE11 && MSMediaKeysConstructor !== undefined) {
-                onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
-                var callbacks = getIE11MediaKeysCallbacks();
-                isTypeSupported_1 = callbacks.isTypeSupported;
-                createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
+            else if (browser_detection_1.isIE11 && ie11_media_keys_1.MSMediaKeysConstructor !== undefined) {
+                onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["encrypted", "needkey"]);
+                const callbacks = (0, ie11_media_keys_1.default)();
+                isTypeSupported = callbacks.isTypeSupported;
+                createCustomMediaKeys = callbacks.createCustomMediaKeys;
                 setMediaKeys = callbacks.setMediaKeys;
                 implementation = "ms";
             }
-            else if (MozMediaKeysConstructor !== undefined) {
-                onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
-                var callbacks = getMozMediaKeysCallbacks();
-                isTypeSupported_1 = callbacks.isTypeSupported;
-                createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
+            else if (moz_media_keys_constructor_1.MozMediaKeysConstructor !== undefined) {
+                onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["encrypted", "needkey"]);
+                const callbacks = (0, moz_media_keys_constructor_1.default)();
+                isTypeSupported = callbacks.isTypeSupported;
+                createCustomMediaKeys = callbacks.createCustomMediaKeys;
                 setMediaKeys = callbacks.setMediaKeys;
                 implementation = "moz";
             }
             else {
-                onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
-                var MK_1 = globalScope.MediaKeys;
-                var checkForStandardMediaKeys_1 = function () {
-                    if (MK_1 === undefined) {
-                        throw new MediaError("MEDIA_KEYS_NOT_SUPPORTED", "No `MediaKeys` implementation found " +
+                onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["encrypted", "needkey"]);
+                const MK = global_scope_1.default.MediaKeys;
+                const checkForStandardMediaKeys = () => {
+                    if (MK === undefined) {
+                        throw new errors_1.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 " +
+                    if (typeof MK.isTypeSupported === "undefined") {
+                        const 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);
+                isTypeSupported = (keyType) => {
+                    checkForStandardMediaKeys();
+                    (0, assert_1.default)(typeof MK.isTypeSupported === "function");
+                    return MK.isTypeSupported(keyType);
                 };
-                createCustomMediaKeys_1 = function (keyType) {
-                    checkForStandardMediaKeys_1();
-                    return new MK_1(keyType);
+                createCustomMediaKeys = (keyType) => {
+                    checkForStandardMediaKeys();
+                    return new MK(keyType);
                 };
                 implementation = "unknown";
             }
         }
         requestMediaKeySystemAccess = function (keyType, keySystemConfigurations) {
-            if (!isTypeSupported_1(keyType)) {
+            if (!isTypeSupported(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;
+            for (let i = 0; i < keySystemConfigurations.length; i++) {
+                const keySystemConfiguration = keySystemConfigurations[i];
+                const { videoCapabilities, audioCapabilities, initDataTypes, distinctiveIdentifier } = keySystemConfiguration;
+                let supported = true;
                 supported = supported &&
                     (initDataTypes == null ||
-                        initDataTypes.some(function (idt) { return idt === "cenc"; }));
+                        initDataTypes.some((idt) => idt === "cenc"));
                 supported = supported && (distinctiveIdentifier !== "required");
                 if (supported) {
-                    var keySystemConfigurationResponse = {
+                    const keySystemConfigurationResponse = {
                         initDataTypes: ["cenc"],
                         distinctiveIdentifier: "not-allowed",
                         persistentState: "required",
@@ -147,14 +143,17 @@ function getEmeApiImplementation(preferredApiType) {
                         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));
+                    const customMediaKeys = createCustomMediaKeys(keyType);
+                    return Promise.resolve(new custom_key_system_access_1.default(keyType, customMediaKeys, keySystemConfigurationResponse));
                 }
             }
             return Promise.reject(new Error("Unsupported configuration"));
         };
     }
-    return { requestMediaKeySystemAccess: requestMediaKeySystemAccess, onEncrypted: onEncrypted, setMediaKeys: setMediaKeys, implementation: implementation };
+    return { requestMediaKeySystemAccess,
+        onEncrypted,
+        setMediaKeys,
+        implementation };
 }
 /**
  * Set the given MediaKeys on the given HTMLMediaElement.
@@ -165,8 +164,8 @@ function getEmeApiImplementation(preferredApiType) {
  */
 function defaultSetMediaKeys(mediaElement, mediaKeys) {
     try {
-        var ret = void 0;
-        var elt = mediaElement;
+        let ret;
+        const elt = mediaElement;
         /* eslint-disable @typescript-eslint/unbound-method */
         if (typeof elt.setMediaKeys === "function") {
             ret = elt.setMediaKeys(mediaKeys);