rx-player 3.31.1-dev.2023070500 → 3.32.0-dev.2023092900

package/dist/_esm5.processed/compat/eme/eme-api-implementation.js

@@ -0,0 +1,198 @@
+import { MediaError } from "../../errors";
+import assert from "../../utils/assert";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import { isIE11 } from "../browser_detection";
+import { createCompatibleEventListener } 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 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.
+ */
+var defaultEmeImplementation = getEmeApiImplementation("auto");
+export default defaultEmeImplementation;
+/**
+ * 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) {
+    var requestMediaKeySystemAccess;
+    var onEncrypted;
+    var setMediaKeys = defaultSetMediaKeys;
+    var implementation;
+    if ((preferredApiType === "standard" ||
+        (preferredApiType === "auto" && !shouldFavourCustomSafariEME())) &&
+        (
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        isNode || !isNullOrUndefined(navigator.requestMediaKeySystemAccess))) {
+        requestMediaKeySystemAccess = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return navigator.requestMediaKeySystemAccess.apply(navigator, args);
+        };
+        onEncrypted = createCompatibleEventListener(["encrypted"]);
+        implementation = "standard";
+    }
+    else {
+        var isTypeSupported_1;
+        var createCustomMediaKeys_1;
+        if (preferredApiType === "webkit" && WebKitMediaKeysConstructor !== undefined) {
+            onEncrypted = createCompatibleEventListener(["needkey"]);
+            var callbacks = getWebKitMediaKeysCallbacks();
+            isTypeSupported_1 = callbacks.isTypeSupported;
+            createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
+            setMediaKeys = callbacks.setMediaKeys;
+            implementation = "webkit";
+        }
+        else {
+            // This is for Chrome with unprefixed EME api
+            if (isOldWebkitMediaElement(HTMLVideoElement.prototype)) {
+                onEncrypted = createCompatibleEventListener(["needkey"]);
+                var callbacks = getOldKitWebKitMediaKeyCallbacks();
+                isTypeSupported_1 = callbacks.isTypeSupported;
+                createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
+                setMediaKeys = callbacks.setMediaKeys;
+                implementation = "older-webkit";
+                // This is for WebKit with prefixed EME api
+            }
+            else if (WebKitMediaKeysConstructor !== undefined) {
+                onEncrypted = createCompatibleEventListener(["needkey"]);
+                var callbacks = getWebKitMediaKeysCallbacks();
+                isTypeSupported_1 = callbacks.isTypeSupported;
+                createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
+                setMediaKeys = callbacks.setMediaKeys;
+                implementation = "webkit";
+            }
+            else if (isIE11 && MSMediaKeysConstructor !== undefined) {
+                onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
+                var callbacks = getIE11MediaKeysCallbacks();
+                isTypeSupported_1 = callbacks.isTypeSupported;
+                createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
+                setMediaKeys = callbacks.setMediaKeys;
+                implementation = "ms";
+            }
+            else if (MozMediaKeysConstructor !== undefined) {
+                onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
+                var callbacks = getMozMediaKeysCallbacks();
+                isTypeSupported_1 = callbacks.isTypeSupported;
+                createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
+                setMediaKeys = callbacks.setMediaKeys;
+                implementation = "moz";
+            }
+            else {
+                onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
+                var MK_1 = window.MediaKeys;
+                var checkForStandardMediaKeys_1 = function () {
+                    if (MK_1 === undefined) {
+                        throw new MediaError("MEDIA_KEYS_NOT_SUPPORTED", "No `MediaKeys` implementation found " +
+                            "in the current browser.");
+                    }
+                    if (typeof MK_1.isTypeSupported === "undefined") {
+                        var 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_1 = function (keyType) {
+                    checkForStandardMediaKeys_1();
+                    assert(typeof MK_1.isTypeSupported === "function");
+                    return MK_1.isTypeSupported(keyType);
+                };
+                createCustomMediaKeys_1 = function (keyType) {
+                    checkForStandardMediaKeys_1();
+                    return new MK_1(keyType);
+                };
+                implementation = "unknown";
+            }
+        }
+        requestMediaKeySystemAccess = function (keyType, keySystemConfigurations) {
+            if (!isTypeSupported_1(keyType)) {
+                return Promise.reject(new Error("Unsupported key type"));
+            }
+            for (var i = 0; i < keySystemConfigurations.length; i++) {
+                var keySystemConfiguration = keySystemConfigurations[i];
+                var videoCapabilities = keySystemConfiguration.videoCapabilities, audioCapabilities = keySystemConfiguration.audioCapabilities, initDataTypes = keySystemConfiguration.initDataTypes, distinctiveIdentifier = keySystemConfiguration.distinctiveIdentifier;
+                var supported = true;
+                supported = supported &&
+                    (initDataTypes == null ||
+                        initDataTypes.some(function (idt) { return idt === "cenc"; }));
+                supported = supported && (distinctiveIdentifier !== "required");
+                if (supported) {
+                    var keySystemConfigurationResponse = {
+                        initDataTypes: ["cenc"],
+                        distinctiveIdentifier: "not-allowed",
+                        persistentState: "required",
+                        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
+                    var customMediaKeys = createCustomMediaKeys_1(keyType);
+                    return Promise.resolve(new CustomMediaKeySystemAccess(keyType, customMediaKeys, keySystemConfigurationResponse));
+                }
+            }
+            return Promise.reject(new Error("Unsupported configuration"));
+        };
+    }
+    return { requestMediaKeySystemAccess: requestMediaKeySystemAccess, onEncrypted: onEncrypted, setMediaKeys: setMediaKeys, implementation: 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, mediaKeys) {
+    try {
+        var ret = void 0;
+        var elt = mediaElement;
+        /* eslint-disable @typescript-eslint/unbound-method */
+        if (typeof elt.setMediaKeys === "function") {
+            ret = elt.setMediaKeys(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.then === "function") {
+            return ret;
+        }
+        else {
+            return Promise.resolve(ret);
+        }
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+}

package/dist/_esm5.processed/compat/eme/index.d.ts

@@ -14,9 +14,11 @@
  * limitations under the License.
  */
 import closeSession from "./close_session";
-import CustomMediaKeySystemAccess, { ICustomMediaKeySystemAccess } from "./custom_key_system_access";
-import { ICustomMediaKeys, ICustomMediaKeySession, requestMediaKeySystemAccess, setMediaKeys } from "./custom_media_keys";
+import { ICustomMediaKeySystemAccess } from "./custom_key_system_access";
+import { ICustomMediaKeys, ICustomMediaKeySession } 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 { closeSession, CustomMediaKeySystemAccess, generateKeyRequest, getInitData, loadSession, ICustomMediaKeySession, ICustomMediaKeySystemAccess, ICustomMediaKeys, IEncryptedEventData, requestMediaKeySystemAccess, setMediaKeys, };
+export default defaultEmeImplementation;
+export { closeSession, generateKeyRequest, getInitData, loadSession, IEmeApiImplementation, IPreferredEmeApiType, ICustomMediaKeySession, ICustomMediaKeySystemAccess, ICustomMediaKeys, IEncryptedEventData, };

package/dist/_esm5.processed/compat/eme/index.js

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 import closeSession from "./close_session";
-import CustomMediaKeySystemAccess from "./custom_key_system_access";
-import { requestMediaKeySystemAccess, setMediaKeys, } from "./custom_media_keys";
+import defaultEmeImplementation from "./eme-api-implementation";
 import generateKeyRequest from "./generate_key_request";
 import getInitData from "./get_init_data";
 import loadSession from "./load_session";
-export { closeSession, CustomMediaKeySystemAccess, generateKeyRequest, getInitData, loadSession, requestMediaKeySystemAccess, setMediaKeys, };
+export default defaultEmeImplementation;
+export { closeSession, generateKeyRequest, getInitData, loadSession, };

package/dist/_esm5.processed/compat/event_listeners.d.ts

@@ -22,6 +22,18 @@ export interface IEventEmitterLike {
     removeEventListener: (eventName: string, handler: () => void) => void;
 }
 export type IEventTargetLike = HTMLElement | IEventEmitterLike | IEventEmitter<unknown>;
+/**
+ * Returns a function allowing to add event listeners for particular event(s)
+ * optionally automatically adding browser prefixes if needed.
+ * @param {Array.<string>} eventNames - The event(s) to listen to. If multiple
+ * events are set, the event listener will be triggered when any of them emits.
+ * @param {Array.<string>|undefined} [prefixes] - Optional vendor prefixes with
+ * which the event might also be sent. If not defined, default prefixes might be
+ * tested.
+ * @returns {Function} - Returns function allowing to easily add a callback to
+ * be triggered when that event is emitted on a given event target.
+ */
+declare function createCompatibleEventListener(eventNames: string[], prefixes?: string[]): (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * Returns a reference:
  *   - Set to `true` when the current page is considered visible and active.
@@ -112,10 +124,6 @@ declare const onSourceBufferUpdate: (element: IEventTargetLike, listener: (event
  * @param {Object} cancelSignal
  */
 declare const onRemoveSourceBuffers: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
-/**
- * @param {HTMLMediaElement} mediaElement
- */
-declare const onEncrypted: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {MediaKeySession} mediaKeySession
  */
@@ -155,4 +163,4 @@ declare const onEnded: (element: IEventTargetLike, listener: (event?: unknown) =
  * emits
  */
 declare function addEventListener(elt: IEventEmitterLike, evt: string, listener: (x?: unknown) => void, stopListening: CancellationSignal): void;
-export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted, onEnded, onFullscreenChange, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };
+export { addEventListener, createCompatibleEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEnded, onFullscreenChange, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };

package/dist/_esm5.processed/compat/event_listeners.js

@@ -18,9 +18,8 @@ import log from "../log";
 import isNonEmptyString from "../utils/is_non_empty_string";
 import isNullOrUndefined from "../utils/is_null_or_undefined";
 import noop from "../utils/noop";
-import createSharedReference from "../utils/reference";
+import SharedReference from "../utils/reference";
 import isNode from "./is_node";
-import shouldFavourCustomSafariEME from "./should_favour_custom_safari_EME";
 var BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
 var pixelRatio = isNode ||
     window.devicePixelRatio == null ||
@@ -160,7 +159,7 @@ function getDocumentVisibilityRef(stopListening) {
     var visibilityChangeEvent = isNonEmptyString(prefix) ? prefix + "visibilitychange" :
         "visibilitychange";
     var isHidden = document[hidden];
-    var ref = createSharedReference(!isHidden, stopListening);
+    var ref = new SharedReference(!isHidden, stopListening);
     addEventListener(document, visibilityChangeEvent, function () {
         var isVisible = !(document[hidden]);
         ref.setValueIfChanged(isVisible);
@@ -178,7 +177,7 @@ function getDocumentVisibilityRef(stopListening) {
 function getPageActivityRef(stopListening) {
     var isDocVisibleRef = getDocumentVisibilityRef(stopListening);
     var currentTimeout;
-    var ref = createSharedReference(true, stopListening);
+    var ref = new SharedReference(true, stopListening);
     stopListening.register(function () {
         clearTimeout(currentTimeout);
         currentTimeout = undefined;
@@ -219,7 +218,7 @@ function getPictureOnPictureStateRef(elt, stopListening) {
     if (mediaElement.webkitSupportsPresentationMode === true &&
         typeof mediaElement.webkitSetPresentationMode === "function") {
         var isWebKitPIPEnabled = mediaElement.webkitPresentationMode === "picture-in-picture";
-        var ref_1 = createSharedReference({
+        var ref_1 = new SharedReference({
             isEnabled: isWebKitPIPEnabled,
             pipWindow: null,
         }, stopListening);
@@ -230,7 +229,7 @@ function getPictureOnPictureStateRef(elt, stopListening) {
         return ref_1;
     }
     var isPIPEnabled = (document.pictureInPictureElement === mediaElement);
-    var ref = createSharedReference({ isEnabled: isPIPEnabled,
+    var ref = new SharedReference({ isEnabled: isPIPEnabled,
         pipWindow: null }, stopListening);
     addEventListener(mediaElement, "enterpictureinpicture", function (evt) {
         var _a;
@@ -257,7 +256,7 @@ function getPictureOnPictureStateRef(elt, stopListening) {
 function getVideoVisibilityRef(pipStatus, stopListening) {
     var isDocVisibleRef = getDocumentVisibilityRef(stopListening);
     var currentTimeout;
-    var ref = createSharedReference(true, stopListening);
+    var ref = new SharedReference(true, stopListening);
     stopListening.register(function () {
         clearTimeout(currentTimeout);
         currentTimeout = undefined;
@@ -289,7 +288,7 @@ function getVideoVisibilityRef(pipStatus, stopListening) {
  * @returns {Object}
  */
 function getVideoWidthRef(mediaElement, pipStatusRef, stopListening) {
-    var ref = createSharedReference(mediaElement.clientWidth * pixelRatio, stopListening);
+    var ref = new SharedReference(mediaElement.clientWidth * pixelRatio, stopListening);
     var clearPreviousEventListener = noop;
     pipStatusRef.onUpdate(checkVideoWidth, { clearSignal: stopListening });
     addEventListener(window, "resize", checkVideoWidth, stopListening);
@@ -376,11 +375,6 @@ var onSourceBufferUpdate = createCompatibleEventListener(["update"]);
  * @param {Object} cancelSignal
  */
 var onRemoveSourceBuffers = createCompatibleEventListener(["removesourcebuffer"]);
-/**
- * @param {HTMLMediaElement} mediaElement
- */
-var onEncrypted = createCompatibleEventListener(shouldFavourCustomSafariEME() ? ["needkey"] :
-    ["encrypted", "needkey"]);
 /**
  * @param {MediaKeySession} mediaKeySession
  */
@@ -425,4 +419,4 @@ function addEventListener(elt, evt, listener, stopListening) {
         elt.removeEventListener(evt, listener);
     });
 }
-export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted, onEnded, onFullscreenChange, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };
+export { addEventListener, createCompatibleEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEnded, onFullscreenChange, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };

package/dist/_esm5.processed/compat/index.d.ts

@@ -20,12 +20,10 @@ import canPatchISOBMFFSegment from "./can_patch_isobmff";
 import canReuseMediaKeys from "./can_reuse_media_keys";
 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 { exitFullscreen, isFullscreen, 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";
@@ -38,4 +36,4 @@ 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";
-export { addClassName, addTextTrack, 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, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, shouldWaitForHaveEnoughData, tryToChangeSourceBufferType, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, canReuseMediaKeys, clearElementSrc, enableAudioTrack, events, exitFullscreen, getStartDate, ICompatTextTrack, ICompatVTTCue, ICompatSourceBuffer, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, makeVTTCue, MediaSource_, onHeightWidthChange, requestFullscreen, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeySystemAccess, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, shouldWaitForHaveEnoughData, tryToChangeSourceBufferType, };

package/dist/_esm5.processed/compat/index.js

@@ -20,12 +20,10 @@ import canPatchISOBMFFSegment from "./can_patch_isobmff";
 import canReuseMediaKeys from "./can_reuse_media_keys";
 import tryToChangeSourceBufferType from "./change_source_buffer_type";
 import clearElementSrc from "./clear_element_src";
-import { closeSession, CustomMediaKeySystemAccess, generateKeyRequest, getInitData, loadSession, requestMediaKeySystemAccess, setMediaKeys, } from "./eme";
 import enableAudioTrack from "./enable_audio_track";
 import * as events from "./event_listeners";
 import { exitFullscreen, isFullscreen, 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";
@@ -44,4 +42,4 @@ import shouldWaitForHaveEnoughData from "./should_wait_for_have_enough_data";
 // we  would prefer to disallow (both for the understandability of the code and
 // to better exploit tree shaking.
 patchWebkitSourceBuffer();
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, canReuseMediaKeys, clearElementSrc, closeSession, CustomMediaKeySystemAccess, enableAudioTrack, events, exitFullscreen, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, requestFullscreen, requestMediaKeySystemAccess, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeySystemAccess, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, shouldWaitForHaveEnoughData, tryToChangeSourceBufferType, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, canReuseMediaKeys, clearElementSrc, enableAudioTrack, events, exitFullscreen, getStartDate, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, makeVTTCue, MediaSource_, onHeightWidthChange, requestFullscreen, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeySystemAccess, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, shouldWaitForHaveEnoughData, tryToChangeSourceBufferType, };

package/dist/_esm5.processed/compat/is_debug_mode_enabled.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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;

package/dist/_esm5.processed/compat/is_debug_mode_enabled.js

@@ -0,0 +1,9 @@
+/**
+ * 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() {
+    return typeof __RX_PLAYER_DEBUG_MODE__ === "boolean" && __RX_PLAYER_DEBUG_MODE__;
+}

package/dist/_esm5.processed/compat/on_height_width_change.js

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import log from "../log";
-import createSharedReference from "../utils/reference";
+import SharedReference from "../utils/reference";
 import isNode from "./is_node";
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
@@ -35,7 +35,7 @@ var _ResizeObserver = isNode ? undefined :
  */
 export default function onHeightWidthChange(element, interval, cancellationSignal) {
     var _a = element.getBoundingClientRect(), initHeight = _a.height, initWidth = _a.width;
-    var ref = createSharedReference({
+    var ref = new SharedReference({
         height: initHeight,
         width: initWidth,
     }, cancellationSignal);

package/dist/_esm5.processed/core/adaptive/adaptive_representation_selector.js

@@ -17,7 +17,7 @@ import config from "../../config";
 import log from "../../log";
 import noop from "../../utils/noop";
 import { getLeftSizeOfRange } from "../../utils/ranges";
-import createSharedReference from "../../utils/reference";
+import SharedReference from "../../utils/reference";
 import takeFirstSet from "../../utils/take_first_set";
 import TaskCanceller from "../../utils/task_canceller";
 import BufferBasedChooser from "./buffer_based_chooser";
@@ -31,15 +31,15 @@ import PendingRequestsStore from "./utils/pending_requests_store";
 import RepresentationScoreCalculator from "./utils/representation_score_calculator";
 import selectOptimalRepresentation from "./utils/select_optimal_representation";
 // Create default shared references
-var manualBitrateDefaultRef = createSharedReference(-1);
+var manualBitrateDefaultRef = new SharedReference(-1);
 manualBitrateDefaultRef.finish();
-var minAutoBitrateDefaultRef = createSharedReference(0);
+var minAutoBitrateDefaultRef = new SharedReference(0);
 minAutoBitrateDefaultRef.finish();
-var maxAutoBitrateDefaultRef = createSharedReference(Infinity);
+var maxAutoBitrateDefaultRef = new SharedReference(Infinity);
 maxAutoBitrateDefaultRef.finish();
-var limitWidthDefaultRef = createSharedReference(undefined);
+var limitWidthDefaultRef = new SharedReference(undefined);
 limitWidthDefaultRef.finish();
-var throttleBitrateDefaultRef = createSharedReference(Infinity);
+var throttleBitrateDefaultRef = new SharedReference(Infinity);
 throttleBitrateDefaultRef.finish();
 /**
  * Select the most adapted Representation according to the network and buffer
@@ -121,6 +121,10 @@ function getEstimateReference(_a, stopAllEstimates) {
     var scoreCalculator = new RepresentationScoreCalculator();
     var networkAnalyzer = new NetworkAnalyzer(initialBitrate !== null && initialBitrate !== void 0 ? initialBitrate : 0, lowLatencyMode);
     var requestsStore = new PendingRequestsStore();
+    /**
+     * Callback called each time a new segment is pushed, with the information on the
+     * new pushed segment.
+     */
     var onAddedSegment = noop;
     var callbacks = {
         metrics: onMetric,
@@ -136,15 +140,14 @@ function getEstimateReference(_a, stopAllEstimates) {
      */
     var currentEstimatesCanceller = new TaskCanceller();
     currentEstimatesCanceller.linkToSignal(stopAllEstimates);
-    // Create `ISharedReference` on which estimates will be emitted.
-    var estimateRef = createEstimateReference(manualBitrate.getValue(), representationsRef.getValue(), currentEstimatesCanceller.signal);
-    manualBitrate.onUpdate(restartEstimatesProductionFromCurrentConditions, { clearSignal: stopAllEstimates });
+    // Create `SharedReference` on which estimates will be emitted.
+    var estimateRef = createEstimateReference(representationsRef.getValue(), currentEstimatesCanceller.signal);
     representationsRef.onUpdate(restartEstimatesProductionFromCurrentConditions, { clearSignal: stopAllEstimates });
     return { estimates: estimateRef, callbacks: callbacks };
-    function createEstimateReference(manualBitrateVal, representations, innerCancellationSignal) {
+    function createEstimateReference(representations, innerCancellationSignal) {
         if (representations.length === 0) {
             // No Representation given, return `null` as documented
-            return createSharedReference({
+            return new SharedReference({
                 representation: null,
                 bitrate: undefined,
                 knownStableBitrate: undefined,
@@ -152,20 +155,9 @@ function getEstimateReference(_a, stopAllEstimates) {
                 urgent: true,
             });
         }
-        if (manualBitrateVal >= 0) {
-            // A manual bitrate has been set. Just choose Representation according to it.
-            var manualRepresentation = selectOptimalRepresentation(representations, manualBitrateVal, 0, Infinity);
-            return createSharedReference({
-                representation: manualRepresentation,
-                bitrate: undefined,
-                knownStableBitrate: undefined,
-                manual: true,
-                urgent: true, // a manual bitrate switch should happen immediately
-            });
-        }
         if (representations.length === 1) {
             // There's only a single Representation. Just choose it.
-            return createSharedReference({ bitrate: undefined,
+            return new SharedReference({ bitrate: undefined,
                 representation: representations[0],
                 manual: false,
                 urgent: true,
@@ -173,18 +165,12 @@ function getEstimateReference(_a, stopAllEstimates) {
         }
         /** If true, Representation estimates based on the buffer health might be used. */
         var allowBufferBasedEstimates = false;
-        /**
-         * Current optimal Representation's bandwidth choosen by a buffer-based
-         * adaptive algorithm.
-         */
-        var currentBufferBasedEstimate;
-        var bitrates = representations.map(function (r) { return r.bitrate; });
         /**
          * Module calculating the optimal Representation based on the current
          * buffer's health (i.e. whether enough data is buffered, history of
          * buffer size etc.).
          */
-        var bufferBasedChooser = new BufferBasedChooser(bitrates);
+        var bufferBasedChooser = new BufferBasedChooser(representations.map(function (r) { return r.bitrate; }));
         /** Store the previous estimate made here. */
         var prevEstimate = new LastEstimateStorage();
         /**
@@ -196,7 +182,7 @@ function getEstimateReference(_a, stopAllEstimates) {
         // get initial observation for initial estimate
         var lastPlaybackObservation = playbackObserver.getReference().getValue();
         /** Reference through which estimates are emitted. */
-        var innerEstimateRef = createSharedReference(getCurrentEstimate());
+        var innerEstimateRef = new SharedReference(getCurrentEstimate());
         // Listen to playback observations
         playbackObserver.listen(function (obs) {
             lastPlaybackObservation = obs;
@@ -213,9 +199,13 @@ function getEstimateReference(_a, stopAllEstimates) {
             var currentScore = scoreCalculator.getEstimate(representation);
             var currentBitrate = representation.bitrate;
             var observation = { bufferGap: bufferGap, currentBitrate: currentBitrate, currentScore: currentScore, speed: speed };
-            currentBufferBasedEstimate = bufferBasedChooser.getEstimate(observation);
+            bufferBasedChooser.onAddedSegment(observation);
             updateEstimate();
         };
+        innerCancellationSignal.register(function () {
+            onAddedSegment = noop;
+        });
+        manualBitrate.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
         minAutoBitrate.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
         maxAutoBitrate.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
         filters.limitWidth.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
@@ -226,6 +216,18 @@ function getEstimateReference(_a, stopAllEstimates) {
         }
         /** Returns the actual estimate based on all methods and algorithm available. */
         function getCurrentEstimate() {
+            var manualBitrateVal = manualBitrate.getValue();
+            if (manualBitrateVal >= 0) {
+                // A manual bitrate has been set. Just choose Representation according to it.
+                var manualRepresentation = selectOptimalRepresentation(representations, manualBitrateVal, 0, Infinity);
+                return {
+                    representation: manualRepresentation,
+                    bitrate: undefined,
+                    knownStableBitrate: undefined,
+                    manual: true,
+                    urgent: true, // a manual bitrate switch should happen immediately
+                };
+            }
             var bufferGap = lastPlaybackObservation.bufferGap, position = lastPlaybackObservation.position, maximumPosition = lastPlaybackObservation.maximumPosition;
             var widthLimit = filters.limitWidth.getValue();
             var bitrateThrottle = filters.throttleBitrate.getValue();
@@ -258,6 +260,11 @@ function getEstimateReference(_a, stopAllEstimates) {
              * could actually profit from.
              */
             var chosenRepFromBandwidth = selectOptimalRepresentation(filteredReps, bitrateChosen, minAutoBitrateVal, maxAutoBitrateVal);
+            /**
+             * Current optimal Representation's bandwidth choosen by a buffer-based
+             * adaptive algorithm.
+             */
+            var currentBufferBasedEstimate = bufferBasedChooser.getLastEstimate();
             var currentBestBitrate = chosenRepFromBandwidth.bitrate;
             /**
              * Representation chosen when considering the current buffer size.
@@ -332,12 +339,11 @@ function getEstimateReference(_a, stopAllEstimates) {
      * conditions (such as a manual bitrate and/or a new list of Representations).
      */
     function restartEstimatesProductionFromCurrentConditions() {
-        var manualBitrateVal = manualBitrate.getValue();
         var representations = representationsRef.getValue();
         currentEstimatesCanceller.cancel();
         currentEstimatesCanceller = new TaskCanceller();
         currentEstimatesCanceller.linkToSignal(stopAllEstimates);
-        var newRef = createEstimateReference(manualBitrateVal, representations, currentEstimatesCanceller.signal);
+        var newRef = createEstimateReference(representations, currentEstimatesCanceller.signal);
         newRef.onUpdate(function onNewEstimate(newEstimate) {
             estimateRef.setValue(newEstimate);
         }, { clearSignal: currentEstimatesCanceller.signal,

package/dist/_esm5.processed/core/adaptive/buffer_based_chooser.d.ts

@@ -32,6 +32,13 @@ import { IRepresentationMaintainabilityScore } from "./utils/representation_scor
 export default class BufferBasedChooser {
     private _levelsMap;
     private _bitrates;
+    /**
+     * Current last best Representation's bitrate estimate made by the
+     * `BufferBasedChooser` or `undefined` if it has no such guess for now.
+     *
+     * Might be updated each time `onAddedSegment` is called.
+     */
+    private _currentEstimate;
     /**
      * Laast timestamp, in terms of `performance.now`, at which the current
      * quality was seen as too high by this algorithm.
@@ -54,7 +61,16 @@ export default class BufferBasedChooser {
      * @param {Object} playbackObservation
      * @returns {number|undefined}
      */
-    getEstimate(playbackObservation: IBufferBasedChooserPlaybackObservation): number | undefined;
+    onAddedSegment(playbackObservation: IBufferBasedChooserPlaybackObservation): void;
+    /**
+     * Returns the last best Representation's bitrate estimate made by the
+     * `BufferBasedChooser` or `undefined` if it has no such guess for now.
+     *
+     * Might be updated after `onAddedSegment` is called.
+     *
+     * @returns {number|undefined}
+     */
+    getLastEstimate(): number | undefined;
 }
 /** Playback observation needed by the `BufferBasedChooser`. */
 export interface IBufferBasedChooserPlaybackObservation {