rx-player 3.29.0 → 3.30.0-dev.2023011800

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## v3.30.0-dev.2023011700 (2023-01-17)
+
+### Features
+
+  - Add `updateContentUrls` API, allowing to update the Manifest's URL during playback [#1182]
+  - DASH: implement forced-subtitles, adding the `forced` property to the audio tracks API and selecting by default a forced text track linked to the audio track's language if present [#1187]
+
+### Bug fixes
+
+  - Fix segment requesting error when playing a DASH content without an url and without BaseURL elements [#1192]
+  - API: Stop sending events if the content is stopped due to a side-effect of one of the event handler [#1197]
+  - text-tracks/ttml: fix inconsistent line spacing when resizing the `textTrackElement` [#1191]
+  - DRM: Fix race condition leading to a JS error instead of a `NO_PLAYABLE_REPRESENTATION` [#1201]
+  - DRM/Compat: Renew MediaKeys at each `loadVideo` on all WebOS (LG TV) platforms to work around issues [#1188]
+
+### Other improvements
+
+  - DASH: handle `endNumber` DASH attribute [#1186]
+  - API: send available...TracksChange events in the very unlikely scenario where tracks are added after a manifest update [#1197]
+  - Completely remove RxJS dependency from the RxPlayer's source code [#1193]
+  - DRM: Request PR recommendation when PlayReady is asked and try default recommendation robustnesses [#1189]
+
+
 ## v3.29.0 (2022-11-16)
 
 ### Features

package/VERSION

@@ -1 +1 @@
-3.29.0
+3.30.0-dev.2023011800

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

@@ -4,8 +4,9 @@
  *
  * This should usually be the case but we found rare devices where this would
  * cause problem:
- *   - (2022-10-26): WebOS (LG TVs) 2021 and 2022 just rebuffered indefinitely
- *     when loading a content already-loaded on the HTMLMediaElement.
+ *   - (2022-11-21): WebOS (LG TVs), for some encrypted contents, just
+ *     rebuffered indefinitely when loading a content already-loaded on the
+ *     HTMLMediaElement.
  *
  * @returns {boolean}
  */

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

@@ -1,15 +1,16 @@
-import { isWebOs2021, isWebOs2022, } from "./browser_detection";
+import { isWebOs } from "./browser_detection";
 /**
  * Returns `true` if a `MediaKeys` instance (the  `Encrypted Media Extension`
  * concept) can be reused between contents.
  *
  * This should usually be the case but we found rare devices where this would
  * cause problem:
- *   - (2022-10-26): WebOS (LG TVs) 2021 and 2022 just rebuffered indefinitely
- *     when loading a content already-loaded on the HTMLMediaElement.
+ *   - (2022-11-21): WebOS (LG TVs), for some encrypted contents, just
+ *     rebuffered indefinitely when loading a content already-loaded on the
+ *     HTMLMediaElement.
  *
  * @returns {boolean}
  */
 export default function canReuseMediaKeys() {
-    return !(isWebOs2021 || isWebOs2022);
+    return !isWebOs;
 }

package/dist/_esm5.processed/compat/eme/custom_media_keys/ie11_media_keys.js

@@ -28,8 +28,8 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import { merge as observableMerge, Subject, takeUntil, } from "rxjs";
 import EventEmitter from "../../../utils/event_emitter";
+import TaskCanceller from "../../../utils/task_canceller";
 import * as events from "../../event_listeners";
 import { MSMediaKeysConstructor, } from "./ms_media_keys_constructor";
 var IE11MediaKeySession = /** @class */ (function (_super) {
@@ -39,9 +39,9 @@ var IE11MediaKeySession = /** @class */ (function (_super) {
         _this.expiration = NaN;
         _this.keyStatuses = new Map();
         _this._mk = mk;
-        _this._closeSession$ = new Subject();
+        _this._sessionClosingCanceller = new TaskCanceller();
         _this.closed = new Promise(function (resolve) {
-            _this._closeSession$.subscribe(resolve);
+            _this._sessionClosingCanceller.signal.register(function () { return resolve(); });
         });
         _this.update = function (license) {
             return new Promise(function (resolve, reject) {
@@ -65,8 +65,18 @@ var IE11MediaKeySession = /** @class */ (function (_super) {
                 initData instanceof ArrayBuffer ? new Uint8Array(initData) :
                     new Uint8Array(initData.buffer);
             _this._ss = _this._mk.createSession("video/mp4", initDataU8);
-            observableMerge(events.onKeyMessage$(_this._ss), events.onKeyAdded$(_this._ss), events.onKeyError$(_this._ss)).pipe(takeUntil(_this._closeSession$))
-                .subscribe(function (evt) { return _this.trigger(evt.type, evt); });
+            events.onKeyMessage(_this._ss, function (evt) {
+                var _a;
+                _this.trigger((_a = evt.type) !== null && _a !== void 0 ? _a : "message", evt);
+            }, _this._sessionClosingCanceller.signal);
+            events.onKeyAdded(_this._ss, function (evt) {
+                var _a;
+                _this.trigger((_a = evt.type) !== null && _a !== void 0 ? _a : "keyadded", evt);
+            }, _this._sessionClosingCanceller.signal);
+            events.onKeyError(_this._ss, function (evt) {
+                var _a;
+                _this.trigger((_a = evt.type) !== null && _a !== void 0 ? _a : "keyerror", evt);
+            }, _this._sessionClosingCanceller.signal);
             resolve();
         });
     };
@@ -77,8 +87,7 @@ var IE11MediaKeySession = /** @class */ (function (_super) {
                 _this._ss.close();
                 _this._ss = undefined;
             }
-            _this._closeSession$.next();
-            _this._closeSession$.complete();
+            _this._sessionClosingCanceller.cancel();
             resolve();
         });
     };

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

@@ -13,11 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * This file provides browser-agnostic event listeners under the form of
- * RxJS Observables
- */
-import { Observable } from "rxjs";
 import { IEventEmitter } from "../utils/event_emitter";
 import { IReadOnlySharedReference } from "../utils/reference";
 import { CancellationSignal } from "../utils/task_canceller";
@@ -44,7 +39,7 @@ export interface IPictureInPictureEvent {
  * Emit when video enters and leaves Picture-In-Picture mode.
  * @param {HTMLMediaElement} elt
  * @param {Object} stopListening
- * @returns {Observable}
+ * @returns {Object}
  */
 declare function getPictureOnPictureStateRef(elt: HTMLMediaElement, stopListening: CancellationSignal): IReadOnlySharedReference<IPictureInPictureEvent>;
 /**
@@ -55,7 +50,7 @@ declare function getPictureOnPictureStateRef(elt: HTMLMediaElement, stopListenin
  * @param {Object} pipStatus
  * @param {Object} stopListening - `CancellationSignal` allowing to free the
  * resources reserved to listen to video visibility change.
- * @returns {Observable}
+ * @returns {Object}
  */
 declare function getVideoVisibilityRef(pipStatus: IReadOnlySharedReference<IPictureInPictureEvent>, stopListening: CancellationSignal): IReadOnlySharedReference<boolean>;
 /**
@@ -69,102 +64,84 @@ declare function getVideoVisibilityRef(pipStatus: IReadOnlySharedReference<IPict
 declare function getVideoWidthRef(mediaElement: HTMLMediaElement, pipStatusRef: IReadOnlySharedReference<IPictureInPictureEvent>, stopListening: CancellationSignal): IReadOnlySharedReference<number>;
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-declare const onLoadedMetadata$: (element: IEventTargetLike) => Observable<Event>;
-/**
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-declare const onSeeking$: (element: IEventTargetLike) => Observable<Event>;
-/**
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
-declare const onSeeked$: (element: IEventTargetLike) => Observable<Event>;
+declare const onLoadedMetadata: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
-declare const onEnded$: (element: IEventTargetLike) => Observable<Event>;
+declare const onTimeUpdate: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
+ * @param {HTMLElement} element
  */
-declare const onTimeUpdate$: (element: IEventTargetLike) => Observable<Event>;
+declare const onFullscreenChange: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
- * @param {HTMLElement} element
- * @returns {Observable}
+ * @param {TextTrackList} textTrackList
  */
-declare const onFullscreenChange$: (element: IEventTargetLike) => Observable<Event>;
+declare const onTextTrackAdded: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
+ * @param {TextTrackList} textTrackList
  */
-declare const onTextTrackChanges$: (textTrackList: TextTrackList) => Observable<TrackEvent>;
+declare const onTextTrackRemoved: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {MediaSource} mediaSource
- * @returns {Observable}
+ * @param {Function} listener
+ * @param {Object} cancelSignal
  */
-declare const onSourceOpen$: (element: IEventTargetLike) => Observable<Event>;
+declare const onSourceOpen: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {MediaSource} mediaSource
- * @returns {Observable}
+ * @param {Function} listener
+ * @param {Object} cancelSignal
  */
-declare const onSourceClose$: (element: IEventTargetLike) => Observable<Event>;
+declare const onSourceClose: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {MediaSource} mediaSource
- * @returns {Observable}
+ * @param {Function} listener
+ * @param {Object} cancelSignal
  */
-declare const onSourceEnded$: (element: IEventTargetLike) => Observable<Event>;
+declare const onSourceEnded: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
- * @param {SourceBuffer} sourceBuffer
- * @returns {Observable}
+ * @param {MediaSource} mediaSource
+ * @param {Function} listener
+ * @param {Object} cancelSignal
  */
-declare const onUpdate$: (element: IEventTargetLike) => Observable<Event>;
+declare const onSourceBufferUpdate: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
- * @param {MediaSource} mediaSource
- * @returns {Observable}
+ * @param {SourceBufferList} sourceBuffers
+ * @param {Function} listener
+ * @param {Object} cancelSignal
  */
-declare const onRemoveSourceBuffers$: (element: IEventTargetLike) => Observable<Event>;
+declare const onRemoveSourceBuffers: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
-declare const onEncrypted$: (element: IEventTargetLike) => Observable<MediaEncryptedEvent>;
+declare const onEncrypted: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {MediaKeySession} mediaKeySession
- * @returns {Observable}
  */
-declare const onKeyMessage$: (element: IEventTargetLike) => Observable<MediaKeyMessageEvent>;
+declare const onKeyMessage: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {MediaKeySession} mediaKeySession
- * @returns {Observable}
  */
-declare const onKeyAdded$: (element: IEventTargetLike) => Observable<Event>;
+declare const onKeyAdded: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {MediaKeySession} mediaKeySession
- * @returns {Observable}
  */
-declare const onKeyError$: (element: IEventTargetLike) => Observable<Event>;
+declare const onKeyError: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {MediaKeySession} mediaKeySession
- * @returns {Observable}
  */
-declare const onKeyStatusesChange$: (element: IEventTargetLike) => Observable<Event>;
+declare const onKeyStatusesChange: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
 declare const onSeeking: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
 declare const onSeeked: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
 declare const onEnded: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
@@ -178,4 +155,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, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked, onSeeked$, onSeeking, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };
+export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted, 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

@@ -13,11 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * This file provides browser-agnostic event listeners under the form of
- * RxJS Observables
- */
-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";
@@ -65,7 +60,7 @@ function findSupportedEvent(element, eventNames) {
  */
 function eventPrefixed(eventNames, prefixes) {
     return eventNames.reduce(function (parent, name) {
-        return parent.concat((prefixes == null ? BROWSER_PREFIXES :
+        return parent.concat((prefixes === undefined ? BROWSER_PREFIXES :
             prefixes)
             .map(function (p) { return p + name; }));
     }, []);
@@ -75,12 +70,15 @@ function eventPrefixed(eventNames, prefixes) {
  * 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.
  */
-function createCompatibleEventListener(eventNames) {
+function createCompatibleEventListener(eventNames, prefixes) {
     var mem;
-    var prefixedEvents = eventPrefixed(eventNames);
+    var prefixedEvents = eventPrefixed(eventNames, prefixes);
     return function (element, listener, cancelSignal) {
         if (cancelSignal.isCancelled) {
             return;
@@ -109,45 +107,29 @@ function createCompatibleEventListener(eventNames) {
             }
         }
         prefixedEvents.forEach(function (eventName) {
-            element.addEventListener(eventName, listener);
-            cancelSignal.register(function () {
-                element.removeEventListener(eventName, listener);
-            });
-        });
-    };
-}
-/**
- * @param {Array.<string>} eventNames
- * @param {Array.<string>|undefined} prefixes
- * @returns {Observable}
- */
-function compatibleListener(eventNames, prefixes) {
-    var mem;
-    var prefixedEvents = eventPrefixed(eventNames, prefixes);
-    return function (element) {
-        // if the element is a HTMLElement we can detect
-        // the supported event, and memoize it in `mem`
-        if (element instanceof HTMLElement) {
-            if (typeof mem === "undefined") {
-                mem = findSupportedEvent(element, prefixedEvents);
-            }
-            if (isNonEmptyString(mem)) {
-                return observableFromEvent(element, mem);
+            var hasSetOnFn = false;
+            if (typeof element.addEventListener === "function") {
+                element.addEventListener(eventName, listener);
             }
             else {
-                if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-                    log.warn("compat: element ".concat(element.tagName) +
-                        " does not support any of these events: " +
-                        prefixedEvents.join(", "));
-                }
-                return NEVER;
+                hasSetOnFn = true;
+                /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+                /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+                element["on" + eventName] = listener;
+                /* eslint-enable @typescript-eslint/no-unsafe-member-access */
             }
-        }
-        // otherwise, we need to listen to all the events
-        // and merge them into one observable sequence
-        return observableMerge.apply(void 0, prefixedEvents.map(function (eventName) {
-            return observableFromEvent(element, eventName);
-        }));
+            cancelSignal.register(function () {
+                if (typeof element.removeEventListener === "function") {
+                    element.removeEventListener(eventName, listener);
+                }
+                if (hasSetOnFn) {
+                    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+                    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+                    delete element["on" + eventName];
+                    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+                }
+            });
+        });
     };
 }
 /**
@@ -178,14 +160,11 @@ function getDocumentVisibilityRef(stopListening) {
     var visibilityChangeEvent = isNonEmptyString(prefix) ? prefix + "visibilitychange" :
         "visibilitychange";
     var isHidden = document[hidden];
-    var ref = createSharedReference(!isHidden);
+    var ref = createSharedReference(!isHidden, stopListening);
     addEventListener(document, visibilityChangeEvent, function () {
         var isVisible = !(document[hidden]);
         ref.setValueIfChanged(isVisible);
     }, stopListening);
-    stopListening.register(function () {
-        ref.finish();
-    });
     return ref;
 }
 /**
@@ -199,11 +178,10 @@ function getDocumentVisibilityRef(stopListening) {
 function getPageActivityRef(stopListening) {
     var isDocVisibleRef = getDocumentVisibilityRef(stopListening);
     var currentTimeout;
-    var ref = createSharedReference(true);
+    var ref = createSharedReference(true, stopListening);
     stopListening.register(function () {
         clearTimeout(currentTimeout);
         currentTimeout = undefined;
-        ref.finish();
     });
     isDocVisibleRef.onUpdate(function onDocVisibilityChange(isVisible) {
         clearTimeout(currentTimeout); // clear potential previous timeout
@@ -234,7 +212,7 @@ function getVideoWidthFromPIPWindow(mediaElement, pipWindow) {
  * Emit when video enters and leaves Picture-In-Picture mode.
  * @param {HTMLMediaElement} elt
  * @param {Object} stopListening
- * @returns {Observable}
+ * @returns {Object}
  */
 function getPictureOnPictureStateRef(elt, stopListening) {
     var mediaElement = elt;
@@ -244,19 +222,16 @@ function getPictureOnPictureStateRef(elt, stopListening) {
         var ref_1 = createSharedReference({
             isEnabled: isWebKitPIPEnabled,
             pipWindow: null,
-        });
+        }, stopListening);
         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 });
+        pipWindow: null }, stopListening);
     addEventListener(mediaElement, "enterpictureinpicture", function (evt) {
         var _a;
         ref.setValue({
@@ -267,9 +242,6 @@ function getPictureOnPictureStateRef(elt, stopListening) {
     addEventListener(mediaElement, "leavepictureinpicture", function () {
         ref.setValue({ isEnabled: false, pipWindow: null });
     }, stopListening);
-    stopListening.register(function () {
-        ref.finish();
-    });
     return ref;
 }
 /**
@@ -280,16 +252,15 @@ function getPictureOnPictureStateRef(elt, stopListening) {
  * @param {Object} pipStatus
  * @param {Object} stopListening - `CancellationSignal` allowing to free the
  * resources reserved to listen to video visibility change.
- * @returns {Observable}
+ * @returns {Object}
  */
 function getVideoVisibilityRef(pipStatus, stopListening) {
     var isDocVisibleRef = getDocumentVisibilityRef(stopListening);
     var currentTimeout;
-    var ref = createSharedReference(true);
+    var ref = createSharedReference(true, stopListening);
     stopListening.register(function () {
         clearTimeout(currentTimeout);
         currentTimeout = undefined;
-        ref.finish();
     });
     isDocVisibleRef.onUpdate(checkCurrentVisibility, { clearSignal: stopListening });
     pipStatus.onUpdate(checkCurrentVisibility, { clearSignal: stopListening });
@@ -318,7 +289,7 @@ function getVideoVisibilityRef(pipStatus, stopListening) {
  * @returns {Object}
  */
 function getVideoWidthRef(mediaElement, pipStatusRef, stopListening) {
-    var ref = createSharedReference(mediaElement.clientWidth * pixelRatio);
+    var ref = createSharedReference(mediaElement.clientWidth * pixelRatio, stopListening);
     var clearPreviousEventListener = noop;
     pipStatusRef.onUpdate(checkVideoWidth, { clearSignal: stopListening });
     addEventListener(window, "resize", checkVideoWidth, stopListening);
@@ -327,7 +298,6 @@ function getVideoWidthRef(mediaElement, pipStatusRef, stopListening) {
     stopListening.register(function stopUpdatingVideoWidthRef() {
         clearPreviousEventListener();
         clearInterval(interval);
-        ref.finish();
     });
     return ref;
     function checkVideoWidth() {
@@ -356,107 +326,87 @@ function getVideoWidthRef(mediaElement, pipStatusRef, stopListening) {
 }
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
-var onLoadedMetadata$ = compatibleListener(["loadedmetadata"]);
+var onLoadedMetadata = createCompatibleEventListener(["loadedmetadata"]);
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
-var onSeeking$ = compatibleListener(["seeking"]);
-/**
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-var onSeeked$ = compatibleListener(["seeked"]);
-/**
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-var onEnded$ = compatibleListener(["ended"]);
-/**
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-var onTimeUpdate$ = compatibleListener(["timeupdate"]);
+var onTimeUpdate = createCompatibleEventListener(["timeupdate"]);
 /**
  * @param {HTMLElement} element
- * @returns {Observable}
  */
-var onFullscreenChange$ = compatibleListener(["fullscreenchange", "FullscreenChange"], 
+var onFullscreenChange = createCompatibleEventListener(["fullscreenchange", "FullscreenChange"], 
 // On IE11, fullscreen change events is called MSFullscreenChange
 BROWSER_PREFIXES.concat("MS"));
 /**
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
+ * @param {TextTrackList} textTrackList
  */
-var onTextTrackChanges$ = function (textTrackList) {
-    return observableMerge(compatibleListener(["addtrack"])(textTrackList), compatibleListener(["removetrack"])(textTrackList));
-};
+var onTextTrackAdded = createCompatibleEventListener(["addtrack"]);
 /**
- * @param {MediaSource} mediaSource
- * @returns {Observable}
+ * @param {TextTrackList} textTrackList
  */
-var onSourceOpen$ = compatibleListener(["sourceopen", "webkitsourceopen"]);
+var onTextTrackRemoved = createCompatibleEventListener(["removetrack"]);
 /**
  * @param {MediaSource} mediaSource
- * @returns {Observable}
+ * @param {Function} listener
+ * @param {Object} cancelSignal
  */
-var onSourceClose$ = compatibleListener(["sourceclose", "webkitsourceclose"]);
+var onSourceOpen = createCompatibleEventListener(["sourceopen", "webkitsourceopen"]);
 /**
  * @param {MediaSource} mediaSource
- * @returns {Observable}
+ * @param {Function} listener
+ * @param {Object} cancelSignal
  */
-var onSourceEnded$ = compatibleListener(["sourceended", "webkitsourceended"]);
+var onSourceClose = createCompatibleEventListener(["sourceclose", "webkitsourceclose"]);
 /**
- * @param {SourceBuffer} sourceBuffer
- * @returns {Observable}
+ * @param {MediaSource} mediaSource
+ * @param {Function} listener
+ * @param {Object} cancelSignal
  */
-var onUpdate$ = compatibleListener(["update"]);
+var onSourceEnded = createCompatibleEventListener(["sourceended", "webkitsourceended"]);
 /**
  * @param {MediaSource} mediaSource
- * @returns {Observable}
+ * @param {Function} listener
+ * @param {Object} cancelSignal
+ */
+var onSourceBufferUpdate = createCompatibleEventListener(["update"]);
+/**
+ * @param {SourceBufferList} sourceBuffers
+ * @param {Function} listener
+ * @param {Object} cancelSignal
  */
-var onRemoveSourceBuffers$ = compatibleListener(["onremovesourcebuffer"]);
+var onRemoveSourceBuffers = createCompatibleEventListener(["removesourcebuffer"]);
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
-var onEncrypted$ = compatibleListener(shouldFavourCustomSafariEME() ? ["needkey"] :
+var onEncrypted = createCompatibleEventListener(shouldFavourCustomSafariEME() ? ["needkey"] :
     ["encrypted", "needkey"]);
 /**
  * @param {MediaKeySession} mediaKeySession
- * @returns {Observable}
  */
-var onKeyMessage$ = compatibleListener(["keymessage", "message"]);
+var onKeyMessage = createCompatibleEventListener(["keymessage", "message"]);
 /**
  * @param {MediaKeySession} mediaKeySession
- * @returns {Observable}
  */
-var onKeyAdded$ = compatibleListener(["keyadded", "ready"]);
+var onKeyAdded = createCompatibleEventListener(["keyadded", "ready"]);
 /**
  * @param {MediaKeySession} mediaKeySession
- * @returns {Observable}
  */
-var onKeyError$ = compatibleListener(["keyerror", "error"]);
+var onKeyError = createCompatibleEventListener(["keyerror", "error"]);
 /**
  * @param {MediaKeySession} mediaKeySession
- * @returns {Observable}
  */
-var onKeyStatusesChange$ = compatibleListener(["keystatuseschange"]);
+var onKeyStatusesChange = createCompatibleEventListener(["keystatuseschange"]);
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
 var onSeeking = createCompatibleEventListener(["seeking"]);
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
 var onSeeked = createCompatibleEventListener(["seeked"]);
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
 var onEnded = createCompatibleEventListener(["ended"]);
 /**
@@ -475,4 +425,4 @@ function addEventListener(elt, evt, listener, stopListening) {
         elt.removeEventListener(evt, listener);
     });
 }
-export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked, onSeeked$, onSeeking, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };
+export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted, onEnded, onFullscreenChange, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };