diff --git a/.eslintrc.js b/.eslintrc.js
index 473df4d2eb..907cfcb3e5 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 d552e015b5..2196488dfe 100644
--- a/src/compat/browser_compatibility_types.ts
+++ b/src/compat/browser_compatibility_types.ts
@@ -17,12 +17,6 @@
 import type { IListener } from "../utils/event_emitter";
 import globalScope from "../utils/global_scope";
 
-/** 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?
@@ -191,18 +185,22 @@ export interface ISourceBuffer extends IEventTarget<ISourceBufferEventMap> {
   onupdatestart: ((evt: Event) => void) | null;
 }
 
+export interface IMediaEncryptedEvent extends MediaEncryptedEvent {
+  forceSessionRecreation?: boolean;
+}
+
 /** Events potentially dispatched by an `IMediaElement` */
 export interface IMediaElementEventMap {
   canplay: Event;
   canplaythrough: Event;
-  encrypted: MediaEncryptedEvent;
+  encrypted: IMediaEncryptedEvent;
   ended: Event;
   enterpictureinpicture: Event;
   error: Event;
   leavepictureinpicture: Event;
   loadeddata: Event;
   loadedmetadata: Event;
-  needkey: MediaEncryptedEvent;
+  needkey: IMediaEncryptedEvent;
   pause: Event;
   play: Event;
   playing: Event;
@@ -214,7 +212,7 @@ export interface IMediaElementEventMap {
   visibilitychange: Event;
   volumechange: Event;
   waiting: Event;
-  webkitneedkey: MediaEncryptedEvent;
+  webkitneedkey: IMediaEncryptedEvent;
 }
 
 /**
@@ -241,7 +239,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;
@@ -264,9 +262,9 @@ 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;
+  onencrypted: ((evt: IMediaEncryptedEvent) => void) | null;
   oncanplay: ((evt: Event) => void) | null;
   oncanplaythrough: ((evt: Event) => void) | null;
   onended: ((evt: Event) => void) | null;
@@ -308,12 +306,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>;
+}
+
 // @ts-expect-error unused function, just used for compile-time typechecking
 // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-restricted-types
 function testMediaElement(x: HTMLMediaElement) {
@@ -346,6 +368,30 @@ function testSourceBufferList(x: SourceBufferList) {
 function assertCompatibleISourceBufferList(_x: ISourceBufferList) {
   // Noop
 }
+// @ts-expect-error unused function, just used for compile-time typechecking
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-restricted-types
+function testMediaKeySystemAccess(x: MediaKeySystemAccess) {
+  assertCompatibleIMediaKeySystemAccess(x);
+}
+function assertCompatibleIMediaKeySystemAccess(_x: IMediaKeySystemAccess) {
+  // Noop
+}
+// @ts-expect-error unused function, just used for compile-time typechecking
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-restricted-types
+function testMediaKeys(x: MediaKeys) {
+  assertCompatibleIMediaKeys(x);
+}
+function assertCompatibleIMediaKeys(_x: IMediaKeys) {
+  // Noop
+}
+// @ts-expect-error unused function, just used for compile-time typechecking
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-restricted-types
+function testMediaKeySession(x: MediaKeySession) {
+  assertCompatibleIMediaKeySession(x);
+}
+function assertCompatibleIMediaKeySession(_x: IMediaKeySession) {
+  // Noop
+}
 
 /**
  * AudioTrackList implementation (that TS forgot).
@@ -459,7 +505,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 e615f17279..203af1c121 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;
 }
 
@@ -41,11 +40,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) {
@@ -64,7 +60,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 92dce51f13..134d93d9a3 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");
       };
     });
 
@@ -155,7 +153,7 @@ class OldWebkitMediaKeySession
   }
 }
 
-class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
+class OldWebKitCustomMediaKeys implements IMediaKeys {
   private readonly _keySystem: string;
   private _videoElement?: IOldWebkitHTMLMediaElement;
 
@@ -172,14 +170,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");
   }
 }
@@ -187,10 +185,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
@@ -217,7 +212,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 d81509a418..0000000000
--- a/src/compat/eme/custom_media_keys/types.ts
+++ /dev/null
@@ -1,66 +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" */
-}
-
-export interface ICustomMediaEncryptedEvent extends MediaEncryptedEvent {
-  forceSessionRecreation?: boolean | undefined;
-}
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 b220d381b6..0ff73e0c80 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) => Promise<unknown>;
-  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();
@@ -167,7 +159,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;
@@ -190,30 +182,33 @@ class WebkitMediaKeySession
     return this._nativeSession?.sessionId ?? "";
   }
 
-  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);
     };
 
     ["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,
+          );
         },
       );
     };
   }
 }
 
-class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
+class WebKitCustomMediaKeys implements IMediaKeys {
   private _videoElement?: IMediaElement;
   private _mediaKeys?: IWebKitMediaKeys;
   private _serverCertificate?: Uint8Array;
@@ -235,7 +230,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");
     }
@@ -246,19 +241,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.");
@@ -267,7 +259,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 3844781fd5..36c6afd4cf 100644
--- a/src/compat/eme/eme-api-implementation.ts
+++ b/src/compat/eme/eme-api-implementation.ts
@@ -5,7 +5,12 @@ import isNode from "../../utils/is_node";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import objectAssign from "../../utils/object_assign";
 import type { CancellationSignal } from "../../utils/task_canceller";
-import type { IMediaElement } from "../browser_compatibility_types";
+import type {
+  IMediaElement,
+  IMediaEncryptedEvent,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../browser_compatibility_types";
 import { isIE11 } from "../browser_detection";
 import type { IEventTargetLike } from "../event_listeners";
 import { createCompatibleEventListener } from "../event_listeners";
@@ -20,10 +25,6 @@ import getMozMediaKeysCallbacks, {
 import getOldKitWebKitMediaKeyCallbacks, {
   isOldWebkitMediaElement,
 } from "./custom_media_keys/old_webkit_media_keys";
-import type {
-  ICustomMediaEncryptedEvent,
-  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";
 
@@ -53,7 +54,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
@@ -67,12 +68,12 @@ export interface IEmeApiImplementation {
    */
   onEncrypted: (
     target: IEventTargetLike,
-    listener: (evt: ICustomMediaEncryptedEvent) => void,
+    listener: (evt: IMediaEncryptedEvent) => void,
     cancelSignal: CancellationSignal,
   ) => 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.
@@ -82,7 +83,7 @@ export interface IEmeApiImplementation {
    */
   setMediaKeys: (
     mediaElement: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ) => Promise<unknown>;
 
   /**
@@ -144,7 +145,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) {
       const callbacks = getWebKitMediaKeysCallbacks();
@@ -188,7 +189,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) {
@@ -222,7 +223,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"));
       }
@@ -289,7 +290,7 @@ function createOnEncryptedForWebkit(): IEmeApiImplementation["onEncrypted"] {
   );
   const onEncrypted = (
     target: IEventTargetLike,
-    listener: (event: ICustomMediaEncryptedEvent) => void,
+    listener: (event: IMediaEncryptedEvent) => void,
     cancelSignal: CancellationSignal,
   ) => {
     compatibleEventListener(
@@ -315,11 +316,12 @@ function createOnEncryptedForWebkit(): IEmeApiImplementation["onEncrypted"] {
  */
 function defaultSetMediaKeys(
   elt: IMediaElement,
-  mediaKeys: MediaKeys | ICustomMediaKeys | null,
+  mediaKeys: IMediaKeys | null,
 ): Promise<unknown> {
   try {
     let ret: unknown;
     if (typeof elt.setMediaKeys === "function") {
+      // eslint-disable-next-line @typescript-eslint/no-restricted-types
       ret = elt.setMediaKeys(mediaKeys as MediaKeys);
     }
 
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/get_init_data.ts b/src/compat/eme/get_init_data.ts
index 985f3edd1c..6999fe9615 100644
--- a/src/compat/eme/get_init_data.ts
+++ b/src/compat/eme/get_init_data.ts
@@ -19,8 +19,8 @@ import { getPsshSystemID } from "../../parsers/containers/isobmff";
 import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
 import { be4toi } from "../../utils/byte_parsing";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import type { IMediaEncryptedEvent } from "../browser_compatibility_types";
 import { PSSH_TO_INTEGER } from "./constants";
-import type { ICustomMediaEncryptedEvent } from "./custom_media_keys/types";
 
 /** Data recuperated from parsing the payload of an `encrypted` event. */
 export interface IEncryptedEventData {
@@ -147,7 +147,7 @@ function isPSSHAlreadyEncountered(
  * encountered in the given event.
  */
 export default function getInitData(
-  encryptedEvent: ICustomMediaEncryptedEvent,
+  encryptedEvent: IMediaEncryptedEvent,
 ): IEncryptedEventData | null {
   const { initData, initDataType, forceSessionRecreation } = encryptedEvent;
   if (isNullOrUndefined(initData)) {
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/compat/event_listeners.ts b/src/compat/event_listeners.ts
index 29bbe31f62..0ed7718996 100644
--- a/src/compat/event_listeners.ts
+++ b/src/compat/event_listeners.ts
@@ -29,8 +29,8 @@ import type {
   ICompatPictureInPictureWindow,
   IEventTarget,
   IMediaElement,
+  IMediaEncryptedEvent,
 } from "./browser_compatibility_types";
-import type { ICustomMediaEncryptedEvent } from "./eme/custom_media_keys/types";
 
 const BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
 
@@ -112,7 +112,7 @@ function createCompatibleEventListener(
   prefixes?: string[],
 ): (
   element: IEventTargetLike,
-  listener: (event: ICustomMediaEncryptedEvent) => void,
+  listener: (event: IMediaEncryptedEvent) => void,
   cancelSignal: CancellationSignal,
 ) => void;
 
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 6821016fc4..05eb09c0b3 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
@@ -1,5 +1,5 @@
 import { describe, beforeEach, afterEach, it, expect, vi } from "vitest";
-import type { ICustomMediaKeySystemAccess } from "../../../../compat/eme";
+import type { IMediaKeySystemAccess } from "../../../../compat/browser_compatibility_types";
 import type { IKeySystemOption } from "../../../../public_types";
 import type IContentDecryptor from "../../content_decryptor";
 import {
@@ -13,7 +13,7 @@ import {
 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/content_decryptor.ts b/src/main_thread/decrypt/content_decryptor.ts
index f9b07fe5fe..35cf2a55cf 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";
@@ -991,7 +994,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");
@@ -1367,9 +1370,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 8bb8cfaab8..666d4f0077 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);
@@ -111,7 +111,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 6de768fe1c..cd0243b397 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,
@@ -44,7 +46,7 @@ export type ICodecSupportList = Array<{
 
 export interface IMediaKeySystemAccessInfos {
   /** `MediaKeySystemAccess` to use to create `MediaKeys` instances. */
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
   /**
    * The MediaKeySystemConfiguration that has been provided to the
    * `requestMediaKeySystemAccess` API.
diff --git a/src/main_thread/decrypt/get_media_keys.ts b/src/main_thread/decrypt/get_media_keys.ts
index 3cb8511312..a845365643 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";
@@ -50,14 +53,14 @@ function createPersistentSessionsStorage(
 /** Object returned by `getMediaKeysInfos`. */
 export interface IMediaKeysInfos {
   /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
   /**
    * The MediaKeySystemConfiguration that has been provided to the
    * `requestMediaKeySystemAccess` API.
    */
   askedConfiguration: MediaKeySystemConfiguration;
   /** The MediaKeys instance. */
-  mediaKeys: MediaKeys | ICustomMediaKeys;
+  mediaKeys: IMediaKeys;
   /** Stores allowing to create and retrieve MediaKeySessions. */
   stores: IMediaKeySessionStores;
   /** IKeySystemOption compatible to the created MediaKeys instance. */
@@ -145,8 +148,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 96d075ba38..77a50726c0 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_attacher.ts b/src/main_thread/decrypt/utils/media_keys_attacher.ts
index b3e8586265..d565a75bf4 100644
--- a/src/main_thread/decrypt/utils/media_keys_attacher.ts
+++ b/src/main_thread/decrypt/utils/media_keys_attacher.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,
+  IMediaKeys,
+  IMediaKeySystemAccess,
+} from "../../../compat/browser_compatibility_types";
+import type { IEmeApiImplementation } from "../../../compat/eme";
 import { setMediaKeys } from "../../../compat/eme/set_media_keys";
 import { EncryptedMediaError } from "../../../errors";
 import log from "../../../log";
@@ -44,10 +44,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 b57f76c52b..74e2e73d3f 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}
  */