rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/src/compat/eme/eme-api-implementation.ts

@@ -0,0 +1,319 @@
+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 globalScope from "../global_scope";
+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 = globalScope.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);
+  }
+}

package/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,
 };

package/src/compat/event_listeners.ts

@@ -20,7 +20,7 @@ import { IEventEmitter } from "../utils/event_emitter";
 import isNonEmptyString from "../utils/is_non_empty_string";
 import isNullOrUndefined from "../utils/is_null_or_undefined";
 import noop from "../utils/noop";
-import createSharedReference, {
+import SharedReference, {
   IReadOnlySharedReference,
 } from "../utils/reference";
 import { CancellationSignal } from "../utils/task_canceller";
@@ -29,7 +29,7 @@ import {
   ICompatHTMLMediaElement,
   ICompatPictureInPictureWindow,
 } from "./browser_compatibility_types";
-import shouldFavourCustomSafariEME from "./should_favour_custom_safari_EME";
+import globalScope from "./global_scope";
 
 const BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
 
@@ -125,7 +125,7 @@ function createCompatibleEventListener(
 
     // if the element is a HTMLElement we can detect
     // the supported event, and memoize it in `mem`
-    if (element instanceof HTMLElement) {
+    if (typeof HTMLElement !== "undefined" && element instanceof HTMLElement) {
       if (typeof mem === "undefined") {
         mem = findSupportedEvent(element, prefixedEvents);
       }
@@ -138,7 +138,7 @@ function createCompatibleEventListener(
           }
         });
       } else {
-        if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+        if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
           log.warn(`compat: element ${element.tagName}` +
                    " does not support any of these events: " +
                    prefixedEvents.join(", "));
@@ -188,26 +188,26 @@ function getDocumentVisibilityRef(
   let prefix : string|undefined;
 
   const doc = document as ICompatDocument;
-  if (doc.hidden != null) {
+  if (!isNullOrUndefined(doc.hidden)) {
     prefix = "";
-  } else if (doc.mozHidden != null) {
+  } else if (!isNullOrUndefined(doc.mozHidden)) {
     prefix = "moz";
-  } else if (doc.msHidden != null) {
+  } else if (!isNullOrUndefined(doc.msHidden)) {
     prefix = "ms";
-  } else if (doc.webkitHidden != null) {
+  } else if (!isNullOrUndefined(doc.webkitHidden)) {
     prefix = "webkit";
   }
 
-  const hidden = isNonEmptyString(prefix) ? prefix + "Hidden" :
+  const hidden = isNonEmptyString(prefix) ? (prefix + "Hidden" as "hidden") :
                                             "hidden";
   const visibilityChangeEvent = isNonEmptyString(prefix) ? prefix + "visibilitychange" :
                                                            "visibilitychange";
 
-  const isHidden = document[hidden as "hidden"];
-  const ref = createSharedReference(!isHidden, stopListening);
+  const isHidden = document[hidden];
+  const ref = new SharedReference(!isHidden, stopListening);
 
   addEventListener(document, visibilityChangeEvent, () => {
-    const isVisible = !(document[hidden as "hidden"]);
+    const isVisible = !(document[hidden]);
     ref.setValueIfChanged(isVisible);
   }, stopListening);
 
@@ -241,7 +241,7 @@ function getPictureOnPictureStateRef(
   {
     const isWebKitPIPEnabled =
       mediaElement.webkitPresentationMode === "picture-in-picture";
-    const ref = createSharedReference<IPictureInPictureEvent>({
+    const ref = new SharedReference<IPictureInPictureEvent>({
       isEnabled: isWebKitPIPEnabled,
       pipWindow: null,
     }, stopListening);
@@ -255,9 +255,9 @@ function getPictureOnPictureStateRef(
   const isPIPEnabled = (
     (document as ICompatDocument).pictureInPictureElement === mediaElement
   );
-  const ref = createSharedReference<IPictureInPictureEvent>({ isEnabled: isPIPEnabled,
-                                                              pipWindow: null },
-                                                            stopListening);
+  const ref = new SharedReference<IPictureInPictureEvent>({ isEnabled: isPIPEnabled,
+                                                            pipWindow: null },
+                                                          stopListening);
   addEventListener(mediaElement, "enterpictureinpicture", (evt) => {
     ref.setValue({
       isEnabled: true,
@@ -288,7 +288,7 @@ function getVideoVisibilityRef(
 ) : IReadOnlySharedReference<boolean> {
   const isDocVisibleRef = getDocumentVisibilityRef(stopListening);
   let currentTimeout : number | undefined;
-  const ref = createSharedReference(true, stopListening);
+  const ref = new SharedReference(true, stopListening);
   stopListening.register(() => {
     clearTimeout(currentTimeout);
     currentTimeout = undefined;
@@ -308,7 +308,7 @@ function getVideoVisibilityRef(
       ref.setValueIfChanged(true);
     } else {
       const { INACTIVITY_DELAY } = config.getCurrent();
-      currentTimeout = window.setTimeout(() => {
+      currentTimeout = setTimeout(() => {
         ref.setValueIfChanged(false);
       }, INACTIVITY_DELAY);
     }
@@ -325,18 +325,18 @@ function getScreenResolutionRef(
 ) : IReadOnlySharedReference<{ width : number | undefined;
                                height : number | undefined;
                                pixelRatio : number; }> {
-  const pixelRatio = window.devicePixelRatio == null ||
-                     window.devicePixelRatio === 0 ? 1 :
-                                                     window.devicePixelRatio;
-  const ref = createSharedReference<{
+  const pixelRatio = globalScope.devicePixelRatio == null ||
+                     globalScope.devicePixelRatio === 0 ? 1 :
+                                                          globalScope.devicePixelRatio;
+  const ref = new SharedReference<{
     width : number | undefined;
     height : number | undefined;
     pixelRatio : number;
-  }>({ width: window.screen.width,
-       height: window.screen.height,
+  }>({ width: globalScope.screen?.width,
+       height: globalScope.screen?.height,
        pixelRatio },
      stopListening);
-  const interval = window.setInterval(checkScreenResolution, 20000);
+  const interval = setInterval(checkScreenResolution, 20000);
   stopListening.register(function stopUpdating() {
     clearInterval(interval);
   });
@@ -370,10 +370,10 @@ function getElementResolutionRef(
                                height : number | undefined;
                                pixelRatio : number; }> {
 
-  const pixelRatio = window.devicePixelRatio == null ||
-                     window.devicePixelRatio === 0 ? 1 :
-                                                     window.devicePixelRatio;
-  const ref = createSharedReference<{
+  const pixelRatio = globalScope.devicePixelRatio == null ||
+                     globalScope.devicePixelRatio === 0 ? 1 :
+                                                          globalScope.devicePixelRatio;
+  const ref = new SharedReference<{
     width : number | undefined;
     height : number | undefined;
     pixelRatio : number;
@@ -383,7 +383,7 @@ function getElementResolutionRef(
      stopListening);
   let clearPreviousEventListener = noop;
   pipStatusRef.onUpdate(checkElementResolution, { clearSignal: stopListening });
-  addEventListener(window, "resize", checkElementResolution, stopListening);
+  addEventListener(globalScope, "resize", checkElementResolution, stopListening);
   addEventListener(mediaElement,
                    "enterpictureinpicture",
                    checkElementResolution,
@@ -392,7 +392,7 @@ function getElementResolutionRef(
                    "leavepictureinpicture",
                    checkElementResolution,
                    stopListening);
-  const interval = window.setInterval(checkElementResolution, 20000);
+  const interval = setInterval(checkElementResolution, 20000);
 
   checkElementResolution();
 
@@ -506,13 +506,6 @@ const onSourceBufferUpdate = createCompatibleEventListener(["update"]);
  */
 const onRemoveSourceBuffers = createCompatibleEventListener(["removesourcebuffer"]);
 
-/**
- * @param {HTMLMediaElement} mediaElement
- */
-const onEncrypted = createCompatibleEventListener(
-  shouldFavourCustomSafariEME() ? ["needkey"] :
-                                  ["encrypted", "needkey"]);
-
 /**
  * @param {MediaKeySession} mediaKeySession
  */
@@ -572,11 +565,11 @@ function addEventListener(
 
 export {
   addEventListener,
+  createCompatibleEventListener,
   getPictureOnPictureStateRef,
   getVideoVisibilityRef,
   getElementResolutionRef,
   getScreenResolutionRef,
-  onEncrypted,
   onEnded,
   onKeyAdded,
   onKeyError,

package/src/compat/global_scope.ts

@@ -0,0 +1,18 @@
+import isNode from "./is_node";
+import isWorker from "./is_worker";
+
+declare const global: typeof self;
+
+/**
+ * The current environment's global object, written in such a way to maximize
+ * compatibility.
+ *
+ * Though the RxPlayer should theoretically not be runnable in NodeJS, we still
+ * had to support it for some applications implementing server-side rendering.
+ */
+const globalScope : typeof globalThis =
+  isWorker ? self :
+  isNode   ? global :
+             window;
+
+export default globalScope;

package/src/compat/index.ts

@@ -27,22 +27,9 @@ 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 getStartDate from "./get_start_date";
-import hasEMEAPIs from "./has_eme_apis";
 import isCodecSupported from "./is_codec_supported";
 import isNode from "./is_node";
 import isVTTCue from "./is_vtt_cue";
@@ -55,6 +42,7 @@ import shouldRenewMediaKeySystemAccess from "./should_renew_media_key_system_acc
 import shouldUnsetMediaKeys from "./should_unset_media_keys";
 import shouldValidateMetadata from "./should_validate_metadata";
 import shouldWaitForDataBeforeLoaded from "./should_wait_for_data_before_loaded";
+import shouldWaitForHaveEnoughData from "./should_wait_for_have_enough_data";
 
 // TODO To remove. This seems to be the only side-effect done on import, which
 // we  would prefer to disallow (both for the understandability of the code and
@@ -67,33 +55,23 @@ export {
   canPatchISOBMFFSegment,
   canReuseMediaKeys,
   clearElementSrc,
-  closeSession,
-  CustomMediaKeySystemAccess,
   enableAudioTrack,
   events,
-  generateKeyRequest,
-  getInitData,
   getStartDate,
-  hasEMEAPIs,
   ICompatTextTrack,
   ICompatVTTCue,
-  ICustomMediaKeySession,
-  ICustomMediaKeySystemAccess,
-  ICustomMediaKeys,
   ICompatSourceBuffer,
   isCodecSupported,
   isNode,
   isVTTCue,
-  loadSession,
   makeVTTCue,
   MediaSource_,
   onHeightWidthChange,
-  requestMediaKeySystemAccess,
-  setMediaKeys,
   shouldReloadMediaSourceOnDecipherabilityUpdate,
   shouldRenewMediaKeySystemAccess,
   shouldUnsetMediaKeys,
   shouldValidateMetadata,
   shouldWaitForDataBeforeLoaded,
+  shouldWaitForHaveEnoughData,
   tryToChangeSourceBufferType,
 };

package/src/compat/is_debug_mode_enabled.ts

@@ -0,0 +1,12 @@
+/* eslint-disable-next-line @typescript-eslint/naming-convention */
+declare const __RX_PLAYER_DEBUG_MODE__ : boolean | undefined;
+
+/**
+ * Some external tools set that boolean, in which case, we should enable DEBUG
+ * logs and various tricks to make as much logs as available to those tools.
+ *
+ * @returns {boolean}
+ */
+export default function isDebugModeEnabled(): boolean {
+  return typeof __RX_PLAYER_DEBUG_MODE__ === "boolean" && __RX_PLAYER_DEBUG_MODE__;
+}

package/src/compat/is_node.ts

@@ -14,5 +14,8 @@
  * limitations under the License.
  */
 
-const isNode = typeof window === "undefined";
+import isWorker from "./is_worker";
+
+/** `true` if we're currently in a Node.JS environment. */
+const isNode = typeof window === "undefined" && !isWorker;
 export default isNode;

package/src/compat/is_vtt_cue.ts

@@ -15,6 +15,7 @@
  */
 
 import { ICompatVTTCue } from "./browser_compatibility_types";
+import globalScope from "./global_scope";
 
 /**
  * Returns true if the given cue is an instance of a VTTCue.
@@ -25,6 +26,6 @@ export default function isVTTCue(
   cue : ICompatVTTCue|TextTrackCue
 ) : cue is ICompatVTTCue {
   /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-  return typeof window.VTTCue === "function" && cue instanceof window.VTTCue;
+  return typeof globalScope.VTTCue === "function" && cue instanceof globalScope.VTTCue;
   /* eslint-enable @typescript-eslint/no-unsafe-member-access */
 }