rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/compat/clear_element_src.ts

@@ -15,19 +15,21 @@
  */
 
 import log from "../log";
-import { isFirefox } from "./browser_detection";
+import isNullOrUndefined from "../utils/is_null_or_undefined";
 
 /**
  * Clear element's src attribute.
  * @param {HTMLMediaElement} element
  */
 export default function clearElementSrc(element : HTMLMediaElement) : void {
-  // On Firefox, we also have to make sure the textTracks elements are both
-  // disabled and removed from the DOM.
+  // On some browsers, we first have to make sure the textTracks elements are
+  // both disabled and removed from the DOM.
   // If we do not do that, we may be left with displayed text tracks on the
-  // screen
-  if (isFirefox) {
-    const { textTracks } = element;
+  // screen, even if the track elements are properly removed, due to browser
+  // issues.
+  // Bug seen on Firefox (I forgot which version) and Chrome 96.
+  const { textTracks } = element;
+  if (!isNullOrUndefined(textTracks)) {
     for (let i = 0; i < textTracks.length; i++) {
       textTracks[i].mode = "disabled";
     }

package/src/compat/eme/close_session.ts

@@ -15,16 +15,14 @@
  */
 
 import {
+  catchError,
+  map,
+  mergeMap,
   Observable,
   of as observableOf,
   race as observableRace,
   timer as observableTimer,
 } from "rxjs";
-import {
-  catchError,
-  map,
-  mergeMap,
-} from "rxjs/operators";
 import castToObservable from "../../utils/cast_to_observable";
 import { ICustomMediaKeySession } from "./custom_media_keys";
 
@@ -61,7 +59,10 @@ export default function closeSession$(
             }
             // The `closed` promise may resolve, even if `close()` result has not
             // (it may happen on Firefox). Wait for it and timeout after 1 second.
-            const sessionIsClosed$ = castToObservable(session.closed);
+            // 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(

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

@@ -17,12 +17,17 @@
 import {
   merge as observableMerge,
   Subject,
+  takeUntil,
 } from "rxjs";
-import { takeUntil } from "rxjs/operators";
 import EventEmitter from "../../../utils/event_emitter";
 import PPromise from "../../../utils/promise";
+import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import * as events from "../../event_listeners";
-import { MSMediaKeysConstructor } from "./ms_media_keys_constructor";
+import {
+  MSMediaKeysConstructor,
+  MSMediaKeys,
+  MSMediaKeySession,
+} from "./ms_media_keys_constructor";
 import {
   ICustomMediaKeys,
   ICustomMediaKeySession,
@@ -40,7 +45,7 @@ class IE11MediaKeySession
   public keyStatuses: ICustomMediaKeyStatusMap;
   private readonly _mk: MSMediaKeys;
   private readonly _closeSession$: Subject<void>;
-  private _ss?: MediaKeySession;
+  private _ss: MSMediaKeySession | undefined;
   constructor(mk: MSMediaKeys) {
     super();
     this.expiration = NaN;
@@ -56,27 +61,25 @@ class IE11MediaKeySession
           return reject("MediaKeySession not set.");
         }
         try {
-          /* eslint-disable @typescript-eslint/no-unsafe-call */
-          /* eslint-disable @typescript-eslint/no-unsafe-member-access */
           resolve(
-            (this._ss as any).update(license, /* sessionId */ "")
+            (this._ss.update as (
+              license : Uint8Array,
+              sessionId : string
+            ) => void)(license, "")
           );
-          /* eslint-enable @typescript-eslint/no-unsafe-call */
-          /* eslint-enable @typescript-eslint/no-unsafe-member-access */
         } catch (err) {
           reject(err);
         }
       });
     };
   }
-  generateRequest(_initDataType: string, initData: ArrayBuffer): Promise<void> {
+  generateRequest(_initDataType: string, initData: BufferSource): Promise<void> {
     return new PPromise((resolve) => {
-      /* eslint-disable @typescript-eslint/no-unsafe-call */
-      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-      this._ss = (this._mk as any).createSession("video/mp4",
-                                                 initData) as MediaKeySession;
-      /* eslint-enable @typescript-eslint/no-unsafe-call */
-      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+      const initDataU8 =
+        initData instanceof Uint8Array  ? initData :
+        initData instanceof ArrayBuffer ? new Uint8Array(initData) :
+                                          new Uint8Array(initData.buffer);
+      this._ss = this._mk.createSession("video/mp4", initDataU8);
       observableMerge(events.onKeyMessage$(this._ss),
                       events.onKeyAdded$(this._ss),
                       events.onKeyError$(this._ss)
@@ -88,9 +91,7 @@ class IE11MediaKeySession
   close(): Promise<void> {
     return new PPromise((resolve) => {
       if (this._ss != null) {
-        /* eslint-disable @typescript-eslint/no-floating-promises */
         this._ss.close();
-        /* eslint-enable @typescript-eslint/no-floating-promises */
         this._ss = undefined;
       }
       this._closeSession$.next();
@@ -110,7 +111,7 @@ class IE11MediaKeySession
 }
 
 class IE11CustomMediaKeys implements ICustomMediaKeys {
-  private _videoElement?: HTMLMediaElement;
+  private _videoElement?: ICompatHTMLMediaElement;
   private _mediaKeys?: MSMediaKeys;
 
   constructor(keyType: string) {
@@ -121,15 +122,10 @@ class IE11CustomMediaKeys implements ICustomMediaKeys {
   }
 
   _setVideo(videoElement: HTMLMediaElement): void {
-    this._videoElement = videoElement;
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    /* eslint-disable @typescript-eslint/no-unsafe-call */
-    if ((this._videoElement as any).msSetMediaKeys !== undefined) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return (this._videoElement as any).msSetMediaKeys(this._mediaKeys);
+    this._videoElement = videoElement as ICompatHTMLMediaElement;
+    if (this._videoElement.msSetMediaKeys !== undefined) {
+      return this._videoElement.msSetMediaKeys(this._mediaKeys);
     }
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-    /* eslint-enable @typescript-eslint/no-unsafe-call */
   }
 
   createSession(/* sessionType */): ICustomMediaKeySession {

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

@@ -21,7 +21,9 @@ import {
   throwError as observableThrow,
 } from "rxjs";
 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";
 import shouldFavourCustomSafariEME from "../../should_favour_custom_safari_EME";
@@ -42,48 +44,40 @@ import {
 import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 
-let requestMediaKeySystemAccess : null |
-                                  ((keyType : string,
-                                    config : MediaKeySystemConfiguration[])
-                                      => Observable<MediaKeySystemAccess |
-                                                    CustomMediaKeySystemAccess>)
-                                = null;
+/** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
+type ICompatRequestMediaKeySystemAccessFn =
+  (keyType : string, config : MediaKeySystemConfiguration[]) =>
+    Observable<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+
+let requestMediaKeySystemAccess : null | ICompatRequestMediaKeySystemAccessFn = null;
 
 let _setMediaKeys :
 ((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => void) =
   function defaultSetMediaKeys(
-    elt: HTMLMediaElement,
+    mediaElement: HTMLMediaElement,
     mediaKeys: MediaKeys | ICustomMediaKeys | null
   ) {
+    const elt : ICompatHTMLMediaElement = mediaElement;
     /* eslint-disable @typescript-eslint/unbound-method */
     if (typeof elt.setMediaKeys === "function") {
       return elt.setMediaKeys(mediaKeys as MediaKeys);
     }
     /* eslint-enable @typescript-eslint/unbound-method */
 
-    /* eslint-disable @typescript-eslint/strict-boolean-expressions */
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    /* eslint-disable @typescript-eslint/no-unsafe-return */
-    /* eslint-disable @typescript-eslint/no-unsafe-call */
-
     // 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 ((elt as any).webkitSetMediaKeys) {
-      return (elt as any).webkitSetMediaKeys(mediaKeys);
+    if (typeof elt.webkitSetMediaKeys === "function") {
+      return elt.webkitSetMediaKeys(mediaKeys);
     }
 
-    if ((elt as any).mozSetMediaKeys) {
-      return (elt as any).mozSetMediaKeys(mediaKeys);
+    if (typeof elt.mozSetMediaKeys === "function") {
+      return elt.mozSetMediaKeys(mediaKeys);
     }
 
-    if ((elt as any).msSetMediaKeys && mediaKeys !== null) {
-      return (elt as any).msSetMediaKeys(mediaKeys);
+    if (typeof elt.msSetMediaKeys === "function" && mediaKeys !== null) {
+      return elt.msSetMediaKeys(mediaKeys);
     }
-    /* eslint-enable @typescript-eslint/strict-boolean-expressions */
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-    /* eslint-enable @typescript-eslint/no-unsafe-return */
-    /* eslint-enable @typescript-eslint/no-unsafe-call */
   };
 
 /**
@@ -130,17 +124,17 @@ if (isNode ||
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
     _setMediaKeys = callbacks.setMediaKeys;
   } else {
-    /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    /* eslint-disable @typescript-eslint/no-unsafe-return */
-    const { MediaKeys } = window as any;
+    const MK = window.MediaKeys as unknown as typeof MediaKeys & {
+      isTypeSupported? : (keyType : string) => boolean;
+      new(keyType? : string) : ICustomMediaKeys;
+    };
     const checkForStandardMediaKeys = () => {
-      if (MediaKeys === undefined) {
+      if (MK === undefined) {
         throw new MediaError("MEDIA_KEYS_NOT_SUPPORTED",
                              "No `MediaKeys` implementation found " +
                              "in the current browser.");
       }
-      if (MediaKeys.isTypeSupported === undefined) {
+      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.";
@@ -149,17 +143,13 @@ if (isNode ||
     };
     isTypeSupported = (keyType: string): boolean => {
       checkForStandardMediaKeys();
-      /* eslint-disable-next-line @typescript-eslint/no-unsafe-call */
-      return MediaKeys.isTypeSupported(keyType);
+      assert(typeof MK.isTypeSupported === "function");
+      return MK.isTypeSupported(keyType);
     };
     createCustomMediaKeys = (keyType: string) => {
       checkForStandardMediaKeys();
-      /* eslint-disable-next-line @typescript-eslint/no-unsafe-call */
-      return new MediaKeys(keyType);
+      return new MK(keyType);
     };
-    /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-    /* eslint-enable @typescript-eslint/no-unsafe-return */
   }
 
   requestMediaKeySystemAccess = function(
@@ -183,14 +173,18 @@ if (isNode ||
       supported = supported && (distinctiveIdentifier !== "required");
 
       if (supported) {
-        const keySystemConfigurationResponse = {
-          videoCapabilities,
-          audioCapabilities,
+        const keySystemConfigurationResponse : MediaKeySystemConfiguration = {
           initDataTypes: ["cenc"],
           distinctiveIdentifier: "not-allowed" as const,
           persistentState: "required" as const,
           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
         const customMediaKeys = createCustomMediaKeys(keyType);

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import isNode from "../../is_node";
 import { ICustomMediaKeys } from "./types";
 
@@ -24,17 +25,19 @@ interface IMozMediaKeysConstructor {
 
 let MozMediaKeysConstructor: IMozMediaKeysConstructor|undefined;
 if (!isNode) {
-  /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-  const { MozMediaKeys } = (window as any);
-  if (MozMediaKeys !== undefined &&
-      MozMediaKeys.prototype !== undefined &&
-      typeof MozMediaKeys.isTypeSupported === "function" &&
-      typeof MozMediaKeys.prototype.createSession === "function") {
+  const { MozMediaKeys } = (window as Window & {
+    MozMediaKeys? : IMozMediaKeysConstructor;
+  });
+  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;
   }
-  /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-  /* eslint-enable @typescript-eslint/no-unsafe-member-access */
 }
 export { MozMediaKeysConstructor };
 
@@ -62,20 +65,14 @@ export default function getMozMediaKeysCallbacks() : {
     return new MozMediaKeysConstructor(keyType);
   };
   const setMediaKeys = (
-    elt: HTMLMediaElement,
+    mediaElement: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
   ): void => {
-    /* eslint-disable @typescript-eslint/no-unsafe-return */
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    /* eslint-disable @typescript-eslint/no-unsafe-call */
-    if ((elt as any).mozSetMediaKeys === undefined ||
-        typeof (elt as any).mozSetMediaKeys !== "function") {
+    const elt : ICompatHTMLMediaElement = mediaElement;
+    if (elt.mozSetMediaKeys === undefined || typeof elt.mozSetMediaKeys !== "function") {
       throw new Error("Can't set video on MozMediaKeys.");
     }
-    return (elt as any).mozSetMediaKeys(mediaKeys);
-    /* eslint-enable @typescript-eslint/no-unsafe-return */
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-    /* eslint-enable @typescript-eslint/no-unsafe-call */
+    return elt.mozSetMediaKeys(mediaKeys);
   };
   return {
     isTypeSupported,

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

@@ -16,6 +16,34 @@
 
 import isNode from "../../is_node";
 
+export interface MSMediaKeyError {
+    readonly code: number;
+    readonly systemCode: number;
+    readonly MS_MEDIA_KEYERR_CLIENT: number;
+    readonly MS_MEDIA_KEYERR_DOMAIN: number;
+    readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
+    readonly MS_MEDIA_KEYERR_OUTPUT: number;
+    readonly MS_MEDIA_KEYERR_SERVICE: number;
+    readonly MS_MEDIA_KEYERR_UNKNOWN: number;
+}
+
+export interface MSMediaKeySession extends EventTarget {
+    readonly error: MSMediaKeyError | null;
+    readonly keySystem: string;
+    readonly sessionId: string;
+    close(): void;
+    update(key: Uint8Array): void;
+}
+
+export interface MSMediaKeys {
+    readonly keySystem: string;
+    createSession(
+      type: string,
+      initData: Uint8Array,
+      cdmData?: Uint8Array | null
+    ): MSMediaKeySession;
+}
+
 interface IMSMediaKeysConstructor {
   new(keySystem: string): MSMediaKeys;
   isTypeSupported(keySystem: string, type?: string | null): boolean;
@@ -24,16 +52,18 @@ interface IMSMediaKeysConstructor {
 
 let MSMediaKeysConstructor: IMSMediaKeysConstructor|undefined;
 if (!isNode) {
-  /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-  const { MSMediaKeys } = (window as any);
-  if (MSMediaKeys !== undefined &&
-      MSMediaKeys.prototype !== undefined &&
-      typeof MSMediaKeys.isTypeSupported === "function" &&
-      typeof MSMediaKeys.prototype.createSession === "function") {
+  const { MSMediaKeys } = (window as Window & {
+    MSMediaKeys? : IMSMediaKeysConstructor;
+  });
+  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;
   }
-  /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-  /* eslint-enable @typescript-eslint/no-unsafe-member-access */
 }
 export { MSMediaKeysConstructor };

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

@@ -17,8 +17,8 @@
 import {
   merge as observableMerge,
   Subject,
+  takeUntil,
 } from "rxjs";
-import { takeUntil } from "rxjs/operators";
 import { base64ToBytes } from "../../../utils/base64";
 import EventEmitter from "../../../utils/event_emitter";
 import PPromise from "../../../utils/promise";
@@ -94,12 +94,15 @@ class OldWebkitMediaKeySession
             const licenseTypedArray =
               license instanceof ArrayBuffer ? new Uint8Array(license) :
                                                license;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const json = JSON.parse(utf8ToStr(licenseTypedArray));
             /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+            /* eslint-disable @typescript-eslint/no-unsafe-argument */
+            /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+            const json = JSON.parse(utf8ToStr(licenseTypedArray));
             const key = base64ToBytes(json.keys[0].k);
             const kid = base64ToBytes(json.keys[0].kid);
             /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+            /* eslint-enable @typescript-eslint/no-unsafe-argument */
+            /* eslint-enable @typescript-eslint/no-unsafe-assignment */
             resolve(this._vid.webkitAddKey(this._key, key, kid, /* sessionId */ ""));
           } else {
             resolve(this._vid.webkitAddKey(this._key, license, null, /* sessionId */ ""));
@@ -177,16 +180,11 @@ export default function getOldWebKitMediaKeysCallbacks() : {
     if (videoElement == null) {
       videoElement = document.createElement("video");
     }
-    /* eslint-disable @typescript-eslint/unbound-method */
     if (videoElement != null && typeof videoElement.canPlayType === "function") {
-      /* eslint-enable @typescript-eslint/unbound-method */
-      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-      /* eslint-disable @typescript-eslint/strict-boolean-expressions */
-      /* eslint-disable @typescript-eslint/no-unsafe-call */
-      return !!(videoElement as any).canPlayType("video/mp4", keyType);
-      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-      /* eslint-enable @typescript-eslint/strict-boolean-expressions */
-      /* eslint-enable @typescript-eslint/no-unsafe-call */
+      return !!(videoElement.canPlayType as unknown as (
+        mimeType : string,
+        keyType? : string
+      ) => boolean)("video/mp4", keyType);
     } else {
       return false;
     }

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

@@ -47,7 +47,7 @@ export interface ICustomMediaKeys {
 
 export interface ICustomMediaKeyStatusMap {
   readonly size: number;
-  forEach(callback: (status : MediaKeyStatus) => void, thisArg?: any): void;
+  forEach(callback: (status : MediaKeyStatus) => void, thisArg?: unknown): void;
   get(
     keyId: BufferSource |
            null

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

@@ -17,10 +17,11 @@
 import {
   merge as observableMerge,
   Subject,
+  takeUntil,
 } from "rxjs";
-import { takeUntil } from "rxjs/operators";
 import EventEmitter from "../../../utils/event_emitter";
 import PPromise from "../../../utils/promise";
+import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import * as events from "../../event_listeners";
 import getWebKitFairplayInitData from "../get_webkit_fairplay_initdata";
 import {
@@ -56,17 +57,15 @@ function isFairplayKeyType(keyType: string): boolean {
  * @param {HTMLMediaElement} videoElement
  * @param {Object|null} mediaKeys
  */
-function setWebKitMediaKeys(videoElement: HTMLMediaElement,
-                            mediaKeys: IWebKitMediaKeys|null): void {
-  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-  if ((videoElement as any).webkitSetMediaKeys === undefined) {
+function setWebKitMediaKeys(
+  videoElement: HTMLMediaElement,
+  mediaKeys: IWebKitMediaKeys|null
+): void {
+  const elt : ICompatHTMLMediaElement = videoElement;
+  if (elt.webkitSetMediaKeys === undefined) {
     throw new Error("No webKitMediaKeys API.");
   }
-  /* eslint-disable @typescript-eslint/no-unsafe-return */
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-  return (videoElement as any).webkitSetMediaKeys(mediaKeys);
-  /* eslint-enable @typescript-eslint/no-unsafe-return */
-  /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+  return elt.webkitSetMediaKeys(mediaKeys);
 }
 
 /**
@@ -89,7 +88,7 @@ class WebkitMediaKeySession
   private readonly _videoElement: HTMLMediaElement;
   private readonly _closeSession$: Subject<void>;
   private readonly _keyType: string;
-  private _nativeSession: undefined | any;
+  private _nativeSession: undefined | MediaKeySession;
   private _serverCertificate: Uint8Array | undefined;
 
   /**
@@ -114,7 +113,7 @@ class WebkitMediaKeySession
     this.keyStatuses = new Map();
     this.expiration = NaN;
 
-    this.update = (license: Uint8Array) => {
+    this.update = (license: BufferSource) => {
       return new PPromise((resolve, reject) => {
         /* eslint-disable @typescript-eslint/no-unsafe-member-access */
         if (this._nativeSession === undefined ||
@@ -123,9 +122,17 @@ class WebkitMediaKeySession
           return reject("Unavailable WebKit key session.");
         }
         try {
+          let uInt8Arraylicense: Uint8Array;
+          if (license instanceof ArrayBuffer) {
+            uInt8Arraylicense = new Uint8Array(license);
+          } else if (license instanceof Uint8Array) {
+            uInt8Arraylicense = license;
+          } else {
+            uInt8Arraylicense = new Uint8Array(license.buffer);
+          }
           /* eslint-disable @typescript-eslint/no-unsafe-member-access */
           // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-          resolve(this._nativeSession.update(license));
+          resolve(this._nativeSession.update(uInt8Arraylicense));
           /* eslint-enable @typescript-eslint/no-unsafe-member-access */
         } catch (err) {
           reject(err);
@@ -135,7 +142,7 @@ class WebkitMediaKeySession
     };
   }
 
-  listenEvent(session: any) {
+  listenEvent(session: MediaKeySession) {
     observableMerge(events.onKeyMessage$(session),
                     events.onKeyAdded$(session),
                     events.onKeyError$(session))
@@ -150,12 +157,10 @@ class WebkitMediaKeySession
     initData: ArrayBuffer
   ): Promise<void> {
     return new PPromise((resolve) => {
-      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-      if ((this._videoElement as any).webkitKeys === undefined ||
-        (this._videoElement as any).webkitKeys.createSession === undefined) {
+      const elt = this._videoElement as ICompatHTMLMediaElement;
+      if (elt.webkitKeys?.createSession === undefined) {
         throw new Error("No WebKitMediaKeys API.");
       }
-      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
 
       let formattedInitData;
       if (isFairplayKeyType(this._keyType)) {
@@ -168,15 +173,8 @@ class WebkitMediaKeySession
         formattedInitData = initData;
       }
 
-      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-      /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-      /* eslint-disable @typescript-eslint/no-unsafe-call */
       const keySession =
-        (this._videoElement as any).webkitKeys.createSession("video/mp4",
-                                                             formattedInitData);
-      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-      /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-      /* eslint-enable @typescript-eslint/no-unsafe-call */
+        elt.webkitKeys.createSession("video/mp4", formattedInitData);
       if (keySession === undefined || keySession === null) {
         throw new Error("Impossible to get the key sessions");
       }
@@ -193,12 +191,11 @@ class WebkitMediaKeySession
       this._closeSession$.complete();
       if (this._nativeSession === undefined) {
         reject("No session to close.");
+        return;
       }
-      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-      /* eslint-disable @typescript-eslint/no-unsafe-call */
+      /* eslint-disable @typescript-eslint/no-floating-promises */
       this._nativeSession.close();
-      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-      /* eslint-enable @typescript-eslint/no-unsafe-call */
+      /* eslint-enable @typescript-eslint/no-floating-promises */
       resolve();
     });
   }

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import isNode from "../../is_node";
 
 type IWebKitMediaKeys = unknown;
@@ -28,12 +29,15 @@ let WebKitMediaKeysConstructor: undefined|IWebKitMediaKeysConstructor;
 if (!isNode) {
   /* eslint-disable @typescript-eslint/no-unsafe-assignment */
   /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-  const { WebKitMediaKeys } = (window as any);
+  const { WebKitMediaKeys } = (window as Window & {
+    WebKitMediaKeys? : IWebKitMediaKeysConstructor;
+  });
 
   if (WebKitMediaKeys !== undefined &&
       typeof WebKitMediaKeys.isTypeSupported === "function" &&
       typeof WebKitMediaKeys.prototype.createSession === "function" &&
-      typeof (HTMLMediaElement.prototype as any).webkitSetMediaKeys === "function") {
+      typeof (HTMLMediaElement.prototype as ICompatHTMLMediaElement)
+        .webkitSetMediaKeys === "function") {
     WebKitMediaKeysConstructor = WebKitMediaKeys;
   }
   /* eslint-enable @typescript-eslint/no-unsafe-assignment */

package/src/compat/eme/generate_key_request.ts

@@ -15,10 +15,10 @@
  */
 
 import {
+  catchError,
   defer as observableDefer,
   Observable,
 } from "rxjs";
-import { catchError } from "rxjs/operators";
 import log from "../../log";
 import { getNextBoxOffsets } from "../../parsers/containers/isobmff";
 import {