rx-player 3.27.1-dev.2022060300 → 3.28.0-dev.2022061700

package/CHANGELOG.md

@@ -1,21 +1,34 @@
 # Changelog
 
-## v3.27.1-dev.2022051100 (2022-06-03)
+## v3.28.0-dev.2022061700 (2022-06-17)
+
+### Features
+
+  - Add `label` to audio, video and text track APIs (such as `getAvailableAudioTracks`) which gives a human-readable description of the corresponding track, if available in the Manifest [#1105, #1109]
+  - Automatically set the LogLevel to `"DEBUG"` if a global `__RX_PLAYER_DEBUG_MODE__` constant is set to `true`, to simplify debugging [#1115]
+  - TTML: Add support for percent based thickness for textOutline in TTML Subtitles [#1108]
 
 ### Bug fixes
 
   - Use the first **compatible** codec of the current AdaptationSet when creating a SourceBuffer [#1094]
   - DASH/DRM: Fix potential infinite rebuffering when a KID is not anounced in the MPD [#1113]
   - DASH: Avoid infinite loop due to rounding errors while parsing multi-Periods MPDs [#1111, #1110]
-  - TTML: Add support for percent based thickness for textOutline in TTML Subtitles
-  - If seeking after the last potential position, load last segments before ending [#1097]
+  - Fix issue with `maxVideoBufferSize` setting which could lead to too much data being buffered [#1125]
+  - Prevent possibility of requests loops and infinite rebuffering when a pushed segment is always completely and immediately garbage collected by the browser [#1123]
+  - DASH: Fix issues that could arise if a segment is calculated to start at a negative position [#1122]
   - DASH: Fix possibility of wrong segments being requested when a SegmentTimeline in a given Period (whose Period@end is set) had an S@r set to `-1` at its end [#1098]
-  - DASH: Don't include presentationTimeOffset for the default initial time of the first `<S>` element if its S@t is not set.
+  - DASH: If the first `<S>` has its S@t attribute not set, make as if it is set to `0` [#1118]
+  - Reload in the paused state when the action that lead to reloading was performed directly as the RxPlayer went into the `PAUSED` state [#1132]
 
 ### Other improvements
 
+  - If seeking after the last potential position, load last segments before ending [#1097]
   - The duration set on the media element is now only relative to the current chosen tracks (it was previously relative to all potential track). This allows to seek later when switching e.g. to a longer video track [#1102]
   - Errors coming from an HTMLMediaElement now have the browser's error message if it exists [#1112]
+  - TTML: Better handle EBU-TT subtitles by handling the `tt` XML namespace in our TTML parser [#1131]
+  - DRM: Information on persisted DRM sessions are now automatically updated to their last version when possible [#1096]
+  - Only log values which are relatively inexpensive to stringify to reduce the difference between debugging sessions and what is usually seen in production [#1116]
+
 
 ## v3.27.0 (2022-03-31)
 

package/FILES.md

@@ -22,7 +22,7 @@ a single directory or subdirectory, in alphabetical order.
   - [src/typings/: Typescript typings](#src-typings)
   - [src/utils/: The utils](#src-utils)
 - [src/core/: The core directory](#core)
-  - [src/core/abr/: The adaptive bitrate code](#core-abr)
+  - [src/core/adaptive/: The adaptive bitrate code](#core-abr)
   - [src/core/api/: The API definition](#core-api)
   - [src/core/stream/: Load the right segments](#core-stream)
   - [src/core/decrypt/: Decryption management](#core-decrypt)
@@ -211,17 +211,17 @@ As this directory is versatile and complicated, it also deserves its own chapter
 
 
 <a name="core-abr"></a>
-### src/core/abr/: The adaptive bitrate code ###################################
+### src/core/adaptive/: The adaptive bitrate code ##############################
 
-Defines an ABRManager class which manages the adaptive streaming part of the
-player.
+Defines functions which manages the adaptive streaming part of the player.
 
 This manager takes various observables/options as inputs to record the current
 situation of the player, give an opinion about the best media tracks to choose,
-and provide methods allowing to get/set various ABR-related options.
+and provide methods allowing to get/set various adaptive-related options.
 
-Despite containing several files and using several classes, only the ABRManager
-defined in ``abr/index.js`` should be needed by the rest of the core.
+Despite containing several files and using several classes, only the
+`AdaptiveRepresentationSelector` exported in `adaptive/index.js` should be
+needed by the rest of the core.
 This allows to isolate this complex part and facilitate future refactoring and
 improvements.
 

package/VERSION

@@ -1 +1 @@
-3.27.1-dev.2022060300
+3.28.0-dev.2022061700

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

@@ -28,7 +28,7 @@ export default function tryToChangeSourceBufferType(sourceBuffer, codec) {
             sourceBuffer.changeType(codec);
         }
         catch (e) {
-            log.warn("Could not call 'changeType' on the given SourceBuffer:", e);
+            log.warn("Could not call 'changeType' on the given SourceBuffer:", e instanceof Error ? e : "");
             return false;
         }
         return true;

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

@@ -19,6 +19,8 @@
  */
 import { Observable } from "rxjs";
 import { IEventEmitter } from "../utils/event_emitter";
+import { IReadOnlySharedReference } from "../utils/reference";
+import { CancellationSignal } from "../utils/task_canceller";
 import { ICompatPictureInPictureWindow } from "./browser_compatibility_types";
 export interface IEventEmitterLike {
     addEventListener: (eventName: string, handler: () => void) => void;
@@ -26,12 +28,14 @@ export interface IEventEmitterLike {
 }
 export declare type IEventTargetLike = HTMLElement | IEventEmitterLike | IEventEmitter<unknown>;
 /**
- * Emit `true` if the page is considered active.
- * `false` when considered inactive.
- * Emit the original value on subscription.
- * @returns {Observable}
+ * Returns a reference:
+ *   - Set to `true` when the current page is considered visible and active.
+ *   - Set to `false` otherwise.
+ * @param {Object} stopListening - `CancellationSignal` allowing to free the
+ * resources allocated to update this value.
+ * @returns {Object}
  */
-declare function isPageActive(): Observable<boolean>;
+declare function getPageActivityRef(stopListening: CancellationSignal): IReadOnlySharedReference<boolean>;
 export interface IPictureInPictureEvent {
     isEnabled: boolean;
     pipWindow: ICompatPictureInPictureWindow | null;
@@ -41,22 +45,27 @@ export interface IPictureInPictureEvent {
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-declare function onPictureInPictureEvent$(elt: HTMLMediaElement): Observable<IPictureInPictureEvent>;
+declare function getPictureOnPictureStateRef(elt: HTMLMediaElement, stopListening: CancellationSignal): IReadOnlySharedReference<IPictureInPictureEvent>;
 /**
- * Returns `true` when video is considered as visible (the page is visible and/or
- * the Picture-In-Picture is activated). Returns `false` otherwise.
- * @param {Observable} pip$
+ * Returns a reference:
+ *   - Set to `true` when video is considered as visible (the page is visible
+ *     and/or the Picture-In-Picture is activated).
+ *   - Set to `false` otherwise.
+ * @param {Object} pipStatus
+ * @param {Object} stopListening - `CancellationSignal` allowing to free the
+ * resources reserved to listen to video visibility change.
  * @returns {Observable}
  */
-declare function isVideoVisible(pip$: Observable<IPictureInPictureEvent>): Observable<boolean>;
+declare function getVideoVisibilityRef(pipStatus: IReadOnlySharedReference<IPictureInPictureEvent>, stopListening: CancellationSignal): IReadOnlySharedReference<boolean>;
 /**
  * Get video width from HTML video element, or video estimated dimensions
  * when Picture-in-Picture is activated.
  * @param {HTMLMediaElement} mediaElement
- * @param {Observable} pip$
- * @returns {Observable}
+ * @param {Object} pipStatusRef
+ * @param {Object} stopListening
+ * @returns {Object}
  */
-declare function videoWidth$(mediaElement: HTMLMediaElement, pip$: Observable<IPictureInPictureEvent>): Observable<number>;
+declare function getVideoWidthRef(mediaElement: HTMLMediaElement, pipStatusRef: IReadOnlySharedReference<IPictureInPictureEvent>, stopListening: CancellationSignal): IReadOnlySharedReference<number>;
 /**
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
@@ -87,11 +96,6 @@ declare const onTimeUpdate$: (element: IEventTargetLike) => Observable<Event>;
  * @returns {Observable}
  */
 declare const onFullscreenChange$: (element: IEventTargetLike) => Observable<Event>;
-/**
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-declare const onPlayPause$: (mediaElement: HTMLMediaElement) => Observable<Event>;
 /**
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
@@ -147,4 +151,15 @@ declare const onKeyError$: (element: IEventTargetLike) => Observable<Event>;
  * @returns {Observable}
  */
 declare const onKeyStatusesChange$: (element: IEventTargetLike) => Observable<Event>;
-export { isPageActive, isVideoVisible, videoWidth$, onPlayPause$, onTextTrackChanges$, onLoadedMetadata$, onSeeking$, onSeeked$, onEnded$, onTimeUpdate$, onFullscreenChange$, onSourceOpen$, onSourceClose$, onSourceEnded$, onUpdate$, onRemoveSourceBuffers$, onEncrypted$, onKeyMessage$, onKeyAdded$, onKeyError$, onKeyStatusesChange$, onPictureInPictureEvent$, };
+/**
+ * Utilitary function allowing to add an event listener and remove it
+ * automatically once the given `CancellationSignal` emits.
+ * @param {EventTarget} elt - The element on which should be attached the event
+ * listener.
+ * @param {string} evt - The event you wish to listen to
+ * @param {Function} listener - The listener function
+ * @param {Object} stopListening - Removes the event listener once this signal
+ * 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$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };

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

@@ -17,10 +17,13 @@
  * This file provides browser-agnostic event listeners under the form of
  * RxJS Observables
  */
-import { NEVER, combineLatest as observableCombineLatest, defer as observableDefer, delay, distinctUntilChanged, fromEvent as observableFromEvent, interval as observableInterval, map, merge as observableMerge, of as observableOf, startWith, switchMap, throttleTime, } from "rxjs";
+import { NEVER, fromEvent as observableFromEvent, merge as observableMerge, } from "rxjs";
 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 isNode from "./is_node";
 import shouldFavourCustomSafariEME from "./should_favour_custom_safari_EME";
 var BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
@@ -86,7 +89,7 @@ function compatibleListener(eventNames, prefixes) {
                 return observableFromEvent(element, mem);
             }
             else {
-                if (0 /* CURRENT_ENV */ === 1 /* DEV */) {
+                if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
                     log.warn("compat: element ".concat(element.tagName) +
                         " does not support any of these events: " +
                         prefixedEvents.join(", "));
@@ -102,12 +105,14 @@ function compatibleListener(eventNames, prefixes) {
     };
 }
 /**
- * Returns an observable:
- *   - emitting true when the document is visible
- *   - emitting false when the document is hidden
- * @returns {Observable}
+ * Returns a reference:
+ *   - set to `true` when the document is visible
+ *   - set to `false` when the document is hidden
+ * @param {Object} stopListening - `CancellationSignal` allowing to free the
+ * ressources allocated to update this value.
+ * @returns {Object}
  */
-function visibilityChange() {
+function getDocumentVisibilityRef(stopListening) {
     var prefix;
     var doc = document;
     if (doc.hidden != null) {
@@ -126,26 +131,44 @@ function visibilityChange() {
         "hidden";
     var visibilityChangeEvent = isNonEmptyString(prefix) ? prefix + "visibilitychange" :
         "visibilitychange";
-    return observableDefer(function () {
-        var isHidden = document[hidden];
-        return observableFromEvent(document, visibilityChangeEvent)
-            .pipe(map(function () { return !(document[hidden]); }), startWith(!isHidden), distinctUntilChanged());
+    var isHidden = document[hidden];
+    var ref = createSharedReference(isHidden);
+    addEventListener(document, visibilityChangeEvent, function () {
+        var isVisible = !(document[hidden]);
+        ref.setValueIfChanged(isVisible);
+    }, stopListening);
+    stopListening.register(function () {
+        ref.finish();
     });
+    return ref;
 }
 /**
- * Emit `true` if the page is considered active.
- * `false` when considered inactive.
- * Emit the original value on subscription.
- * @returns {Observable}
+ * Returns a reference:
+ *   - Set to `true` when the current page is considered visible and active.
+ *   - Set to `false` otherwise.
+ * @param {Object} stopListening - `CancellationSignal` allowing to free the
+ * resources allocated to update this value.
+ * @returns {Object}
  */
-function isPageActive() {
-    var INACTIVITY_DELAY = config.getCurrent().INACTIVITY_DELAY;
-    return visibilityChange().pipe(switchMap(function (x) {
-        if (!x) {
-            return observableOf(x).pipe(delay(INACTIVITY_DELAY));
+function getPageActivityRef(stopListening) {
+    var isDocVisibleRef = getDocumentVisibilityRef(stopListening);
+    var currentTimeout;
+    var ref = createSharedReference(true);
+    stopListening.register(function () {
+        clearTimeout(currentTimeout);
+        ref.finish();
+    });
+    isDocVisibleRef.onUpdate(function onDocVisibilityChange(isVisible) {
+        clearTimeout(currentTimeout); // clear potential previous timeout
+        if (!isVisible) {
+            var INACTIVITY_DELAY = config.getCurrent().INACTIVITY_DELAY;
+            currentTimeout = window.setTimeout(function () {
+                ref.setValueIfChanged(false);
+            }, INACTIVITY_DELAY);
         }
-        return observableOf(x);
-    }));
+        ref.setValueIfChanged(true);
+    }, { clearSignal: stopListening, emitCurrentValue: true });
+    return ref;
 }
 /**
  * Get video width from Picture-in-Picture window
@@ -164,73 +187,120 @@ function getVideoWidthFromPIPWindow(mediaElement, pipWindow) {
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-function onPictureInPictureEvent$(elt) {
-    return observableDefer(function () {
-        var mediaElement = elt;
-        if (mediaElement.webkitSupportsPresentationMode === true &&
-            typeof mediaElement.webkitSetPresentationMode === "function") {
-            var isWebKitPIPEnabled = mediaElement.webkitPresentationMode === "picture-in-picture";
-            return observableFromEvent(mediaElement, "webkitpresentationmodechanged").pipe(map(function () { return ({
-                isEnabled: mediaElement.webkitPresentationMode === "picture-in-picture",
-                pipWindow: null,
-            }); }), startWith({ isEnabled: isWebKitPIPEnabled, pipWindow: null }));
-        }
-        var isPIPEnabled = (document.pictureInPictureElement === mediaElement);
-        var initialState = { isEnabled: isPIPEnabled, pipWindow: null };
-        return observableMerge(observableFromEvent(mediaElement, "enterpictureinpicture")
-            .pipe(map(function (evt) {
-            var _a;
-            return ({
-                isEnabled: true,
-                pipWindow: (_a = evt.pictureInPictureWindow) !== null && _a !== void 0 ? _a : null,
-            });
-        })), observableFromEvent(mediaElement, "leavepictureinpicture")
-            .pipe(map(function () { return ({ isEnabled: false, pipWindow: null }); }))).pipe(startWith(initialState));
+function getPictureOnPictureStateRef(elt, stopListening) {
+    var mediaElement = elt;
+    if (mediaElement.webkitSupportsPresentationMode === true &&
+        typeof mediaElement.webkitSetPresentationMode === "function") {
+        var isWebKitPIPEnabled = mediaElement.webkitPresentationMode === "picture-in-picture";
+        var ref_1 = createSharedReference({
+            isEnabled: isWebKitPIPEnabled,
+            pipWindow: null,
+        });
+        addEventListener(mediaElement, "webkitpresentationmodechanged", function () {
+            var isEnabled = mediaElement.webkitPresentationMode === "picture-in-picture";
+            ref_1.setValue({ isEnabled: isEnabled, pipWindow: null });
+        }, stopListening);
+        stopListening.register(function () {
+            ref_1.finish();
+        });
+        return ref_1;
+    }
+    var isPIPEnabled = (document.pictureInPictureElement === mediaElement);
+    var ref = createSharedReference({ isEnabled: isPIPEnabled,
+        pipWindow: null });
+    addEventListener(mediaElement, "enterpictureinpicture", function (evt) {
+        var _a;
+        ref.setValue({
+            isEnabled: true,
+            pipWindow: (_a = evt.pictureInPictureWindow) !== null && _a !== void 0 ? _a : null,
+        });
+    }, stopListening);
+    addEventListener(mediaElement, "leavepictureinpicture", function () {
+        ref.setValue({ isEnabled: false, pipWindow: null });
+    }, stopListening);
+    stopListening.register(function () {
+        ref.finish();
     });
+    return ref;
 }
 /**
- * Returns `true` when video is considered as visible (the page is visible and/or
- * the Picture-In-Picture is activated). Returns `false` otherwise.
- * @param {Observable} pip$
+ * Returns a reference:
+ *   - Set to `true` when video is considered as visible (the page is visible
+ *     and/or the Picture-In-Picture is activated).
+ *   - Set to `false` otherwise.
+ * @param {Object} pipStatus
+ * @param {Object} stopListening - `CancellationSignal` allowing to free the
+ * resources reserved to listen to video visibility change.
  * @returns {Observable}
  */
-function isVideoVisible(pip$) {
-    var INACTIVITY_DELAY = config.getCurrent().INACTIVITY_DELAY;
-    return observableCombineLatest([visibilityChange(), pip$]).pipe(switchMap(function (_a) {
-        var isVisible = _a[0], pip = _a[1];
-        if (pip.isEnabled || isVisible) {
-            return observableOf(true);
+function getVideoVisibilityRef(pipStatus, stopListening) {
+    var isDocVisibleRef = getDocumentVisibilityRef(stopListening);
+    var currentTimeout;
+    var ref = createSharedReference(true);
+    stopListening.register(function () {
+        clearTimeout(currentTimeout);
+        ref.finish();
+    });
+    isDocVisibleRef.onUpdate(checkCurrentVisibility, { clearSignal: stopListening });
+    pipStatus.onUpdate(checkCurrentVisibility, { clearSignal: stopListening });
+    checkCurrentVisibility();
+    return ref;
+    function checkCurrentVisibility() {
+        if (pipStatus.getValue().isEnabled || isDocVisibleRef.getValue()) {
+            ref.setValueIfChanged(true);
         }
-        return observableOf(false)
-            .pipe(delay(INACTIVITY_DELAY));
-    }), distinctUntilChanged());
+        else {
+            var INACTIVITY_DELAY = config.getCurrent().INACTIVITY_DELAY;
+            currentTimeout = window.setTimeout(function () {
+                ref.setValueIfChanged(false);
+            }, INACTIVITY_DELAY);
+        }
+    }
 }
 /**
  * Get video width from HTML video element, or video estimated dimensions
  * when Picture-in-Picture is activated.
  * @param {HTMLMediaElement} mediaElement
- * @param {Observable} pip$
- * @returns {Observable}
+ * @param {Object} pipStatusRef
+ * @param {Object} stopListening
+ * @returns {Object}
  */
-function videoWidth$(mediaElement, pip$) {
-    return observableCombineLatest([
-        pip$,
-        observableInterval(20000).pipe(startWith(null)),
-        observableFromEvent(window, "resize").pipe(throttleTime(500), startWith(null)),
-    ]).pipe(switchMap(function (_a) {
-        var pip = _a[0];
-        if (!pip.isEnabled) {
-            return observableOf(mediaElement.clientWidth * pixelRatio);
+function getVideoWidthRef(mediaElement, pipStatusRef, stopListening) {
+    var ref = createSharedReference(mediaElement.clientWidth * pixelRatio);
+    var clearPreviousEventListener = noop;
+    pipStatusRef.onUpdate(checkVideoWidth, { clearSignal: stopListening });
+    addEventListener(window, "resize", checkVideoWidth, stopListening);
+    var interval = window.setInterval(checkVideoWidth, 20000);
+    checkVideoWidth();
+    stopListening.register(function stopUpdatingVideoWidthRef() {
+        clearPreviousEventListener();
+        clearInterval(interval);
+        ref.finish();
+    });
+    return ref;
+    function checkVideoWidth() {
+        clearPreviousEventListener();
+        var pipStatus = pipStatusRef.getValue();
+        if (!pipStatus.isEnabled) {
+            ref.setValueIfChanged(mediaElement.clientWidth * pixelRatio);
         }
-        else if (pip.pipWindow != null) {
-            var pipWindow_1 = pip.pipWindow;
+        else if (!isNullOrUndefined(pipStatus.pipWindow)) {
+            var pipWindow_1 = pipStatus.pipWindow;
             var firstWidth = getVideoWidthFromPIPWindow(mediaElement, pipWindow_1);
-            return observableFromEvent(pipWindow_1, "resize").pipe(startWith(firstWidth * pixelRatio), map(function () { return getVideoWidthFromPIPWindow(mediaElement, pipWindow_1) * pixelRatio; }));
+            var onPipResize_1 = function () {
+                ref.setValueIfChanged(getVideoWidthFromPIPWindow(mediaElement, pipWindow_1) * pixelRatio);
+            };
+            pipWindow_1.addEventListener("resize", onPipResize_1);
+            clearPreviousEventListener = function () {
+                pipWindow_1.removeEventListener("resize", onPipResize_1);
+                clearPreviousEventListener = noop;
+            };
+            ref.setValueIfChanged(firstWidth * pixelRatio);
         }
         else {
-            return observableOf(Infinity);
+            ref.setValueIfChanged(Infinity);
         }
-    }), distinctUntilChanged());
+    }
 }
 /**
  * @param {HTMLMediaElement} mediaElement
@@ -264,13 +334,6 @@ var onTimeUpdate$ = compatibleListener(["timeupdate"]);
 var onFullscreenChange$ = compatibleListener(["fullscreenchange", "FullscreenChange"], 
 // On IE11, fullscreen change events is called MSFullscreenChange
 BROWSER_PREFIXES.concat("MS"));
-/**
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-var onPlayPause$ = function (mediaElement) {
-    return observableMerge(compatibleListener(["play"])(mediaElement), compatibleListener(["pause"])(mediaElement));
-};
 /**
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
@@ -329,4 +392,20 @@ var onKeyError$ = compatibleListener(["keyerror", "error"]);
  * @returns {Observable}
  */
 var onKeyStatusesChange$ = compatibleListener(["keystatuseschange"]);
-export { isPageActive, isVideoVisible, videoWidth$, onPlayPause$, onTextTrackChanges$, onLoadedMetadata$, onSeeking$, onSeeked$, onEnded$, onTimeUpdate$, onFullscreenChange$, onSourceOpen$, onSourceClose$, onSourceEnded$, onUpdate$, onRemoveSourceBuffers$, onEncrypted$, onKeyMessage$, onKeyAdded$, onKeyError$, onKeyStatusesChange$, onPictureInPictureEvent$, };
+/**
+ * Utilitary function allowing to add an event listener and remove it
+ * automatically once the given `CancellationSignal` emits.
+ * @param {EventTarget} elt - The element on which should be attached the event
+ * listener.
+ * @param {string} evt - The event you wish to listen to
+ * @param {Function} listener - The listener function
+ * @param {Object} stopListening - Removes the event listener once this signal
+ * emits
+ */
+function addEventListener(elt, evt, listener, stopListening) {
+    elt.addEventListener(evt, listener);
+    stopListening.register(function () {
+        elt.removeEventListener(evt, listener);
+    });
+}
+export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked$, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };

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

@@ -38,5 +38,4 @@ import shouldUnsetMediaKeys from "./should_unset_media_keys";
 import shouldValidateMetadata from "./should_validate_metadata";
 import shouldWaitForDataBeforeLoaded from "./should_wait_for_data_before_loaded";
 import whenLoadedMetadata$ from "./when_loaded_metadata";
-import whenMediaSourceOpen$ from "./when_media_source_open";
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, ICompatTextTrack, ICompatVTTCue, ICustomMediaKeySession, ICustomMediaKeySystemAccess, ICustomMediaKeys, ICompatSourceBuffer, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, whenMediaSourceOpen$, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, ICompatTextTrack, ICompatVTTCue, ICustomMediaKeySession, ICustomMediaKeySystemAccess, ICustomMediaKeys, ICompatSourceBuffer, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, };

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

@@ -40,9 +40,8 @@ import shouldUnsetMediaKeys from "./should_unset_media_keys";
 import shouldValidateMetadata from "./should_validate_metadata";
 import shouldWaitForDataBeforeLoaded from "./should_wait_for_data_before_loaded";
 import whenLoadedMetadata$ from "./when_loaded_metadata";
-import whenMediaSourceOpen$ from "./when_media_source_open";
 // 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
 // to better exploit tree shaking.
 patchWebkitSourceBuffer();
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, whenMediaSourceOpen$, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, };