From 9f3e0faeb7b9668f84f9bd80312571f00f65a6f2 Mon Sep 17 00:00:00 2001
From: Paul Berberian <paul.berberian+github@proton.me>
Date: Fri, 5 Jul 2024 16:00:53 +0200
Subject: [PATCH] [Proposal] Forbid usage of the `MediaKeys` type and other EME
 TS types

Based on #1397.

In the idea of including fake encrypted contents in our integration
tests by mocking MSE+EME+HTML 5 media API (not as complex as it sounds)
to increase by a lot the types of issues our CI is capable to catch, I
noticed an opportunity to even improve on the current code.

Like in #1397, the idea is there to provide typings subset of the
various EME API and to rely on them instead in the RxPlayer code (and
enforcing this through our linter).

This allows to:

  - much simplify EME API mocking by not having to implement the full
    extent of the EME API - though almost all of it is implemented
    instead (exceptions are the `EventTarget`'s third `options` optional
    parameter which we never use, `dispatchEvent`, and the `onevent`
    methods that we never rely on).

  - Allow the definition of environment-specific APIs

  - Be more aware of which EME API we currently use

The gain is here much more evident than in #1397 as we already had some
kind of sub-typings with the `ICustom...` types (e.g.
`ICustomMediaKeys`). By renaming those `I...` (e.g. `IMediaKeys`) and
ensuring they are actually compatible with the base type (e.g.
`MediaKeys`), we end up in my opinion with simpler code.
---
 .eslintrc.js                                  | 12 ++++
 src/compat/browser_compatibility_types.ts     | 58 ++++++++++++++---
 src/compat/eme/close_session.ts               |  6 +-
 src/compat/eme/custom_key_system_access.ts    | 15 ++---
 .../eme/custom_media_keys/ie11_media_keys.ts  | 52 ++++++++-------
 src/compat/eme/custom_media_keys/index.ts     |  2 -
 .../moz_media_keys_constructor.ts             | 14 ++--
 .../old_webkit_media_keys.ts                  | 35 +++++-----
 src/compat/eme/custom_media_keys/types.ts     | 62 ------------------
 .../custom_media_keys/webkit_media_keys.ts    | 64 ++++++++-----------
 src/compat/eme/eme-api-implementation.ts      | 25 ++++----
 src/compat/eme/generate_key_request.ts        |  4 +-
 src/compat/eme/index.ts                       | 11 +---
 src/compat/eme/load_session.ts                | 14 ++--
 src/compat/eme/set_media_keys.ts              |  5 +-
 .../media_key_system_access.test.ts           |  4 +-
 src/main_thread/decrypt/attach_media_keys.ts  | 14 ++--
 src/main_thread/decrypt/content_decryptor.ts  | 13 ++--
 .../decrypt/create_or_load_session.ts         |  6 +-
 src/main_thread/decrypt/create_session.ts     |  6 +-
 src/main_thread/decrypt/find_key_system.ts    | 12 ++--
 src/main_thread/decrypt/get_media_keys.ts     | 15 +++--
 .../decrypt/session_events_listener.ts        |  6 +-
 .../decrypt/set_server_certificate.ts         |  8 +--
 .../decrypt/utils/check_key_statuses.ts       |  4 +-
 .../decrypt/utils/is_session_usable.ts        |  6 +-
 .../decrypt/utils/loaded_sessions_store.ts    | 31 +++++----
 .../decrypt/utils/media_keys_infos_store.ts   | 14 ++--
 .../utils/persistent_sessions_store.ts        | 12 ++--
 .../decrypt/utils/server_certificate_store.ts | 18 ++----
 .../isobmff/extract_complete_chunks.ts        |  2 +-
 31 files changed, 250 insertions(+), 300 deletions(-)
 delete mode 100644 src/compat/eme/custom_media_keys/types.ts

diff --git a/.eslintrc.js b/.eslintrc.js
index f3f79911d0..19fc6b5398 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -71,6 +71,18 @@ module.exports = {
             message:
               "Avoid relying on `SourceBufferList` directly unless it is API-facing. Prefer our more restricted `ISourceBufferList` type",
           },
+          MediaKeySystemAccess: {
+            message:
+              "Avoid relying on `MediaKeySystemAccess` directly unless it is API-facing. Prefer our more restricted `IMediaKeySystemAccess` type",
+          },
+          MediaKeys: {
+            message:
+              "Avoid relying on `MediaKeys` directly unless it is API-facing. Prefer our more restricted `IMediaKeys` type",
+          },
+          MediaKeySession: {
+            message:
+              "Avoid relying on `MediaKeySession` directly unless it is API-facing. Prefer our more restricted `IMediaKeySession` type",
+          },
         },
       },
     ],
diff --git a/src/compat/browser_compatibility_types.ts b/src/compat/browser_compatibility_types.ts
index 9c8de9cac9..54a149c103 100644
--- a/src/compat/browser_compatibility_types.ts
+++ b/src/compat/browser_compatibility_types.ts
@@ -18,12 +18,6 @@ import type { IListener } from "../utils/event_emitter";
 import globalScope from "../utils/global_scope";
 import isNullOrUndefined from "../utils/is_null_or_undefined";
 
-/** Regular MediaKeys type + optional functions present in IE11. */
-interface ICompatMediaKeysConstructor {
-  isTypeSupported?: (type: string) => boolean; // IE11 only
-  new (keyType?: string): MediaKeys; // argument for IE11 only
-}
-
 /**
  * Browser implementation of a VTTCue constructor.
  * TODO open TypeScript issue about it?
@@ -239,7 +233,7 @@ export interface IMediaElement extends IEventTarget<IMediaElementEventMap> {
   duration: number;
   ended: boolean;
   error: MediaError | null;
-  mediaKeys: null | MediaKeys;
+  mediaKeys: null | IMediaKeys;
   muted: boolean;
   nodeName: string;
   paused: boolean;
@@ -261,7 +255,7 @@ export interface IMediaElement extends IEventTarget<IMediaElementEventMap> {
   play(): Promise<void>;
   removeAttribute(attr: string): void;
   removeChild(x: unknown): void;
-  setMediaKeys(x: MediaKeys | null): Promise<void>;
+  setMediaKeys(x: IMediaKeys | null): Promise<void>;
 
   onencrypted: ((evt: MediaEncryptedEvent) => void) | null;
   oncanplay: ((evt: Event) => void) | null;
@@ -293,12 +287,36 @@ export interface IMediaElement extends IEventTarget<IMediaElementEventMap> {
   msSetMediaKeys?: (mediaKeys: unknown) => void;
   webkitSetMediaKeys?: (mediaKeys: unknown) => void;
   webkitKeys?: {
-    createSession?: (mimeType: string, initData: BufferSource) => MediaKeySession;
+    createSession?: (mimeType: string, initData: BufferSource) => IMediaKeySession;
   };
   audioTracks?: ICompatAudioTrackList;
   videoTracks?: ICompatVideoTrackList;
 }
 
+export interface IMediaKeySystemAccess {
+  readonly keySystem: string;
+  getConfiguration(): MediaKeySystemConfiguration;
+  createMediaKeys(): Promise<IMediaKeys>;
+}
+
+export interface IMediaKeys {
+  isTypeSupported?: (type: string) => boolean; // IE11 only
+  createSession(sessionType?: MediaKeySessionType): IMediaKeySession;
+  setServerCertificate(serverCertificate: BufferSource): Promise<boolean>;
+}
+
+export interface IMediaKeySession extends IEventTarget<MediaKeySessionEventMap> {
+  readonly closed: Promise<MediaKeySessionClosedReason>;
+  readonly expiration: number;
+  readonly keyStatuses: MediaKeyStatusMap;
+  readonly sessionId: string;
+  close(): Promise<void>;
+  generateRequest(_initDataType: string, _initData: BufferSource): Promise<void>;
+  load(sessionId: string): Promise<boolean>;
+  remove(): Promise<void>;
+  update(response: BufferSource): Promise<void>;
+}
+
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/ban-types */
 // @ts-expect-error unused function, just used for compile-time typechecking
 function testMediaElement(x: HTMLMediaElement) {
@@ -328,6 +346,27 @@ function testSourceBufferList(x: SourceBufferList) {
 function assertCompatibleISourceBufferList(_x: ISourceBufferList) {
   // Noop
 }
+// @ts-expect-error unused function, just used for compile-time typechecking
+function testMediaKeySystemAccess(x: MediaKeySystemAccess) {
+  assertCompatibleIMediaKeySystemAccess(x);
+}
+function assertCompatibleIMediaKeySystemAccess(_x: IMediaKeySystemAccess) {
+  // Noop
+}
+// @ts-expect-error unused function, just used for compile-time typechecking
+function testMediaKeys(x: MediaKeys) {
+  assertCompatibleIMediaKeys(x);
+}
+function assertCompatibleIMediaKeys(_x: IMediaKeys) {
+  // Noop
+}
+// @ts-expect-error unused function, just used for compile-time typechecking
+function testMediaKeySession(x: MediaKeySession) {
+  assertCompatibleIMediaKeySession(x);
+}
+function assertCompatibleIMediaKeySession(_x: IMediaKeySession) {
+  // Noop
+}
 /* eslint-enable @typescript-eslint/no-unused-vars, @typescript-eslint/ban-types */
 
 /**
@@ -441,7 +480,6 @@ export type {
   ICompatVideoTrackList,
   ICompatAudioTrack,
   ICompatVideoTrack,
-  ICompatMediaKeysConstructor,
   ICompatTextTrack,
   ICompatVTTCue,
   ICompatVTTCueConstructor,
diff --git a/src/compat/eme/close_session.ts b/src/compat/eme/close_session.ts
index 92a42d6f81..d0babfa7f3 100644
--- a/src/compat/eme/close_session.ts
+++ b/src/compat/eme/close_session.ts
@@ -17,7 +17,7 @@
 import log from "../../log";
 import cancellableSleep from "../../utils/cancellable_sleep";
 import TaskCanceller, { CancellationError } from "../../utils/task_canceller";
-import type { ICustomMediaKeySession } from "./custom_media_keys";
+import type { IMediaKeySession } from "../browser_compatibility_types";
 
 /**
  * Close the given `MediaKeySession` and returns a Promise resolving when the
@@ -32,9 +32,7 @@ import type { ICustomMediaKeySession } from "./custom_media_keys";
  * @param {MediaKeySession|Object} session
  * @returns {Promise.<undefined>}
  */
-export default function closeSession(
-  session: MediaKeySession | ICustomMediaKeySession,
-): Promise<void> {
+export default function closeSession(session: IMediaKeySession): Promise<void> {
   const timeoutCanceller = new TaskCanceller();
 
   return Promise.race([
diff --git a/src/compat/eme/custom_key_system_access.ts b/src/compat/eme/custom_key_system_access.ts
index af888b79f1..da27d29e4a 100644
--- a/src/compat/eme/custom_key_system_access.ts
+++ b/src/compat/eme/custom_key_system_access.ts
@@ -13,14 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { ICustomMediaKeys } from "./custom_media_keys";
-
-// MediaKeySystemAccess implementation
-export interface ICustomMediaKeySystemAccess {
-  readonly keySystem: string;
-  getConfiguration(): MediaKeySystemConfiguration;
-  createMediaKeys(): Promise<MediaKeys | ICustomMediaKeys>;
-}
+import type { IMediaKeySystemAccess, IMediaKeys } from "../browser_compatibility_types";
 
 /**
  * Simple implementation of the MediaKeySystemAccess EME API.
@@ -28,7 +21,7 @@ export interface ICustomMediaKeySystemAccess {
  * All needed arguments are given to the constructor
  * @class CustomMediaKeySystemAccess
  */
-export default class CustomMediaKeySystemAccess implements ICustomMediaKeySystemAccess {
+export default class CustomMediaKeySystemAccess implements IMediaKeySystemAccess {
   /**
    * @param {string} _keyType - type of key system (e.g. "widevine" or
    * "com.widevine.alpha").
@@ -38,7 +31,7 @@ export default class CustomMediaKeySystemAccess implements ICustomMediaKeySystem
    */
   constructor(
     private readonly _keyType: string,
-    private readonly _mediaKeys: ICustomMediaKeys | MediaKeys,
+    private readonly _mediaKeys: IMediaKeys,
     private readonly _configuration: MediaKeySystemConfiguration,
   ) {}
 
@@ -54,7 +47,7 @@ export default class CustomMediaKeySystemAccess implements ICustomMediaKeySystem
    * @returns {Promise.<Object>} - Promise wrapping the MediaKeys for this
    * MediaKeySystemAccess. Never rejects.
    */
-  public createMediaKeys(): Promise<ICustomMediaKeys | MediaKeys> {
+  public createMediaKeys(): Promise<IMediaKeys> {
     return new Promise((res) => res(this._mediaKeys));
   }
 
diff --git a/src/compat/eme/custom_media_keys/ie11_media_keys.ts b/src/compat/eme/custom_media_keys/ie11_media_keys.ts
index 9cd20c8aca..e10108b611 100644
--- a/src/compat/eme/custom_media_keys/ie11_media_keys.ts
+++ b/src/compat/eme/custom_media_keys/ie11_media_keys.ts
@@ -18,25 +18,23 @@ import EventEmitter from "../../../utils/event_emitter";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import TaskCanceller from "../../../utils/task_canceller";
 import wrapInPromise from "../../../utils/wrapInPromise";
-import type { IMediaElement } from "../../browser_compatibility_types";
+import type {
+  IMediaElement,
+  IMediaKeySession,
+  IMediaKeys,
+} from "../../browser_compatibility_types";
 import * as events from "../../event_listeners";
 import type { MSMediaKeys, MSMediaKeySession } from "./ms_media_keys_constructor";
 import { MSMediaKeysConstructor } from "./ms_media_keys_constructor";
-import type {
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  ICustomMediaKeyStatusMap,
-  IMediaKeySessionEvents,
-} from "./types";
 
 class IE11MediaKeySession
-  extends EventEmitter<IMediaKeySessionEvents>
-  implements ICustomMediaKeySession
+  extends EventEmitter<MediaKeySessionEventMap>
+  implements IMediaKeySession
 {
   public readonly update: (license: Uint8Array) => Promise<void>;
-  public readonly closed: Promise<void>;
+  public readonly closed: Promise<MediaKeySessionClosedReason>;
   public expiration: number;
-  public keyStatuses: ICustomMediaKeyStatusMap;
+  public keyStatuses: MediaKeyStatusMap;
   private readonly _mk: MSMediaKeys;
   private readonly _sessionClosingCanceller: TaskCanceller;
   private _ss: MSMediaKeySession | undefined;
@@ -47,7 +45,9 @@ class IE11MediaKeySession
     this._mk = mk;
     this._sessionClosingCanceller = new TaskCanceller();
     this.closed = new Promise((resolve) => {
-      this._sessionClosingCanceller.signal.register(() => resolve());
+      this._sessionClosingCanceller.signal.register(() =>
+        resolve("closed-by-application"),
+      );
     });
     this.update = (license: Uint8Array) => {
       return new Promise((resolve, reject) => {
@@ -81,21 +81,30 @@ class IE11MediaKeySession
       events.onKeyMessage(
         this._ss,
         (evt) => {
-          this.trigger((evt as Event).type ?? "message", evt as Event);
+          this.trigger(
+            ((evt as Event).type ?? "message") as keyof MediaKeySessionEventMap,
+            evt as Event,
+          );
         },
         this._sessionClosingCanceller.signal,
       );
       events.onKeyAdded(
         this._ss,
         (evt) => {
-          this.trigger((evt as Event).type ?? "keyadded", evt as Event);
+          this.trigger(
+            ((evt as Event).type ?? "keyadded") as keyof MediaKeySessionEventMap,
+            evt as Event,
+          );
         },
         this._sessionClosingCanceller.signal,
       );
       events.onKeyError(
         this._ss,
         (evt) => {
-          this.trigger((evt as Event).type ?? "keyerror", evt as Event);
+          this.trigger(
+            ((evt as Event).type ?? "keyerror") as keyof MediaKeySessionEventMap,
+            evt as Event,
+          );
         },
         this._sessionClosingCanceller.signal,
       );
@@ -123,7 +132,7 @@ class IE11MediaKeySession
   }
 }
 
-class IE11CustomMediaKeys implements ICustomMediaKeys {
+class IE11CustomMediaKeys implements IMediaKeys {
   private _videoElement?: IMediaElement;
   private _mediaKeys?: MSMediaKeys;
 
@@ -143,14 +152,14 @@ class IE11CustomMediaKeys implements ICustomMediaKeys {
     });
   }
 
-  createSession(/* sessionType */): ICustomMediaKeySession {
+  createSession(/* sessionType */): IMediaKeySession {
     if (this._videoElement === undefined || this._mediaKeys === undefined) {
       throw new Error("Video not attached to the MediaKeys");
     }
     return new IE11MediaKeySession(this._mediaKeys);
   }
 
-  setServerCertificate(): Promise<void> {
+  setServerCertificate(): Promise<boolean> {
     throw new Error("Server certificate is not implemented in your browser");
   }
 }
@@ -158,10 +167,7 @@ class IE11CustomMediaKeys implements ICustomMediaKeys {
 export default function getIE11MediaKeysCallbacks(): {
   isTypeSupported: (keyType: string) => boolean;
   createCustomMediaKeys: (keyType: string) => IE11CustomMediaKeys;
-  setMediaKeys: (
-    elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
-  ) => Promise<unknown>;
+  setMediaKeys: (elt: IMediaElement, mediaKeys: IMediaKeys | null) => Promise<unknown>;
 } {
   const isTypeSupported = (keySystem: string, type?: string | null) => {
     if (MSMediaKeysConstructor === undefined) {
@@ -175,7 +181,7 @@ export default function getIE11MediaKeysCallbacks(): {
   const createCustomMediaKeys = (keyType: string) => new IE11CustomMediaKeys(keyType);
   const setMediaKeys = (
     elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ): Promise<unknown> => {
     if (mediaKeys === null) {
       // msSetMediaKeys only accepts native MSMediaKeys as argument.
diff --git a/src/compat/eme/custom_media_keys/index.ts b/src/compat/eme/custom_media_keys/index.ts
index 19ae83bb8e..21eff0060c 100644
--- a/src/compat/eme/custom_media_keys/index.ts
+++ b/src/compat/eme/custom_media_keys/index.ts
@@ -5,11 +5,9 @@ import getMozMediaKeysCallbacks, {
 import getOldKitWebKitMediaKeyCallbacks, {
   isOldWebkitMediaElement,
 } from "./old_webkit_media_keys";
-import type { ICustomMediaKeys, ICustomMediaKeySession } from "./types";
 import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 
-export type { ICustomMediaKeys, ICustomMediaKeySession };
 export {
   getIE11MediaKeysCallbacks,
   MSMediaKeysConstructor,
diff --git a/src/compat/eme/custom_media_keys/moz_media_keys_constructor.ts b/src/compat/eme/custom_media_keys/moz_media_keys_constructor.ts
index 28d0c09e4f..a7577f17ea 100644
--- a/src/compat/eme/custom_media_keys/moz_media_keys_constructor.ts
+++ b/src/compat/eme/custom_media_keys/moz_media_keys_constructor.ts
@@ -16,11 +16,10 @@
 
 import globalScope from "../../../utils/global_scope";
 import wrapInPromise from "../../../utils/wrapInPromise";
-import type { IMediaElement } from "../../browser_compatibility_types";
-import type { ICustomMediaKeys } from "./types";
+import type { IMediaElement, IMediaKeys } from "../../browser_compatibility_types";
 
 interface IMozMediaKeysConstructor {
-  new (keySystem: string): ICustomMediaKeys;
+  new (keySystem: string): IMediaKeys;
   isTypeSupported(keySystem: string, type?: string | null): boolean;
 }
 
@@ -42,11 +41,8 @@ export { MozMediaKeysConstructor };
 
 export default function getMozMediaKeysCallbacks(): {
   isTypeSupported: (keyType: string) => boolean;
-  createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
-  setMediaKeys: (
-    elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
-  ) => Promise<unknown>;
+  createCustomMediaKeys: (keyType: string) => IMediaKeys;
+  setMediaKeys: (elt: IMediaElement, mediaKeys: IMediaKeys | null) => Promise<unknown>;
 } {
   const isTypeSupported = (keySystem: string, type?: string | null) => {
     if (MozMediaKeysConstructor === undefined) {
@@ -65,7 +61,7 @@ export default function getMozMediaKeysCallbacks(): {
   };
   const setMediaKeys = (
     elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ): Promise<unknown> => {
     return wrapInPromise(() => {
       if (
diff --git a/src/compat/eme/custom_media_keys/old_webkit_media_keys.ts b/src/compat/eme/custom_media_keys/old_webkit_media_keys.ts
index f4cb0c1026..bf71168508 100644
--- a/src/compat/eme/custom_media_keys/old_webkit_media_keys.ts
+++ b/src/compat/eme/custom_media_keys/old_webkit_media_keys.ts
@@ -20,13 +20,11 @@ import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import noop from "../../../utils/noop";
 import { utf8ToStr } from "../../../utils/string_parsing";
 import wrapInPromise from "../../../utils/wrapInPromise";
-import type { IMediaElement } from "../../browser_compatibility_types";
 import type {
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  ICustomMediaKeyStatusMap,
-  IMediaKeySessionEvents,
-} from "./types";
+  IMediaElement,
+  IMediaKeySession,
+  IMediaKeys,
+} from "../../browser_compatibility_types";
 
 export interface IOldWebkitHTMLMediaElement extends HTMLVideoElement {
   webkitGenerateKeyRequest: (keyType: string, initData: ArrayBuffer) => void;
@@ -60,12 +58,12 @@ export function isOldWebkitMediaElement(
  * @class OldWebkitMediaKeySession
  */
 class OldWebkitMediaKeySession
-  extends EventEmitter<IMediaKeySessionEvents>
-  implements ICustomMediaKeySession
+  extends EventEmitter<MediaKeySessionEventMap>
+  implements IMediaKeySession
 {
-  public readonly closed: Promise<void>;
+  public readonly closed: Promise<MediaKeySessionClosedReason>;
   public expiration: number;
-  public keyStatuses: ICustomMediaKeyStatusMap;
+  public keyStatuses: MediaKeyStatusMap;
   public sessionId: string;
 
   private readonly _vid: IOldWebkitHTMLMediaElement;
@@ -84,7 +82,7 @@ class OldWebkitMediaKeySession
     this.expiration = NaN;
 
     const onSessionRelatedEvent = (evt: Event) => {
-      this.trigger(evt.type, evt);
+      this.trigger(evt.type as keyof MediaKeySessionEventMap, evt);
     };
     this.closed = new Promise((resolve) => {
       this._closeSession = () => {
@@ -94,7 +92,7 @@ class OldWebkitMediaKeySession
             mediaElement.removeEventListener(`webkit${evt}`, onSessionRelatedEvent);
           },
         );
-        resolve();
+        resolve("closed-by-application");
       };
     });
 
@@ -158,7 +156,7 @@ class OldWebkitMediaKeySession
   }
 }
 
-class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
+class OldWebKitCustomMediaKeys implements IMediaKeys {
   private readonly _keySystem: string;
   private _videoElement?: IOldWebkitHTMLMediaElement;
 
@@ -175,14 +173,14 @@ class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
     });
   }
 
-  createSession(/* sessionType */): ICustomMediaKeySession {
+  createSession(/* sessionType */): IMediaKeySession {
     if (isNullOrUndefined(this._videoElement)) {
       throw new Error("Video not attached to the MediaKeys");
     }
     return new OldWebkitMediaKeySession(this._videoElement, this._keySystem);
   }
 
-  setServerCertificate(): Promise<void> {
+  setServerCertificate(): Promise<boolean> {
     throw new Error("Server certificate is not implemented in your browser");
   }
 }
@@ -190,10 +188,7 @@ class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
 export default function getOldWebKitMediaKeysCallbacks(): {
   isTypeSupported: (keyType: string) => boolean;
   createCustomMediaKeys: (keyType: string) => OldWebKitCustomMediaKeys;
-  setMediaKeys: (
-    elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
-  ) => Promise<unknown>;
+  setMediaKeys: (elt: IMediaElement, mediaKeys: IMediaKeys | null) => Promise<unknown>;
 } {
   const isTypeSupported = function (keyType: string): boolean {
     // get any <video> element from the DOM or create one
@@ -220,7 +215,7 @@ export default function getOldWebKitMediaKeysCallbacks(): {
     new OldWebKitCustomMediaKeys(keyType);
   const setMediaKeys = (
     elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ): Promise<unknown> => {
     if (mediaKeys === null) {
       return Promise.resolve(undefined);
diff --git a/src/compat/eme/custom_media_keys/types.ts b/src/compat/eme/custom_media_keys/types.ts
deleted file mode 100644
index 143006fa8d..0000000000
--- a/src/compat/eme/custom_media_keys/types.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-/**
- * 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 type { IEventEmitter } from "../../../utils/event_emitter";
-import type { IMediaElement } from "../../browser_compatibility_types";
-
-export interface ICustomMediaKeySession extends IEventEmitter<IMediaKeySessionEvents> {
-  // Attributes
-  readonly closed: Promise<void>;
-  expiration: number;
-  keyStatuses: ICustomMediaKeyStatusMap;
-  sessionId: string;
-
-  // Event handlers
-  onmessage?: (message: MediaKeyMessageEvent) => void;
-  onkeystatusesChange?: (evt: Event) => void;
-
-  // Functions
-
-  generateRequest(initDataType: string, initData: BufferSource | null): Promise<void>;
-
-  load(sessionId: string): Promise<boolean>;
-  update(response: BufferSource | null): Promise<void>;
-  close(): Promise<void>;
-  remove(): Promise<void>;
-}
-
-export interface ICustomMediaKeys {
-  _setVideo: (vid: IMediaElement) => Promise<unknown>;
-  createSession(sessionType?: MediaKeySessionType): ICustomMediaKeySession;
-  setServerCertificate(setServerCertificate: BufferSource): Promise<void>;
-}
-
-export interface ICustomMediaKeyStatusMap {
-  readonly size: number;
-  forEach(callback: (status: MediaKeyStatus) => void, thisArg?: unknown): void;
-  get(keyId: BufferSource | null): MediaKeyStatus | undefined;
-  has(keyId: BufferSource | null): boolean;
-}
-
-export interface IMediaKeySessionEvents {
-  [key: string]: MediaKeyMessageEvent | Event;
-  // "keymessage"
-  // "message"
-  // "keyadded"
-  // "ready"
-  // "keyerror"
-  /* "error" */
-}
diff --git a/src/compat/eme/custom_media_keys/webkit_media_keys.ts b/src/compat/eme/custom_media_keys/webkit_media_keys.ts
index 26cf19e821..862ab880b6 100644
--- a/src/compat/eme/custom_media_keys/webkit_media_keys.ts
+++ b/src/compat/eme/custom_media_keys/webkit_media_keys.ts
@@ -18,23 +18,15 @@ import EventEmitter from "../../../utils/event_emitter";
 import noop from "../../../utils/noop";
 import startsWith from "../../../utils/starts_with";
 import wrapInPromise from "../../../utils/wrapInPromise";
-import type { IMediaElement } from "../../browser_compatibility_types";
-import getWebKitFairplayInitData from "../get_webkit_fairplay_initdata";
 import type {
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  ICustomMediaKeyStatusMap,
-  IMediaKeySessionEvents,
-} from "./types";
+  IMediaElement,
+  IMediaKeySession,
+  IMediaKeys,
+} from "../../browser_compatibility_types";
+import getWebKitFairplayInitData from "../get_webkit_fairplay_initdata";
 import type { IWebKitMediaKeys } from "./webkit_media_keys_constructor";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 
-export interface ICustomWebKitMediaKeys {
-  _setVideo: (videoElement: IMediaElement) => void;
-  createSession(mimeType: string, initData: Uint8Array): ICustomMediaKeySession;
-  setServerCertificate(setServerCertificate: BufferSource): Promise<void>;
-}
-
 /**
  * Check if keyType is for fairplay DRM
  * @param {string} keyType
@@ -69,19 +61,19 @@ function setWebKitMediaKeys(elt: IMediaElement, mediaKeys: unknown): Promise<unk
  * EME custom APIs.
  */
 class WebkitMediaKeySession
-  extends EventEmitter<IMediaKeySessionEvents>
-  implements ICustomMediaKeySession
+  extends EventEmitter<MediaKeySessionEventMap>
+  implements IMediaKeySession
 {
-  public readonly closed: Promise<void>;
+  public readonly closed: Promise<MediaKeySessionClosedReason>;
   public expiration: number;
-  public keyStatuses: ICustomMediaKeyStatusMap;
+  public keyStatuses: MediaKeyStatusMap;
 
   private readonly _videoElement: IMediaElement;
   private readonly _keyType: string;
-  private _nativeSession: undefined | MediaKeySession;
+  private _nativeSession: undefined | IMediaKeySession;
   private _serverCertificate: Uint8Array | undefined;
 
-  private _closeSession: () => void;
+  private _closeSession: (val: MediaKeySessionClosedReason) => void;
   private _unbindSession: () => void;
 
   /**
@@ -101,7 +93,7 @@ class WebkitMediaKeySession
 
     this._unbindSession = noop;
     this._closeSession = noop; // Just here to make TypeScript happy
-    this.closed = new Promise((resolve) => {
+    this.closed = new Promise((resolve: (val: MediaKeySessionClosedReason) => void) => {
       this._closeSession = resolve;
     });
     this.keyStatuses = new Map();
@@ -171,7 +163,7 @@ class WebkitMediaKeySession
   public close(): Promise<void> {
     return new Promise((resolve, reject) => {
       this._unbindSession();
-      this._closeSession();
+      this._closeSession("closed-by-application");
       if (this._nativeSession === undefined) {
         reject("No session to close.");
         return;
@@ -199,26 +191,29 @@ class WebkitMediaKeySession
     /* eslint-enable @typescript-eslint/no-unsafe-return */
   }
 
-  private _listenEvent(session: MediaKeySession): void {
+  private _listenEvent(session: IMediaKeySession): void {
     this._unbindSession(); // If previous session was linked
 
     const onEvent = (evt: Event) => {
-      this.trigger(evt.type, evt);
+      this.trigger(evt.type as keyof MediaKeySessionEventMap, 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((evt) => {
-      session.addEventListener(evt, onEvent);
-      session.addEventListener(`webkit${evt}`, onEvent);
+      session.addEventListener(evt as keyof MediaKeySessionEventMap, onEvent);
+      session.addEventListener(`webkit${evt}` as keyof MediaKeySessionEventMap, onEvent);
     });
 
     this._unbindSession = () => {
       ["keymessage", "message", "keyadded", "ready", "keyerror", "error"].forEach(
         (evt) => {
-          session.removeEventListener(evt, onEvent);
-          session.removeEventListener(`webkit${evt}`, onEvent);
+          session.removeEventListener(evt as keyof MediaKeySessionEventMap, onEvent);
+          session.removeEventListener(
+            `webkit${evt}` as keyof MediaKeySessionEventMap,
+            onEvent,
+          );
         },
       );
     };
@@ -228,7 +223,7 @@ class WebkitMediaKeySession
   }
 }
 
-class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
+class WebKitCustomMediaKeys implements IMediaKeys {
   private _videoElement?: IMediaElement;
   private _mediaKeys?: IWebKitMediaKeys;
   private _serverCertificate?: Uint8Array;
@@ -250,7 +245,7 @@ class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
     return setWebKitMediaKeys(this._videoElement, this._mediaKeys);
   }
 
-  createSession(/* sessionType */): ICustomMediaKeySession {
+  createSession(/* sessionType */): IMediaKeySession {
     if (this._videoElement === undefined || this._mediaKeys === undefined) {
       throw new Error("Video not attached to the MediaKeys");
     }
@@ -261,19 +256,16 @@ class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
     );
   }
 
-  setServerCertificate(serverCertificate: Uint8Array): Promise<void> {
+  setServerCertificate(serverCertificate: Uint8Array): Promise<boolean> {
     this._serverCertificate = serverCertificate;
-    return Promise.resolve();
+    return Promise.resolve(true);
   }
 }
 
 export default function getWebKitMediaKeysCallbacks(): {
   isTypeSupported: (keyType: string) => boolean;
   createCustomMediaKeys: (keyType: string) => WebKitCustomMediaKeys;
-  setMediaKeys: (
-    elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
-  ) => Promise<unknown>;
+  setMediaKeys: (elt: IMediaElement, mediaKeys: IMediaKeys | null) => Promise<unknown>;
 } {
   if (WebKitMediaKeysConstructor === undefined) {
     throw new Error("No WebKitMediaKeys API.");
@@ -282,7 +274,7 @@ export default function getWebKitMediaKeysCallbacks(): {
   const createCustomMediaKeys = (keyType: string) => new WebKitCustomMediaKeys(keyType);
   const setMediaKeys = (
     elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ): Promise<unknown> => {
     if (mediaKeys === null) {
       return setWebKitMediaKeys(elt, mediaKeys);
diff --git a/src/compat/eme/eme-api-implementation.ts b/src/compat/eme/eme-api-implementation.ts
index 96e7885deb..aa338373ee 100644
--- a/src/compat/eme/eme-api-implementation.ts
+++ b/src/compat/eme/eme-api-implementation.ts
@@ -4,7 +4,11 @@ import globalScope from "../../utils/global_scope";
 import isNode from "../../utils/is_node";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import type { CancellationSignal } from "../../utils/task_canceller";
-import type { IMediaElement } from "../browser_compatibility_types";
+import type {
+  IMediaElement,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../browser_compatibility_types";
 import { isIE11 } from "../browser_detection";
 import type { IEventTargetLike } from "../event_listeners";
 import { createCompatibleEventListener } from "../event_listeners";
@@ -19,7 +23,6 @@ import getMozMediaKeysCallbacks, {
 import getOldKitWebKitMediaKeyCallbacks, {
   isOldWebkitMediaElement,
 } from "./custom_media_keys/old_webkit_media_keys";
-import type { ICustomMediaKeys } from "./custom_media_keys/types";
 import getWebKitMediaKeysCallbacks from "./custom_media_keys/webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./custom_media_keys/webkit_media_keys_constructor";
 
@@ -49,7 +52,7 @@ export interface IEmeApiImplementation {
   requestMediaKeySystemAccess: (
     keyType: string,
     config: MediaKeySystemConfiguration[],
-  ) => Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+  ) => Promise<IMediaKeySystemAccess | CustomMediaKeySystemAccess>;
 
   /**
    * API allowing to listen for `"encrypted"` events, presumably sent by the
@@ -68,7 +71,7 @@ export interface IEmeApiImplementation {
   ) => void;
 
   /**
-   * API allowing to attach a `MediaKeys` instance (or an `ICustomMediaKeys`) to
+   * API allowing to attach a `MediaKeys` instance (or an `IMediaKeys`) to
    * the HTMLMediaElement so it can start decoding.
    * @param {HTMLMediaElement} The HTMLMediaElement on which the content plays.
    * @param {MediaKeys} mediaKeys - The MediaKeys instance to attach.
@@ -78,7 +81,7 @@ export interface IEmeApiImplementation {
    */
   setMediaKeys: (
     mediaElement: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ) => Promise<unknown>;
 
   /**
@@ -140,7 +143,7 @@ function getEmeApiImplementation(
     implementation = "standard";
   } else {
     let isTypeSupported: (keyType: string) => boolean;
-    let createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
+    let createCustomMediaKeys: (keyType: string) => IMediaKeys;
 
     if (preferredApiType === "webkit" && WebKitMediaKeysConstructor !== undefined) {
       onEncrypted = createCompatibleEventListener(["needkey"]);
@@ -184,7 +187,7 @@ function getEmeApiImplementation(
         onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
         const MK = globalScope.MediaKeys as unknown as typeof MediaKeys & {
           isTypeSupported?: (keyType: string) => boolean;
-          new (keyType?: string): ICustomMediaKeys;
+          new (keyType?: string): IMediaKeys;
         };
         const checkForStandardMediaKeys = () => {
           if (MK === undefined) {
@@ -218,7 +221,7 @@ function getEmeApiImplementation(
     requestMediaKeySystemAccess = function (
       keyType: string,
       keySystemConfigurations: MediaKeySystemConfiguration[],
-    ): Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess> {
+    ): Promise<IMediaKeySystemAccess> {
       if (!isTypeSupported(keyType)) {
         return Promise.reject(new Error("Unsupported key type"));
       }
@@ -284,15 +287,15 @@ function getEmeApiImplementation(
  */
 function defaultSetMediaKeys(
   elt: IMediaElement,
-  mediaKeys: MediaKeys | ICustomMediaKeys | null,
+  mediaKeys: IMediaKeys | null,
 ): Promise<unknown> {
   try {
     let ret: unknown;
-    /* eslint-disable @typescript-eslint/unbound-method */
+    /* eslint-disable-next-line @typescript-eslint/unbound-method */
     if (typeof elt.setMediaKeys === "function") {
+      // eslint-disable-next-line @typescript-eslint/ban-types
       ret = elt.setMediaKeys(mediaKeys as MediaKeys);
     }
-    /* eslint-enable @typescript-eslint/unbound-method */
 
     // If we get in the following code, it means that no compat case has been
     // found and no standard setMediaKeys API exists. This case is particulary
diff --git a/src/compat/eme/generate_key_request.ts b/src/compat/eme/generate_key_request.ts
index 280eb7a744..bd51c1db8d 100644
--- a/src/compat/eme/generate_key_request.ts
+++ b/src/compat/eme/generate_key_request.ts
@@ -17,8 +17,8 @@
 import log from "../../log";
 import { getNextBoxOffsets } from "../../parsers/containers/isobmff";
 import { be4toi, concat } from "../../utils/byte_parsing";
+import type { IMediaKeySession } from "../browser_compatibility_types";
 import { PSSH_TO_INTEGER } from "./constants";
-import type { ICustomMediaKeySession } from "./custom_media_keys";
 
 /**
  * Modify "initialization data" sent to a `generateKeyRequest` EME call to
@@ -129,7 +129,7 @@ export function patchInitData(initData: Uint8Array): Uint8Array {
  * @returns {Promise} - Emit when done. Errors if fails.
  */
 export default function generateKeyRequest(
-  session: MediaKeySession | ICustomMediaKeySession,
+  session: IMediaKeySession,
   initializationDataType: string | undefined,
   initializationData: Uint8Array,
 ): Promise<unknown> {
diff --git a/src/compat/eme/index.ts b/src/compat/eme/index.ts
index b5d13ea619..5f529b9e75 100644
--- a/src/compat/eme/index.ts
+++ b/src/compat/eme/index.ts
@@ -15,8 +15,6 @@
  */
 
 import closeSession from "./close_session";
-import type { ICustomMediaKeySystemAccess } from "./custom_key_system_access";
-import type { ICustomMediaKeys, ICustomMediaKeySession } from "./custom_media_keys";
 import type {
   IEmeApiImplementation,
   IPreferredEmeApiType,
@@ -28,12 +26,5 @@ import getInitData from "./get_init_data";
 import loadSession from "./load_session";
 
 export default defaultEmeImplementation;
-export type {
-  IEmeApiImplementation,
-  IPreferredEmeApiType,
-  ICustomMediaKeySession,
-  ICustomMediaKeySystemAccess,
-  ICustomMediaKeys,
-  IEncryptedEventData,
-};
+export type { IEmeApiImplementation, IPreferredEmeApiType, IEncryptedEventData };
 export { closeSession, generateKeyRequest, getInitData, loadSession };
diff --git a/src/compat/eme/load_session.ts b/src/compat/eme/load_session.ts
index 13efbbe6d0..c737d465ec 100644
--- a/src/compat/eme/load_session.ts
+++ b/src/compat/eme/load_session.ts
@@ -15,7 +15,7 @@
  */
 
 import log from "../../log";
-import type { ICustomMediaKeySession } from "./custom_media_keys";
+import type { IMediaKeySession } from "../browser_compatibility_types";
 
 const EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
 
@@ -33,7 +33,7 @@ const EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
  * @returns {Promise.<boolean>}
  */
 export default async function loadSession(
-  session: MediaKeySession | ICustomMediaKeySession,
+  session: IMediaKeySession,
   sessionId: string,
 ): Promise<boolean> {
   log.info("DRM: Load persisted session", sessionId);
@@ -48,10 +48,7 @@ export default async function loadSession(
   // MediaKeySession would not be populated directly as the load answer but
   // asynchronously after.
   return new Promise((resolve) => {
-    (session as MediaKeySession).addEventListener(
-      "keystatuseschange",
-      resolveWithLoadedStatus,
-    );
+    session.addEventListener("keystatuseschange", resolveWithLoadedStatus);
     const timeout = setTimeout(
       resolveWithLoadedStatus,
       EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES,
@@ -64,10 +61,7 @@ export default async function loadSession(
 
     function cleanUp() {
       clearTimeout(timeout);
-      (session as MediaKeySession).removeEventListener(
-        "keystatuseschange",
-        resolveWithLoadedStatus,
-      );
+      session.removeEventListener("keystatuseschange", resolveWithLoadedStatus);
     }
   });
 }
diff --git a/src/compat/eme/set_media_keys.ts b/src/compat/eme/set_media_keys.ts
index d8b33d970b..990e8ec119 100644
--- a/src/compat/eme/set_media_keys.ts
+++ b/src/compat/eme/set_media_keys.ts
@@ -1,8 +1,7 @@
 import log from "../../log";
 import sleep from "../../utils/sleep";
-import type { IMediaElement } from "../browser_compatibility_types";
+import type { IMediaElement, IMediaKeys } from "../browser_compatibility_types";
 import shouldAwaitSetMediaKeys from "../should_await_set_media_keys";
-import type { ICustomMediaKeys } from "./custom_media_keys";
 import type { IEmeApiImplementation } from "./eme-api-implementation";
 
 /**
@@ -14,7 +13,7 @@ import type { IEmeApiImplementation } from "./eme-api-implementation";
 export function setMediaKeys(
   emeImplementation: IEmeApiImplementation,
   mediaElement: IMediaElement,
-  mediaKeys: MediaKeys | ICustomMediaKeys | null,
+  mediaKeys: IMediaKeys | null,
 ): Promise<unknown> {
   const prom = emeImplementation
     .setMediaKeys(mediaElement, mediaKeys)
diff --git a/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts b/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts
index a4c3834607..d71b1eadd8 100644
--- a/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts
+++ b/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts
@@ -8,7 +8,7 @@ import { describe, beforeEach, afterEach, it, expect, vi } from "vitest";
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable no-restricted-properties */
 
-import type { ICustomMediaKeySystemAccess } from "../../../../compat/eme";
+import type { IMediaKeySystemAccess } from "../../../../compat/browser_compatibility_types";
 import {
   defaultKSConfig,
   defaultPRRecommendationKSConfig,
@@ -20,7 +20,7 @@ import {
 export function requestMediaKeySystemAccessNoMediaKeys(
   keySystem: string,
   config: MediaKeySystemConfiguration[],
-): Promise<ICustomMediaKeySystemAccess> {
+): Promise<IMediaKeySystemAccess> {
   if (config.length === 0) {
     throw new Error("requestMediaKeySystemAccessNoMediaKeys: no config given");
   }
diff --git a/src/main_thread/decrypt/attach_media_keys.ts b/src/main_thread/decrypt/attach_media_keys.ts
index efece246f1..7d550d4368 100644
--- a/src/main_thread/decrypt/attach_media_keys.ts
+++ b/src/main_thread/decrypt/attach_media_keys.ts
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import type {
-  ICustomMediaKeys,
-  ICustomMediaKeySystemAccess,
-  IEmeApiImplementation,
-} from "../../compat/eme";
+  IMediaElement,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../../compat/browser_compatibility_types";
+import type { IEmeApiImplementation } from "../../compat/eme";
 import eme from "../../compat/eme";
 import { setMediaKeys } from "../../compat/eme/set_media_keys";
 import { EncryptedMediaError } from "../../errors";
@@ -106,9 +106,9 @@ export interface IMediaKeysState {
   /** LoadedSessionsStore associated to the MediaKeys instance. */
   loadedSessionsStore: LoadedSessionsStore;
   /** The MediaKeySystemAccess allowing to create MediaKeys instances. */
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
   /** The MediaKeys instance to attach to the media element. */
-  mediaKeys: MediaKeys | ICustomMediaKeys;
+  mediaKeys: IMediaKeys;
   /**
    * The chosen EME implementation abstraction linked to `mediaKeys`.
    * Different EME implementation might for example be used while debugging or
diff --git a/src/main_thread/decrypt/content_decryptor.ts b/src/main_thread/decrypt/content_decryptor.ts
index 1c8e186781..46274d5d0f 100644
--- a/src/main_thread/decrypt/content_decryptor.ts
+++ b/src/main_thread/decrypt/content_decryptor.ts
@@ -14,8 +14,11 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../compat/browser_compatibility_types";
-import type { ICustomMediaKeys, ICustomMediaKeySystemAccess } from "../../compat/eme";
+import type {
+  IMediaElement,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../../compat/browser_compatibility_types";
 import eme, { getInitData } from "../../compat/eme";
 import config from "../../config";
 import { EncryptedMediaError, OtherError } from "../../errors";
@@ -891,7 +894,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
  * @returns {Boolean}
  */
 function canCreatePersistentSession(
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess,
+  mediaKeySystemAccess: IMediaKeySystemAccess,
 ): boolean {
   const { sessionTypes } = mediaKeySystemAccess.getConfiguration();
   return sessionTypes !== undefined && arrayIncludes(sessionTypes, "persistent-license");
@@ -1267,9 +1270,9 @@ interface IActiveSessionInfo {
  */
 interface IAttachedMediaKeysData {
   /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
   /** The MediaKeys instance. */
-  mediaKeys: MediaKeys | ICustomMediaKeys;
+  mediaKeys: IMediaKeys;
   stores: IMediaKeySessionStores;
   options: IKeySystemOption;
 }
diff --git a/src/main_thread/decrypt/create_or_load_session.ts b/src/main_thread/decrypt/create_or_load_session.ts
index 23587597c2..9d31316525 100644
--- a/src/main_thread/decrypt/create_or_load_session.ts
+++ b/src/main_thread/decrypt/create_or_load_session.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../compat/eme";
+import type { IMediaKeySession } from "../../compat/browser_compatibility_types";
 import log from "../../log";
 import type { CancellationSignal } from "../../utils/task_canceller";
 import createSession from "./create_session";
@@ -49,7 +49,7 @@ export default async function createOrLoadSession(
   cancelSignal: CancellationSignal,
 ): Promise<ICreateOrLoadSessionResult> {
   /** Store previously-loaded compatible MediaKeySession, if one. */
-  let previousLoadedSession: MediaKeySession | ICustomMediaKeySession | null = null;
+  let previousLoadedSession: IMediaKeySession | null = null;
 
   const { loadedSessionsStore, persistentSessionsStore } = stores;
   const entry = loadedSessionsStore.reuse(initializationData);
@@ -106,7 +106,7 @@ export default async function createOrLoadSession(
 /** Information concerning a MediaKeySession. */
 export interface IMediaKeySessionContext {
   /** The MediaKeySession itself. */
-  mediaKeySession: MediaKeySession | ICustomMediaKeySession;
+  mediaKeySession: IMediaKeySession;
   /** The type of MediaKeySession (e.g. "temporary"). */
   sessionType: MediaKeySessionType;
   /** `KeySessionRecord` assiociated to this MediaKeySession. */
diff --git a/src/main_thread/decrypt/create_session.ts b/src/main_thread/decrypt/create_session.ts
index 0a4b2c7371..e9de0bf758 100644
--- a/src/main_thread/decrypt/create_session.ts
+++ b/src/main_thread/decrypt/create_session.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../compat/eme";
+import type { IMediaKeySession } from "../../compat/browser_compatibility_types";
 import log from "../../log";
 import type { CancellationSignal } from "../../utils/task_canceller";
 import type { IProcessedProtectionData, IMediaKeySessionStores } from "./types";
@@ -193,7 +193,7 @@ async function createAndTryToRetrievePersistentSession(
 export interface INewSessionCreatedEvent {
   type: MediaKeySessionLoadingType.Created;
   value: {
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession;
+    mediaKeySession: IMediaKeySession;
     sessionType: MediaKeySessionType;
     keySessionRecord: KeySessionRecord;
   };
@@ -202,7 +202,7 @@ export interface INewSessionCreatedEvent {
 export interface IPersistentSessionRecoveryEvent {
   type: MediaKeySessionLoadingType.LoadedPersistentSession;
   value: {
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession;
+    mediaKeySession: IMediaKeySession;
     sessionType: MediaKeySessionType;
     keySessionRecord: KeySessionRecord;
   };
diff --git a/src/main_thread/decrypt/find_key_system.ts b/src/main_thread/decrypt/find_key_system.ts
index 65643176d3..e8d551f8f8 100644
--- a/src/main_thread/decrypt/find_key_system.ts
+++ b/src/main_thread/decrypt/find_key_system.ts
@@ -14,9 +14,11 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../compat/browser_compatibility_types";
+import type {
+  IMediaElement,
+  IMediaKeySystemAccess,
+} from "../../compat/browser_compatibility_types";
 import { canRelyOnRequestMediaKeySystemAccess } from "../../compat/can_rely_on_request_media_key_system_access";
-import type { ICustomMediaKeySystemAccess } from "../../compat/eme";
 import eme from "../../compat/eme";
 import {
   generatePlayReadyInitData,
@@ -36,7 +38,7 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 type MediaKeysRequirement = "optional" | "required" | "not-allowed";
 
 export interface IMediaKeySystemAccessInfos {
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
   options: IKeySystemOption;
 }
 
@@ -76,11 +78,11 @@ interface IKeySystemType {
  */
 function checkCachedMediaKeySystemAccess(
   keySystems: IKeySystemOption[],
-  currentKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess,
+  currentKeySystemAccess: IMediaKeySystemAccess,
   currentKeySystemOptions: IKeySystemOption,
 ): null | {
   keySystemOptions: IKeySystemOption;
-  keySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  keySystemAccess: IMediaKeySystemAccess;
 } {
   const mksConfiguration = currentKeySystemAccess.getConfiguration();
   if (shouldRenewMediaKeySystemAccess() || isNullOrUndefined(mksConfiguration)) {
diff --git a/src/main_thread/decrypt/get_media_keys.ts b/src/main_thread/decrypt/get_media_keys.ts
index 1708ab9ddd..09be42f889 100644
--- a/src/main_thread/decrypt/get_media_keys.ts
+++ b/src/main_thread/decrypt/get_media_keys.ts
@@ -14,9 +14,12 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../compat/browser_compatibility_types";
+import type {
+  IMediaElement,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../../compat/browser_compatibility_types";
 import canReuseMediaKeys from "../../compat/can_reuse_media_keys";
-import type { ICustomMediaKeys, ICustomMediaKeySystemAccess } from "../../compat/eme";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import type { IKeySystemOption } from "../../public_types";
@@ -49,9 +52,9 @@ function createPersistentSessionsStorage(
 /** Object returned by `getMediaKeysInfos`. */
 export interface IMediaKeysInfos {
   /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
   /** The MediaKeys instance. */
-  mediaKeys: MediaKeys | ICustomMediaKeys;
+  mediaKeys: IMediaKeys;
   /** Stores allowing to create and retrieve MediaKeySessions. */
   stores: IMediaKeySessionStores;
   /** IKeySystemOption compatible to the created MediaKeys instance. */
@@ -131,8 +134,8 @@ export default async function getMediaKeysInfos(
  * @returns {Promise.<MediaKeys>}
  */
 async function createMediaKeys(
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess,
-): Promise<MediaKeys | ICustomMediaKeys> {
+  mediaKeySystemAccess: IMediaKeySystemAccess,
+): Promise<IMediaKeys> {
   log.info("DRM: Calling createMediaKeys on the MediaKeySystemAccess");
   try {
     const mediaKeys = await mediaKeySystemAccess.createMediaKeys();
diff --git a/src/main_thread/decrypt/session_events_listener.ts b/src/main_thread/decrypt/session_events_listener.ts
index 381f95144f..80ebefc88f 100644
--- a/src/main_thread/decrypt/session_events_listener.ts
+++ b/src/main_thread/decrypt/session_events_listener.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../compat/eme";
+import type { IMediaKeySession } from "../../compat/browser_compatibility_types";
 import {
   onKeyError,
   onKeyMessage,
@@ -40,7 +40,7 @@ import checkKeyStatuses from "./utils/check_key_statuses";
  * @param {Object} cancelSignal
  */
 export default function SessionEventsListener(
-  session: MediaKeySession | ICustomMediaKeySession,
+  session: IMediaKeySession,
   keySystemOptions: IKeySystemOption,
   keySystem: string,
   callbacks: ISessionEventListenerCallbacks,
@@ -286,7 +286,7 @@ function formatGetLicenseError(error: unknown): IPlayerError {
  * @returns {Promise}
  */
 async function updateSessionWithMessage(
-  session: MediaKeySession | ICustomMediaKeySession,
+  session: IMediaKeySession,
   message: BufferSource,
 ): Promise<void> {
   log.info("DRM: Updating MediaKeySession with message");
diff --git a/src/main_thread/decrypt/set_server_certificate.ts b/src/main_thread/decrypt/set_server_certificate.ts
index 6336e9c7cf..46b2dbc97d 100644
--- a/src/main_thread/decrypt/set_server_certificate.ts
+++ b/src/main_thread/decrypt/set_server_certificate.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeys } from "../../compat/eme";
+import type { IMediaKeys } from "../../compat/browser_compatibility_types";
 import { EncryptedMediaError, isKnownError } from "../../errors";
 import log from "../../log";
 import type { IPlayerError } from "../../public_types";
@@ -35,11 +35,11 @@ import ServerCertificateStore from "./utils/server_certificate_store";
  * @returns {Promise}
  */
 async function setServerCertificate(
-  mediaKeys: ICustomMediaKeys | MediaKeys,
+  mediaKeys: IMediaKeys,
   serverCertificate: BufferSource,
 ): Promise<unknown> {
   try {
-    const res = await (mediaKeys as MediaKeys).setServerCertificate(serverCertificate);
+    const res = await mediaKeys.setServerCertificate(serverCertificate);
     // Note: Even if `setServerCertificate` technically should return a
     // Promise.<boolean>, this is not technically always true.
     // Thus we prefer to return unknown here.
@@ -63,7 +63,7 @@ async function setServerCertificate(
  * @returns {Promise.<Object>}
  */
 export default async function trySettingServerCertificate(
-  mediaKeys: ICustomMediaKeys | MediaKeys,
+  mediaKeys: IMediaKeys,
   serverCertificate: BufferSource,
 ): Promise<
   | { type: "success"; value: unknown }
diff --git a/src/main_thread/decrypt/utils/check_key_statuses.ts b/src/main_thread/decrypt/utils/check_key_statuses.ts
index c97e0c863f..039630abe1 100644
--- a/src/main_thread/decrypt/utils/check_key_statuses.ts
+++ b/src/main_thread/decrypt/utils/check_key_statuses.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../../compat/eme";
+import type { IMediaKeySession } from "../../../compat/browser_compatibility_types";
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
 import log from "../../../log";
@@ -83,7 +83,7 @@ type IKeyStatusesForEach = (
  * @returns {Object} - Warnings to send, whitelisted and blacklisted key ids.
  */
 export default function checkKeyStatuses(
-  session: MediaKeySession | ICustomMediaKeySession,
+  session: IMediaKeySession,
   options: IKeyStatusesCheckingOptions,
   keySystem: string,
 ): {
diff --git a/src/main_thread/decrypt/utils/is_session_usable.ts b/src/main_thread/decrypt/utils/is_session_usable.ts
index 129d3be4d2..f83e1b2727 100644
--- a/src/main_thread/decrypt/utils/is_session_usable.ts
+++ b/src/main_thread/decrypt/utils/is_session_usable.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../../compat/eme";
+import type { IMediaKeySession } from "../../../compat/browser_compatibility_types";
 import log from "../../../log";
 import arrayIncludes from "../../../utils/array_includes";
 
@@ -25,9 +25,7 @@ import arrayIncludes from "../../../utils/array_includes";
  * @param {MediaKeySession} loadedSession
  * @returns {MediaKeySession}
  */
-export default function isSessionUsable(
-  loadedSession: MediaKeySession | ICustomMediaKeySession,
-): boolean {
+export default function isSessionUsable(loadedSession: IMediaKeySession): boolean {
   if (loadedSession.sessionId === "") {
     return false;
   }
diff --git a/src/main_thread/decrypt/utils/loaded_sessions_store.ts b/src/main_thread/decrypt/utils/loaded_sessions_store.ts
index 888768ecec..537151e997 100644
--- a/src/main_thread/decrypt/utils/loaded_sessions_store.ts
+++ b/src/main_thread/decrypt/utils/loaded_sessions_store.ts
@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeys, ICustomMediaKeySession } from "../../../compat/eme";
+import type {
+  IMediaKeySession,
+  IMediaKeys,
+} from "../../../compat/browser_compatibility_types";
 import { closeSession, generateKeyRequest, loadSession } from "../../../compat/eme";
 import log from "../../../log";
 import assert from "../../../utils/assert";
@@ -32,7 +35,7 @@ import KeySessionRecord from "./key_session_record";
  */
 export default class LoadedSessionsStore {
   /** MediaKeys instance on which the MediaKeySessions are created. */
-  private readonly _mediaKeys: MediaKeys | ICustomMediaKeys;
+  private readonly _mediaKeys: IMediaKeys;
 
   /** Store unique MediaKeySession information per initialization data. */
   private _storage: IStoredSessionEntry[];
@@ -42,7 +45,7 @@ export default class LoadedSessionsStore {
    * loaded MediaKeySessions on the given MediaKeys instance.
    * @param {MediaKeys} mediaKeys
    */
-  constructor(mediaKeys: MediaKeys | ICustomMediaKeys) {
+  constructor(mediaKeys: IMediaKeys) {
     this._mediaKeys = mediaKeys;
     this._storage = [];
   }
@@ -128,7 +131,7 @@ export default class LoadedSessionsStore {
    * @returns {Object|null}
    */
   public getEntryForSession(
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession,
+    mediaKeySession: IMediaKeySession,
   ): IStoredSessionEntry | null {
     for (let i = this._storage.length - 1; i >= 0; i--) {
       const stored = this._storage[i];
@@ -144,14 +147,14 @@ export default class LoadedSessionsStore {
    * to the LoadedSessionsStore that a license-request is pending so
    * session-closing orders are properly scheduled after it is done.
    * @param {Object} mediaKeySession
-   * @param {string} initializationDataType - Initialization data type given
-   * e.g. by the "encrypted" event for the corresponding request.
+   * @param {string|undefined} initializationDataType - Initialization data type
+   * given e.g. by the "encrypted" event for the corresponding request.
    * @param {Uint8Array} initializationData - Initialization data given e.g. by
    * the "encrypted" event for the corresponding request.
    * @returns {Promise}
    */
   public async generateLicenseRequest(
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession,
+    mediaKeySession: IMediaKeySession,
     initializationDataType: string | undefined,
     initializationData: Uint8Array,
   ): Promise<unknown> {
@@ -212,7 +215,7 @@ export default class LoadedSessionsStore {
    * @returns {Promise}
    */
   public async loadPersistentSession(
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession,
+    mediaKeySession: IMediaKeySession,
     sessionId: string,
   ): Promise<boolean> {
     let entry: IStoredSessionEntry | undefined;
@@ -266,9 +269,7 @@ export default class LoadedSessionsStore {
    * @param {Object} mediaKeySession
    * @returns {Promise}
    */
-  public async closeSession(
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession,
-  ): Promise<boolean> {
+  public async closeSession(mediaKeySession: IMediaKeySession): Promise<boolean> {
     let entry: IStoredSessionEntry | undefined;
     for (const stored of this._storage) {
       if (stored.mediaKeySession === mediaKeySession) {
@@ -333,9 +334,7 @@ export default class LoadedSessionsStore {
    * @param {MediaKeySession} mediaKeySession
    * @returns {boolean}
    */
-  public removeSessionWithoutClosingIt(
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession,
-  ): boolean {
+  public removeSessionWithoutClosingIt(mediaKeySession: IMediaKeySession): boolean {
     assert(
       mediaKeySession.sessionId === "",
       "Initialized `MediaKeySession`s should always be properly closed",
@@ -433,7 +432,7 @@ export interface IStoredSessionEntry {
   keySessionRecord: KeySessionRecord;
 
   /** The MediaKeySession created. */
-  mediaKeySession: MediaKeySession | ICustomMediaKeySession;
+  mediaKeySession: IMediaKeySession;
 
   /**
    * The MediaKeySessionType (e.g. "temporary" or "persistent-license") with
@@ -494,7 +493,7 @@ export interface IStoredSessionEntry {
  * @returns {Promise}
  */
 async function safelyCloseMediaKeySession(
-  mediaKeySession: MediaKeySession | ICustomMediaKeySession,
+  mediaKeySession: IMediaKeySession,
 ): Promise<void> {
   log.debug("DRM: Trying to close a MediaKeySession", mediaKeySession.sessionId);
   try {
diff --git a/src/main_thread/decrypt/utils/media_keys_infos_store.ts b/src/main_thread/decrypt/utils/media_keys_infos_store.ts
index fb4fb5b5f8..f3c2e1099b 100644
--- a/src/main_thread/decrypt/utils/media_keys_infos_store.ts
+++ b/src/main_thread/decrypt/utils/media_keys_infos_store.ts
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../../compat/browser_compatibility_types";
 import type {
-  ICustomMediaKeys,
-  ICustomMediaKeySystemAccess,
-  IEmeApiImplementation,
-} from "../../../compat/eme";
+  IMediaElement,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../../../compat/browser_compatibility_types";
+import type { IEmeApiImplementation } from "../../../compat/eme";
 import type { IKeySystemOption } from "../../../public_types";
 import type LoadedSessionsStore from "./loaded_sessions_store";
 
@@ -34,10 +34,10 @@ export interface IMediaElementMediaKeysInfos {
    * Last MediaKeySystemAccess used to create a MediaKeys bound to that
    * HTMLMediaElement.
    */
-  mediaKeySystemAccess: ICustomMediaKeySystemAccess | MediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
 
   /** Last MediaKeys instance bound to that HTMLMediaElement. */
-  mediaKeys: MediaKeys | ICustomMediaKeys;
+  mediaKeys: IMediaKeys;
 
   /**
    * Store containing information about every MediaKeySession active on the
diff --git a/src/main_thread/decrypt/utils/persistent_sessions_store.ts b/src/main_thread/decrypt/utils/persistent_sessions_store.ts
index b74aaea3ae..ab8811036e 100644
--- a/src/main_thread/decrypt/utils/persistent_sessions_store.ts
+++ b/src/main_thread/decrypt/utils/persistent_sessions_store.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../../compat/eme";
+import type { IMediaKeySession } from "../../../compat/browser_compatibility_types";
 import log from "../../../log";
 import type {
   IPersistentLicenseConfig,
@@ -99,7 +99,6 @@ export default class PersistentSessionsStore {
   /**
    * Retrieve an entry based on its initialization data.
    * @param {Object}  initData
-   * @param {string|undefined} initDataType
    * @returns {Object|null}
    */
   public get(initData: IProcessedProtectionData): IPersistentSessionInfo | null {
@@ -114,8 +113,7 @@ export default class PersistentSessionsStore {
    * re-used to then be able to implement a caching replacement algorithm based
    * on the least-recently-used values by just evicting the first values
    * returned by `getAll`.
-   * @param {Uint8Array} initData
-   * @param {string|undefined} initDataType
+   * @param {Object} initData
    * @returns {*}
    */
   public getAndReuse(initData: IProcessedProtectionData): IPersistentSessionInfo | null {
@@ -130,14 +128,14 @@ export default class PersistentSessionsStore {
 
   /**
    * Add a new entry in the PersistentSessionsStore.
-   * @param {Uint8Array}  initData
-   * @param {string|undefined} initDataType
+   * @param {Object}  initData
+   * @param {Array.<Uint8Array>|undefined} keyIds
    * @param {MediaKeySession} session
    */
   public add(
     initData: IProcessedProtectionData,
     keyIds: Uint8Array[] | undefined,
-    session: MediaKeySession | ICustomMediaKeySession,
+    session: IMediaKeySession,
   ): void {
     if (isNullOrUndefined(session) || !isNonEmptyString(session.sessionId)) {
       log.warn("DRM-PSS: Invalid Persisten Session given.");
diff --git a/src/main_thread/decrypt/utils/server_certificate_store.ts b/src/main_thread/decrypt/utils/server_certificate_store.ts
index 78e3fb1e59..c9e121e61c 100644
--- a/src/main_thread/decrypt/utils/server_certificate_store.ts
+++ b/src/main_thread/decrypt/utils/server_certificate_store.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeys } from "../../../compat/eme";
+import type { IMediaKeys } from "../../../compat/browser_compatibility_types";
 import hashBuffer from "../../../utils/hash_buffer";
 
 /**
@@ -31,7 +31,7 @@ import hashBuffer from "../../../utils/hash_buffer";
  * EME APIs failed or had an unexpected behavior).
  */
 const serverCertificateHashesMap = new WeakMap<
-  MediaKeys | ICustomMediaKeys,
+  IMediaKeys,
   { hash: number; serverCertificate: Uint8Array } | null
 >();
 
@@ -49,7 +49,7 @@ export default {
    * server certificate attached to this MediaKeys is for now invalid.
    * @param {MediaKeys | Object} mediaKeys
    */
-  prepare(mediaKeys: MediaKeys | ICustomMediaKeys): void {
+  prepare(mediaKeys: IMediaKeys): void {
     serverCertificateHashesMap.set(mediaKeys, null);
   },
 
@@ -64,10 +64,7 @@ export default {
    * @param {MediaKeys | Object} mediaKeys
    * @param {ArrayBufferView | BufferSource} serverCertificate
    */
-  set(
-    mediaKeys: MediaKeys | ICustomMediaKeys,
-    serverCertificate: ArrayBufferView | BufferSource,
-  ): void {
+  set(mediaKeys: IMediaKeys, serverCertificate: ArrayBufferView | BufferSource): void {
     const formattedServerCertificate: Uint8Array =
       serverCertificate instanceof Uint8Array
         ? serverCertificate
@@ -92,7 +89,7 @@ export default {
    * @param {MediaKeys} mediaKeys
    * @returns {Boolean|undefined}
    */
-  hasOne(mediaKeys: MediaKeys | ICustomMediaKeys): boolean | undefined {
+  hasOne(mediaKeys: IMediaKeys): boolean | undefined {
     const currentServerCertificate = serverCertificateHashesMap.get(mediaKeys);
     if (currentServerCertificate === undefined) {
       return false;
@@ -111,10 +108,7 @@ export default {
    * @param {ArrayBufferView | BufferSource} serverCertificate
    * @returns {boolean}
    */
-  has(
-    mediaKeys: MediaKeys | ICustomMediaKeys,
-    serverCertificate: ArrayBufferView | BufferSource,
-  ): boolean {
+  has(mediaKeys: IMediaKeys, serverCertificate: ArrayBufferView | BufferSource): boolean {
     const serverCertificateHash = serverCertificateHashesMap.get(mediaKeys);
     if (serverCertificateHash === undefined || serverCertificateHash === null) {
       return false;
diff --git a/src/parsers/containers/isobmff/extract_complete_chunks.ts b/src/parsers/containers/isobmff/extract_complete_chunks.ts
index cb7a4e87aa..836a756d8e 100644
--- a/src/parsers/containers/isobmff/extract_complete_chunks.ts
+++ b/src/parsers/containers/isobmff/extract_complete_chunks.ts
@@ -21,7 +21,7 @@ import findCompleteBox from "./find_complete_box";
  * Take a chunk of ISOBMFF data and extract complete `moof`+`mdat` subsegments
  * which are ready to be decoded.
  * Returns a tuple of two containing first an array of those subsegments
- * followed by tha last un-decodable part.
+ * followed by the last un-decodable part.
  * @param {Uint8Array} buffer
  * @returns {Array}
  */