rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.2022032100

package/.eslintrc.js

@@ -350,10 +350,6 @@ module.exports = {
         "property": "substr",
         "message": "Please use `substring` instead.",
       },
-      {
-        "object": "Promise",
-        "message": "Not available in IE11, use promise ponyfill instead",
-      }
     ],
     "quote-props": [
       "error",

package/CHANGELOG.md

@@ -1,21 +1,36 @@
 # Changelog
 
-## v3.26.3-dev.2022021400 (2022-02-14)
+## v3.27.0-dev.2022032100 (2022-03-21)
+
+### Features
+
+  - Add a `maxVideoBufferSize` constructor option and `{get,set}MaxVideoBufferSize` methods to limit the size of loaded video data buffered at the same time [#1041, #1054]
+  - DRM: Add a `"periods"` mode to the `keySystems[].singleLicensePer` `loadVideo` option, allowing to obtain decryption license for groups of Periods allowing a compromise between optimization, features and compatibility [#1028, #1061]
+  - Add a `"reload"` `audioTrackSwitchingMode` to work-around rare compatibility issues when switching audio tracks [#1089]
 
 ### Bug fixes
 
   - subtitles: Fix rare issue where subtitles could be skipped due to a rounding error [#1064]
   - DASH: fix issue where the wrong segments would be requested on $Number$-based MPD with a SegmentTimeline older than the `timeShiftBufferDepth` [#1052, #1060]
   - directfile: disable all audio tracks before enabling one to work-around Safari issue on MacOS Monterey [#1067]
+  - avoid performing a small seek when changing the audio track [#1080]
+  - api: allow switching to RELOADING state synchronously after LOADED [#1083]
+  - Safari Mobile: Improve decryption support on Safari mobile by relying on the vendored `WebKitMediaKeys` API [#1072]
   - avoid unnecessary warning logs when loading some initialization segments [#1049]
   - TypeScript: Add forgotten TypeScript types in the exposed segment and manifest loader APIs [#1057]
+  - DRM: Avoid decryption issues when a license is persisted in a `singleLicensePer` `"init-data"` mode but loaded in a `"content"` mode [#1031, #1042]
 
 ### Other improvements
 
   - DASH: always consider that the non-last Period is finished when it contains SegmentTimeline elements [#1047]
   - add better buffer cleaning logic on a browser's `QuotaExceededError` to better handle memory limitations [#1065]
-  - avoid mistakenly relying on pinkie's Promise implementation when a native one is already available [#1058]
+  - DASH: Prioritize selectionPriority attribute over a "main" Role when ordering AdaptationSets [#1082]
+  - directfile/Safari: use the `getStartDate` method in `getWallClockTime` when available to obtain true offseted times when playing HLS contents on Safari [#1055]
+  - DRM: Improve DRM Session caches performance when `singleLicensePer` is set to `"content"`
+  - TypeScript: Add IBitrateEstimate, IPositionUpdate and IPlayerState types to the exported types [#1084]
+  - Remove dependency on pinkie's promise ponyfill [#1058, #1090]
   - tests: add performance tests, to better catch and avoid performance regressions [#1053, #1062]
+  - DRM: Refactor DRM logic for better maintainability. DRM-linked logs are now prefixed by `DRM:` instead of `EME:` like previously [#1042]
 
 
 ## v3.26.2 (2022-01-11)

package/FILES.md

@@ -25,7 +25,7 @@ a single directory or subdirectory, in alphabetical order.
   - [src/core/abr/: The adaptive bitrate code](#core-abr)
   - [src/core/api/: The API definition](#core-api)
   - [src/core/stream/: Load the right segments](#core-stream)
-  - [src/core/eme/: Encryption management](#core-eme)
+  - [src/core/decrypt/: Decryption management](#core-decrypt)
   - [src/core/fetchers/: The fetchers](#core-fetchers)
   - [src/core/segment_buffers/: The Media buffers](#core-sb)
   - [src/core/init/: Media streaming logic](#core-init)
@@ -240,10 +240,11 @@ The code there calculate which segments should be downloaded, ask for their
 download and push the segments into the `SegmentBuffers`.
 
 
-<a name="core-eme"></a>
-### src/core/eme/: Encryption management #######################################
+<a name="core-decrypt"></a>
+### src/core/decrypt/: Decryption management ###################################
 
-Defines functions allowing to handle encrypted contents through the EME APIs.
+Defines functions allowing to handle encrypted contents through the EME browser
+APIs.
 
 
 <a name="core-fetchers"></a>

package/VERSION

@@ -1 +1 @@
-3.26.3-dev.2022021400
+3.27.0-dev.2022032100

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

@@ -19,6 +19,8 @@ declare const isEdgeChromium: boolean;
 declare const isFirefox: boolean;
 declare const isSamsungBrowser: boolean;
 declare const isTizen: boolean;
-declare const isSafari: boolean;
+/** `true` on Safari on a PC platform (i.e. not iPhone / iPad etc.) */
+declare const isSafariDesktop: boolean;
+/** `true` on Safari on an iPhone, iPad & iPod platform */
 declare const isSafariMobile: boolean;
-export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isSafari, isSafariMobile, isSamsungBrowser, isTizen, };
+export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, };

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

@@ -34,10 +34,12 @@ var isSamsungBrowser = !isNode &&
     /SamsungBrowser/.test(navigator.userAgent);
 var isTizen = !isNode &&
     /Tizen/.test(navigator.userAgent);
-var isSafari = !isNode && (Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") >= 0 ||
+/** `true` on Safari on a PC platform (i.e. not iPhone / iPad etc.) */
+var isSafariDesktop = !isNode && (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()) ===
         "[object SafariRemoteNotification]");
+/** `true` on Safari on an iPhone, iPad & iPod platform */
 var isSafariMobile = !isNode &&
     typeof navigator.platform === "string" &&
     /iPad|iPhone|iPod/.test(navigator.platform);
-export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isSafari, isSafariMobile, isSamsungBrowser, isTizen, };
+export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, };

package/dist/_esm5.processed/compat/eme/close_session.d.ts

@@ -13,12 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import { ICustomMediaKeySession } from "./custom_media_keys";
 /**
- * Close session and returns and observable that emits when
- * the session is closed.
+ * Close the given `MediaKeySession` and returns a Promise resolving when the
+ * session is closed.
+ * This promise does not reject, even if we're unable to close the
+ * `MediaKeySession`.
+ *
+ * Note that there is a lot of browser issues linked to the impossibility to
+ * either close a MediaKeySession or to know if a MediaKeySession was closed.
+ * Due to this, the returned Promise might take some time before resolving on
+ * some devices.
  * @param {MediaKeySession|Object} session
- * @returns {Observable}
+ * @returns {Promise.<undefined>}
  */
-export default function closeSession$(session: MediaKeySession | ICustomMediaKeySession): Observable<unknown>;
+export default function closeSession(session: MediaKeySession | ICustomMediaKeySession): Promise<void>;

package/dist/_esm5.processed/compat/eme/close_session.js

@@ -13,43 +13,150 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { catchError, map, mergeMap, of as observableOf, race as observableRace, timer as observableTimer, } from "rxjs";
-import castToObservable from "../../utils/cast_to_observable";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import log from "../../log";
+import cancellableSleep from "../../utils/cancellable_sleep";
+import TaskCanceller, { CancellationError, } from "../../utils/task_canceller";
 /**
- * Close session and returns and observable that emits when
- * the session is closed.
+ * Close the given `MediaKeySession` and returns a Promise resolving when the
+ * session is closed.
+ * This promise does not reject, even if we're unable to close the
+ * `MediaKeySession`.
+ *
+ * Note that there is a lot of browser issues linked to the impossibility to
+ * either close a MediaKeySession or to know if a MediaKeySession was closed.
+ * Due to this, the returned Promise might take some time before resolving on
+ * some devices.
  * @param {MediaKeySession|Object} session
- * @returns {Observable}
+ * @returns {Promise.<undefined>}
  */
-export default function closeSession$(session) {
-    return observableRace(castToObservable(session.close()), 
-    // If the session is not closed after 1000ms, try
-    // to call another method on session to guess if
-    // session is closed or not.
-    observableTimer(1000).pipe(mergeMap(function () {
-        var tryToUpdateSession$ = castToObservable(session.update(new Uint8Array(1)));
-        return tryToUpdateSession$.pipe(
-        // Update has resolved, so we can't know if session is closed
-        map(function () {
-            throw new Error("Compat: Couldn't know if session is " +
-                "closed");
-        }), catchError(function (err) {
-            // The caught error can tell if session is closed
-            // (Chrome may throw this error)
-            if (err instanceof Error &&
-                err.message === "The session is already closed.") {
-                return observableOf(null);
-            }
-            // The `closed` promise may resolve, even if `close()` result has not
-            // (it may happen on Firefox). Wait for it and timeout after 1 second.
-            // TODO There is a subtle TypeScript issue there that made casting to
-            // a type-compatible type mandatory. If a more elegant solution can
-            // be found, it should be preffered.
-            var sessionIsClosed$ = castToObservable(session.closed);
-            return observableRace(sessionIsClosed$, observableTimer(1000).pipe(map(function () {
-                throw new Error("Compat: Couldn't know if session is " +
-                    "closed");
-            })));
-        }));
-    })));
+export default function closeSession(session) {
+    var timeoutCanceller = new TaskCanceller();
+    return Promise.race([
+        session.close()
+            .then(function () { timeoutCanceller.cancel(); }),
+        // The `closed` promise may resolve, even if `close()` result has not
+        // (seen at some point on Firefox).
+        session.closed
+            .then(function () { timeoutCanceller.cancel(); }),
+        waitTimeoutAndCheck(),
+    ]);
+    /**
+     * If the session is not closed after 1000ms, try to communicate with the
+     * MediaKeySession and check if an error is returned.
+     * This is needed because on some browsers with poor EME implementation,
+     * knowing when a MediaKeySession is closed is actually a hard task.
+     *
+     * The returned Promise will never reject.
+     * @returns {Promise.<undefined>}
+     */
+    function waitTimeoutAndCheck() {
+        return __awaiter(this, void 0, void 0, function () {
+            var err_1, message;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, cancellableSleep(1000, timeoutCanceller.signal)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, tryUpdatingSession()];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        if (err_1 instanceof CancellationError) { // cancelled == session closed
+                            return [2 /*return*/];
+                        }
+                        message = err_1 instanceof Error ?
+                            err_1.message :
+                            "Unknown error made it impossible to close the session";
+                        log.error("DRM: ".concat(message));
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    /**
+     * Try to update `MediaKeySession` and check its error if it failed.
+     * If we still don't know whether it closed yet, wait a second
+     * timeout then quit.
+     *
+     * The returned Promise resolves if the `MediaKeySession` seems closed and
+     * rejects if we couldn't know or it doesn't.
+     * @returns {Promise.<undefined>}
+     */
+    function tryUpdatingSession() {
+        return __awaiter(this, void 0, void 0, function () {
+            var err_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 4]);
+                        return [4 /*yield*/, session.update(new Uint8Array(1))];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        err_2 = _a.sent();
+                        if (timeoutCanceller.isUsed) { // Reminder: cancelled == session closed
+                            return [2 /*return*/];
+                        }
+                        // The caught error can tell if session is closed
+                        // (Chrome may throw this error)
+                        // I know... Checking the error message is not the best practice ever.
+                        if (err_2 instanceof Error &&
+                            err_2.message === "The session is already closed.") {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, cancellableSleep(1000, timeoutCanceller.signal)];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 4:
+                        if (timeoutCanceller.isUsed) { // Reminder: cancelled == session closed
+                            return [2 /*return*/];
+                        }
+                        throw new Error("Compat: Couldn't know if session is closed");
+                }
+            });
+        });
+    }
 }

package/dist/_esm5.processed/compat/eme/custom_key_system_access.d.ts

@@ -1,3 +1,18 @@
+/**
+ * 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 { ICustomMediaKeys } from "./custom_media_keys";
 export interface ICustomMediaKeySystemAccess {
     readonly keySystem: string;

package/dist/_esm5.processed/compat/eme/custom_key_system_access.js

@@ -1,19 +1,3 @@
-/**
- * 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 PPromise from "../../utils/promise";
 /**
  * Simple implementation of the MediaKeySystemAccess EME API.
  *
@@ -50,7 +34,7 @@ var CustomMediaKeySystemAccess = /** @class */ (function () {
      */
     CustomMediaKeySystemAccess.prototype.createMediaKeys = function () {
         var _this = this;
-        return new PPromise(function (res) { return res(_this._mediaKeys); });
+        return new Promise(function (res) { return res(_this._mediaKeys); });
     };
     /**
      * @returns {Object} - Configuration accepted for this MediaKeySystemAccess.

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

@@ -30,7 +30,6 @@ var __extends = (this && this.__extends) || (function () {
 })();
 import { merge as observableMerge, Subject, takeUntil, } from "rxjs";
 import EventEmitter from "../../../utils/event_emitter";
-import PPromise from "../../../utils/promise";
 import * as events from "../../event_listeners";
 import { MSMediaKeysConstructor, } from "./ms_media_keys_constructor";
 var IE11MediaKeySession = /** @class */ (function (_super) {
@@ -41,11 +40,11 @@ var IE11MediaKeySession = /** @class */ (function (_super) {
         _this.keyStatuses = new Map();
         _this._mk = mk;
         _this._closeSession$ = new Subject();
-        _this.closed = new PPromise(function (resolve) {
+        _this.closed = new Promise(function (resolve) {
             _this._closeSession$.subscribe(resolve);
         });
         _this.update = function (license) {
-            return new PPromise(function (resolve, reject) {
+            return new Promise(function (resolve, reject) {
                 if (_this._ss === undefined) {
                     return reject("MediaKeySession not set.");
                 }
@@ -61,7 +60,7 @@ var IE11MediaKeySession = /** @class */ (function (_super) {
     }
     IE11MediaKeySession.prototype.generateRequest = function (_initDataType, initData) {
         var _this = this;
-        return new PPromise(function (resolve) {
+        return new Promise(function (resolve) {
             var initDataU8 = initData instanceof Uint8Array ? initData :
                 initData instanceof ArrayBuffer ? new Uint8Array(initData) :
                     new Uint8Array(initData.buffer);
@@ -73,7 +72,7 @@ var IE11MediaKeySession = /** @class */ (function (_super) {
     };
     IE11MediaKeySession.prototype.close = function () {
         var _this = this;
-        return new PPromise(function (resolve) {
+        return new Promise(function (resolve) {
             if (_this._ss != null) {
                 _this._ss.close();
                 _this._ss = undefined;
@@ -84,10 +83,10 @@ var IE11MediaKeySession = /** @class */ (function (_super) {
         });
     };
     IE11MediaKeySession.prototype.load = function () {
-        return PPromise.resolve(false);
+        return Promise.resolve(false);
     };
     IE11MediaKeySession.prototype.remove = function () {
-        return PPromise.resolve();
+        return Promise.resolve();
     };
     Object.defineProperty(IE11MediaKeySession.prototype, "sessionId", {
         get: function () {

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

@@ -13,18 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import CustomMediaKeySystemAccess from "./../custom_key_system_access";
 import { ICustomMediaKeys, ICustomMediaKeySession } from "./types";
 /** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
-declare type ICompatRequestMediaKeySystemAccessFn = (keyType: string, config: MediaKeySystemConfiguration[]) => Observable<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
-declare let requestMediaKeySystemAccess: null | ICompatRequestMediaKeySystemAccessFn;
+declare 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
- * @returns {Observable}
  */
-declare function setMediaKeys(elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null): Observable<unknown>;
+declare let setMediaKeys: ((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => unknown);
 export { requestMediaKeySystemAccess, setMediaKeys, ICustomMediaKeys, ICustomMediaKeySession, };

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

@@ -13,10 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, of as observableOf, throwError as observableThrow, } from "rxjs";
 import { MediaError } from "../../../errors";
 import assert from "../../../utils/assert";
-import castToObservable from "../../../utils/cast_to_observable";
 import { isIE11 } from "../../browser_detection";
 import isNode from "../../is_node";
 import shouldFavourCustomSafariEME from "../../should_favour_custom_safari_EME";
@@ -27,7 +25,13 @@ import getOldKitWebKitMediaKeyCallbacks, { isOldWebkitMediaElement, } from "./ol
 import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 var requestMediaKeySystemAccess = null;
-var _setMediaKeys = function defaultSetMediaKeys(mediaElement, mediaKeys) {
+/**
+ * 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") {
@@ -58,8 +62,12 @@ var _setMediaKeys = function defaultSetMediaKeys(mediaElement, mediaKeys) {
  */
 if (isNode ||
     (navigator.requestMediaKeySystemAccess != null && !shouldFavourCustomSafariEME())) {
-    requestMediaKeySystemAccess = function (a, b) {
-        return castToObservable(navigator.requestMediaKeySystemAccess(a, b));
+    requestMediaKeySystemAccess = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return navigator.requestMediaKeySystemAccess.apply(navigator, args);
     };
 }
 else {
@@ -70,26 +78,26 @@ else {
         var callbacks = getOldKitWebKitMediaKeyCallbacks();
         isTypeSupported_1 = callbacks.isTypeSupported;
         createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        _setMediaKeys = callbacks.setMediaKeys;
+        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;
+        setMediaKeys = callbacks.setMediaKeys;
     }
     else if (isIE11 && MSMediaKeysConstructor !== undefined) {
         var callbacks = getIE11MediaKeysCallbacks();
         isTypeSupported_1 = callbacks.isTypeSupported;
         createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        _setMediaKeys = callbacks.setMediaKeys;
+        setMediaKeys = callbacks.setMediaKeys;
     }
     else if (MozMediaKeysConstructor !== undefined) {
         var callbacks = getMozMediaKeysCallbacks();
         isTypeSupported_1 = callbacks.isTypeSupported;
         createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        _setMediaKeys = callbacks.setMediaKeys;
+        setMediaKeys = callbacks.setMediaKeys;
     }
     else {
         var MK_1 = window.MediaKeys;
@@ -117,7 +125,7 @@ else {
     }
     requestMediaKeySystemAccess = function (keyType, keySystemConfigurations) {
         if (!isTypeSupported_1(keyType)) {
-            return observableThrow(function () { return new Error("Unsupported key type"); });
+            return Promise.reject(new Error("Unsupported key type"));
         }
         for (var i = 0; i < keySystemConfigurations.length; i++) {
             var keySystemConfiguration = keySystemConfigurations[i];
@@ -142,20 +150,10 @@ else {
                 }
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 var customMediaKeys = createCustomMediaKeys_1(keyType);
-                return observableOf(new CustomMediaKeySystemAccess(keyType, customMediaKeys, keySystemConfigurationResponse));
+                return Promise.resolve(new CustomMediaKeySystemAccess(keyType, customMediaKeys, keySystemConfigurationResponse));
             }
         }
-        return observableThrow(function () { return new Error("Unsupported configuration"); });
+        return Promise.reject(new Error("Unsupported configuration"));
     };
 }
-/**
- * Set the given MediaKeys on the given HTMLMediaElement.
- * Emits null when done then complete.
- * @param {HTMLMediaElement} elt
- * @param {Object} mediaKeys
- * @returns {Observable}
- */
-function setMediaKeys(elt, mediaKeys) {
-    return observableDefer(function () { return castToObservable(_setMediaKeys(elt, mediaKeys)); });
-}
 export { requestMediaKeySystemAccess, setMediaKeys, };