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

package/dummy

@@ -0,0 +1 @@
+This is an unnecessary file, just added to trigger the integration tests in a PR through GitHub actions.

package/{dist/_esm5.processed/core/eme/dispose_eme.d.ts → experimental/index.d.ts}

@@ -13,7 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * Free up all ressources taken by the EME management.
- */
-export default function disposeEME(mediaElement: HTMLMediaElement): void;
+ export * from "../dist/_esm5.processed/experimental/index";

package/{dist/_esm5.processed/core/eme/dispose_media_keys.d.ts → experimental/index.js}

@@ -13,9 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-/**
- * @param {Object} mediaKeysInfos
- * @returns {Observable}
- */
-export default function disposeMediaKeys(mediaElement: HTMLMediaElement): Observable<unknown>;
+export * from "../dist/_esm5.processed/experimental/index.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.26.3-dev.2022021400",
+  "version": "3.27.0-dev.20220317",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [
@@ -38,7 +38,7 @@
     "build:wasm:release": "cd ./src/parsers/manifest/dash/wasm-parser && cargo build --target wasm32-unknown-unknown --release && wasm-opt -O3 -o ../../../../../dist/mpd-parser.wasm target/wasm32-unknown-unknown/release/mpd_node_parser.wasm && cd ../../../../../ && npm run wasm-strip",
     "certificate": "./scripts/generate_certificate",
     "check": "npm run check:types && npm run lint",
-    "check:all": "npm run check:types && npm run lint && npm run lint:demo && npm run lint:tests && npm run test && npm run test:memory && node -r esm ./scripts/check_nodejs_import_compatibility.js",
+    "check:all": "npm run check:types && npm run lint && npm run lint:demo && npm run lint:tests && npm run test:unit && npm run test:integration && npm run test:memory && node -r esm ./scripts/check_nodejs_import_compatibility.js",
     "check:appveyor": "npm run check:types && npm run lint && npm run lint:demo && npm run lint:tests && npm run test:appveyor",
     "check:types": "tsc --noEmit --project .",
     "check:types:watch": "tsc --noEmit --watch --project .",
@@ -80,42 +80,40 @@
     "rxjs": "7.4.0"
   },
   "devDependencies": {
-    "@babel/core": "7.16.7",
-    "@babel/plugin-transform-runtime": "7.16.7",
-    "@babel/preset-env": "7.16.7",
+    "@babel/core": "7.17.7",
+    "@babel/plugin-transform-runtime": "7.17.0",
+    "@babel/preset-env": "7.16.11",
     "@babel/preset-react": "7.16.7",
     "@types/chai": "4.3.0",
-    "@types/jest": "27.4.0",
-    "@types/mocha": "9.0.0",
-    "@types/node": "17.0.7",
-    "@types/sinon": "10.0.6",
-    "@typescript-eslint/eslint-plugin": "5.8.1",
-    "@typescript-eslint/eslint-plugin-tslint": "5.8.1",
-    "@typescript-eslint/parser": "5.8.1",
+    "@types/jest": "27.4.1",
+    "@types/mocha": "9.1.0",
+    "@types/node": "17.0.21",
+    "@types/sinon": "10.0.11",
+    "@typescript-eslint/eslint-plugin": "5.15.0",
+    "@typescript-eslint/eslint-plugin-tslint": "5.15.0",
+    "@typescript-eslint/parser": "5.15.0",
     "arraybuffer-loader": "1.0.8",
     "babel-loader": "8.2.3",
-    "chai": "4.3.4",
+    "chai": "4.3.6",
     "cheerio": "1.0.0-rc.10",
-    "core-js": "3.20.2",
-    "esbuild": "0.14.10",
-    "eslint": "8.6.0",
+    "core-js": "3.21.1",
+    "esbuild": "0.14.27",
+    "eslint": "8.11.0",
     "eslint-plugin-import": "2.25.4",
-    "eslint-plugin-jsdoc": "37.5.0",
-    "eslint-plugin-react": "7.28.0",
+    "eslint-plugin-jsdoc": "38.0.4",
+    "eslint-plugin-react": "7.29.4",
     "esm": "3.2.25",
-    "express": "4.17.2",
-    "highlight.js": "11.3.1",
+    "express": "4.17.3",
+    "highlight.js": "11.5.0",
     "html-entities": "2.3.2",
-    "istanbul-instrumenter-loader": "3.0.1",
-    "jest": "27.4.5",
-    "karma": "6.3.14",
-    "karma-chrome-launcher": "3.1.0",
-    "karma-coverage-istanbul-reporter": "3.0.3",
+    "jest": "27.5.1",
+    "karma": "6.3.17",
+    "karma-chrome-launcher": "3.1.1",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
     "karma-webpack": "5.0.0",
-    "markdown-it": "12.3.0",
-    "mocha": "9.1.3",
+    "markdown-it": "12.3.2",
+    "mocha": "9.2.2",
     "mocha-loader": "5.1.5",
     "raw-loader": "4.0.2",
     "react": "17.0.2",
@@ -123,15 +121,15 @@
     "regenerator-runtime": "0.13.9",
     "rimraf": "3.0.2",
     "semver": "7.3.5",
-    "sinon": "12.0.1",
-    "terser-webpack-plugin": "5.3.0",
-    "ts-jest": "27.1.2",
-    "ts-loader": "9.2.6",
+    "sinon": "13.0.1",
+    "terser-webpack-plugin": "5.3.1",
+    "ts-jest": "27.1.3",
+    "ts-loader": "9.2.8",
     "tslint": "6.1.3",
-    "typescript": "4.5.4",
-    "webpack": "5.65.0",
+    "typescript": "4.6.2",
+    "webpack": "5.70.0",
     "webpack-bundle-analyzer": "4.5.0",
-    "webpack-cli": "4.9.1"
+    "webpack-cli": "4.9.2"
   },
   "scripts-list": {
     "Build a demo page (e.g. to test a code change)": {

package/scripts/build/templates/experimental/index.d.ts

@@ -0,0 +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.
+ */
+ export * from "../__BUILD_DIR__/experimental/index";

package/scripts/build/templates/experimental/index.js

@@ -0,0 +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.
+ */
+export * from "../__BUILD_DIR__/experimental/index.js";

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.26.3-dev.2022021400
+sonar.projectVersion=3.27.0-dev.2022031700
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

package/src/README.md

@@ -33,12 +33,12 @@ To better understand the player's architecture, you can find below a
   Facilitate track                V ~                  | ~     Abstract the streaming ^ ~
   switching for           +---------------+            | ~     protocol               | ~
   the API                 |               |            | V                            | ~
- +--------------+         |               |         +--------------------------+      | ~
- |              |         |     Init      | ------> |                          |      | ~
- |  EMEManager  | <------ | (./core/init) | <~~~~~~ |     Manifest Fetcher     |      | ~
- | (./core/eme) | ~~~~~~> |               |         |(./core/fetchers/manifest)|      | ~
- |              |         |               |         |                          |      | ~
- +--------------+         +---------------+         +--------------------------+      | ~
+ +----------------+       |               |         +--------------------------+      | ~
+ |    Content     |       |     Init      | ------> |                          |      | ~
+ |   Decryptor    | <---- | (./core/init) | <~~~~~~ |     Manifest Fetcher     |      | ~
+ |(./core/decrypt)| ~~~~> |               |         |(./core/fetchers/manifest)|      | ~
+ |                |       |               |         |                          |      | ~
+ +----------------+       +---------------+         +--------------------------+      | ~
  Negotiate content               | ^  Initialize     Load and refresh the Manifest    | ~
  decryption                      | ~  playback and                                    | ~
                                  | ~  create/connect                                  | ~

package/src/compat/__tests__/should_favour_custom_safari_EME.test.ts

@@ -40,27 +40,66 @@ describe("compat - shouldFavourSafariMediaKeys", () => {
   it("should return false if we are not on Safari", () => {
     jest.mock("../browser_detection", () => {
       return { __esModule: true as const,
-               isSafari: false };
+               isSafariDesktop: false,
+               isSafariMobile: false };
     });
     const shouldFavourCustomSafariEME = require("../should_favour_custom_safari_EME");
     expect(shouldFavourCustomSafariEME.default()).toBe(false);
   });
 
   /* eslint-disable max-len */
-  it("should return false if we are on Safari but WekitMediaKeys is not available", () => {
+  it("should return false if we are on Safari Desktop but WekitMediaKeys is not available", () => {
   /* eslint-enable max-len */
 
     win.WebKitMediaKeys = undefined;
     jest.mock("../browser_detection", () => {
       return { __esModule: true as const,
-               isSafari: true };
+               isSafariDesktop: true,
+               isSafariMobile: false };
     });
     const shouldFavourCustomSafariEME = require("../should_favour_custom_safari_EME");
     expect(shouldFavourCustomSafariEME.default()).toBe(false);
   });
 
   /* eslint-disable max-len */
-  it("should return true if we are on Safari and a WebKitMediaKeys implementation is available", () => {
+  it("should return false if we are on Safari Mobile but WekitMediaKeys is not available", () => {
+  /* eslint-enable max-len */
+
+    win.WebKitMediaKeys = undefined;
+    jest.mock("../browser_detection", () => {
+      return { __esModule: true as const,
+               isSafariDesktop: false,
+               isSafariMobile: true };
+    });
+    const shouldFavourCustomSafariEME = require("../should_favour_custom_safari_EME");
+    expect(shouldFavourCustomSafariEME.default()).toBe(false);
+  });
+
+  /* eslint-disable max-len */
+  it("should return true if we are on Safari Desktop and a WebKitMediaKeys implementation is available", () => {
+  /* eslint-enable max-len */
+
+    win.WebKitMediaKeys = {
+      isTypeSupported: () => ({}),
+      prototype: {
+        createSession: () => ({}),
+      },
+    };
+    const proto = win.HTMLMediaElement.prototype as unknown as {
+      webkitSetMediaKeys : () => Record<string, never>;
+    };
+    proto.webkitSetMediaKeys = () => ({});
+    jest.mock("../browser_detection", () => {
+      return { __esModule: true as const,
+               isSafariDesktop: true,
+               isSafariMobile: false };
+    });
+    const shouldFavourCustomSafariEME = require("../should_favour_custom_safari_EME");
+    expect(shouldFavourCustomSafariEME.default()).toBe(true);
+  });
+
+  /* eslint-disable max-len */
+  it("should return true if we are on Safari Mobile and a WebKitMediaKeys implementation is available", () => {
   /* eslint-enable max-len */
 
     win.WebKitMediaKeys = {
@@ -75,7 +114,8 @@ describe("compat - shouldFavourSafariMediaKeys", () => {
     proto.webkitSetMediaKeys = () => ({});
     jest.mock("../browser_detection", () => {
       return { __esModule: true as const,
-               isSafari: true };
+               isSafariDesktop: false,
+               isSafariMobile: true };
     });
     const shouldFavourCustomSafariEME = require("../should_favour_custom_safari_EME");
     expect(shouldFavourCustomSafariEME.default()).toBe(true);

package/src/compat/browser_detection.ts

@@ -54,13 +54,15 @@ interface ISafariWindowObject extends Window {
   safari? : { pushNotification? : { toString() : string } };
 }
 
-const isSafari : boolean =
+/** `true` on Safari on a PC platform (i.e. not iPhone / iPad etc.) */
+const isSafariDesktop : boolean =
   !isNode && (
     Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") >= 0 ||
     (window as ISafariWindowObject).safari?.pushNotification?.toString() ===
       "[object SafariRemoteNotification]"
   );
 
+/** `true` on Safari on an iPhone, iPad & iPod platform */
 const isSafariMobile : boolean = !isNode &&
                                  typeof navigator.platform === "string" &&
                                  /iPad|iPhone|iPod/.test(navigator.platform);
@@ -70,7 +72,7 @@ export {
   isIE11,
   isIEOrEdge,
   isFirefox,
-  isSafari,
+  isSafariDesktop,
   isSafariMobile,
   isSamsungBrowser,
   isTizen,

package/src/compat/eme/close_session.ts

@@ -14,65 +14,99 @@
  * limitations under the License.
  */
 
-import {
-  catchError,
-  map,
-  mergeMap,
-  Observable,
-  of as observableOf,
-  race as observableRace,
-  timer as observableTimer,
-} from "rxjs";
-import castToObservable from "../../utils/cast_to_observable";
+import log from "../../log";
+import cancellableSleep from "../../utils/cancellable_sleep";
+import PPromise from "../../utils/promise";
+import TaskCanceller, {
+  CancellationError,
+} from "../../utils/task_canceller";
 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> {
-  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(() => {
-        const tryToUpdateSession$ = castToObservable(
-          session.update(new Uint8Array(1))
-        );
-        return tryToUpdateSession$.pipe(
-          // Update has resolved, so we can't know if session is closed
-          map(() => { throw new Error("Compat: Couldn't know if session is " +
-                                      "closed"); }),
-          catchError((err : unknown) => {
-            // 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.
-            const sessionIsClosed$ = castToObservable(session.closed as Promise<unknown>);
-            return observableRace(
-              sessionIsClosed$,
-              observableTimer(1000).pipe(
-                map(() => { throw new Error("Compat: Couldn't know if session is " +
-                                            "closed"); })
-              )
-            );
-          })
-        );
-      })
-    )
-  );
+export default function closeSession(
+  session: MediaKeySession | ICustomMediaKeySession
+): Promise<void> {
+  const timeoutCanceller = new TaskCanceller();
+
+  return PPromise.race([
+    session.close()
+      .then(() => { timeoutCanceller.cancel(); }),
+    // The `closed` promise may resolve, even if `close()` result has not
+    // (seen at some point on Firefox).
+    session.closed
+      .then(() => { 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>}
+   */
+  async function waitTimeoutAndCheck() : Promise<void> {
+    try {
+      await cancellableSleep(1000, timeoutCanceller.signal);
+      await tryUpdatingSession();
+    } catch (err) {
+      if (err instanceof CancellationError) { // cancelled == session closed
+        return;
+      }
+      const message = err instanceof Error ?
+        err.message :
+        "Unknown error made it impossible to close the session";
+      log.error(`DRM: ${message}`);
+    }
+  }
+
+  /**
+   * 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>}
+   */
+  async function tryUpdatingSession() : Promise<void> {
+    try {
+      await session.update(new Uint8Array(1));
+    } catch (err) {
+      if (timeoutCanceller.isUsed) { // Reminder: cancelled == session closed
+        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 instanceof Error &&
+          err.message === "The session is already closed."
+      ) {
+        return;
+      }
+
+      await cancellableSleep(1000, timeoutCanceller.signal);
+    }
+
+    if (timeoutCanceller.isUsed) { // Reminder: cancelled == session closed
+      return;
+    }
+
+    throw new Error("Compat: Couldn't know if session is closed");
+  }
 }

package/src/compat/eme/custom_media_keys/index.ts

@@ -14,15 +14,9 @@
  * limitations under the License.
  */
 
-import {
-  defer as observableDefer,
-  Observable,
-  of as observableOf,
-  throwError as observableThrow,
-} from "rxjs";
+import PPromise from "pinkie";
 import { MediaError } from "../../../errors";
 import assert from "../../../utils/assert";
-import castToObservable from "../../../utils/cast_to_observable";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import { isIE11 } from "../../browser_detection";
 import isNode from "../../is_node";
@@ -47,12 +41,18 @@ import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 /** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
 type ICompatRequestMediaKeySystemAccessFn =
   (keyType : string, config : MediaKeySystemConfiguration[]) =>
-    Observable<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+    Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
 
-let requestMediaKeySystemAccess : null | ICompatRequestMediaKeySystemAccessFn = null;
+let requestMediaKeySystemAccess : ICompatRequestMediaKeySystemAccessFn | null = null;
 
-let _setMediaKeys :
-((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => void) =
+/**
+ * Set the given MediaKeys on the given HTMLMediaElement.
+ * Emits null when done then complete.
+ * @param {HTMLMediaElement} elt
+ * @param {Object} mediaKeys
+ */
+let setMediaKeys :
+((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => unknown) =
   function defaultSetMediaKeys(
     mediaElement: HTMLMediaElement,
     mediaKeys: MediaKeys | ICustomMediaKeys | null
@@ -92,11 +92,8 @@ let _setMediaKeys :
 if (isNode ||
     (navigator.requestMediaKeySystemAccess != null && !shouldFavourCustomSafariEME())
 ) {
-  requestMediaKeySystemAccess = (
-    a : string,
-    b : MediaKeySystemConfiguration[]
-  ) : Observable<MediaKeySystemAccess> =>
-    castToObservable(navigator.requestMediaKeySystemAccess(a, b));
+  requestMediaKeySystemAccess = (...args) =>
+    navigator.requestMediaKeySystemAccess(...args);
 } else {
   let isTypeSupported: (keyType: string) => boolean;
   let createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
@@ -106,23 +103,23 @@ if (isNode ||
     const callbacks = getOldKitWebKitMediaKeyCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   // This is for WebKit with prefixed EME api
   } else if (WebKitMediaKeysConstructor !== undefined) {
     const callbacks = getWebKitMediaKeysCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   } else if (isIE11 && MSMediaKeysConstructor !== undefined) {
     const callbacks = getIE11MediaKeysCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   } else if (MozMediaKeysConstructor !== undefined) {
     const callbacks = getMozMediaKeysCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   } else {
     const MK = window.MediaKeys as unknown as typeof MediaKeys & {
       isTypeSupported? : (keyType : string) => boolean;
@@ -155,9 +152,9 @@ if (isNode ||
   requestMediaKeySystemAccess = function(
     keyType : string,
     keySystemConfigurations : MediaKeySystemConfiguration[]
-  ) : Observable<MediaKeySystemAccess|CustomMediaKeySystemAccess> {
+  ) : Promise<MediaKeySystemAccess|CustomMediaKeySystemAccess> {
     if (!isTypeSupported(keyType)) {
-      return observableThrow(() => new Error("Unsupported key type"));
+      return PPromise.reject(new Error("Unsupported key type"));
     }
 
     for (let i = 0; i < keySystemConfigurations.length; i++) {
@@ -188,7 +185,7 @@ if (isNode ||
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const customMediaKeys = createCustomMediaKeys(keyType);
-        return observableOf(
+        return PPromise.resolve(
           new CustomMediaKeySystemAccess(keyType,
                                          customMediaKeys,
                                          keySystemConfigurationResponse)
@@ -196,24 +193,10 @@ if (isNode ||
       }
     }
 
-    return observableThrow(() => new Error("Unsupported configuration"));
+    return PPromise.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 : HTMLMediaElement,
-  mediaKeys : MediaKeys|ICustomMediaKeys|null
-) : Observable<unknown> {
-  return observableDefer(() => castToObservable(_setMediaKeys(elt, mediaKeys)));
-}
-
 export {
   requestMediaKeySystemAccess,
   setMediaKeys,