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

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,14 +14,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../config";
-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 shouldFavourCustomSafariEME from "./should_favour_custom_safari_EME";
-var BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onTextTrackRemoved = exports.onTextTrackAdded = exports.onSourceBufferUpdate = exports.onTimeUpdate = exports.onSourceOpen = exports.onSourceEnded = exports.onSourceClose = exports.onSeeking = exports.onSeeked = exports.onRemoveSourceBuffers = exports.onLoadedMetadata = exports.onKeyStatusesChange = exports.onKeyMessage = exports.onKeyError = exports.onKeyAdded = exports.onEnded = exports.getScreenResolutionRef = exports.getElementResolutionRef = exports.getVideoVisibilityRef = exports.getPictureOnPictureStateRef = exports.createCompatibleEventListener = exports.addEventListener = void 0;
+const config_1 = require("../config");
+const log_1 = require("../log");
+const is_non_empty_string_1 = require("../utils/is_non_empty_string");
+const is_null_or_undefined_1 = require("../utils/is_null_or_undefined");
+const noop_1 = require("../utils/noop");
+const reference_1 = require("../utils/reference");
+const global_scope_1 = require("./global_scope");
+const BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
 /**
  * Find the first supported event from the list given.
  * @param {HTMLElement} element
@@ -28,8 +31,8 @@ var BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
  * @returns {Boolean}
  */
 function isEventSupported(element, eventNameSuffix) {
-    var clone = document.createElement(element.tagName);
-    var eventName = "on" + eventNameSuffix;
+    const clone = document.createElement(element.tagName);
+    const eventName = "on" + eventNameSuffix;
     if (eventName in clone) {
         return true;
     }
@@ -46,7 +49,7 @@ function isEventSupported(element, eventNameSuffix) {
  */
 function findSupportedEvent(element, eventNames) {
     return eventNames
-        .filter(function (name) { return isEventSupported(element, name); })[0];
+        .filter((name) => isEventSupported(element, name))[0];
 }
 /**
  * @param {Array.<string>} eventNames
@@ -54,11 +57,9 @@ function findSupportedEvent(element, eventNames) {
  * @returns {Array.<string>}
  */
 function eventPrefixed(eventNames, prefixes) {
-    return eventNames.reduce(function (parent, name) {
-        return parent.concat((prefixes === undefined ? BROWSER_PREFIXES :
-            prefixes)
-            .map(function (p) { return p + name; }));
-    }, []);
+    return eventNames.reduce((parent, name) => parent.concat((prefixes === undefined ? BROWSER_PREFIXES :
+        prefixes)
+        .map((p) => p + name)), []);
 }
 /**
  * Returns a function allowing to add event listeners for particular event(s)
@@ -72,21 +73,21 @@ function eventPrefixed(eventNames, prefixes) {
  * be triggered when that event is emitted on a given event target.
  */
 function createCompatibleEventListener(eventNames, prefixes) {
-    var mem;
-    var prefixedEvents = eventPrefixed(eventNames, prefixes);
-    return function (element, listener, cancelSignal) {
+    let mem;
+    const prefixedEvents = eventPrefixed(eventNames, prefixes);
+    return (element, listener, cancelSignal) => {
         if (cancelSignal.isCancelled()) {
             return;
         }
         // 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);
             }
-            if (isNonEmptyString(mem)) {
+            if ((0, is_non_empty_string_1.default)(mem)) {
                 element.addEventListener(mem, listener);
-                cancelSignal.register(function () {
+                cancelSignal.register(() => {
                     if (mem !== undefined) {
                         element.removeEventListener(mem, listener);
                     }
@@ -94,15 +95,15 @@ function createCompatibleEventListener(eventNames, prefixes) {
             }
             else {
                 if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-                    log.warn("compat: element ".concat(element.tagName) +
+                    log_1.default.warn(`compat: element ${element.tagName}` +
                         " does not support any of these events: " +
                         prefixedEvents.join(", "));
                 }
                 return;
             }
         }
-        prefixedEvents.forEach(function (eventName) {
-            var hasSetOnFn = false;
+        prefixedEvents.forEach(eventName => {
+            let hasSetOnFn = false;
             if (typeof element.addEventListener === "function") {
                 element.addEventListener(eventName, listener);
             }
@@ -113,7 +114,7 @@ function createCompatibleEventListener(eventNames, prefixes) {
                 element["on" + eventName] = listener;
                 /* eslint-enable @typescript-eslint/no-unsafe-member-access */
             }
-            cancelSignal.register(function () {
+            cancelSignal.register(() => {
                 if (typeof element.removeEventListener === "function") {
                     element.removeEventListener(eventName, listener);
                 }
@@ -127,6 +128,7 @@ function createCompatibleEventListener(eventNames, prefixes) {
         });
     };
 }
+exports.createCompatibleEventListener = createCompatibleEventListener;
 /**
  * Returns a reference:
  *   - set to `true` when the document is visible
@@ -136,28 +138,28 @@ function createCompatibleEventListener(eventNames, prefixes) {
  * @returns {Object}
  */
 function getDocumentVisibilityRef(stopListening) {
-    var prefix;
-    var doc = document;
-    if (doc.hidden != null) {
+    let prefix;
+    const doc = document;
+    if (!(0, is_null_or_undefined_1.default)(doc.hidden)) {
         prefix = "";
     }
-    else if (doc.mozHidden != null) {
+    else if (!(0, is_null_or_undefined_1.default)(doc.mozHidden)) {
         prefix = "moz";
     }
-    else if (doc.msHidden != null) {
+    else if (!(0, is_null_or_undefined_1.default)(doc.msHidden)) {
         prefix = "ms";
     }
-    else if (doc.webkitHidden != null) {
+    else if (!(0, is_null_or_undefined_1.default)(doc.webkitHidden)) {
         prefix = "webkit";
     }
-    var hidden = isNonEmptyString(prefix) ? prefix + "Hidden" :
+    const hidden = (0, is_non_empty_string_1.default)(prefix) ? prefix + "Hidden" :
         "hidden";
-    var visibilityChangeEvent = isNonEmptyString(prefix) ? prefix + "visibilitychange" :
+    const visibilityChangeEvent = (0, is_non_empty_string_1.default)(prefix) ? prefix + "visibilitychange" :
         "visibilitychange";
-    var isHidden = document[hidden];
-    var ref = createSharedReference(!isHidden, stopListening);
-    addEventListener(document, visibilityChangeEvent, function () {
-        var isVisible = !(document[hidden]);
+    const isHidden = document[hidden];
+    const ref = new reference_1.default(!isHidden, stopListening);
+    addEventListener(document, visibilityChangeEvent, () => {
+        const isVisible = !(document[hidden]);
         ref.setValueIfChanged(isVisible);
     }, stopListening);
     return ref;
@@ -169,35 +171,36 @@ function getDocumentVisibilityRef(stopListening) {
  * @returns {Object}
  */
 function getPictureOnPictureStateRef(elt, stopListening) {
-    var mediaElement = elt;
+    const mediaElement = elt;
     if (mediaElement.webkitSupportsPresentationMode === true &&
         typeof mediaElement.webkitSetPresentationMode === "function") {
-        var isWebKitPIPEnabled = mediaElement.webkitPresentationMode === "picture-in-picture";
-        var ref_1 = createSharedReference({
+        const isWebKitPIPEnabled = mediaElement.webkitPresentationMode === "picture-in-picture";
+        const ref = new reference_1.default({
             isEnabled: isWebKitPIPEnabled,
             pipWindow: null,
         }, stopListening);
-        addEventListener(mediaElement, "webkitpresentationmodechanged", function () {
-            var isEnabled = mediaElement.webkitPresentationMode === "picture-in-picture";
-            ref_1.setValue({ isEnabled: isEnabled, pipWindow: null });
+        addEventListener(mediaElement, "webkitpresentationmodechanged", () => {
+            const isEnabled = mediaElement.webkitPresentationMode === "picture-in-picture";
+            ref.setValue({ isEnabled, pipWindow: null });
         }, stopListening);
-        return ref_1;
+        return ref;
     }
-    var isPIPEnabled = (document.pictureInPictureElement === mediaElement);
-    var ref = createSharedReference({ isEnabled: isPIPEnabled,
+    const isPIPEnabled = (document.pictureInPictureElement === mediaElement);
+    const ref = new reference_1.default({ isEnabled: isPIPEnabled,
         pipWindow: null }, stopListening);
-    addEventListener(mediaElement, "enterpictureinpicture", function (evt) {
+    addEventListener(mediaElement, "enterpictureinpicture", (evt) => {
         var _a;
         ref.setValue({
             isEnabled: true,
             pipWindow: (_a = evt.pictureInPictureWindow) !== null && _a !== void 0 ? _a : null,
         });
     }, stopListening);
-    addEventListener(mediaElement, "leavepictureinpicture", function () {
+    addEventListener(mediaElement, "leavepictureinpicture", () => {
         ref.setValue({ isEnabled: false, pipWindow: null });
     }, stopListening);
     return ref;
 }
+exports.getPictureOnPictureStateRef = getPictureOnPictureStateRef;
 /**
  * Returns a reference:
  *   - Set to `true` when video is considered as visible (the page is visible
@@ -209,10 +212,10 @@ function getPictureOnPictureStateRef(elt, stopListening) {
  * @returns {Object}
  */
 function getVideoVisibilityRef(pipStatus, stopListening) {
-    var isDocVisibleRef = getDocumentVisibilityRef(stopListening);
-    var currentTimeout;
-    var ref = createSharedReference(true, stopListening);
-    stopListening.register(function () {
+    const isDocVisibleRef = getDocumentVisibilityRef(stopListening);
+    let currentTimeout;
+    const ref = new reference_1.default(true, stopListening);
+    stopListening.register(() => {
         clearTimeout(currentTimeout);
         currentTimeout = undefined;
     });
@@ -227,39 +230,44 @@ function getVideoVisibilityRef(pipStatus, stopListening) {
             ref.setValueIfChanged(true);
         }
         else {
-            var INACTIVITY_DELAY = config.getCurrent().INACTIVITY_DELAY;
-            currentTimeout = window.setTimeout(function () {
+            const { INACTIVITY_DELAY } = config_1.default.getCurrent();
+            currentTimeout = setTimeout(() => {
                 ref.setValueIfChanged(false);
             }, INACTIVITY_DELAY);
         }
     }
 }
+exports.getVideoVisibilityRef = getVideoVisibilityRef;
 /**
  * Get video width and height from the screen dimensions.
  * @param {Object} stopListening
  * @returns {Object}
  */
 function getScreenResolutionRef(stopListening) {
-    var pixelRatio = window.devicePixelRatio == null ||
-        window.devicePixelRatio === 0 ? 1 :
-        window.devicePixelRatio;
-    var ref = createSharedReference({ width: window.screen.width,
-        height: window.screen.height, pixelRatio: pixelRatio }, stopListening);
-    var interval = window.setInterval(checkScreenResolution, 20000);
+    var _a, _b;
+    const pixelRatio = global_scope_1.default.devicePixelRatio == null ||
+        global_scope_1.default.devicePixelRatio === 0 ? 1 :
+        global_scope_1.default.devicePixelRatio;
+    const ref = new reference_1.default({ width: (_a = global_scope_1.default.screen) === null || _a === void 0 ? void 0 : _a.width,
+        height: (_b = global_scope_1.default.screen) === null || _b === void 0 ? void 0 : _b.height,
+        pixelRatio }, stopListening);
+    const interval = setInterval(checkScreenResolution, 20000);
     stopListening.register(function stopUpdating() {
         clearInterval(interval);
     });
     return ref;
     function checkScreenResolution() {
-        var oldVal = ref.getValue();
+        const oldVal = ref.getValue();
         if (oldVal.width !== screen.width ||
             oldVal.height !== screen.height ||
             oldVal.pixelRatio !== pixelRatio) {
             ref.setValue({ width: screen.width,
-                height: screen.height, pixelRatio: pixelRatio });
+                height: screen.height,
+                pixelRatio });
         }
     }
 }
+exports.getScreenResolutionRef = getScreenResolutionRef;
 /**
  * Get video width and height from HTML media element, or video estimated
  * dimensions when Picture-in-Picture is activated.
@@ -269,17 +277,18 @@ function getScreenResolutionRef(stopListening) {
  * @returns {Object}
  */
 function getElementResolutionRef(mediaElement, pipStatusRef, stopListening) {
-    var pixelRatio = window.devicePixelRatio == null ||
-        window.devicePixelRatio === 0 ? 1 :
-        window.devicePixelRatio;
-    var ref = createSharedReference({ width: mediaElement.clientWidth,
-        height: mediaElement.clientHeight, pixelRatio: pixelRatio }, stopListening);
-    var clearPreviousEventListener = noop;
+    const pixelRatio = global_scope_1.default.devicePixelRatio == null ||
+        global_scope_1.default.devicePixelRatio === 0 ? 1 :
+        global_scope_1.default.devicePixelRatio;
+    const ref = new reference_1.default({ width: mediaElement.clientWidth,
+        height: mediaElement.clientHeight,
+        pixelRatio }, stopListening);
+    let clearPreviousEventListener = noop_1.default;
     pipStatusRef.onUpdate(checkElementResolution, { clearSignal: stopListening });
-    addEventListener(window, "resize", checkElementResolution, stopListening);
+    addEventListener(global_scope_1.default, "resize", checkElementResolution, stopListening);
     addEventListener(mediaElement, "enterpictureinpicture", checkElementResolution, stopListening);
     addEventListener(mediaElement, "leavepictureinpicture", checkElementResolution, stopListening);
-    var interval = window.setInterval(checkElementResolution, 20000);
+    const interval = setInterval(checkElementResolution, 20000);
     checkElementResolution();
     stopListening.register(function stopUpdating() {
         clearPreviousEventListener();
@@ -288,127 +297,142 @@ function getElementResolutionRef(mediaElement, pipStatusRef, stopListening) {
     return ref;
     function checkElementResolution() {
         clearPreviousEventListener();
-        var pipStatus = pipStatusRef.getValue();
-        var pipWindow = pipStatus.pipWindow;
+        const pipStatus = pipStatusRef.getValue();
+        const { pipWindow } = pipStatus;
         if (!pipStatus.isEnabled) {
-            var oldVal = ref.getValue();
+            const oldVal = ref.getValue();
             if (oldVal.width !== mediaElement.clientWidth ||
                 oldVal.height !== mediaElement.clientHeight ||
                 oldVal.pixelRatio !== pixelRatio) {
                 ref.setValue({ width: mediaElement.clientWidth,
-                    height: mediaElement.clientHeight, pixelRatio: pixelRatio });
+                    height: mediaElement.clientHeight,
+                    pixelRatio });
             }
         }
-        else if (!isNullOrUndefined(pipWindow)) {
-            var onPipResize_1 = function () {
+        else if (!(0, is_null_or_undefined_1.default)(pipWindow)) {
+            const onPipResize = () => {
                 updateToPipWindowResolution();
             };
-            pipWindow.addEventListener("resize", onPipResize_1);
-            clearPreviousEventListener = function () {
-                pipWindow.removeEventListener("resize", onPipResize_1);
-                clearPreviousEventListener = noop;
+            pipWindow.addEventListener("resize", onPipResize);
+            clearPreviousEventListener = () => {
+                pipWindow.removeEventListener("resize", onPipResize);
+                clearPreviousEventListener = noop_1.default;
             };
             updateToPipWindowResolution();
         }
         else {
-            var oldVal = ref.getValue();
+            const oldVal = ref.getValue();
             if (oldVal.width !== undefined ||
                 oldVal.height !== undefined ||
                 oldVal.pixelRatio !== pixelRatio) {
                 ref.setValue({ width: undefined,
-                    height: undefined, pixelRatio: pixelRatio });
+                    height: undefined,
+                    pixelRatio });
             }
         }
         function updateToPipWindowResolution() {
-            var oldVal = ref.getValue();
+            const oldVal = ref.getValue();
             if (oldVal.width !== (pipWindow === null || pipWindow === void 0 ? void 0 : pipWindow.width) ||
                 oldVal.height !== (pipWindow === null || pipWindow === void 0 ? void 0 : pipWindow.height) ||
                 oldVal.pixelRatio !== pixelRatio) {
                 ref.setValue({ width: pipWindow === null || pipWindow === void 0 ? void 0 : pipWindow.width,
-                    height: pipWindow === null || pipWindow === void 0 ? void 0 : pipWindow.height, pixelRatio: pixelRatio });
+                    height: pipWindow === null || pipWindow === void 0 ? void 0 : pipWindow.height,
+                    pixelRatio });
             }
         }
     }
 }
+exports.getElementResolutionRef = getElementResolutionRef;
 /**
  * @param {HTMLMediaElement} mediaElement
  */
-var onLoadedMetadata = createCompatibleEventListener(["loadedmetadata"]);
+const onLoadedMetadata = createCompatibleEventListener(["loadedmetadata"]);
+exports.onLoadedMetadata = onLoadedMetadata;
 /**
  * @param {HTMLMediaElement} mediaElement
  */
-var onTimeUpdate = createCompatibleEventListener(["timeupdate"]);
+const onTimeUpdate = createCompatibleEventListener(["timeupdate"]);
+exports.onTimeUpdate = onTimeUpdate;
 /**
  * @param {TextTrackList} mediaElement
  */
-var onTextTrackAdded = createCompatibleEventListener(["addtrack"]);
+const onTextTrackAdded = createCompatibleEventListener(["addtrack"]);
+exports.onTextTrackAdded = onTextTrackAdded;
 /**
  * @param {TextTrackList} textTrackList
  */
-var onTextTrackRemoved = createCompatibleEventListener(["removetrack"]);
+const onTextTrackRemoved = createCompatibleEventListener(["removetrack"]);
+exports.onTextTrackRemoved = onTextTrackRemoved;
 /**
  * @param {MediaSource} mediaSource
  * @param {Function} listener
  * @param {Object} cancelSignal
  */
-var onSourceOpen = createCompatibleEventListener(["sourceopen", "webkitsourceopen"]);
+const onSourceOpen = createCompatibleEventListener(["sourceopen", "webkitsourceopen"]);
+exports.onSourceOpen = onSourceOpen;
 /**
  * @param {MediaSource} mediaSource
  * @param {Function} listener
  * @param {Object} cancelSignal
  */
-var onSourceClose = createCompatibleEventListener(["sourceclose", "webkitsourceclose"]);
+const onSourceClose = createCompatibleEventListener(["sourceclose", "webkitsourceclose"]);
+exports.onSourceClose = onSourceClose;
 /**
  * @param {MediaSource} mediaSource
  * @param {Function} listener
  * @param {Object} cancelSignal
  */
-var onSourceEnded = createCompatibleEventListener(["sourceended", "webkitsourceended"]);
+const onSourceEnded = createCompatibleEventListener(["sourceended", "webkitsourceended"]);
+exports.onSourceEnded = onSourceEnded;
 /**
  * @param {MediaSource} mediaSource
  * @param {Function} listener
  * @param {Object} cancelSignal
  */
-var onSourceBufferUpdate = createCompatibleEventListener(["update"]);
+const onSourceBufferUpdate = createCompatibleEventListener(["update"]);
+exports.onSourceBufferUpdate = onSourceBufferUpdate;
 /**
  * @param {SourceBufferList} sourceBuffers
  * @param {Function} listener
  * @param {Object} cancelSignal
  */
-var onRemoveSourceBuffers = createCompatibleEventListener(["removesourcebuffer"]);
-/**
- * @param {HTMLMediaElement} mediaElement
- */
-var onEncrypted = createCompatibleEventListener(shouldFavourCustomSafariEME() ? ["needkey"] :
-    ["encrypted", "needkey"]);
+const onRemoveSourceBuffers = createCompatibleEventListener(["removesourcebuffer"]);
+exports.onRemoveSourceBuffers = onRemoveSourceBuffers;
 /**
  * @param {MediaKeySession} mediaKeySession
  */
-var onKeyMessage = createCompatibleEventListener(["keymessage", "message"]);
+const onKeyMessage = createCompatibleEventListener(["keymessage", "message"]);
+exports.onKeyMessage = onKeyMessage;
 /**
  * @param {MediaKeySession} mediaKeySession
  */
-var onKeyAdded = createCompatibleEventListener(["keyadded", "ready"]);
+const onKeyAdded = createCompatibleEventListener(["keyadded", "ready"]);
+exports.onKeyAdded = onKeyAdded;
 /**
  * @param {MediaKeySession} mediaKeySession
  */
-var onKeyError = createCompatibleEventListener(["keyerror", "error"]);
+const onKeyError = createCompatibleEventListener(["keyerror", "error"]);
+exports.onKeyError = onKeyError;
 /**
  * @param {MediaKeySession} mediaKeySession
  */
-var onKeyStatusesChange = createCompatibleEventListener(["keystatuseschange"]);
+const onKeyStatusesChange = createCompatibleEventListener(["keystatuseschange"]);
+exports.onKeyStatusesChange = onKeyStatusesChange;
 /**
  * @param {HTMLMediaElement} mediaElement
  */
-var onSeeking = createCompatibleEventListener(["seeking"]);
+const onSeeking = createCompatibleEventListener(["seeking"]);
+exports.onSeeking = onSeeking;
 /**
  * @param {HTMLMediaElement} mediaElement
  */
-var onSeeked = createCompatibleEventListener(["seeked"]);
+const onSeeked = createCompatibleEventListener(["seeked"]);
+exports.onSeeked = onSeeked;
 /**
  * @param {HTMLMediaElement} mediaElement
  */
-var onEnded = createCompatibleEventListener(["ended"]);
+const onEnded = createCompatibleEventListener(["ended"]);
+exports.onEnded = onEnded;
 /**
  * Utilitary function allowing to add an event listener and remove it
  * automatically once the given `CancellationSignal` emits.
@@ -421,8 +445,8 @@ var onEnded = createCompatibleEventListener(["ended"]);
  */
 function addEventListener(elt, evt, listener, stopListening) {
     elt.addEventListener(evt, listener);
-    stopListening.register(function () {
+    stopListening.register(() => {
         elt.removeEventListener(evt, listener);
     });
 }
-export { addEventListener, getPictureOnPictureStateRef, getVideoVisibilityRef, getElementResolutionRef, getScreenResolutionRef, onEncrypted, onEnded, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };
+exports.addEventListener = addEventListener;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Calculating a live-offseted media position necessitate to obtain first an
  * offset, and then adding that offset to the wanted position.
@@ -27,12 +29,12 @@
  * @param {HTMLMediaElement} mediaElement
  * @returns {number|undefined}
  */
-export default function getStartDate(mediaElement) {
-    var _mediaElement = mediaElement;
+function getStartDate(mediaElement) {
+    const _mediaElement = mediaElement;
     if (typeof _mediaElement.getStartDate === "function") {
-        var startDate = _mediaElement.getStartDate();
+        const startDate = _mediaElement.getStartDate();
         if (typeof startDate === "object" && startDate !== null) {
-            var startDateNum = +startDate;
+            const startDateNum = +startDate;
             if (!isNaN(startDateNum)) {
                 return startDateNum / 1000;
             }
@@ -42,3 +44,4 @@ export default function getStartDate(mediaElement) {
         }
     }
 }
+exports.default = getStartDate;

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

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+declare const globalScope: typeof globalThis;
+export default globalScope;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_node_1 = require("./is_node");
+const is_worker_1 = require("./is_worker");
+/**
+ * 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 = is_worker_1.default ? self :
+    is_node_1.default ? global :
+        window;
+exports.default = globalScope;

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

@@ -1,4 +1,6 @@
-import { isPlayStation5 } from "./browser_detection";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const browser_detection_1 = require("./browser_detection");
 /**
  * Some platforms have issues when the `MediaSource`'s `duration` property
  * is set to a very high value (playback freezes) but not when setting it
@@ -19,8 +21,9 @@ import { isPlayStation5 } from "./browser_detection";
  *
  * @returns {boolean}
  */
-export default function hasIssuesWithHighMediaSourceDuration() {
+function hasIssuesWithHighMediaSourceDuration() {
     // For now only seen on the Webkit present in the PlayStation 5, for which the
     // alternative is known to work.
-    return isPlayStation5;
+    return browser_detection_1.isPlayStation5;
 }
+exports.default = hasIssuesWithHighMediaSourceDuration;

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

@@ -20,11 +20,9 @@ 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 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";
@@ -35,4 +33,5 @@ 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";
-export { addClassName, addTextTrack, 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, tryToChangeSourceBufferType, };
+import shouldWaitForHaveEnoughData from "./should_wait_for_have_enough_data";
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, canReuseMediaKeys, clearElementSrc, enableAudioTrack, events, getStartDate, ICompatTextTrack, ICompatVTTCue, ICompatSourceBuffer, isCodecSupported, isNode, isVTTCue, makeVTTCue, MediaSource_, onHeightWidthChange, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeySystemAccess, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, shouldWaitForHaveEnoughData, tryToChangeSourceBufferType, };