diff --git a/src/compat/__tests__/has_eme_apis.test.ts b/src/compat/__tests__/has_eme_apis.test.ts
deleted file mode 100644
index a471dbb323..0000000000
--- a/src/compat/__tests__/has_eme_apis.test.ts
+++ /dev/null
@@ -1,56 +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.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-
-describe("compat - hasEMEAPIs", () => {
-  beforeEach(() => {
-    jest.resetModules();
-  });
-
-  /* eslint-disable max-len */
-  it("should return true if we could define a requestMediaKeySystemAccess function", () => {
-  /* eslint-enable max-len */
-
-    jest.mock("../eme", () => {
-      return {
-        __esModule: true as const,
-        requestMediaKeySystemAccess: () => null,
-      };
-    });
-    const hasEMEAPIs = jest.requireActual("../has_eme_apis");
-    expect(hasEMEAPIs.default()).toBe(true);
-  });
-
-  /* eslint-disable max-len */
-  it("should return false if we could not define a requestMediaKeySystemAccess function", () => {
-  /* eslint-enable max-len */
-
-    jest.mock("../eme", () => {
-      return {
-        __esModule: true as const,
-        requestMediaKeySystemAccess: null,
-      };
-    });
-    const hasEMEAPIs = jest.requireActual("../has_eme_apis");
-    expect(hasEMEAPIs.default()).toBe(false);
-  });
-});
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 372290b557..e20655f18c 100644
--- a/src/compat/eme/custom_media_keys/ie11_media_keys.ts
+++ b/src/compat/eme/custom_media_keys/ie11_media_keys.ts
@@ -16,6 +16,7 @@
 
 import EventEmitter from "../../../utils/event_emitter";
 import TaskCanceller from "../../../utils/task_canceller";
+import wrapInPromise from "../../../utils/wrapInPromise";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import * as events from "../../event_listeners";
 import {
@@ -119,11 +120,13 @@ class IE11CustomMediaKeys implements ICustomMediaKeys {
     this._mediaKeys = new MSMediaKeysConstructor(keyType);
   }
 
-  _setVideo(videoElement: HTMLMediaElement): void {
-    this._videoElement = videoElement as ICompatHTMLMediaElement;
-    if (this._videoElement.msSetMediaKeys !== undefined) {
-      return this._videoElement.msSetMediaKeys(this._mediaKeys);
-    }
+  _setVideo(videoElement: HTMLMediaElement): Promise<unknown> {
+    return wrapInPromise(() => {
+      this._videoElement = videoElement as ICompatHTMLMediaElement;
+      if (this._videoElement.msSetMediaKeys !== undefined) {
+        this._videoElement.msSetMediaKeys(this._mediaKeys);
+      }
+    });
   }
 
   createSession(/* sessionType */): ICustomMediaKeySession {
@@ -144,7 +147,7 @@ export default function getIE11MediaKeysCallbacks() : {
   setMediaKeys: (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => void;
+  ) => Promise<unknown>;
 } {
   const isTypeSupported = (keySystem: string, type?: string|null) => {
     if (MSMediaKeysConstructor === undefined) {
@@ -160,12 +163,12 @@ export default function getIE11MediaKeysCallbacks() : {
   const setMediaKeys = (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): void => {
+  ): Promise<unknown> => {
     if (mediaKeys === null) {
       // msSetMediaKeys only accepts native MSMediaKeys as argument.
       // Calling it with null or undefined will raise an exception.
       // There is no way to unset the mediakeys in that case, so return here.
-      return;
+      return Promise.resolve(undefined);
     }
     if (!(mediaKeys instanceof IE11CustomMediaKeys)) {
       throw new Error("Custom setMediaKeys is supposed to be called " +
diff --git a/src/compat/eme/custom_media_keys/index.ts b/src/compat/eme/custom_media_keys/index.ts
index a029facbe7..1f649a5087 100644
--- a/src/compat/eme/custom_media_keys/index.ts
+++ b/src/compat/eme/custom_media_keys/index.ts
@@ -1,26 +1,3 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { MediaError } from "../../../errors";
-import assert from "../../../utils/assert";
-import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
-import { isIE11 } from "../../browser_detection";
-import isNode from "../../is_node";
-import shouldFavourCustomSafariEME from "../../should_favour_custom_safari_EME";
-import CustomMediaKeySystemAccess from "./../custom_key_system_access";
 import getIE11MediaKeysCallbacks, {
   MSMediaKeysConstructor,
 } from "./ie11_media_keys";
@@ -37,168 +14,15 @@ import {
 import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 
-/** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
-type ICompatRequestMediaKeySystemAccessFn =
-  (keyType : string, config : MediaKeySystemConfiguration[]) =>
-    Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
-
-let requestMediaKeySystemAccess : ICompatRequestMediaKeySystemAccessFn | null = null;
-
-/**
- * Set the given MediaKeys on the given HTMLMediaElement.
- * Emits null when done then complete.
- * @param {HTMLMediaElement} elt
- * @param {Object} mediaKeys
- */
-let setMediaKeys :
-((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => unknown) =
-  function defaultSetMediaKeys(
-    mediaElement: HTMLMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null
-  ) {
-    const elt : ICompatHTMLMediaElement = mediaElement;
-    /* eslint-disable @typescript-eslint/unbound-method */
-    if (typeof elt.setMediaKeys === "function") {
-      return elt.setMediaKeys(mediaKeys as MediaKeys);
-    }
-    /* eslint-enable @typescript-eslint/unbound-method */
-
-    // If we get in the following code, it means that no compat case has been
-    // found and no standard setMediaKeys API exists. This case is particulary
-    // rare. We will try to call each API with native media keys.
-    if (typeof elt.webkitSetMediaKeys === "function") {
-      return elt.webkitSetMediaKeys(mediaKeys);
-    }
-
-    if (typeof elt.mozSetMediaKeys === "function") {
-      return elt.mozSetMediaKeys(mediaKeys);
-    }
-
-    if (typeof elt.msSetMediaKeys === "function" && mediaKeys !== null) {
-      return elt.msSetMediaKeys(mediaKeys);
-    }
-  };
-
-/**
- * Since Safari 12.1, EME APIs are available without webkit prefix.
- * However, it seems that since fairplay CDM implementation within the browser is not
- * standard with EME w3c current spec, the requestMediaKeySystemAccess API doesn't resolve
- * positively, even if the drm (fairplay in most cases) is supported.
- *
- * Therefore, we prefer not to use requestMediaKeySystemAccess on Safari when webkit API
- * is available.
- */
-if (isNode ||
-    (navigator.requestMediaKeySystemAccess != null && !shouldFavourCustomSafariEME())
-) {
-  requestMediaKeySystemAccess = (...args) =>
-    navigator.requestMediaKeySystemAccess(...args);
-} else {
-  let isTypeSupported: (keyType: string) => boolean;
-  let createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
-
-  // This is for Chrome with unprefixed EME api
-  if (isOldWebkitMediaElement(HTMLVideoElement.prototype)) {
-    const callbacks = getOldKitWebKitMediaKeyCallbacks();
-    isTypeSupported = callbacks.isTypeSupported;
-    createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    setMediaKeys = callbacks.setMediaKeys;
-  // This is for WebKit with prefixed EME api
-  } else if (WebKitMediaKeysConstructor !== undefined) {
-    const callbacks = getWebKitMediaKeysCallbacks();
-    isTypeSupported = callbacks.isTypeSupported;
-    createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    setMediaKeys = callbacks.setMediaKeys;
-  } else if (isIE11 && MSMediaKeysConstructor !== undefined) {
-    const callbacks = getIE11MediaKeysCallbacks();
-    isTypeSupported = callbacks.isTypeSupported;
-    createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    setMediaKeys = callbacks.setMediaKeys;
-  } else if (MozMediaKeysConstructor !== undefined) {
-    const callbacks = getMozMediaKeysCallbacks();
-    isTypeSupported = callbacks.isTypeSupported;
-    createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    setMediaKeys = callbacks.setMediaKeys;
-  } else {
-    const MK = window.MediaKeys as unknown as typeof MediaKeys & {
-      isTypeSupported? : (keyType : string) => boolean;
-      new(keyType? : string) : ICustomMediaKeys;
-    };
-    const checkForStandardMediaKeys = () => {
-      if (MK === undefined) {
-        throw new MediaError("MEDIA_KEYS_NOT_SUPPORTED",
-                             "No `MediaKeys` implementation found " +
-                             "in the current browser.");
-      }
-      if (typeof MK.isTypeSupported === "undefined") {
-        const message = "This browser seems to be unable to play encrypted contents " +
-                        "currently. Note: Some browsers do not allow decryption " +
-                        "in some situations, like when not using HTTPS.";
-        throw new Error(message);
-      }
-    };
-    isTypeSupported = (keyType: string): boolean => {
-      checkForStandardMediaKeys();
-      assert(typeof MK.isTypeSupported === "function");
-      return MK.isTypeSupported(keyType);
-    };
-    createCustomMediaKeys = (keyType: string) => {
-      checkForStandardMediaKeys();
-      return new MK(keyType);
-    };
-  }
-
-  requestMediaKeySystemAccess = function(
-    keyType : string,
-    keySystemConfigurations : MediaKeySystemConfiguration[]
-  ) : Promise<MediaKeySystemAccess|CustomMediaKeySystemAccess> {
-    if (!isTypeSupported(keyType)) {
-      return Promise.reject(new Error("Unsupported key type"));
-    }
-
-    for (let i = 0; i < keySystemConfigurations.length; i++) {
-      const keySystemConfiguration = keySystemConfigurations[i];
-      const { videoCapabilities,
-              audioCapabilities,
-              initDataTypes,
-              distinctiveIdentifier } = keySystemConfiguration;
-      let supported = true;
-      supported = supported &&
-                  (initDataTypes == null ||
-                   initDataTypes.some((idt) => idt === "cenc"));
-      supported = supported && (distinctiveIdentifier !== "required");
-
-      if (supported) {
-        const keySystemConfigurationResponse : MediaKeySystemConfiguration = {
-          initDataTypes: ["cenc"],
-          distinctiveIdentifier: "not-allowed" as const,
-          persistentState: "required" as const,
-          sessionTypes: ["temporary", "persistent-license"],
-        };
-        if (videoCapabilities !== undefined) {
-          keySystemConfigurationResponse.videoCapabilities = videoCapabilities;
-        }
-        if (audioCapabilities !== undefined) {
-          keySystemConfigurationResponse.audioCapabilities = audioCapabilities;
-        }
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const customMediaKeys = createCustomMediaKeys(keyType);
-        return Promise.resolve(
-          new CustomMediaKeySystemAccess(keyType,
-                                         customMediaKeys,
-                                         keySystemConfigurationResponse)
-        );
-      }
-    }
-
-    return Promise.reject(new Error("Unsupported configuration"));
-  };
-}
-
 export {
-  requestMediaKeySystemAccess,
-  setMediaKeys,
+  getIE11MediaKeysCallbacks,
+  MSMediaKeysConstructor,
+  getMozMediaKeysCallbacks,
+  MozMediaKeysConstructor,
+  getOldKitWebKitMediaKeyCallbacks,
+  isOldWebkitMediaElement,
   ICustomMediaKeys,
   ICustomMediaKeySession,
+  getWebKitMediaKeysCallbacks,
+  WebKitMediaKeysConstructor,
 };
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 8e1a971bb1..c552adbf34 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
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import wrapInPromise from "../../../utils/wrapInPromise";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import isNode from "../../is_node";
 import { ICustomMediaKeys } from "./types";
@@ -47,7 +48,7 @@ export default function getMozMediaKeysCallbacks() : {
   setMediaKeys: (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => void;
+  ) => Promise<unknown>;
 } {
   const isTypeSupported = (keySystem: string, type?: string|null) => {
     if (MozMediaKeysConstructor === undefined) {
@@ -67,12 +68,17 @@ export default function getMozMediaKeysCallbacks() : {
   const setMediaKeys = (
     mediaElement: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): void => {
-    const elt : ICompatHTMLMediaElement = mediaElement;
-    if (elt.mozSetMediaKeys === undefined || typeof elt.mozSetMediaKeys !== "function") {
-      throw new Error("Can't set video on MozMediaKeys.");
-    }
-    return elt.mozSetMediaKeys(mediaKeys);
+  ): Promise<unknown> => {
+    return wrapInPromise(() => {
+      const elt : ICompatHTMLMediaElement = mediaElement;
+      if (
+        elt.mozSetMediaKeys === undefined ||
+        typeof elt.mozSetMediaKeys !== "function"
+      ) {
+        throw new Error("Can't set video on MozMediaKeys.");
+      }
+      return elt.mozSetMediaKeys(mediaKeys);
+    });
   };
   return {
     isTypeSupported,
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 f9323a757d..6c7df1dee2 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
@@ -18,6 +18,7 @@ import { base64ToBytes } from "../../../utils/base64";
 import EventEmitter from "../../../utils/event_emitter";
 import noop from "../../../utils/noop";
 import { utf8ToStr } from "../../../utils/string_parsing";
+import wrapInPromise from "../../../utils/wrapInPromise";
 import {
   ICustomMediaKeys,
   ICustomMediaKeySession,
@@ -166,11 +167,13 @@ class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
     this._keySystem = keySystem;
   }
 
-  _setVideo(videoElement: IOldWebkitHTMLMediaElement|HTMLMediaElement): void {
-    if (!isOldWebkitMediaElement(videoElement)) {
-      throw new Error("Video not attached to the MediaKeys");
-    }
-    this._videoElement = videoElement;
+  _setVideo(videoElement: IOldWebkitHTMLMediaElement|HTMLMediaElement): Promise<unknown> {
+    return wrapInPromise(() => {
+      if (!isOldWebkitMediaElement(videoElement)) {
+        throw new Error("Video not attached to the MediaKeys");
+      }
+      this._videoElement = videoElement;
+    });
   }
 
   createSession(/* sessionType */): ICustomMediaKeySession {
@@ -191,7 +194,7 @@ export default function getOldWebKitMediaKeysCallbacks() : {
   setMediaKeys: (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => void;
+  ) => Promise<unknown>;
 } {
   const isTypeSupported = function (keyType: string): boolean {
     // get any <video> element from the DOM or create one
@@ -214,9 +217,9 @@ export default function getOldWebKitMediaKeysCallbacks() : {
   const setMediaKeys = (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): void => {
+  ): Promise<unknown> => {
     if (mediaKeys === null) {
-      return;
+      return Promise.resolve(undefined);
     }
     if (!(mediaKeys instanceof OldWebKitCustomMediaKeys)) {
       throw new Error("Custom setMediaKeys is supposed to be called " +
diff --git a/src/compat/eme/custom_media_keys/types.ts b/src/compat/eme/custom_media_keys/types.ts
index 4614192d75..a3ccb95a6d 100644
--- a/src/compat/eme/custom_media_keys/types.ts
+++ b/src/compat/eme/custom_media_keys/types.ts
@@ -40,7 +40,7 @@ export interface ICustomMediaKeySession extends IEventEmitter<IMediaKeySessionEv
 }
 
 export interface ICustomMediaKeys {
-  _setVideo : (vid : HTMLMediaElement) => void;
+  _setVideo : (vid : HTMLMediaElement) => Promise<unknown>;
   createSession(sessionType? : MediaKeySessionType) : ICustomMediaKeySession;
   setServerCertificate(setServerCertificate : BufferSource) : Promise<void>;
 }
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 646f743da5..330d5520c6 100644
--- a/src/compat/eme/custom_media_keys/webkit_media_keys.ts
+++ b/src/compat/eme/custom_media_keys/webkit_media_keys.ts
@@ -16,6 +16,8 @@
 
 import EventEmitter from "../../../utils/event_emitter";
 import noop from "../../../utils/noop";
+import startsWith from "../../../utils/starts_with";
+import wrapInPromise from "../../../utils/wrapInPromise";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import getWebKitFairplayInitData from "../get_webkit_fairplay_initdata";
 import {
@@ -41,8 +43,7 @@ export interface ICustomWebKitMediaKeys {
  * @returns {boolean}
  */
 function isFairplayKeyType(keyType: string): boolean {
-  return keyType === "com.apple.fps.1_0" ||
-         keyType === "com.apple.fps.2_0";
+  return startsWith(keyType, "com.apple.fps");
 }
 
 /**
@@ -50,16 +51,19 @@ function isFairplayKeyType(keyType: string): boolean {
  * setMediaKeys from WebKit.
  * @param {HTMLMediaElement} videoElement
  * @param {Object|null} mediaKeys
+ * @returns {Promise}
  */
 function setWebKitMediaKeys(
   videoElement: HTMLMediaElement,
   mediaKeys: IWebKitMediaKeys|null
-): void {
+): Promise<unknown> {
   const elt : ICompatHTMLMediaElement = videoElement;
-  if (elt.webkitSetMediaKeys === undefined) {
-    throw new Error("No webKitMediaKeys API.");
-  }
-  return elt.webkitSetMediaKeys(mediaKeys);
+  return wrapInPromise(() => {
+    if (elt.webkitSetMediaKeys === undefined) {
+      throw new Error("No webKitMediaKeys API.");
+    }
+    elt.webkitSetMediaKeys(mediaKeys);
+  });
 }
 
 /**
@@ -245,7 +249,7 @@ class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
     this._mediaKeys = new WebKitMediaKeysConstructor(keyType);
   }
 
-  _setVideo(videoElement: HTMLMediaElement): void {
+  _setVideo(videoElement: HTMLMediaElement): Promise<unknown> {
     this._videoElement = videoElement;
     if (this._videoElement === undefined) {
       throw new Error("Video not attached to the MediaKeys");
@@ -275,7 +279,7 @@ export default function getWebKitMediaKeysCallbacks() : {
   setMediaKeys: (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => void;
+  ) => Promise<unknown>;
 } {
   if (WebKitMediaKeysConstructor === undefined) {
     throw new Error("No WebKitMediaKeys API.");
@@ -286,7 +290,7 @@ export default function getWebKitMediaKeysCallbacks() : {
   const setMediaKeys = (
     elt: HTMLMediaElement,
     mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): void => {
+  ): 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
new file mode 100644
index 0000000000..7d96421bc4
--- /dev/null
+++ b/src/compat/eme/eme-api-implementation.ts
@@ -0,0 +1,318 @@
+import { MediaError } from "../../errors";
+import assert from "../../utils/assert";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import { CancellationSignal } from "../../utils/task_canceller";
+import { ICompatHTMLMediaElement } from "../browser_compatibility_types";
+import { isIE11 } from "../browser_detection";
+import { createCompatibleEventListener, IEventTargetLike } from "../event_listeners";
+import isNode from "../is_node";
+import shouldFavourCustomSafariEME from "../should_favour_custom_safari_EME";
+import CustomMediaKeySystemAccess from "./custom_key_system_access";
+import getIE11MediaKeysCallbacks, {
+  MSMediaKeysConstructor,
+} from "./custom_media_keys/ie11_media_keys";
+import getMozMediaKeysCallbacks, {
+  MozMediaKeysConstructor,
+} from "./custom_media_keys/moz_media_keys_constructor";
+import getOldKitWebKitMediaKeyCallbacks, {
+  isOldWebkitMediaElement,
+} from "./custom_media_keys/old_webkit_media_keys";
+import {
+  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";
+
+/**
+ * Automatically detect and set which EME implementation should be used in the
+ * current platform.
+ *
+ * You can call `getEmeApiImplementation` for a different implementation.
+ */
+const defaultEmeImplementation = getEmeApiImplementation("auto");
+
+export default defaultEmeImplementation;
+
+/**
+ * Generic interface harmonizing the structure of the different EME API
+ * implementations the RxPlayer could use.
+ */
+export interface IEmeApiImplementation {
+  /**
+   * API implementing the `navigator.requestMediaKeySystemAccess` static method
+   * from EME.
+   * @param {string} keyType - Key system name, as a reverse domain name.
+   * @param {Array.<MediaKeySystemMediaCapability>} Wanted configurations, from
+   * the most wanted to the least.
+   * @returns {Promise}
+   */
+  requestMediaKeySystemAccess : (
+    keyType : string,
+    config : MediaKeySystemConfiguration[]
+  ) => Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+
+  /**
+   * API allowing to listen for `"encrypted"` events, presumably sent by the
+   * HTMLMediaElement on which encrypted content is pushed.
+   * @param {EventTarget} The element on which the event will be listened to.
+   * Generally it is the HTMLMediaElement.
+   * @param {Function} listener - The event listener on which that event's
+   * payload will be dispatched.
+   * @param {Object} cancelSignal - The event listener will be removed once that
+   * `CancellationSignal` emits.
+   */
+  onEncrypted : (
+    target : IEventTargetLike,
+    listener : (evt : unknown) => void,
+    cancelSignal : CancellationSignal,
+  ) => void;
+
+  /**
+   * API allowing to attach a `MediaKeys` instance (or an `ICustomMediaKeys`) 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.
+   * @returns {Promise} - That promise resolves if the `MediaKeys` instance was
+   * attached to the `HTMLMediaElement` with success, or rejects on the opposite
+   * scenario.
+   */
+  setMediaKeys : (
+    mediaElement: HTMLMediaElement,
+    mediaKeys: MediaKeys | ICustomMediaKeys | null
+  ) => Promise<unknown>;
+
+  /**
+   * String describing the currently used EME implementation:
+   *
+   *   - "standard": regular EME implementation
+   *
+   *   - "webkit": The webkit-prefixed variant of the EME API
+   *
+   *   - "older-webkit": An even older webkit-prefixed variant of the EME API
+   *
+   *   - "ms": The ms-prefixed variant of the EME API
+   *
+   *   - "moz": The moz-prefixed variant of the EME API
+   *
+   *   - "unknown": An unidentified variant of the EME API
+   */
+  implementation : "standard" | "webkit" | "older-webkit" | "ms" | "moz" | "unknown";
+}
+
+/**
+ * Union of all the different value the preferred EME API type can be set to:
+ *
+ *   - "auto": The implementation will be chosen automatically based on what
+ *     we've most confidence on on the current device.
+ *
+ *   - "standard": If present, the standard EME API will be given precedence
+ *     over custom and browser-specific ones.
+ *
+ *   - "webkit": The webkit-prefixed variant of the EME API will be given
+ *     precedence over any other one if present.
+ *
+ */
+export type IPreferredEmeApiType = "auto" | "standard" | "webkit";
+
+/**
+ * Returns the current EME implementation based on what's present on the device
+ * and the given preference.
+ * @param {string} preferredApiType - EME API preference
+ * (@see IPreferredEmeApiType).
+ * @returns {Object}
+ */
+function getEmeApiImplementation(
+  preferredApiType : IPreferredEmeApiType
+) : IEmeApiImplementation {
+  let requestMediaKeySystemAccess : IEmeApiImplementation["requestMediaKeySystemAccess"];
+  let onEncrypted : IEmeApiImplementation["onEncrypted"];
+  let setMediaKeys : IEmeApiImplementation["setMediaKeys"] = defaultSetMediaKeys;
+  let implementation : IEmeApiImplementation["implementation"];
+  if (
+    (
+      preferredApiType === "standard" ||
+      (preferredApiType === "auto" && !shouldFavourCustomSafariEME())
+    ) &&
+    (
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      isNode || !isNullOrUndefined(navigator.requestMediaKeySystemAccess)
+    )
+  ) {
+    requestMediaKeySystemAccess = (...args) =>
+      navigator.requestMediaKeySystemAccess(...args);
+    onEncrypted = createCompatibleEventListener(["encrypted"]);
+    implementation = "standard";
+  } else {
+    let isTypeSupported: (keyType: string) => boolean;
+    let createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
+
+    if (preferredApiType === "webkit" && WebKitMediaKeysConstructor !== undefined) {
+      onEncrypted = createCompatibleEventListener(["needkey"]);
+      const callbacks = getWebKitMediaKeysCallbacks();
+      isTypeSupported = callbacks.isTypeSupported;
+      createCustomMediaKeys = callbacks.createCustomMediaKeys;
+      setMediaKeys = callbacks.setMediaKeys;
+      implementation = "webkit";
+    } else {
+      // This is for Chrome with unprefixed EME api
+      if (isOldWebkitMediaElement(HTMLVideoElement.prototype)) {
+        onEncrypted = createCompatibleEventListener(["needkey"]);
+        const callbacks = getOldKitWebKitMediaKeyCallbacks();
+        isTypeSupported = callbacks.isTypeSupported;
+        createCustomMediaKeys = callbacks.createCustomMediaKeys;
+        setMediaKeys = callbacks.setMediaKeys;
+        implementation = "older-webkit";
+      // This is for WebKit with prefixed EME api
+      } else if (WebKitMediaKeysConstructor !== undefined) {
+        onEncrypted = createCompatibleEventListener(["needkey"]);
+        const callbacks = getWebKitMediaKeysCallbacks();
+        isTypeSupported = callbacks.isTypeSupported;
+        createCustomMediaKeys = callbacks.createCustomMediaKeys;
+        setMediaKeys = callbacks.setMediaKeys;
+        implementation = "webkit";
+      } else if (isIE11 && MSMediaKeysConstructor !== undefined) {
+        onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
+        const callbacks = getIE11MediaKeysCallbacks();
+        isTypeSupported = callbacks.isTypeSupported;
+        createCustomMediaKeys = callbacks.createCustomMediaKeys;
+        setMediaKeys = callbacks.setMediaKeys;
+        implementation = "ms";
+      } else if (MozMediaKeysConstructor !== undefined) {
+        onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
+        const callbacks = getMozMediaKeysCallbacks();
+        isTypeSupported = callbacks.isTypeSupported;
+        createCustomMediaKeys = callbacks.createCustomMediaKeys;
+        setMediaKeys = callbacks.setMediaKeys;
+        implementation = "moz";
+      } else {
+        onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
+        const MK = window.MediaKeys as unknown as typeof MediaKeys & {
+          isTypeSupported? : (keyType : string) => boolean;
+          new(keyType? : string) : ICustomMediaKeys;
+        };
+        const checkForStandardMediaKeys = () => {
+          if (MK === undefined) {
+            throw new MediaError("MEDIA_KEYS_NOT_SUPPORTED",
+                                 "No `MediaKeys` implementation found " +
+                                 "in the current browser.");
+          }
+          if (typeof MK.isTypeSupported === "undefined") {
+            const message = "This browser seems to be unable to play encrypted " +
+                            "contents currently." +
+                            "Note: Some browsers do not allow decryption " +
+                            "in some situations, like when not using HTTPS.";
+            throw new Error(message);
+          }
+        };
+        isTypeSupported = (keyType: string): boolean => {
+          checkForStandardMediaKeys();
+          assert(typeof MK.isTypeSupported === "function");
+          return MK.isTypeSupported(keyType);
+        };
+        createCustomMediaKeys = (keyType: string) => {
+          checkForStandardMediaKeys();
+          return new MK(keyType);
+        };
+        implementation = "unknown";
+      }
+    }
+
+    requestMediaKeySystemAccess = function(
+      keyType : string,
+      keySystemConfigurations : MediaKeySystemConfiguration[]
+    ) : Promise<MediaKeySystemAccess|CustomMediaKeySystemAccess> {
+      if (!isTypeSupported(keyType)) {
+        return Promise.reject(new Error("Unsupported key type"));
+      }
+
+      for (let i = 0; i < keySystemConfigurations.length; i++) {
+        const keySystemConfiguration = keySystemConfigurations[i];
+        const { videoCapabilities,
+                audioCapabilities,
+                initDataTypes,
+                distinctiveIdentifier } = keySystemConfiguration;
+        let supported = true;
+        supported = supported &&
+                    (initDataTypes == null ||
+                     initDataTypes.some((idt) => idt === "cenc"));
+        supported = supported && (distinctiveIdentifier !== "required");
+
+        if (supported) {
+          const keySystemConfigurationResponse : MediaKeySystemConfiguration = {
+            initDataTypes: ["cenc"],
+            distinctiveIdentifier: "not-allowed" as const,
+            persistentState: "required" as const,
+            sessionTypes: ["temporary", "persistent-license"],
+          };
+          if (videoCapabilities !== undefined) {
+            keySystemConfigurationResponse.videoCapabilities = videoCapabilities;
+          }
+          if (audioCapabilities !== undefined) {
+            keySystemConfigurationResponse.audioCapabilities = audioCapabilities;
+          }
+
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const customMediaKeys = createCustomMediaKeys(keyType);
+          return Promise.resolve(
+            new CustomMediaKeySystemAccess(keyType,
+                                           customMediaKeys,
+                                           keySystemConfigurationResponse)
+          );
+        }
+      }
+
+      return Promise.reject(new Error("Unsupported configuration"));
+    };
+  }
+  return { requestMediaKeySystemAccess,
+           onEncrypted,
+           setMediaKeys,
+           implementation };
+}
+
+/**
+ * Set the given MediaKeys on the given HTMLMediaElement.
+ * Emits null when done then complete.
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Object} mediaKeys
+ * @returns {Promise}
+ */
+function defaultSetMediaKeys(
+  mediaElement: HTMLMediaElement,
+  mediaKeys: MediaKeys | ICustomMediaKeys | null
+): Promise<unknown> {
+  try {
+    let ret : unknown;
+    const elt : ICompatHTMLMediaElement = mediaElement;
+    /* eslint-disable @typescript-eslint/unbound-method */
+    if (typeof elt.setMediaKeys === "function") {
+      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
+    // rare. We will try to call each API with native media keys.
+    else if (typeof elt.webkitSetMediaKeys === "function") {
+      ret = elt.webkitSetMediaKeys(mediaKeys);
+    } else if (typeof elt.mozSetMediaKeys === "function") {
+      ret = elt.mozSetMediaKeys(mediaKeys);
+    } else if (typeof elt.msSetMediaKeys === "function" && mediaKeys !== null) {
+      ret = elt.msSetMediaKeys(mediaKeys);
+    }
+
+    if (
+      typeof ret === "object" &&
+      ret !== null &&
+      typeof (ret as Promise<unknown>).then === "function"
+    ) {
+      return ret as Promise<unknown>;
+    } else {
+      return Promise.resolve(ret);
+    }
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
diff --git a/src/compat/eme/index.ts b/src/compat/eme/index.ts
index eeff7e084d..735b14d6ee 100644
--- a/src/compat/eme/index.ts
+++ b/src/compat/eme/index.ts
@@ -15,31 +15,33 @@
  */
 
 import closeSession from "./close_session";
-import CustomMediaKeySystemAccess, {
+import {
   ICustomMediaKeySystemAccess,
 } from "./custom_key_system_access";
 import {
   ICustomMediaKeys,
   ICustomMediaKeySession,
-  requestMediaKeySystemAccess,
-  setMediaKeys,
 } from "./custom_media_keys";
+import defaultEmeImplementation, {
+  IEmeApiImplementation,
+  IPreferredEmeApiType,
+} from "./eme-api-implementation";
 import generateKeyRequest from "./generate_key_request";
 import getInitData, {
   IEncryptedEventData,
 } from "./get_init_data";
 import loadSession from "./load_session";
 
+export default defaultEmeImplementation;
 export {
   closeSession,
-  CustomMediaKeySystemAccess,
   generateKeyRequest,
   getInitData,
   loadSession,
+  IEmeApiImplementation,
+  IPreferredEmeApiType,
   ICustomMediaKeySession,
   ICustomMediaKeySystemAccess,
   ICustomMediaKeys,
   IEncryptedEventData,
-  requestMediaKeySystemAccess,
-  setMediaKeys,
 };
diff --git a/src/compat/event_listeners.ts b/src/compat/event_listeners.ts
index f8f778bc6e..e61cf8e2ef 100644
--- a/src/compat/event_listeners.ts
+++ b/src/compat/event_listeners.ts
@@ -30,7 +30,6 @@ import {
   ICompatPictureInPictureWindow,
 } from "./browser_compatibility_types";
 import isNode from "./is_node";
-import shouldFavourCustomSafariEME from "./should_favour_custom_safari_EME";
 
 const BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
 
@@ -483,13 +482,6 @@ const onSourceBufferUpdate = createCompatibleEventListener(["update"]);
  */
 const onRemoveSourceBuffers = createCompatibleEventListener(["removesourcebuffer"]);
 
-/**
- * @param {HTMLMediaElement} mediaElement
- */
-const onEncrypted = createCompatibleEventListener(
-  shouldFavourCustomSafariEME() ? ["needkey"] :
-                                  ["encrypted", "needkey"]);
-
 /**
  * @param {MediaKeySession} mediaKeySession
  */
@@ -549,11 +541,11 @@ function addEventListener(
 
 export {
   addEventListener,
+  createCompatibleEventListener,
   getPageActivityRef,
   getPictureOnPictureStateRef,
   getVideoVisibilityRef,
   getVideoWidthRef,
-  onEncrypted,
   onEnded,
   onFullscreenChange,
   onKeyAdded,
diff --git a/src/compat/has_eme_apis.ts b/src/compat/has_eme_apis.ts
deleted file mode 100644
index 78366339cc..0000000000
--- a/src/compat/has_eme_apis.ts
+++ /dev/null
@@ -1,26 +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 { requestMediaKeySystemAccess } from "./eme";
-
-/**
- * Returns true if the browser has the minimum needed EME APIs to decrypt a
- * content.
- * @returns {Boolean}
- */
-export default function hasEMEAPIs() : boolean {
-  return typeof requestMediaKeySystemAccess === "function";
-}
diff --git a/src/compat/index.ts b/src/compat/index.ts
index 09e9f619af..64df0f52cf 100644
--- a/src/compat/index.ts
+++ b/src/compat/index.ts
@@ -27,18 +27,6 @@ import tryToChangeSourceBufferType, {
   ICompatSourceBuffer,
 } from "./change_source_buffer_type";
 import clearElementSrc from "./clear_element_src";
-import {
-  closeSession,
-  CustomMediaKeySystemAccess,
-  generateKeyRequest,
-  getInitData,
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  ICustomMediaKeySystemAccess,
-  loadSession,
-  requestMediaKeySystemAccess,
-  setMediaKeys,
-} from "./eme";
 import enableAudioTrack from "./enable_audio_track";
 import * as events from "./event_listeners";
 import {
@@ -47,7 +35,6 @@ import {
   requestFullscreen,
 } from "./fullscreen";
 import getStartDate from "./get_start_date";
-import hasEMEAPIs from "./has_eme_apis";
 import isCodecSupported from "./is_codec_supported";
 import isNode from "./is_node";
 import isOffline from "./is_offline";
@@ -74,33 +61,22 @@ export {
   canPatchISOBMFFSegment,
   canReuseMediaKeys,
   clearElementSrc,
-  closeSession,
-  CustomMediaKeySystemAccess,
   enableAudioTrack,
   events,
   exitFullscreen,
-  generateKeyRequest,
-  getInitData,
   getStartDate,
-  hasEMEAPIs,
   ICompatTextTrack,
   ICompatVTTCue,
-  ICustomMediaKeySession,
-  ICustomMediaKeySystemAccess,
-  ICustomMediaKeys,
   ICompatSourceBuffer,
   isCodecSupported,
   isFullscreen,
   isNode,
   isOffline,
   isVTTCue,
-  loadSession,
   makeVTTCue,
   MediaSource_,
   onHeightWidthChange,
   requestFullscreen,
-  requestMediaKeySystemAccess,
-  setMediaKeys,
   shouldReloadMediaSourceOnDecipherabilityUpdate,
   shouldRenewMediaKeySystemAccess,
   shouldUnsetMediaKeys,
diff --git a/src/core/decrypt/__tests__/__global__/get_license.test.ts b/src/core/decrypt/__tests__/__global__/get_license.test.ts
index 9a26a9cb8e..45f3412144 100644
--- a/src/core/decrypt/__tests__/__global__/get_license.test.ts
+++ b/src/core/decrypt/__tests__/__global__/get_license.test.ts
@@ -38,7 +38,7 @@ const videoElt = document.createElement("video");
 /* eslint-disable max-len */
 describe("core - decrypt - global tests - getLicense", () => {
 
-  beforeEach(() => {
+  afterEach(() => {
     jest.resetModules();
     jest.restoreAllMocks();
   });
@@ -344,7 +344,7 @@ function checkGetLicense(
     }
 
     // == test ==
-    const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+    const { ContentDecryptorState } = jest.requireActual("../../types");
     const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
     const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
 
diff --git a/src/core/decrypt/__tests__/__global__/init_data.test.ts b/src/core/decrypt/__tests__/__global__/init_data.test.ts
index 34d7723acc..2cf87d9430 100644
--- a/src/core/decrypt/__tests__/__global__/init_data.test.ts
+++ b/src/core/decrypt/__tests__/__global__/init_data.test.ts
@@ -63,7 +63,7 @@ describe("core - decrypt - global tests - init data", () => {
       const initData = new Uint8Array([54, 55, 75]);
 
       // == test ==
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
       contentDecryptor.addEventListener("stateChange", (newState: any) => {
@@ -109,7 +109,7 @@ describe("core - decrypt - global tests - init data", () => {
       const initData = new Uint8Array([54, 55, 75]);
 
       // == test ==
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
       contentDecryptor.addEventListener("stateChange", (newState: any) => {
@@ -173,7 +173,7 @@ describe("core - decrypt - global tests - init data", () => {
                           new Uint8Array([87, 77]) ];
 
       // == test ==
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
       contentDecryptor.addEventListener("stateChange", (newState: any) => {
@@ -260,7 +260,7 @@ describe("core - decrypt - global tests - init data", () => {
       const initData = new Uint8Array([54, 55, 75]);
 
       // == test ==
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
       contentDecryptor.addEventListener("stateChange", (newState: any) => {
@@ -312,7 +312,9 @@ describe("core - decrypt - global tests - init data", () => {
   /* eslint-enable max-len */
     return new Promise<void>((res, rej) => {
       // == mocks ==
-      const { mockGenerateKeyRequest, eventTriggers, mockGetInitData } = mockCompat();
+      const { mockGenerateKeyRequest,
+              eventTriggers,
+              mockGetInitData } = mockCompat();
       const mediaKeySession = new MediaKeySessionImpl();
       const mockCreateSession = jest.spyOn(MediaKeysImpl.prototype, "createSession")
         .mockReturnValue(mediaKeySession);
@@ -321,7 +323,7 @@ describe("core - decrypt - global tests - init data", () => {
       const initData = new Uint8Array([54, 55, 75]);
 
       // == test ==
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
       contentDecryptor.addEventListener("stateChange", (newState: any) => {
@@ -361,7 +363,9 @@ describe("core - decrypt - global tests - init data", () => {
   it("should ignore init data already received through the browser", () => {
     return new Promise<void>((res, rej) => {
       // == mocks ==
-      const { mockGenerateKeyRequest, eventTriggers, mockGetInitData } = mockCompat();
+      const { mockGenerateKeyRequest,
+              eventTriggers,
+              mockGetInitData } = mockCompat();
       const mediaKeySession = new MediaKeySessionImpl();
       const mockCreateSession = jest.spyOn(MediaKeysImpl.prototype, "createSession")
         .mockReturnValue(mediaKeySession);
@@ -370,7 +374,7 @@ describe("core - decrypt - global tests - init data", () => {
       const initData = new Uint8Array([54, 55, 75]);
 
       // == test ==
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
       contentDecryptor.addEventListener("stateChange", (newState: any) => {
@@ -421,7 +425,9 @@ describe("core - decrypt - global tests - init data", () => {
   /* eslint-enable max-len */
     return new Promise<void>((res, rej) => {
       // == mocks ==
-      const { mockGenerateKeyRequest, eventTriggers, mockGetInitData } = mockCompat();
+      const { mockGenerateKeyRequest,
+              eventTriggers,
+              mockGetInitData } = mockCompat();
       const mediaKeySessions = [ new MediaKeySessionImpl(),
                                  new MediaKeySessionImpl(),
                                  new MediaKeySessionImpl() ];
@@ -443,7 +449,7 @@ describe("core - decrypt - global tests - init data", () => {
                                  values: [ { systemId: "15", data: initDatas[2] } ] } ];
 
       // == test ==
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
       contentDecryptor.addEventListener("stateChange", (newState: any) => {
@@ -515,7 +521,9 @@ describe("core - decrypt - global tests - init data", () => {
   /* eslint-enable max-len */
     return new Promise<void>((res, rej) => {
       // == mocks ==
-      const { mockGenerateKeyRequest, eventTriggers, mockGetInitData } = mockCompat();
+      const { mockGenerateKeyRequest,
+              eventTriggers,
+              mockGetInitData } = mockCompat();
       const mediaKeySessions = [ new MediaKeySessionImpl(),
                                  new MediaKeySessionImpl() ];
       let createSessionCallIdx = 0;
@@ -531,7 +539,7 @@ describe("core - decrypt - global tests - init data", () => {
                                  values: [ { systemId: "15", data: initData } ] } ];
 
       // == test ==
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
       contentDecryptor.addEventListener("stateChange", (newState: any) => {
@@ -579,7 +587,9 @@ describe("core - decrypt - global tests - init data", () => {
   it("should consider sent event through arguments and received events through the browser the same way", () => {
     return new Promise<void>((res, rej) => {
       // == mocks ==
-      const { mockGenerateKeyRequest, eventTriggers, mockGetInitData } = mockCompat();
+      const { mockGenerateKeyRequest,
+              eventTriggers,
+              mockGetInitData } = mockCompat();
       const mediaKeySessions = [ new MediaKeySessionImpl(),
                                  new MediaKeySessionImpl(),
                                  new MediaKeySessionImpl() ];
@@ -601,7 +611,7 @@ describe("core - decrypt - global tests - init data", () => {
                                  values: [ { systemId: "15", data: initDatas[2] } ] } ];
 
       // == test ==
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
       contentDecryptor.addEventListener("stateChange", (newState: any) => {
diff --git a/src/core/decrypt/__tests__/__global__/media_key_system_access.test.ts b/src/core/decrypt/__tests__/__global__/media_key_system_access.test.ts
index 2893ef55d1..65d1e40150 100644
--- a/src/core/decrypt/__tests__/__global__/media_key_system_access.test.ts
+++ b/src/core/decrypt/__tests__/__global__/media_key_system_access.test.ts
@@ -24,7 +24,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable no-restricted-properties */
 
-import { ICustomMediaKeySystemAccess } from "../../../../compat";
+import { ICustomMediaKeySystemAccess } from "../../../../compat/eme";
 import {
   defaultKSConfig,
   defaultPRRecommendationKSConfig,
@@ -94,7 +94,9 @@ describe("core - decrypt - global tests - media key system access", () => {
 
   it("should throw if given a single incompatible keySystemsConfigs", async () => {
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     const getLicenseFn = neverCalledFn;
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: getLicenseFn }]);
@@ -104,7 +106,9 @@ describe("core - decrypt - global tests - media key system access", () => {
 
   it("should throw if given multiple incompatible keySystemsConfigs", async () => {
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     const config = [ { type: "foo", getLicense: neverCalledFn },
                      { type: "bar", getLicense: neverCalledFn },
                      { type: "baz", getLicense: neverCalledFn } ];
@@ -118,25 +122,11 @@ describe("core - decrypt - global tests - media key system access", () => {
       .toHaveBeenNthCalledWith(3, "baz", defaultKSConfig);
   });
 
-  /* eslint-disable max-len */
-  it("should throw an error if no implementation of requestMediaKeySystemAccess is set", async () => {
-  /* eslint-enable max-len */
-    mockCompat({ requestMediaKeySystemAccess: undefined });
-    const mediaElement = document.createElement("video");
-    const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
-
-    const config = [{ type: "foo", getLicense: neverCalledFn }];
-    const error : any = await testContentDecryptorError(ContentDecryptor,
-                                                        mediaElement,
-                                                        config);
-    expect(error).not.toBe(null);
-    expect(error.message)
-      .toEqual("requestMediaKeySystemAccess is not implemented in your browser.");
-  });
-
   it("should throw if given a single incompatible keySystemsConfigs", async () => {
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: neverCalledFn }]);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
@@ -147,7 +137,9 @@ describe("core - decrypt - global tests - media key system access", () => {
   it("should change persistentState value if persistentStateRequired is set to true", async () => {
   /* eslint-enable max-len */
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: neverCalledFn,
                                                      persistentStateRequired: true }]);
@@ -163,7 +155,9 @@ describe("core - decrypt - global tests - media key system access", () => {
   it("should not change persistentState value if persistentStateRequired is set to false", async () => {
   /* eslint-enable max-len */
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: neverCalledFn,
                                                      persistentStateRequired: false }]);
@@ -175,12 +169,15 @@ describe("core - decrypt - global tests - media key system access", () => {
   it("should change distinctiveIdentifier value if distinctiveIdentifierRequired is set to true", async () => {
   /* eslint-enable max-len */
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
-    await checkIncompatibleKeySystemsErrorMessage([{
-      type: "foo",
-      getLicense: neverCalledFn,
-      distinctiveIdentifierRequired: true,
-    }]);
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
+    await checkIncompatibleKeySystemsErrorMessage(
+      [{
+        type: "foo",
+        getLicense: neverCalledFn,
+        distinctiveIdentifierRequired: true,
+      }]);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
 
     const expectedConfig = defaultKSConfig.map(conf => {
@@ -193,19 +190,24 @@ describe("core - decrypt - global tests - media key system access", () => {
   it("should not change distinctiveIdentifier value if distinctiveIdentifierRequired is set to false", async () => {
   /* eslint-enable max-len */
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
-    await checkIncompatibleKeySystemsErrorMessage([{
-      type: "foo",
-      getLicense: neverCalledFn,
-      distinctiveIdentifierRequired: false,
-    }]);
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
+    await checkIncompatibleKeySystemsErrorMessage(
+      [{
+        type: "foo",
+        getLicense: neverCalledFn,
+        distinctiveIdentifierRequired: false,
+      }]);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", defaultKSConfig);
   });
 
   it("should do nothing if just licenseStorage is set", async () => {
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     const licenseStorage = { save() { throw new Error("Should not save."); },
                              load() { throw new Error("Should not load."); } };
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
@@ -219,7 +221,9 @@ describe("core - decrypt - global tests - media key system access", () => {
   it("should want persistent sessions if both persistentLicense and licenseStorage are set", async () => {
   /* eslint-enable max-len */
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     const licenseStorage = { save() { throw new Error("Should not save."); },
                              load() { throw new Error("Should not load."); } };
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
@@ -241,7 +245,9 @@ describe("core - decrypt - global tests - media key system access", () => {
   it("should want persistent sessions if just persistentLicense is set to true", async () => {
   /* eslint-enable max-len */
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: neverCalledFn,
                                                      persistentLicense: true }]);
@@ -257,7 +263,9 @@ describe("core - decrypt - global tests - media key system access", () => {
 
   it("should do nothing if persistentLicense is set to false", async () => {
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: neverCalledFn,
                                                      persistentLicense: false }]);
@@ -267,7 +275,9 @@ describe("core - decrypt - global tests - media key system access", () => {
 
   it("should translate a `clearkey` keySystem", async () => {
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "clearkey",
                                                      getLicense: neverCalledFn }]);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
@@ -279,7 +289,9 @@ describe("core - decrypt - global tests - media key system access", () => {
 
   it("should translate a `widevine` keySystem", async () => {
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "widevine",
                                                      getLicense: neverCalledFn }]);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
@@ -289,7 +301,9 @@ describe("core - decrypt - global tests - media key system access", () => {
 
   it("should translate a `playready` keySystem", async () => {
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "playready",
                                                      getLicense: neverCalledFn }]);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(4);
@@ -307,7 +321,9 @@ describe("core - decrypt - global tests - media key system access", () => {
 
   it("should translate a `fairplay` keySystem", async () => {
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "fairplay",
                                                      getLicense: neverCalledFn }]);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
@@ -317,7 +333,9 @@ describe("core - decrypt - global tests - media key system access", () => {
 
   it("should translate a multiple keySystems at the same time", async () => {
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "playready",
                                                      getLicense: neverCalledFn },
                                                    { type: "clearkey",
@@ -343,7 +361,9 @@ describe("core - decrypt - global tests - media key system access", () => {
   it("should translate a multiple keySystems at the same time with different configs", async () => {
   /* eslint-enable max-len */
     const mockRequestMediaKeySystemAccess = jest.fn(() => Promise.reject("nope"));
-    mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "playready",
                                                      persistentLicense: true,
                                                      getLicense: neverCalledFn },
@@ -390,7 +410,9 @@ describe("core - decrypt - global tests - media key system access", () => {
       const mockRequestMediaKeySystemAccess = jest.fn((keyType, conf) => {
         return requestMediaKeySystemAccessNoMediaKeys(keyType, conf);
       });
-      mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+      mockCompat({
+        requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+      });
       const config = [{ type: "com.widevine.alpha",
                         getLicense: neverCalledFn }];
 
@@ -420,7 +442,9 @@ describe("core - decrypt - global tests - media key system access", () => {
         }
         return Promise.reject("nope");
       });
-      mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+      mockCompat({
+        requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+      });
       const config = [{ type: "com.widevine.alpha",
                         getLicense: neverCalledFn },
                       { type: "some-other-working-key-system",
@@ -454,7 +478,9 @@ describe("core - decrypt - global tests - media key system access", () => {
           return Promise.reject("nope");
         });
       });
-      mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+      mockCompat({
+        requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+      });
       const mediaElement = document.createElement("video");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
 
@@ -482,7 +508,9 @@ describe("core - decrypt - global tests - media key system access", () => {
         rmksHasBeenCalled = true;
         throw new Error("nope");
       });
-      mockCompat({ requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess });
+      mockCompat({
+        requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+      });
       const mediaElement = document.createElement("video");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
 
diff --git a/src/core/decrypt/__tests__/__global__/media_keys.test.ts b/src/core/decrypt/__tests__/__global__/media_keys.test.ts
index 49a1d38c7f..101659726d 100644
--- a/src/core/decrypt/__tests__/__global__/media_keys.test.ts
+++ b/src/core/decrypt/__tests__/__global__/media_keys.test.ts
@@ -60,12 +60,15 @@ describe("core - decrypt - global tests - media key system access", () => {
                                getConfiguration() { return conf; },
                                createMediaKeys() { throw new Error("No non no"); } });
     }
-    mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessBadMediaKeys });
+    mockCompat({
+      requestMediaKeySystemAccess: jest.fn(requestMediaKeySystemAccessBadMediaKeys),
+    });
 
     // == test ==
     const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
-    const error : any =
-      await testContentDecryptorError(ContentDecryptor, videoElt, ksConfig);
+    const error : any = await testContentDecryptorError(ContentDecryptor,
+                                                        videoElt,
+                                                        ksConfig);
     expect(error).toBeInstanceOf(Error);
     expect(error.message).toEqual(
       "EncryptedMediaError (CREATE_MEDIA_KEYS_ERROR) No non no"
@@ -86,12 +89,15 @@ describe("core - decrypt - global tests - media key system access", () => {
         createMediaKeys: () => Promise.reject(new Error("No non no")),
       });
     }
-    mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessRejMediaKeys });
+    mockCompat({
+      requestMediaKeySystemAccess: jest.fn(requestMediaKeySystemAccessRejMediaKeys),
+    });
 
     // == test ==
     const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
-    const error : any =
-      await testContentDecryptorError(ContentDecryptor, videoElt, ksConfig);
+    const error : any = await testContentDecryptorError(ContentDecryptor,
+                                                        videoElt,
+                                                        ksConfig);
     expect(error).toBeInstanceOf(Error);
     expect(error.message).toEqual(
       "EncryptedMediaError (CREATE_MEDIA_KEYS_ERROR) No non no"
@@ -104,10 +110,10 @@ describe("core - decrypt - global tests - media key system access", () => {
   it("should go into the WaitingForAttachment state if createMediaKeys resolves", () => {
   /* eslint-enable max-len */
     return new Promise<void>((res, rej) => {
-      mockCompat({});
+      mockCompat();
       const mockCreateMediaKeys = jest.spyOn(MediaKeySystemAccessImpl.prototype,
                                              "createMediaKeys");
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
       let receivedStateChange = 0;
@@ -134,10 +140,10 @@ describe("core - decrypt - global tests - media key system access", () => {
   it("should not call createMediaKeys again if previous one is compatible", () => {
   /* eslint-enable max-len */
     return new Promise<void>((res, rej) => {
-      mockCompat({});
+      mockCompat();
       const mockCreateMediaKeys = jest.spyOn(MediaKeySystemAccessImpl.prototype,
                                              "createMediaKeys");
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
 
       const contentDecryptor1 = new ContentDecryptor(videoElt, ksConfig);
@@ -197,7 +203,7 @@ describe("core - decrypt - global tests - media key system access", () => {
       });
       const mockCreateMediaKeys = jest.spyOn(MediaKeySystemAccessImpl.prototype,
                                              "createMediaKeys");
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
 
       const contentDecryptor1 = new ContentDecryptor(videoElt, ksConfig);
@@ -257,7 +263,7 @@ describe("core - decrypt - global tests - media key system access", () => {
       });
       const mockCreateMediaKeys = jest.spyOn(MediaKeySystemAccessImpl.prototype,
                                              "createMediaKeys");
-      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const { ContentDecryptorState } = jest.requireActual("../../types");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
 
       const contentDecryptor1 = new ContentDecryptor(videoElt, ksConfig);
@@ -318,7 +324,7 @@ describe("core - decrypt - global tests - media key system access", () => {
     const mockCreateSession = jest.spyOn(MediaKeysImpl.prototype, "createSession");
 
     // == test ==
-    const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+    const { ContentDecryptorState } = jest.requireActual("../../types");
     const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
     const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
     contentDecryptor.addEventListener("stateChange", (newState: any) => {
diff --git a/src/core/decrypt/__tests__/__global__/server_certificate.test.ts b/src/core/decrypt/__tests__/__global__/server_certificate.test.ts
index 80d71586a0..e8f4e331d5 100644
--- a/src/core/decrypt/__tests__/__global__/server_certificate.test.ts
+++ b/src/core/decrypt/__tests__/__global__/server_certificate.test.ts
@@ -55,6 +55,7 @@ describe("core - decrypt - global tests - server certificate", () => {
     mockSetMediaKeys.mockImplementation(() => {
       expect(mockCreateSession).not.toHaveBeenCalled();
       expect(mockSetServerCertificate).not.toHaveBeenCalled();
+      return Promise.resolve();
     });
     const mockCreateSession = jest.spyOn(MediaKeysImpl.prototype, "createSession");
     const mockSetServerCertificate =
@@ -65,7 +66,7 @@ describe("core - decrypt - global tests - server certificate", () => {
           return Promise.resolve(true);
         });
 
-    const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+    const { ContentDecryptorState } = jest.requireActual("../../types");
     const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
     const contentDecryptor = new ContentDecryptor(videoElt, ksConfigCert);
 
@@ -78,15 +79,15 @@ describe("core - decrypt - global tests - server certificate", () => {
           expect(mockSetServerCertificate).not.toHaveBeenCalled();
           contentDecryptor.attach();
         }, 5);
+        setTimeout(() => {
+          contentDecryptor.dispose();
+          expect(mockSetMediaKeys).toHaveBeenCalledTimes(1);
+          expect(mockSetServerCertificate).toHaveBeenCalledTimes(1);
+          expect(mockCreateSession).not.toHaveBeenCalled();
+          done();
+        }, 10);
       }
     });
-    setTimeout(() => {
-      contentDecryptor.dispose();
-      expect(mockSetMediaKeys).toHaveBeenCalledTimes(1);
-      expect(mockSetServerCertificate).toHaveBeenCalledTimes(1);
-      expect(mockCreateSession).not.toHaveBeenCalled();
-      done();
-    }, 10);
   });
 
   it("should not call serverCertificate multiple times on init data", (done) => {
@@ -94,6 +95,7 @@ describe("core - decrypt - global tests - server certificate", () => {
     mockSetMediaKeys.mockImplementation(() => {
       expect(mockCreateSession).not.toHaveBeenCalled();
       expect(mockSetServerCertificate).not.toHaveBeenCalled();
+      return Promise.resolve();
     });
     const mockCreateSession = jest.spyOn(MediaKeysImpl.prototype, "createSession");
     const mockSetServerCertificate =
@@ -104,7 +106,7 @@ describe("core - decrypt - global tests - server certificate", () => {
           return Promise.resolve(true);
         });
 
-    const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+    const { ContentDecryptorState } = jest.requireActual("../../types");
     const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
     const contentDecryptor = new ContentDecryptor(videoElt, ksConfigCert);
 
@@ -145,7 +147,7 @@ describe("core - decrypt - global tests - server certificate", () => {
           throw new Error("some error");
         });
 
-    const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+    const { ContentDecryptorState } = jest.requireActual("../../types");
     const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
     const contentDecryptor = new ContentDecryptor(videoElt, ksConfigCert);
 
@@ -184,7 +186,7 @@ describe("core - decrypt - global tests - server certificate", () => {
           return Promise.reject(new Error("some error"));
         });
 
-    const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+    const { ContentDecryptorState } = jest.requireActual("../../types");
     const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
     const contentDecryptor = new ContentDecryptor(videoElt, ksConfigCert);
 
@@ -225,11 +227,12 @@ describe("core - decrypt - global tests - server certificate", () => {
     mockSetMediaKeys.mockImplementation(() => {
       expect(mockCreateSession).not.toHaveBeenCalled();
       expect(mockSetServerCertificate).not.toHaveBeenCalled();
+      return Promise.resolve();
     });
     const mockCreateSession = jest.spyOn(MediaKeysImpl.prototype, "createSession");
     const mockSetServerCertificate = jest.spyOn(MediaKeysImpl.prototype,
                                                 "setServerCertificate");
-    const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+    const { ContentDecryptorState } = jest.requireActual("../../types");
     const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
     const contentDecryptor = new ContentDecryptor(videoElt, ksConfigCert);
 
diff --git a/src/core/decrypt/__tests__/__global__/utils.ts b/src/core/decrypt/__tests__/__global__/utils.ts
index 1e9afde54a..2f43f98e5f 100644
--- a/src/core/decrypt/__tests__/__global__/utils.ts
+++ b/src/core/decrypt/__tests__/__global__/utils.ts
@@ -26,7 +26,10 @@
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 /* eslint-disable no-restricted-properties */
 
-import { IEncryptedEventData } from "../../../../compat/eme";
+import {
+  IEmeApiImplementation,
+  IEncryptedEventData,
+} from "../../../../compat/eme";
 import {
   base64ToBytes,
   bytesToBase64,
@@ -319,24 +322,24 @@ class MockedDecryptorEventEmitter extends EventEmitter<{
  * Mock functions coming from the compat directory.
  */
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function mockCompat(exportedFunctions = {}) {
+export function mockCompat(exportedFunctions : Record<string, jest.Mock | null> = {}) {
   const ee = new MockedDecryptorEventEmitter();
+  const onEncrypted = exportedFunctions.onEncrypted ?? jest.fn((
+    elt : HTMLMediaElement,
+    fn : (x : unknown) => void,
+    signal : CancellationSignal
+  ) => {
+    elt.addEventListener("encrypted", fn);
+    signal.register(() => {
+      elt.removeEventListener("encrypted", fn);
+    });
+    ee.addEventListener("encrypted", (evt) => {
+      if (evt.elt === elt) {
+        fn(evt.value);
+      }
+    }, signal);
+  });
   const mockEvents : Record<string, jest.Mock> = {
-    onEncrypted: jest.fn((
-      elt : HTMLMediaElement,
-      fn : (x : unknown) => void,
-      signal : CancellationSignal
-    ) => {
-      elt.addEventListener("encrypted", fn);
-      signal.register(() => {
-        elt.removeEventListener("encrypted", fn);
-      });
-      ee.addEventListener("encrypted", (evt) => {
-        if (evt.elt === elt) {
-          fn(evt.value);
-        }
-      }, signal);
-    }),
     onKeyMessage: jest.fn((
       elt : MediaKeySessionImpl,
       fn : (x : unknown) => void,
@@ -375,9 +378,11 @@ export function mockCompat(exportedFunctions = {}) {
     }),
   };
 
-  const mockRmksa = jest.fn(requestMediaKeySystemAccessImpl);
-  const mockSetMediaKeys = jest.fn();
-  const mockGenerateKeyRequest = jest.fn((
+  const mockRmksa = exportedFunctions.requestMediaKeySystemAccess ??
+                    jest.fn(requestMediaKeySystemAccessImpl);
+  const mockSetMediaKeys = exportedFunctions.setMediaKeys ??
+                           jest.fn(() => Promise.resolve());
+  const mockGenerateKeyRequest =  jest.fn((
     mks : MediaKeySessionImpl,
     initializationDataType,
     initializationData
@@ -392,14 +397,24 @@ export function mockCompat(exportedFunctions = {}) {
 
   jest.mock("../../../../compat", () => (
     { events: mockEvents,
-      requestMediaKeySystemAccess: mockRmksa,
-      setMediaKeys: mockSetMediaKeys,
-      getInitData: mockGetInitData,
-      generateKeyRequest: mockGenerateKeyRequest,
       shouldRenewMediaKeySystemAccess: jest.fn(() => false),
+      shouldWaitForEncryptedBeforeAttachment: jest.fn(() => false),
       canReuseMediaKeys: jest.fn(() => true),
       ...exportedFunctions }));
 
+  const emeImplementation = {
+    onEncrypted,
+    requestMediaKeySystemAccess: mockRmksa,
+    setMediaKeys: mockSetMediaKeys,
+  } as unknown as IEmeApiImplementation;
+
+  jest.mock("../../../../compat/eme", () => (
+    { __esModule: true as const,
+      default: emeImplementation,
+      getInitData: mockGetInitData,
+      generateKeyRequest: mockGenerateKeyRequest,
+      ...exportedFunctions }));
+
   return { mockEvents,
            eventTriggers: {
              triggerEncrypted(elt : HTMLMediaElement, value : unknown) {
diff --git a/src/core/decrypt/attach_media_keys.ts b/src/core/decrypt/attach_media_keys.ts
index fb3388dc28..0b0d0a9b60 100644
--- a/src/core/decrypt/attach_media_keys.ts
+++ b/src/core/decrypt/attach_media_keys.ts
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-import {
+import eme, {
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
-  setMediaKeys,
-} from "../../compat";
+  IEmeApiImplementation,
+} from "../../compat/eme";
 import log from "../../log";
 import { IKeySystemOption } from "../../public_types";
 import { CancellationSignal } from "../../utils/task_canceller";
@@ -32,7 +32,16 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  */
 export function disableMediaKeys(mediaElement : HTMLMediaElement): void {
   MediaKeysInfosStore.setState(mediaElement, null);
-  setMediaKeys(mediaElement, null);
+  eme.setMediaKeys(mediaElement, null)
+    .then(() => {
+      log.info("DRM: MediaKeys disabled with success");
+    })
+    .catch((err) => {
+      log.error(
+        "DRM: Could not disable MediaKeys",
+        err instanceof Error ? err : "Unknown Error"
+      );
+    });
 }
 
 /**
@@ -46,7 +55,8 @@ export function disableMediaKeys(mediaElement : HTMLMediaElement): void {
  */
 export default async function attachMediaKeys(
   mediaElement : HTMLMediaElement,
-  { keySystemOptions,
+  { emeImplementation,
+    keySystemOptions,
     loadedSessionsStore,
     mediaKeySystemAccess,
     mediaKeys } : IMediaKeysState,
@@ -66,7 +76,8 @@ export default async function attachMediaKeys(
     throw cancelSignal.cancellationError;
   }
 
-  MediaKeysInfosStore.setState(mediaElement, { keySystemOptions,
+  MediaKeysInfosStore.setState(mediaElement, { emeImplementation,
+                                               keySystemOptions,
                                                mediaKeySystemAccess,
                                                mediaKeys,
                                                loadedSessionsStore });
@@ -74,8 +85,16 @@ export default async function attachMediaKeys(
     return ;
   }
   log.info("DRM: Attaching MediaKeys to the media element");
-  setMediaKeys(mediaElement, mediaKeys);
-  log.info("DRM: MediaKeys attached with success");
+  emeImplementation.setMediaKeys(mediaElement, mediaKeys)
+    .then(() => {
+      log.info("DRM: MediaKeys attached with success");
+    })
+    .catch((err) => {
+      log.error(
+        "DRM: Could not set MediaKeys",
+        err instanceof Error ? err : "Unknown Error"
+      );
+    });
 }
 
 /** MediaKeys and associated state attached to a media element. */
@@ -90,4 +109,10 @@ export interface IMediaKeysState {
   /** The MediaKeys instance to attach to the media element. */
   mediaKeys : MediaKeys |
               ICustomMediaKeys;
+  /**
+   * The chosen EME implementation abstraction linked to `mediaKeys`.
+   * Different EME implementation might for example be used while debugging or
+   * work-arounding EME-linked device issues.
+   */
+  emeImplementation : IEmeApiImplementation;
 }
diff --git a/src/core/decrypt/clear_on_stop.ts b/src/core/decrypt/clear_on_stop.ts
index a845d84139..1098a340b8 100644
--- a/src/core/decrypt/clear_on_stop.ts
+++ b/src/core/decrypt/clear_on_stop.ts
@@ -27,7 +27,7 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  */
 export default function clearOnStop(
   mediaElement : HTMLMediaElement
-) : Promise<void> {
+) : Promise<unknown> {
   log.info("DRM: Clearing-up DRM session.");
   if (shouldUnsetMediaKeys()) {
     log.info("DRM: disposing current MediaKeys.");
diff --git a/src/core/decrypt/content_decryptor.ts b/src/core/decrypt/content_decryptor.ts
index fefe8f2796..e2f4c3bc9d 100644
--- a/src/core/decrypt/content_decryptor.ts
+++ b/src/core/decrypt/content_decryptor.ts
@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-import {
-  events,
+import eme, {
   getInitData,
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
-} from "../../compat/";
+} from "../../compat/eme";
 import config from "../../config";
 import {
   EncryptedMediaError,
@@ -53,6 +52,8 @@ import {
   IMediaKeySessionStores,
   MediaKeySessionLoadingType,
   IProcessedProtectionData,
+  ContentDecryptorState,
+  IContentDecryptorEvent,
 } from "./types";
 import { DecommissionedSessionError } from "./utils/check_key_statuses";
 import cleanOldStoredPersistentInfo from "./utils/clean_old_stored_persistent_info";
@@ -66,8 +67,6 @@ import {
 } from "./utils/key_id_comparison";
 import KeySessionRecord from "./utils/key_session_record";
 
-const { onEncrypted } = events;
-
 /**
  * Module communicating with the Content Decryption Module (or CDM) to be able
  * to decrypt contents.
@@ -126,12 +125,6 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    */
   private _canceller : TaskCanceller;
 
-  /**
-   * `true` once the `attach` method has been called`.
-   * Allows to avoid calling multiple times that function.
-   */
-  private _wasAttachCalled : boolean;
-
   /**
    * This queue stores initialization data which hasn't been processed yet,
    * probably because the "queue is locked" for now. (@see _stateData private
@@ -142,6 +135,16 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    */
   private _initDataQueue : IProtectionData[];
 
+  /**
+   * `true` if the EME API are available on the current platform according to
+   * the default EME implementation used.
+   * `false` otherwise.
+   * @returns {boolean}
+   */
+  public static hasEmeApis() : boolean {
+    return !isNullOrUndefined(eme.requestMediaKeySystemAccess);
+  }
+
   /**
    * Create a new `ContentDecryptor`, and initialize its decryption capabilities
    * right away.
@@ -156,7 +159,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    * configurations. It will choose the appropriate one depending on user
    * settings and browser support.
    */
-  constructor(mediaElement : HTMLMediaElement, ksOptions: IKeySystemOption[]) {
+  constructor(mediaElement : HTMLMediaElement, ksOptions : IKeySystemOption[]) {
     super();
 
     log.debug("DRM: Starting ContentDecryptor logic.");
@@ -164,15 +167,14 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     const canceller = new TaskCanceller();
     this._currentSessions = [];
     this._canceller = canceller;
-    this._wasAttachCalled = false;
     this._initDataQueue = [];
     this._stateData = { state: ContentDecryptorState.Initializing,
-                        isMediaKeysAttached: false,
+                        isMediaKeysAttached: MediaKeyAttachmentStatus.NotAttached,
                         isInitDataQueueLocked: true,
                         data: null };
     this.error = null;
 
-    onEncrypted(mediaElement, evt => {
+    eme.onEncrypted(mediaElement, evt => {
       log.debug("DRM: Encrypted event received from media element.");
       const initData = getInitData(evt as MediaEncryptedEvent);
       if (initData !== null) {
@@ -204,7 +206,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
         if (this._stateData.state === ContentDecryptorState.Initializing) {
           this._stateData = { state: ContentDecryptorState.WaitingForAttachment,
                               isInitDataQueueLocked: true,
-                              isMediaKeysAttached: false,
+                              isMediaKeysAttached: MediaKeyAttachmentStatus.NotAttached,
                               data: { mediaKeysInfo,
                                       mediaElement } };
 
@@ -239,36 +241,43 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     if (this._stateData.state !== ContentDecryptorState.WaitingForAttachment) {
       throw new Error("`attach` should only be called when " +
                       "in the WaitingForAttachment state");
-    } else if (this._wasAttachCalled) {
+    } else if (
+      this._stateData.isMediaKeysAttached !== MediaKeyAttachmentStatus.NotAttached
+    ) {
       log.warn("DRM: ContentDecryptor's `attach` method called more than once.");
       return;
     }
-    this._wasAttachCalled = true;
 
     const { mediaElement, mediaKeysInfo } = this._stateData.data;
     const { options, mediaKeys, mediaKeySystemAccess, stores } = mediaKeysInfo;
-    const stateToAttatch = { loadedSessionsStore: stores.loadedSessionsStore,
-                             mediaKeySystemAccess,
-                             mediaKeys,
-                             keySystemOptions: options };
-
     const shouldDisableLock = options.disableMediaKeysAttachmentLock === true;
+
     if (shouldDisableLock) {
       this._stateData = { state: ContentDecryptorState.ReadyForContent,
                           isInitDataQueueLocked: true,
-                          isMediaKeysAttached: false,
-                          data: null };
+                          isMediaKeysAttached: MediaKeyAttachmentStatus.Pending,
+                          data: { mediaKeysInfo, mediaElement } };
       this.trigger("stateChange", this._stateData.state);
-      if (this._isStopped()) { // previous trigger might have lead to disposal
+
+      // previous trigger might have lead to disposal
+      if (this._isStopped()) {
         return ;
       }
     }
 
+    this._stateData.isMediaKeysAttached = MediaKeyAttachmentStatus.Pending;
+    const stateToAttach = { emeImplementation: eme,
+                            loadedSessionsStore: stores.loadedSessionsStore,
+                            mediaKeySystemAccess,
+                            mediaKeys,
+                            keySystemOptions: options };
+
     log.debug("DRM: Attaching current MediaKeys");
-    attachMediaKeys(mediaElement, stateToAttatch, this._canceller.signal)
+    attachMediaKeys(mediaElement, stateToAttach, this._canceller.signal)
       .then(async () => {
-        const { serverCertificate } = options;
+        this._stateData.isMediaKeysAttached = MediaKeyAttachmentStatus.Attached;
 
+        const { serverCertificate } = options;
         if (!isNullOrUndefined(serverCertificate)) {
           const resSsc = await setServerCertificate(mediaKeys, serverCertificate);
           if (resSsc.type === "error") {
@@ -282,7 +291,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
 
         const prevState = this._stateData.state;
         this._stateData = { state: ContentDecryptorState.ReadyForContent,
-                            isMediaKeysAttached: true,
+                            isMediaKeysAttached: MediaKeyAttachmentStatus.Attached,
                             isInitDataQueueLocked: false,
                             data: { mediaKeysData: mediaKeysInfo } };
         if (prevState !== ContentDecryptorState.ReadyForContent) {
@@ -791,7 +800,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
    * Should have no effect if the `_initDataQueue` was not locked.
    */
   private _unlockInitDataQueue() : void {
-    if (this._stateData.isMediaKeysAttached !== true) {
+    if (this._stateData.isMediaKeysAttached !== MediaKeyAttachmentStatus.Attached) {
       log.error("DRM: Trying to unlock in the wrong state");
       return;
     }
@@ -903,226 +912,6 @@ function blackListProtectionData(
   });
 }
 
-/** Events sent by the `ContentDecryptor`, in a `{ event: payload }` format. */
-export interface IContentDecryptorEvent {
-  /**
-   * Event emitted when a major error occured which made the ContentDecryptor
-   * stopped.
-   * When that event is sent, the `ContentDecryptor` is in the `Error` state and
-   * cannot be used anymore.
-   */
-  error : Error;
-
-  /**
-   * Event emitted when a minor error occured which the ContentDecryptor can
-   * recover from.
-   */
-  warning : IPlayerError;
-
-  /**
-   * Event emitted when the `ContentDecryptor`'s state changed.
-   * States are a central aspect of the `ContentDecryptor`, be sure to check the
-   * ContentDecryptorState type.
-   */
-  stateChange: ContentDecryptorState;
-}
-
-/** Enumeration of the various "state" the `ContentDecryptor` can be in. */
-export enum ContentDecryptorState {
-  /**
-   * The `ContentDecryptor` is not yet ready to create key sessions and request
-   * licenses.
-   * This is is the initial state of the ContentDecryptor.
-   */
-  Initializing,
-
-  /**
-   * The `ContentDecryptor` has been initialized.
-   * You should now called the `attach` method when you want to add decryption
-   * capabilities to the HTMLMediaElement. The ContentDecryptor won't go to the
-   * `ReadyForContent` state until `attach` is called.
-   *
-   * For compatibility reasons, this should be done after the HTMLMediaElement's
-   * src attribute is set.
-   *
-   * It is also from when this state is reached that the `ContentDecryptor`'s
-   * `systemId` property may be known.
-   *
-   * This state is always coming after the `Initializing` state.
-   */
-  WaitingForAttachment,
-
-  /**
-   * Content (encrypted or not) can begin to be pushed on the HTMLMediaElement
-   * (this state was needed because some browser quirks sometimes forces us to
-   * call EME API before this can be done).
-   *
-   * This state is always coming after the `WaitingForAttachment` state.
-   */
-  ReadyForContent,
-
-  /**
-   * The `ContentDecryptor` has encountered a fatal error and has been stopped.
-   * It is now unusable.
-   */
-  Error,
-
-  /** The `ContentDecryptor` has been disposed of and is now unusable. */
-  Disposed,
-}
-
-/** Possible states the ContentDecryptor is in and associated data for each one. */
-type IContentDecryptorStateData = IInitializingStateData |
-                                  IWaitingForAttachmentStateData |
-                                  IReadyForContentStateDataUnattached |
-                                  IReadyForContentStateDataAttached |
-                                  IDisposeStateData |
-                                  IErrorStateData;
-
-/** Skeleton that all variants of `IContentDecryptorStateData` use. */
-interface IContentDecryptorStateBase<
-  TStateName extends ContentDecryptorState,
-  TIsQueueLocked extends boolean | undefined,
-  TIsMediaKeyAttached extends boolean | undefined,
-  TData
-> {
-  /** Identify the ContentDecryptor's state. */
-  state: TStateName;
-  /**
-   * If `true`, the `ContentDecryptor` will wait before processing
-   * newly-received initialization data.
-   * If `false`, it will process them right away.
-   * Set to undefined when it won't ever process them like for example in a
-   * disposed or errored state.
-   */
-  isInitDataQueueLocked: TIsQueueLocked;
-  /**
-   * If `true`, the `MediaKeys` instance has been attached to the HTMLMediaElement.
-   * If `false`, it hasn't happened yet.
-   * If uncertain or unimportant (for example if the `ContentDecryptor` is an
-   * disposed/errored state, set to `undefined`).
-   */
-  isMediaKeysAttached: TIsMediaKeyAttached;
-  /** Data stored relative to that state. */
-  data: TData;
-}
-
-/** ContentDecryptor's internal data when in the `Initializing` state. */
-type IInitializingStateData = IContentDecryptorStateBase<
-  ContentDecryptorState.Initializing,
-  true, // isInitDataQueueLocked
-  false, // isMediaKeysAttached
-  null // data
->;
-
-/** ContentDecryptor's internal data when in the `WaitingForAttachment` state. */
-type IWaitingForAttachmentStateData = IContentDecryptorStateBase<
-  ContentDecryptorState.WaitingForAttachment,
-  true, // isInitDataQueueLocked
-  false, // isMediaKeysAttached
-  // data
-  { mediaKeysInfo : IMediaKeysInfos;
-    mediaElement : HTMLMediaElement; }
->;
-
-/**
- * ContentDecryptor's internal data when in the `ReadyForContent` state before
- * it has attached the `MediaKeys` to the media element.
- */
-type IReadyForContentStateDataUnattached = IContentDecryptorStateBase<
-  ContentDecryptorState.ReadyForContent,
-  true, // isInitDataQueueLocked
-  false, // isMediaKeysAttached
-  null // data
->;
-
-/**
- * ContentDecryptor's internal data when in the `ReadyForContent` state once
- * it has attached the `MediaKeys` to the media element.
- */
-type IReadyForContentStateDataAttached = IContentDecryptorStateBase<
-  ContentDecryptorState.ReadyForContent,
-  boolean, // isInitDataQueueLocked
-  true, // isMediaKeysAttached
-  {
-    /**
-     * MediaKeys-related information linked to this instance of the
-     * `ContentDecryptor`.
-     * Set to `null` until it is known.
-     * Should be always set when the `ContentDecryptor` has reached the
-     * Initialized state (@see ContentDecryptorState).
-     */
-    mediaKeysData : IAttachedMediaKeysData;
-  }
->;
-
-/** ContentDecryptor's internal data when in the `Disposed` state. */
-type IDisposeStateData = IContentDecryptorStateBase<
-  ContentDecryptorState.Disposed,
-  undefined, // isInitDataQueueLocked
-  undefined, // isMediaKeysAttached
-  null // data
->;
-
-/** ContentDecryptor's internal data when in the `Error` state. */
-type IErrorStateData = IContentDecryptorStateBase<
-  ContentDecryptorState.Error,
-  undefined, // isInitDataQueueLocked
-  undefined, // isMediaKeysAttached
-  null // data
->;
-
-/** Information linked to a session created by the `ContentDecryptor`. */
-interface IActiveSessionInfo {
-  /**
-   * Record associated to the session.
-   * Most notably, it allows both to identify the session as well as to
-   * anounce and find out which key ids are already handled.
-   */
-  record : KeySessionRecord;
-
-  /** Current keys' statuses linked that session. */
-  keyStatuses : {
-    /** Key ids linked to keys that are "usable". */
-    whitelisted : Uint8Array[];
-    /**
-     * Key ids linked to keys that are not considered "usable".
-     * Content linked to those keys are not decipherable and may thus be
-     * fallbacked from.
-     */
-    blacklisted : Uint8Array[];
-  };
-
-  /** Source of the MediaKeySession linked to that record. */
-  source : MediaKeySessionLoadingType;
-
-  /**
-   * If different than `null`, all initialization data compatible with this
-   * processed initialization data has been blacklisted with this corresponding
-   * error.
-   */
-  blacklistedSessionError : BlacklistedSessionError | null;
-}
-
-/**
- * Sent when the created (or already created) MediaKeys is attached to the
- * current HTMLMediaElement element.
- * On some peculiar devices, we have to wait for that step before the first
- * media segments are to be pushed to avoid issues.
- * Because this event is sent after a MediaKeys is created, you will always have
- * a "created-media-keys" event before an "attached-media-keys" event.
- */
-interface IAttachedMediaKeysData {
-  /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
-  mediaKeySystemAccess: MediaKeySystemAccess |
-                        ICustomMediaKeySystemAccess;
-  /** The MediaKeys instance. */
-  mediaKeys : MediaKeys |
-              ICustomMediaKeys;
-  stores : IMediaKeySessionStores;
-  options : IKeySystemOption;
-}
-
 /**
  * Returns set of all usable and unusable keys - explicit or implicit - that are
  * linked to a `MediaKeySession`.
@@ -1293,3 +1082,164 @@ function addKeyIdsFromPeriod(
     }
   }
 }
+
+/** Possible states the ContentDecryptor is in and associated data for each one. */
+type IContentDecryptorStateData = IInitializingStateData |
+                                  IWaitingForAttachmentStateData |
+                                  IReadyForContentStateDataUnattached |
+                                  IReadyForContentStateDataAttached |
+                                  IDisposeStateData |
+                                  IErrorStateData;
+
+/** Skeleton that all variants of `IContentDecryptorStateData` use. */
+interface IContentDecryptorStateBase<
+  TStateName extends ContentDecryptorState,
+  TIsQueueLocked extends boolean | undefined,
+  TIsMediaKeyAttached extends MediaKeyAttachmentStatus | undefined,
+  TData
+> {
+  /** Identify the ContentDecryptor's state. */
+  state: TStateName;
+  /**
+   * If `true`, the `ContentDecryptor` will wait before processing
+   * newly-received initialization data.
+   * If `false`, it will process them right away.
+   * Set to undefined when it won't ever process them like for example in a
+   * disposed or errored state.
+   */
+  isInitDataQueueLocked: TIsQueueLocked;
+  /**
+   * If `true`, the `MediaKeys` instance has been attached to the HTMLMediaElement.
+   * If `false`, it hasn't happened yet.
+   * If uncertain or unimportant (for example if the `ContentDecryptor` is an
+   * disposed/errored state, set to `undefined`).
+   */
+  isMediaKeysAttached: TIsMediaKeyAttached;
+  /** Data stored relative to that state. */
+  data: TData;
+}
+
+const enum MediaKeyAttachmentStatus {
+  NotAttached,
+  Pending,
+  Attached,
+}
+
+/** ContentDecryptor's internal data when in the `Initializing` state. */
+type IInitializingStateData = IContentDecryptorStateBase<
+  ContentDecryptorState.Initializing,
+  true, // isInitDataQueueLocked
+  MediaKeyAttachmentStatus.NotAttached, // isMediaKeysAttached
+  null // data
+>;
+
+/** ContentDecryptor's internal data when in the `WaitingForAttachment` state. */
+type IWaitingForAttachmentStateData = IContentDecryptorStateBase<
+  ContentDecryptorState.WaitingForAttachment,
+  true, // isInitDataQueueLocked
+  MediaKeyAttachmentStatus.NotAttached, // isMediaKeysAttached
+  // data
+  { mediaKeysInfo : IMediaKeysInfos;
+    mediaElement : HTMLMediaElement; }
+>;
+
+/**
+ * ContentDecryptor's internal data when in the `ReadyForContent` state before
+ * it has attached the `MediaKeys` to the media element.
+ */
+type IReadyForContentStateDataUnattached = IContentDecryptorStateBase<
+  ContentDecryptorState.ReadyForContent,
+  true, // isInitDataQueueLocked
+  MediaKeyAttachmentStatus.NotAttached |
+  MediaKeyAttachmentStatus.Pending, // isMediaKeysAttached
+  { mediaKeysInfo : IMediaKeysInfos;
+    mediaElement : HTMLMediaElement; } // data
+>;
+
+/**
+ * ContentDecryptor's internal data when in the `ReadyForContent` state once
+ * it has attached the `MediaKeys` to the media element.
+ */
+type IReadyForContentStateDataAttached = IContentDecryptorStateBase<
+  ContentDecryptorState.ReadyForContent,
+  boolean, // isInitDataQueueLocked
+  MediaKeyAttachmentStatus.Attached, // isMediaKeysAttached
+  {
+    /**
+     * MediaKeys-related information linked to this instance of the
+     * `ContentDecryptor`.
+     * Set to `null` until it is known.
+     * Should be always set when the `ContentDecryptor` has reached the
+     * Initialized state (@see ContentDecryptorState).
+     */
+    mediaKeysData : IAttachedMediaKeysData;
+  }
+>;
+
+/** ContentDecryptor's internal data when in the `Disposed` state. */
+type IDisposeStateData = IContentDecryptorStateBase<
+  ContentDecryptorState.Disposed,
+  undefined, // isInitDataQueueLocked
+  undefined, // isMediaKeysAttached
+  null // data
+>;
+
+/** ContentDecryptor's internal data when in the `Error` state. */
+type IErrorStateData = IContentDecryptorStateBase<
+  ContentDecryptorState.Error,
+  undefined, // isInitDataQueueLocked
+  undefined, // isMediaKeysAttached
+  null // data
+>;
+
+/** Information linked to a session created by the `ContentDecryptor`. */
+interface IActiveSessionInfo {
+  /**
+   * Record associated to the session.
+   * Most notably, it allows both to identify the session as well as to
+   * anounce and find out which key ids are already handled.
+   */
+  record : KeySessionRecord;
+
+  /** Current keys' statuses linked that session. */
+  keyStatuses : {
+    /** Key ids linked to keys that are "usable". */
+    whitelisted : Uint8Array[];
+    /**
+     * Key ids linked to keys that are not considered "usable".
+     * Content linked to those keys are not decipherable and may thus be
+     * fallbacked from.
+     */
+    blacklisted : Uint8Array[];
+  };
+
+  /** Source of the MediaKeySession linked to that record. */
+  source : MediaKeySessionLoadingType;
+
+  /**
+   * If different than `null`, all initialization data compatible with this
+   * processed initialization data has been blacklisted with this corresponding
+   * error.
+   */
+  blacklistedSessionError : BlacklistedSessionError | null;
+}
+
+/**
+ * Sent when the created (or already created) MediaKeys is attached to the
+ * current HTMLMediaElement element.
+ * On some peculiar devices, we have to wait for that step before the first
+ * media segments are to be pushed to avoid issues.
+ * Because this event is sent after a MediaKeys is created, you will always have
+ * a "created-media-keys" event before an "attached-media-keys" event.
+ */
+interface IAttachedMediaKeysData {
+  /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
+  mediaKeySystemAccess: MediaKeySystemAccess |
+                        ICustomMediaKeySystemAccess;
+  /** The MediaKeys instance. */
+  mediaKeys : MediaKeys |
+              ICustomMediaKeys;
+  stores : IMediaKeySessionStores;
+  options : IKeySystemOption;
+}
+
diff --git a/src/core/decrypt/create_or_load_session.ts b/src/core/decrypt/create_or_load_session.ts
index 3715062865..57cd349d06 100644
--- a/src/core/decrypt/create_or_load_session.ts
+++ b/src/core/decrypt/create_or_load_session.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../compat";
+import { ICustomMediaKeySession } from "../../compat/eme";
 import log from "../../log";
 import { CancellationSignal } from "../../utils/task_canceller";
 import createSession from "./create_session";
diff --git a/src/core/decrypt/create_session.ts b/src/core/decrypt/create_session.ts
index 721d78b76b..c0eea1d9db 100644
--- a/src/core/decrypt/create_session.ts
+++ b/src/core/decrypt/create_session.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../compat";
+import { ICustomMediaKeySession } from "../../compat/eme";
 import log from "../../log";
 import { CancellationSignal } from "../../utils/task_canceller";
 import {
diff --git a/src/core/decrypt/dispose_decryption_resources.ts b/src/core/decrypt/dispose_decryption_resources.ts
index e481dba610..4dbc1c6a2e 100644
--- a/src/core/decrypt/dispose_decryption_resources.ts
+++ b/src/core/decrypt/dispose_decryption_resources.ts
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import { setMediaKeys } from "../../compat";
 import log from "../../log";
+import sleep from "../../utils/sleep";
 import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 
 /**
@@ -25,15 +25,30 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  */
 export default async function disposeDecryptionResources(
   mediaElement : HTMLMediaElement
-) : Promise<void> {
+) : Promise<unknown> {
   const currentState = MediaKeysInfosStore.getState(mediaElement);
   if (currentState === null) {
-    return ;
+    return undefined;
   }
 
   log.info("DRM: Disposing of the current MediaKeys");
   const { loadedSessionsStore } = currentState;
   MediaKeysInfosStore.clearState(mediaElement);
   await loadedSessionsStore.closeAllSessions();
-  setMediaKeys(mediaElement, null);
+
+  return Promise.race(
+    [
+      currentState.emeImplementation.setMediaKeys(mediaElement, null)
+        .catch(err => {
+          log.error(
+            "DRM: Could not reset MediaKeys",
+            err instanceof Error ? err : "Unknown Error"
+          );
+        }),
+
+      // Because we know how much EME has implementation issues, let's not block
+      // everything because that API hangs
+      sleep(1000),
+    ]
+  );
 }
diff --git a/src/core/decrypt/find_key_system.ts b/src/core/decrypt/find_key_system.ts
index 85bffb986f..d8bd148e46 100644
--- a/src/core/decrypt/find_key_system.ts
+++ b/src/core/decrypt/find_key_system.ts
@@ -15,10 +15,11 @@
  */
 
 import {
-  ICustomMediaKeySystemAccess,
-  requestMediaKeySystemAccess,
   shouldRenewMediaKeySystemAccess,
 } from "../../compat";
+import eme, {
+  ICustomMediaKeySystemAccess,
+} from "../../compat/eme";
 import config from "../../config";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
@@ -257,7 +258,7 @@ function buildKeySystemConfigurations(
  *   - reject if no compatible key system has been found.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Array.<Object>} keySystems - The keySystems you want to test.
+ * @param {Array.<Object>} keySystemsConfigs - The keySystems you want to test.
  * @param {Object} cancelSignal
  * @returns {Promise.<Object>}
  */
@@ -268,20 +269,22 @@ export default function getMediaKeySystemAccess(
 ) : Promise<IFoundMediaKeySystemAccessEvent> {
   log.info("DRM: Searching for compatible MediaKeySystemAccess");
   const currentState = MediaKeysInfosStore.getState(mediaElement);
-  if (currentState != null) {
-    // Fast way to find a compatible keySystem if the currently loaded
-    // one as exactly the same compatibility options.
-    const cachedKeySystemAccess =
-      checkCachedMediaKeySystemAccess(keySystemsConfigs,
-                                      currentState.mediaKeySystemAccess,
-                                      currentState.keySystemOptions);
-    if (cachedKeySystemAccess !== null) {
-      log.info("DRM: Found cached compatible keySystem");
-      return Promise.resolve({
-        type: "reuse-media-key-system-access" as const,
-        value: { mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
-                 options: cachedKeySystemAccess.keySystemOptions },
-      });
+  if (currentState !== null) {
+    if (eme.implementation === currentState.emeImplementation.implementation) {
+      // Fast way to find a compatible keySystem if the currently loaded
+      // one as exactly the same compatibility options.
+      const cachedKeySystemAccess =
+        checkCachedMediaKeySystemAccess(keySystemsConfigs,
+                                        currentState.mediaKeySystemAccess,
+                                        currentState.keySystemOptions);
+      if (cachedKeySystemAccess !== null) {
+        log.info("DRM: Found cached compatible keySystem");
+        return Promise.resolve({
+          type: "reuse-media-key-system-access" as const,
+          value: { mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
+                   options: cachedKeySystemAccess.keySystemOptions },
+        });
+      }
     }
   }
 
@@ -340,7 +343,7 @@ export default function getMediaKeySystemAccess(
 
     }
 
-    if (requestMediaKeySystemAccess == null) {
+    if (eme.requestMediaKeySystemAccess == null) {
       throw new Error("requestMediaKeySystemAccess is not implemented in your browser.");
     }
 
@@ -354,8 +357,10 @@ export default function getMediaKeySystemAccess(
               `${index + 1} of ${keySystemsType.length}`);
 
     try {
-      const keySystemAccess = await requestMediaKeySystemAccess(keyType,
-                                                                keySystemConfigurations);
+      const keySystemAccess = await eme.requestMediaKeySystemAccess(
+        keyType,
+        keySystemConfigurations
+      );
       log.info("DRM: Found compatible keysystem", keyType, index + 1);
       return { type: "create-media-key-system-access" as const,
                value: { options: keySystemOptions,
diff --git a/src/core/decrypt/get_media_keys.ts b/src/core/decrypt/get_media_keys.ts
index c0acab5963..3214f664bc 100644
--- a/src/core/decrypt/get_media_keys.ts
+++ b/src/core/decrypt/get_media_keys.ts
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
+import { canReuseMediaKeys } from "../../compat";
 import {
-  canReuseMediaKeys,
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
-} from "../../compat";
+} from "../../compat/eme";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import { IKeySystemOption } from "../../public_types";
diff --git a/src/core/decrypt/index.ts b/src/core/decrypt/index.ts
index 286184a657..2f065c0c81 100644
--- a/src/core/decrypt/index.ts
+++ b/src/core/decrypt/index.ts
@@ -20,10 +20,7 @@
  */
 
 import clearOnStop from "./clear_on_stop";
-import ContentDecryptor, {
-  ContentDecryptorState,
-  IContentDecryptorEvent,
-} from "./content_decryptor";
+import ContentDecryptor from "./content_decryptor";
 import disposeDecryptionResources from "./dispose_decryption_resources";
 import getKeySystemConfiguration, {
   getCurrentKeySystem,
@@ -33,9 +30,7 @@ export * from "./types";
 export default ContentDecryptor;
 export {
   clearOnStop,
-  ContentDecryptorState,
   disposeDecryptionResources,
   getKeySystemConfiguration,
   getCurrentKeySystem,
-  IContentDecryptorEvent,
 };
diff --git a/src/core/decrypt/session_events_listener.ts b/src/core/decrypt/session_events_listener.ts
index 89eb909398..e5031d7e0d 100644
--- a/src/core/decrypt/session_events_listener.ts
+++ b/src/core/decrypt/session_events_listener.ts
@@ -14,10 +14,8 @@
  * limitations under the License.
  */
 
-import {
-  events,
-  ICustomMediaKeySession,
-} from "../../compat";
+import { events } from "../../compat";
+import { ICustomMediaKeySession } from "../../compat/eme";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import {
diff --git a/src/core/decrypt/set_server_certificate.ts b/src/core/decrypt/set_server_certificate.ts
index ec8068c431..e60b7bd799 100644
--- a/src/core/decrypt/set_server_certificate.ts
+++ b/src/core/decrypt/set_server_certificate.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeys } from "../../compat";
+import { ICustomMediaKeys } from "../../compat/eme";
 import {
   EncryptedMediaError,
   isKnownError,
diff --git a/src/core/decrypt/types.ts b/src/core/decrypt/types.ts
index e07f38b335..2b97fcf225 100644
--- a/src/core/decrypt/types.ts
+++ b/src/core/decrypt/types.ts
@@ -19,10 +19,79 @@ import Manifest, {
   Period,
   Representation,
 } from "../../manifest";
+import { IPlayerError } from "../../public_types";
 import InitDataValuesContainer from "./utils/init_data_values_container";
 import LoadedSessionsStore from "./utils/loaded_sessions_store";
 import PersistentSessionsStore from "./utils/persistent_sessions_store";
 
+/** Events sent by the `ContentDecryptor`, in a `{ event: payload }` format. */
+export interface IContentDecryptorEvent {
+  /**
+   * Event emitted when a major error occured which made the ContentDecryptor
+   * stopped.
+   * When that event is sent, the `ContentDecryptor` is in the `Error` state and
+   * cannot be used anymore.
+   */
+  error : Error;
+
+  /**
+   * Event emitted when a minor error occured which the ContentDecryptor can
+   * recover from.
+   */
+  warning : IPlayerError;
+
+  /**
+   * Event emitted when the `ContentDecryptor`'s state changed.
+   * States are a central aspect of the `ContentDecryptor`, be sure to check the
+   * ContentDecryptorState type.
+   */
+  stateChange: ContentDecryptorState;
+}
+
+/** Enumeration of the various "state" the `ContentDecryptor` can be in. */
+export enum ContentDecryptorState {
+  /**
+   * The `ContentDecryptor` is not yet ready to create key sessions and request
+   * licenses.
+   * This is is the initial state of the ContentDecryptor.
+   */
+  Initializing,
+
+  /**
+   * The `ContentDecryptor` has been initialized.
+   * You should now called the `attach` method when you want to add decryption
+   * capabilities to the HTMLMediaElement. The ContentDecryptor won't go to the
+   * `ReadyForContent` state until `attach` is called.
+   *
+   * For compatibility reasons, this should be done after the HTMLMediaElement's
+   * src attribute is set.
+   *
+   * It is also from when this state is reached that the `ContentDecryptor`'s
+   * `systemId` property may be known.
+   *
+   * This state is always coming after the `Initializing` state.
+   */
+  WaitingForAttachment,
+
+  /**
+   * Content (encrypted or not) can begin to be pushed on the HTMLMediaElement
+   * (this state was needed because some browser quirks sometimes forces us to
+   * call EME API before this can be done).
+   *
+   * This state is always coming after the `WaitingForAttachment` state.
+   */
+  ReadyForContent,
+
+  /**
+   * The `ContentDecryptor` has encountered a fatal error and has been stopped.
+   * It is now unusable.
+   */
+  Error,
+
+  /** The `ContentDecryptor` has been disposed of and is now unusable. */
+  Disposed,
+}
+
 /** Information about the encryption initialization data. */
 export interface IProtectionData {
   /**
diff --git a/src/core/decrypt/utils/check_key_statuses.ts b/src/core/decrypt/utils/check_key_statuses.ts
index 7906bab272..71f2d36197 100644
--- a/src/core/decrypt/utils/check_key_statuses.ts
+++ b/src/core/decrypt/utils/check_key_statuses.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../../compat";
+import { ICustomMediaKeySession } from "../../../compat/eme";
 /* eslint-disable-next-line max-len */
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
diff --git a/src/core/decrypt/utils/is_session_usable.ts b/src/core/decrypt/utils/is_session_usable.ts
index fbccac15b8..d4d0ef5958 100644
--- a/src/core/decrypt/utils/is_session_usable.ts
+++ b/src/core/decrypt/utils/is_session_usable.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../../compat";
+import { ICustomMediaKeySession } from "../../../compat/eme";
 import log from "../../../log";
 import arrayIncludes from "../../../utils/array_includes";
 
diff --git a/src/core/decrypt/utils/loaded_sessions_store.ts b/src/core/decrypt/utils/loaded_sessions_store.ts
index f55bb6ccc2..972e73ad01 100644
--- a/src/core/decrypt/utils/loaded_sessions_store.ts
+++ b/src/core/decrypt/utils/loaded_sessions_store.ts
@@ -20,7 +20,7 @@ import {
   ICustomMediaKeys,
   ICustomMediaKeySession,
   loadSession,
-} from "../../../compat";
+} from "../../../compat/eme";
 import log from "../../../log";
 import assert from "../../../utils/assert";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
@@ -47,7 +47,7 @@ export default class LoadedSessionsStore {
    * loaded MediaKeySessions on the given MediaKeys instance.
    * @param {MediaKeys} mediaKeys
    */
-  constructor(mediaKeys : MediaKeys|ICustomMediaKeys) {
+  constructor(mediaKeys : MediaKeys | ICustomMediaKeys) {
     this._mediaKeys = mediaKeys;
     this._storage = [];
   }
diff --git a/src/core/decrypt/utils/media_keys_infos_store.ts b/src/core/decrypt/utils/media_keys_infos_store.ts
index d7ae43d124..862a864c6b 100644
--- a/src/core/decrypt/utils/media_keys_infos_store.ts
+++ b/src/core/decrypt/utils/media_keys_infos_store.ts
@@ -17,12 +17,15 @@
 import {
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
-} from "../../../compat";
+  IEmeApiImplementation,
+} from "../../../compat/eme";
 import { IKeySystemOption } from "../../../public_types";
 import LoadedSessionsStore from "./loaded_sessions_store";
 
 /** DRM-related state that can be associated to a single HTMLMediaElement. */
 export interface IMediaElementMediaKeysInfos {
+  emeImplementation : IEmeApiImplementation;
+
   /** Last keySystemOptions used with that HTMLMediaElement. */
   keySystemOptions : IKeySystemOption;
 
diff --git a/src/core/decrypt/utils/persistent_sessions_store.ts b/src/core/decrypt/utils/persistent_sessions_store.ts
index 53ec5f994e..904f308d25 100644
--- a/src/core/decrypt/utils/persistent_sessions_store.ts
+++ b/src/core/decrypt/utils/persistent_sessions_store.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../../compat";
+import { ICustomMediaKeySession } from "../../../compat/eme";
 import log from "../../../log";
 import {
   IPersistentSessionInfo,
diff --git a/src/core/decrypt/utils/server_certificate_store.ts b/src/core/decrypt/utils/server_certificate_store.ts
index 98802c10f1..c239380ad5 100644
--- a/src/core/decrypt/utils/server_certificate_store.ts
+++ b/src/core/decrypt/utils/server_certificate_store.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeys } from "../../../compat";
+import { ICustomMediaKeys } from "../../../compat/eme";
 import hashBuffer from "../../../utils/hash_buffer";
 
 /**
diff --git a/src/core/init/directfile_content_initializer.ts b/src/core/init/directfile_content_initializer.ts
index 660c8c1792..1b34411fc3 100644
--- a/src/core/init/directfile_content_initializer.ts
+++ b/src/core/init/directfile_content_initializer.ts
@@ -103,10 +103,13 @@ export default class DirectFileContentInitializer extends ContentInitializer {
     decryptionRef.finish();
 
     const drmInitRef =
-      initializeContentDecryption(mediaElement, keySystems, decryptionRef, {
-        onError: (err) =>  this._onFatalError(err),
-        onWarning: (err : IPlayerError) => this.trigger("warning", err),
-      }, cancelSignal);
+      initializeContentDecryption(
+        mediaElement,
+        keySystems,
+        decryptionRef,
+        { onError: (err) =>  this._onFatalError(err),
+          onWarning: (err : IPlayerError) => this.trigger("warning", err) },
+        cancelSignal);
 
     /** Translate errors coming from the media element into RxPlayer errors. */
     listenToMediaError(mediaElement,
diff --git a/src/core/init/media_source_content_initializer.ts b/src/core/init/media_source_content_initializer.ts
index 8dd5c39fad..a49c3327ac 100644
--- a/src/core/init/media_source_content_initializer.ts
+++ b/src/core/init/media_source_content_initializer.ts
@@ -213,10 +213,13 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
       /** Initialize decryption capabilities. */
       const drmInitRef =
-        initializeContentDecryption(mediaElement, keySystems, protectionRef, {
-          onWarning: (err : IPlayerError) => this.trigger("warning", err),
-          onError: (err : Error) => this._onFatalError(err),
-        }, initCanceller.signal);
+        initializeContentDecryption(
+          mediaElement,
+          keySystems,
+          protectionRef,
+          { onWarning: (err : IPlayerError) => this.trigger("warning", err),
+            onError: (err : Error) => this._onFatalError(err) },
+          initCanceller.signal);
 
       drmInitRef.onUpdate((drmStatus, stopListeningToDrmUpdates) => {
         if (drmStatus.initializationState.type === "uninitialized") {
diff --git a/src/core/init/utils/initialize_content_decryption.ts b/src/core/init/utils/initialize_content_decryption.ts
index 9813e6791b..ca4f8d84e5 100644
--- a/src/core/init/utils/initialize_content_decryption.ts
+++ b/src/core/init/utils/initialize_content_decryption.ts
@@ -1,5 +1,5 @@
-import { hasEMEAPIs } from "../../../compat";
 import { EncryptedMediaError } from "../../../errors";
+import features from "../../../features";
 import log from "../../../log";
 import {
   IKeySystemOption,
@@ -12,7 +12,7 @@ import createSharedReference, {
 import TaskCanceller, {
   CancellationSignal,
 } from "../../../utils/task_canceller";
-import ContentDecryptor, {
+import {
   ContentDecryptorState,
   IContentProtection,
 } from "../../decrypt";
@@ -49,37 +49,9 @@ export default function initializeContentDecryption(
   cancelSignal : CancellationSignal
 ) : IReadOnlySharedReference<IDrmInitializationStatus> {
   if (keySystems.length === 0) {
-    protectionRef.onUpdate((data, stopListening) => {
-      if (data === null) { // initial value
-        return;
-      }
-      stopListening();
-      log.error("Init: Encrypted event but no `keySystems` given");
-      const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR",
-                                          "no `keySystems` given.");
-      callbacks.onError(err);
-    }, { clearSignal: cancelSignal });
-    const ref = createSharedReference({
-      initializationState: { type: "initialized" as const, value: null },
-      drmSystemId: undefined });
-    ref.finish(); // We know that no new value will be triggered
-    return ref;
-  } else if (!hasEMEAPIs()) {
-    protectionRef.onUpdate((data, stopListening) => {
-      if (data === null) { // initial value
-        return;
-      }
-      stopListening();
-      log.error("Init: Encrypted event but no EME API available");
-      const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR",
-                                          "Encryption APIs not found.");
-      callbacks.onError(err);
-    }, { clearSignal: cancelSignal });
-    const ref = createSharedReference({
-      initializationState: { type: "initialized" as const, value: null },
-      drmSystemId: undefined });
-    ref.finish(); // We know that no new value will be triggered
-    return ref;
+    return createEmeDisabledReference("No `keySystems` option given.");
+  } else if (features.decrypt === null) {
+    return createEmeDisabledReference("EME feature not activated.");
   }
 
   const decryptorCanceller = new TaskCanceller();
@@ -90,6 +62,11 @@ export default function initializeContentDecryption(
   }, cancelSignal);
 
   log.debug("Init: Creating ContentDecryptor");
+  const ContentDecryptor = features.decrypt;
+
+  if (!ContentDecryptor.hasEmeApis()) {
+    return createEmeDisabledReference("EME API not available on the current page.");
+  }
   const contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
 
   contentDecryptor.addEventListener("stateChange", (state) => {
@@ -136,6 +113,22 @@ export default function initializeContentDecryption(
   });
 
   return drmStatusRef;
+
+  function createEmeDisabledReference(errMsg : string) {
+    protectionRef.onUpdate((data, stopListening) => {
+      if (data === null) { // initial value
+        return;
+      }
+      stopListening();
+      const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
+      callbacks.onError(err);
+    }, { clearSignal: cancelSignal });
+    const ref = createSharedReference({
+      initializationState: { type: "initialized" as const, value: null },
+      drmSystemId: undefined });
+    ref.finish(); // We know that no new value will be triggered
+    return ref;
+  }
 }
 
 /** Status of content decryption initialization. */
diff --git a/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/DRMInfos.test.ts b/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/DRMInfos.test.ts
index f06860eb80..d8a95ab928 100644
--- a/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/DRMInfos.test.ts
+++ b/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/DRMInfos.test.ts
@@ -26,7 +26,7 @@ import { ProberStatus } from "../../types";
 
 
 describe("MediaCapabilitiesProber probers - DRMInfos", () => {
-  beforeEach(() => {
+  afterEach(() => {
     jest.resetModules();
   });
 
@@ -60,8 +60,9 @@ describe("MediaCapabilitiesProber probers - DRMInfos", () => {
         type: "clearkick",
       },
     };
-    jest.mock("../../../../../compat", () => ({
-      requestMediaKeySystemAccess: null,
+    jest.mock("../../../../../compat/eme", () => ({
+      _esModule: true,
+      default: {},
     }));
     const probeDRMInfos = jest.requireActual("../../probers/DRMInfos").default;
     /* eslint-disable @typescript-eslint/no-floating-promises */
@@ -82,11 +83,11 @@ describe("MediaCapabilitiesProber probers - DRMInfos", () => {
         getConfiguration: () => ({}),
       });
     });
-    jest.mock("../../../../../compat", () => ({
-      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    jest.mock("../../../../../compat/eme", () => ({
+      _esModule: true,
+      default: { requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess },
     }));
     const probeDRMInfos = jest.requireActual("../../probers/DRMInfos").default;
-    expect.assertions(2);
     probeDRMInfos(configuration)
       .then((res: unknown) => {
         expect(res).toEqual(
@@ -114,12 +115,12 @@ describe("MediaCapabilitiesProber probers - DRMInfos", () => {
         return Promise.reject(new Error());
       }
     );
-    jest.mock("../../../../../compat", () => ({
-      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    jest.mock("../../../../../compat/eme", () => ({
+      _esModule: true,
+      default: { requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess },
     }));
 
     const probeDRMInfos = jest.requireActual("../../probers/DRMInfos").default;
-    expect.assertions(2);
     probeDRMInfos(configuration)
       .then((res: unknown) => {
         expect(res).toEqual(
diff --git a/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/HDCPPolicy.test.ts b/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/HDCPPolicy.test.ts
index 40f4c5da90..ca1e7a6ef1 100644
--- a/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/HDCPPolicy.test.ts
+++ b/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/HDCPPolicy.test.ts
@@ -24,15 +24,19 @@
 
 import { ProberStatus } from "../../types";
 
+// TODO for whatever reason about which I spent too much time already,
+// `jest.mock` with `_esModule` set to `true` does not work as expected here
+// like it does on every other RxPlayer test file on the planet.
+// I chose to scrap that default import syntax in `jest.mock` just in this
+// file and make it as if compat/eme exported an object instead.
 
 describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
-  beforeEach(() => {
+  afterEach(() => {
     jest.resetModules();
   });
 
   it("should throw if no requestMediaKeySystemAccess", () => {
-    jest.mock("../../../../../compat", () => ({
-      requestMediaKeySystemAccess: null,
+    jest.mock("../../../../../compat/eme", () => ({
     }));
     const probeHDCPPolicy = jest.requireActual("../../probers/HDCPPolicy").default;
     /* eslint-disable @typescript-eslint/no-floating-promises */
@@ -42,8 +46,13 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
   });
 
   it("should throw if no hdcp attribute in config", () => {
-    jest.mock("../../../../../compat", () => ({
-      requestMediaKeySystemAccess: {},
+    const mockRequestMediaKeySystemAccess = jest.fn(() => {
+      return Promise.resolve({
+        getConfiguration: () => ({}),
+      });
+    });
+    jest.mock("../../../../../compat/eme", () => ({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
     }));
     const probeHDCPPolicy = jest.requireActual("../../probers/HDCPPolicy").default;
     /* eslint-disable @typescript-eslint/no-floating-promises */
@@ -63,13 +72,12 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
         createMediaKeys: mockCreateMediaKeys,
       });
     });
-    jest.mock("../../../../../compat", () => ({
+    jest.mock("../../../../../compat/eme", () => ({
       requestMediaKeySystemAccess: mockRequestMediaKeySystemAcces,
     }));
 
     const probeHDCPPolicy = jest.requireActual("../../probers/HDCPPolicy").default;
 
-    expect.assertions(3);
     probeHDCPPolicy({ hdcp: "1.1" })
       .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.Unknown);
@@ -77,8 +85,9 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
         expect(mockRequestMediaKeySystemAcces).toHaveBeenCalledTimes(1);
         done();
       })
-      .catch(() => {
-        done();
+      .catch((err: unknown) => {
+        // eslint-disable-next-line no-console
+        console.error(err);
       });
   });
 
@@ -93,13 +102,12 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
         createMediaKeys: mockCreateMediaKeys,
       });
     });
-    jest.mock("../../../../../compat", () => ({
+    jest.mock("../../../../../compat/eme", () => ({
       requestMediaKeySystemAccess: mockRequestMediaKeySystemAcces,
     }));
 
     const probeHDCPPolicy = jest.requireActual("../../probers/HDCPPolicy").default;
 
-    expect.assertions(3);
     probeHDCPPolicy({ hdcp: "1.1" })
       .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.Supported);
@@ -107,8 +115,9 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
         expect(mockRequestMediaKeySystemAcces).toHaveBeenCalledTimes(1);
         done();
       })
-      .catch(() => {
-        done();
+      .catch((err: unknown) => {
+        // eslint-disable-next-line no-console
+        console.error(err);
       });
   });
 
@@ -123,13 +132,11 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
         createMediaKeys: mockCreateMediaKeys,
       });
     });
-    jest.mock("../../../../../compat", () => ({
+    jest.mock("../../../../../compat/eme", () => ({
       requestMediaKeySystemAccess: mockRequestMediaKeySystemAcces,
     }));
 
     const probeHDCPPolicy = jest.requireActual("../../probers/HDCPPolicy").default;
-
-    expect.assertions(3);
     probeHDCPPolicy({ hdcp: "1.1" })
       .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.NotSupported);
@@ -137,8 +144,9 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
         expect(mockRequestMediaKeySystemAcces).toHaveBeenCalledTimes(1);
         done();
       })
-      .catch(() => {
-        done();
+      .catch((err: unknown) => {
+        // eslint-disable-next-line no-console
+        console.error(err);
       });
   });
 });
diff --git a/src/experimental/tools/mediaCapabilitiesProber/api/index.ts b/src/experimental/tools/mediaCapabilitiesProber/api/index.ts
index b62d8e6090..06bf2993f6 100644
--- a/src/experimental/tools/mediaCapabilitiesProber/api/index.ts
+++ b/src/experimental/tools/mediaCapabilitiesProber/api/index.ts
@@ -73,7 +73,7 @@ const mediaCapabilitiesProber = {
   /**
    * Get HDCP status. Evaluates if current equipement support given
    * HDCP revision.
-   * @param {string}
+   * @param {string} hdcp
    * @returns {Promise}
    */
   getStatusForHDCP(hdcp: string) : Promise<string> {
@@ -171,9 +171,7 @@ const mediaCapabilitiesProber = {
    * @param {Object} displayConfig
    * @returns {Promise}
    */
-  getDisplayCapabilities(
-    displayConfig: IDisplayConfiguration
-  ) : Promise<string> {
+  getDisplayCapabilities(displayConfig: IDisplayConfiguration) : Promise<string> {
     const config = { display: displayConfig };
     const browserAPIS: IBrowserAPIS[] = [
       "matchMedia",
diff --git a/src/experimental/tools/mediaCapabilitiesProber/api/probeMediaConfiguration.ts b/src/experimental/tools/mediaCapabilitiesProber/api/probeMediaConfiguration.ts
index 62231ac6d8..bbc92c9034 100644
--- a/src/experimental/tools/mediaCapabilitiesProber/api/probeMediaConfiguration.ts
+++ b/src/experimental/tools/mediaCapabilitiesProber/api/probeMediaConfiguration.ts
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 import getProbedConfiguration, { ICapabilitiesTypes } from "../capabilities";
 import log from "../log";
 import probers, {
@@ -53,11 +54,12 @@ export interface IProbedMediaConfiguration {
  * "Not Supported").
  *
  * @param {Object} config
- * @param {Array.<Object>} browserAPIs
+ * @param {Array.<Object>} browserAPIS
  * @returns {Promise}
  */
 function probeMediaConfiguration(
-  config: IMediaConfiguration, browserAPIS: IBrowserAPIS[]
+  config: IMediaConfiguration,
+  browserAPIS: IBrowserAPIS[]
 ): Promise<IProbedMediaConfiguration> {
   let globalStatus : ProberStatus|undefined;
   const resultsFromAPIS: Array<{
@@ -68,7 +70,7 @@ function probeMediaConfiguration(
   for (const browserAPI of browserAPIS) {
     const probeWithBrowser = probers[browserAPI];
     if (probeWithBrowser !== undefined) {
-      promises.push(probeWithBrowser(config).then(([currentStatus, result]) => {
+      const prom = probeWithBrowser(config).then(([currentStatus, result]) => {
         resultsFromAPIS.push({ APIName: browserAPI, result });
 
         if (globalStatus == null) {
@@ -97,7 +99,8 @@ function probeMediaConfiguration(
         if (error instanceof Error) {
           log.debug(error.message);
         }
-      }));
+      });
+      promises.push(prom);
     }
   }
 
diff --git a/src/experimental/tools/mediaCapabilitiesProber/probers/DRMInfos.ts b/src/experimental/tools/mediaCapabilitiesProber/probers/DRMInfos.ts
index 1a1532dc23..ef0b4d7f55 100644
--- a/src/experimental/tools/mediaCapabilitiesProber/probers/DRMInfos.ts
+++ b/src/experimental/tools/mediaCapabilitiesProber/probers/DRMInfos.ts
@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-import { requestMediaKeySystemAccess } from "../../../../compat";
+import eme from "../../../../compat/eme";
+import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import log from "../log";
 import {
   ICompatibleKeySystem,
@@ -28,7 +29,7 @@ export interface IMediaKeySystemInfos {
 }
 
 /**
- * @param {Object} config
+ * @param {Object} mediaConfig
  * @returns {Promise}
  */
 export default function probeDRMInfos(
@@ -45,7 +46,7 @@ export default function probeDRMInfos(
                                                                 keySystem.configuration;
   const result: ICompatibleKeySystem = { type, configuration };
 
-  if (requestMediaKeySystemAccess == null) {
+  if (isNullOrUndefined(eme.requestMediaKeySystemAccess)) {
     log.debug("MediaCapabilitiesProber >>> API_CALL: " +
       "Your browser has no API to request a media key system access.");
     // In that case, the API lack means that no EME workflow may be started.
@@ -53,7 +54,7 @@ export default function probeDRMInfos(
     return Promise.resolve([ProberStatus.NotSupported, result]);
   }
 
-  return requestMediaKeySystemAccess(type, [configuration])
+  return eme.requestMediaKeySystemAccess(type, [configuration])
     .then((keySystemAccess) => {
       result.compatibleConfiguration = keySystemAccess.getConfiguration();
       const status : [ProberStatus, ICompatibleKeySystem?] =
diff --git a/src/experimental/tools/mediaCapabilitiesProber/probers/HDCPPolicy.ts b/src/experimental/tools/mediaCapabilitiesProber/probers/HDCPPolicy.ts
index bafcc3c42a..6a3a123b6c 100644
--- a/src/experimental/tools/mediaCapabilitiesProber/probers/HDCPPolicy.ts
+++ b/src/experimental/tools/mediaCapabilitiesProber/probers/HDCPPolicy.ts
@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-import { requestMediaKeySystemAccess } from "../../../../compat";
+import eme from "../../../../compat/eme";
+import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import {
   IMediaConfiguration,
   ProberStatus,
@@ -36,7 +37,7 @@ export type IMediaKeyStatus =
 export default function probeHDCPPolicy(
   config: IMediaConfiguration
 ): Promise<[ProberStatus]> {
-  if (requestMediaKeySystemAccess == null) {
+  if (isNullOrUndefined(eme.requestMediaKeySystemAccess)) {
     return Promise.reject("MediaCapabilitiesProber >>> API_CALL: " +
       "API not available");
   }
@@ -59,7 +60,7 @@ export default function probeHDCPPolicy(
     }],
   };
 
-  return requestMediaKeySystemAccess(keySystem, [drmConfig])
+  return eme.requestMediaKeySystemAccess(keySystem, [drmConfig])
     .then((mediaKeysSystemAccess) => {
       return mediaKeysSystemAccess.createMediaKeys().then((mediaKeys) => {
         if (!("getStatusForPolicy" in mediaKeys)) {
diff --git a/src/features/__tests__/initialize_features.test.ts b/src/features/__tests__/initialize_features.test.ts
index ebe96dc233..80ba481f27 100644
--- a/src/features/__tests__/initialize_features.test.ts
+++ b/src/features/__tests__/initialize_features.test.ts
@@ -95,7 +95,7 @@ describe("Features - initializeFeaturesObject", () => {
       nativeTextTracksParsers: {},
       htmlTextTracksBuffer: null,
       htmlTextTracksParsers: {},
-      ContentDecryptor: null,
+      decrypt: null,
       directfile: null,
     };
     jest.mock("../features_object", () => ({
@@ -115,7 +115,7 @@ describe("Features - initializeFeaturesObject", () => {
         js: jest.requireActual("../../parsers/manifest/dash/js-parser").default,
         wasm: null,
       },
-      ContentDecryptor: jest.requireActual("../../core/decrypt/index").default,
+      decrypt: jest.requireActual("../../core/decrypt/index").default,
       createDebugElement: jest.requireActual("../../core/api/debug").default,
       directfile: {
         initDirectFile: jest.requireActual("../../core/init/directfile_content_initializer").default,
diff --git a/src/features/features_object.ts b/src/features/features_object.ts
index f0103b360c..59a228a8a4 100644
--- a/src/features/features_object.ts
+++ b/src/features/features_object.ts
@@ -24,7 +24,7 @@ const features : IFeaturesObject = { dashParsers: { wasm: null,
                                                     js: null },
                                      createDebugElement: null,
                                      directfile: null,
-                                     ContentDecryptor: null,
+                                     decrypt: null,
                                      htmlTextTracksBuffer: null,
                                      htmlTextTracksParsers: {},
                                      imageBuffer: null,
diff --git a/src/features/initialize_features.ts b/src/features/initialize_features.ts
index caef3da808..a87fe638ad 100644
--- a/src/features/initialize_features.ts
+++ b/src/features/initialize_features.ts
@@ -27,7 +27,7 @@ import features from "./features_object";
  */
 export default function initializeFeaturesObject() : void {
   if (__FEATURES__.EME === __FEATURES__.IS_ENABLED as number) {
-    features.ContentDecryptor = require("../core/decrypt/index.ts").default;
+    features.decrypt = require("../core/decrypt/index.ts").default;
   }
 
   if (__FEATURES__.BIF_PARSER === __FEATURES__.IS_ENABLED as number) {
diff --git a/src/features/list/__tests__/eme.test.ts b/src/features/list/__tests__/eme.test.ts
index 00c668721a..258feefa91 100644
--- a/src/features/list/__tests__/eme.test.ts
+++ b/src/features/list/__tests__/eme.test.ts
@@ -30,7 +30,7 @@ describe("Features list - EME", () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const featureObject : any = {};
     addEMEFeature(featureObject);
-    expect(featureObject).toEqual({ ContentDecryptor });
-    expect(featureObject.ContentDecryptor).toBe(ContentDecryptor);
+    expect(featureObject).toEqual({ decrypt: ContentDecryptor });
+    expect(featureObject.decrypt).toBe(ContentDecryptor);
   });
 });
diff --git a/src/features/list/eme.ts b/src/features/list/eme.ts
index cdc17ae893..02e2bfab30 100644
--- a/src/features/list/eme.ts
+++ b/src/features/list/eme.ts
@@ -22,7 +22,7 @@ import { IFeaturesObject } from "../types";
  * @param {Object} features
  */
 function addEMEFeature(features : IFeaturesObject) : void {
-  features.ContentDecryptor = ContentDecryptor;
+  features.decrypt = ContentDecryptor;
 }
 
 export { addEMEFeature as EME };
diff --git a/src/features/types.ts b/src/features/types.ts
index 3fbeff7fec..bcc647f7af 100644
--- a/src/features/types.ts
+++ b/src/features/types.ts
@@ -79,7 +79,7 @@ export interface IFeaturesObject {
   directfile : { initDirectFile: IDirectFileInit;
                  mediaElementTrackChoiceManager : IMediaElementTrackChoiceManager; } |
                null;
-  ContentDecryptor : IContentDecryptorClass|null;
+  decrypt : IContentDecryptorClass | null;
   createDebugElement : (
     (
       parentElt : HTMLElement,
diff --git a/src/public_types.ts b/src/public_types.ts
index 1a8c79a5dc..c1cd6a919f 100644
--- a/src/public_types.ts
+++ b/src/public_types.ts
@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "./compat";
+import {
+  IPreferredEmeApiType ,
+  ICustomMediaKeySession,
+} from "./compat/eme";
 import {
   IPersistentSessionInfoV0,
   IPersistentSessionInfoV1,
@@ -36,6 +39,8 @@ import { IMetaPlaylist } from "./parsers/manifest/metaplaylist/metaplaylist_pars
 
 export { IMediaErrorTrackContext };
 
+export { IPreferredEmeApiType };
+
 /**
  * This file defines and exports types we want to expose to library users.
  * Those types are considered as part of the API.
diff --git a/src/utils/wrapInPromise.ts b/src/utils/wrapInPromise.ts
new file mode 100644
index 0000000000..e249630d51
--- /dev/null
+++ b/src/utils/wrapInPromise.ts
@@ -0,0 +1,24 @@
+/**
+ * Force function output to be wrapped in a Promise instance, which also rejects
+ * if the function call threw.
+ * @param {Function} val
+ * @returns {Promise}
+ */
+export default function wrapInPromise<T>(
+  val: () => (T | Promise<T>)
+) : Promise<T> {
+  try {
+    const ret = val();
+    if (
+      typeof ret === "object" &&
+      ret !== null &&
+      typeof (ret as Promise<T>).then === "function"
+    ) {
+      return ret as Promise<T>;
+    } else {
+      return Promise.resolve(ret);
+    }
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}