rx-player 4.0.0-alpha.2022110400 → 4.0.0-beta.0

package/CHANGELOG.md

@@ -1,6 +1,122 @@
 # Changelog
 
-## v3.29.0 (XXXX-XX-XX)
+## v4.0.0-beta.0 (2023-01-27)
+
+### Changes
+
+  - Create `"FREEZING"` player state for cases where the playback position is currently not advancing due to an unknown reason, to separate it from regular `"BUFFERING"`. [#1146]
+  - The `RELOADING` player state (gettable  through the `getPlayerState` and `playerStateChange` API) can now happen at any time to unlock playback.
+  - Remove bitrate API: `getAvailableVideoBitrates`, `getAvailableAudioBitrates`, `setAudioBitrate`, `setVideoBitrate`, `getAudioBitrate`, `getVideoBitrate` in profit of the Representations lock APIs [#1144]
+  - Remove max bitrate API: `setMaxVideoBitrate`, `setMaxAudioBitrate`, `getMaxVideoBitrate` and `getMaxAudioBitrate` methods as well as the `maxVideoBitrate` and `maxAudioBitrate` options in profit of the Representations lock APIs
+  - Remove min bitrate API: `setMinVideoBitrate`, `setMinAudioBitrate`, `getMinVideoBitrate` and `getMinAudioBitrate` methods as well as the `minVideoBitrate` and `minAudioBitrate` options in profit of the Representations lock APIs
+  - Remove track preferences API (methods: `getPreferredAudioTracks`, `getPreferredVideoTracks`, `setPreferredAudioTracks` and `setPreferredVideoTracks`, types: `IAudioTrackPreference`, `ITextTrackPreference` and `IVideoTrackPreference`) in profit of the new tracks API
+  - Remove `getManualVideoBitrate` and `getManualAudioBitrate` in profit of the new Representations lock APIs
+  - Replace `initialAudioBitrate` and `initialVideoBitrate` constructor options with a single `baseBandwidth` option, which better translates what this option is actually doing and allows for future optimizations on our side. [#1155]
+  - Rename `audioTrackSwitchingMode` loadVideo option into `defaultAudioTrackSwitchingMode` [#1030]
+  - Remove `manualBitrateSwitchingMode` loadVideo option to instead rely on the `switchingMode` property of each `lockVideoRepresentations` and `lockAudioRepresentations` calls. [#1030]
+  - Remove `audioBitrateChange` and `videoBitrateChange` events in profit of the new `audioRepresentationChange` and `videoRepresentationChange` events
+  - Remove `availableAudioBitratesChange` and `availableVideoBitratesChange` events. Those are less needed with the new Representations lock API and can be mostly replicated through the `audioTrackChange` and `videoTrackChange` events
+  - "Flatten" the `transportOptions` loadVideo options by putting all its inner properties directly at the top level of loadVideo options, to simplify its documentation and discoverability [#1149]
+  - Remove `limitVideoWidth` constructor option in profit of the more configurable `videoResolutionLimit` constructor option
+  - Rename `networkConfig` into `requestConfig` and re-organize its inner properties to pave the way for future request-related APIs.
+  - Remove `stopAtEnd` `loadVideo` option and don't automatically stop when reaching the end by default. This behavior can be counter-intuitive and can be very easily implemented by the application.
+  - Remove `decipherabilityUpdate` event as it appeared to be not easily exploitable and exposed internal logic too much [#1168]
+  - Remove `getUrl` method in profit of the more powerful `getContentUrls`
+  - Impossibility to play the content due to unsupported audio and/or video tracks now triggers an error with the `MANIFEST_INCOMPATIBLE_CODECS_ERROR` instead of `MANIFEST_PARSE_ERROR`
+  - Remove methods: `getManifest`, `getCurrentAdaptations` and `getCurrentRepresentations`, as they reveal the RxPlayer's internals too much
+  - The `"smooth"` transport now needs to be communicated the URL of the Manifest directly (previously, it was possible to redirect it to a XML or JSON file first due to Canal+ legacy reasons).
+  - Remove the `supplementaryTextTracks` loadVideo option. You can use the `TextTrackRenderer` tool if you wish to diplay external subtitles on top of your content.
+  - Rename `maximumBufferTime` in `positionUpdate` events to `maximumPosition`
+  - Remove `getVideoPlayedTime` and `getVideoLoadedTime` methods. Their names was very confusing and can be re-implemented relatively easily using the media element's buffered property.
+  - Rename `getVideoDuration` to `getMediaDuration`, to avoid confusion with the video track's duration.
+  - Rename `getVideoBufferGap` to `getCurrentBufferGap, to avoid confusion with the "buffer gap" specific to the video track.
+  - Remove image-related API: `supplementaryImageTracks` `loadVideo` option, `imageTrackUpdate` event, `getImageTrackData` method. Those are better handled by an application. The `parseBifThumbnails` tool is still available.
+  - Replace `keySystems[].licenseStorage` `keySystems` option (for a `loadVideo` call) by the better-named `persistentLicenseConfig`. The `persistentLicense` boolean (also a `keySystems` option) has also been removed because it was redundant with it) [#1147]
+  - Remove `persistentStateRequired` API, in profit of the more powerful `persistentState` API [#1148]
+  - Remove `distinctiveIdentifierRequired` API, in profit of the more powerful `distinctiveIdentifier` API [#1148]
+  - Remove `keySystems[].fallbackOn` `loadVideo` property as it's now replaced by the more powerful `keySystems[].onKeyOutputRestricted` and `keySystems[].onKeyInternalError` properties.
+  - Remove `keySystems[].onKeyStatusesChange` API as it seems to never be used [#1148]
+  - Remove `keySystems[].throwOnLicenseExpiration` API as it can now be fully replaced by the `keySystems[].onKeyExpiration` option
+  - Remove `aggressiveMode` from the `transportOptions` `loadVideo` option
+  - Remove deprecated `throttleWhenHidden` player option in profit of `throttleVideoBitrateWhenHidden`
+  - Change payload of `periodChange` events, so they emit only core properties related to a `Period`.
+  - Change arguments given to a `transportOptions.segmentLoader` function (the `loadVideo` option): it now doesn't give the full `Manifest`, `Period`, `Adaptation`, `Representation` and `ISegment` structures in arguments but only core properties from it [#995]
+  - Custom `manifestLoader` function added to what was previously the `loadVideo`'s `transportOptions` option now set an object as argument (with an `url`property), to let us bring improvements on it in the future [#995]
+  - A Representation's `frameRate` is now always a number - in terms of frame per seconds - instead of a string.
+  - Update the arguments of the `representationFilter` API
+  - `Representations` (in methods: `getAvailableVideoTracks`, `getVideoTrack`, `representationFilter`, `getAvailableAudioTracks`, `getAudioTrack` and events: `audioTrackChange` and `videoTrackChange`) can have an `undefined` bitrate
+  - Remove deprecated fullscreen related APIs (methods: `isFullscreen`, `setFullscreen`, `exitFullscreen`, event: `fullscreenChange`) as a a UI is much more adapted to that task and can also bring with it things like a progress bar or HTML text tracks
+  - Remove deprecated `getNativeTextTrack` method. If advanced features are wanted, it's better to just use the HTML text track API
+  - Remove deprecated `nativeTextTracksChange` event. Same reason than for `getNativeTextTrack`
+  - Remove deprecated `hideNativeSubtitles` from `loadVideo` options. Same reason than for `getNativeTextTrack`
+  - Remove `xhr` property from a `NetworkError`. Doing so stop us from using the fetch API
+  - Remove deprecated `defaultAudioTrack` and `defaultTextTrack`in profit of new track APIs
+  - Remove `bitrateEstimationChange` event as it is poorly understood (it's not always close to the expected bandwidth) and has a very complex relationship with the chosen quality.
+  - Remove the notion of environment variables linked to personalized builds (e.g. RXP_DASH) in profit of the minimal RxPlayer.
+  - Rename `IPersistentSessionStorage` type to `IPersistentLicenseConfig` [#1147]
+  - Remove undocumented `audioRobustnesses` and `videoRobustnesses` properties of the `keySystems` option of `loadVideo` calls, as more powerful solutions now exist: respectively `audioCapabilitiesConfig` and `videoCapabilitiesConfig` [#1148]
+  - Remove public types `ISupplementaryTextTrackOption` and `ISupplementaryImageTrackOption`. Those are the types respectively for `supplementaryTextTracks` and `supplementaryImageTracks` which have been removed
+  - Remove public types `IBitrateEstimate` as no API depend on it anymore.
+  - Remove public types `IManifest`, `IPeriod`, `IAdaptation`, `IRepresentation`, `IRepresentationInfos`, `IBifThumbnail`, `IBifObject` and `IExposedSegment` as no API depend on them anymore.
+  - Remove public types `IDefaultAudioTrackOption` and `IDefaultTextTrackOption`. Those are the types respectively for `defaultAudioTrack` and `defaultTextTrack` `loadVideo` options which have been removed
+  - Remove public types `IAudioTrackPreference`, `ITextTrackPreference` and `IVideoTrackPreference` as the corresponding API do not exist anymore.
+  - Stop officially supporting the Internet Explorer 11 browser
+
+### Features
+
+  - `setAudioTrack`, `setVideoTrack` and `setTextTrack` now may take an object in argument, with the track's id set as a `trackId` property, to allow new features
+  - Add `switchingMode` optional property to `setVideoTrack` and `setAudioTrack`, to configure the way in which the RxPlayer switches between the previous and new track
+  - Add optional `periodId` property to `setAudioTrack`, `setVideoTrack` and `setTextTrack`, to allow setting the track of another, future or past, Period.
+  - `getAvailableAudioTracks`, `getAvailableTextTracks`, `getAvailableVideoTracks`, `getAudioTrack`, `getTextTrack` and `getVideoTrack` can now optionally take a `periodId` argument to retrieve track information on a specific Period, different than the current one.
+  - `disableTextTrack`, and`disableVideoTrack` can now optionally take a `periodId` argument to disable a track for a specific Period
+  - Add optional `lockedRepresentations` property to  `setAudioTrack` and `setVideoTrack`, to only filter some allowed Representations (i.e. qualities) after switching to the wanted track.
+  - Add `getCurrentPeriod` method to retrieve information on the Period currently played
+  - Add `getAvailablePeriods` method to retrieve information on all Periods on which a track or Representation choice can be made
+  - Add `lockVideoRepresentations`, `lockAudioRepresentations`, `getLockedVideoRepresentations`, `getLockedAudioRepresentations`, `unlockVideoRepresentations` and `unlockAudioRepresentations` methods to allow a complex selection of Representations that are currently allowed to play.
+  - Add `getVideoRepresentation` and `getAudioRepresentation` method to retrieve information on the currently loaded representations [#1144]
+  - Add `audioRepresentationChange` and `videoRepresentationChange` events to be notified when the currently-loaded Representation for the current Period changes.
+  - 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]
+  - Add `getContentUrls` allowing to retrieve the one or several known URLs through which the current Manifest or content is reachable.
+  - Add `videoResolutionLimit` constructor option allowing to automatically limit a video Representation's resolution.
+  - Add `newAvailablePeriods` event to signal new Period on which a track and/or Representation choice can be made
+  - Add `brokenRepresentationsLock` event for when a Representations lock could not be respected anymore
+  - Add `trackUpdate` event for when a track has been updated for any type and Period
+  - Add  `distinctiveIdentifier` property in the `keySystems` option (given to the `loadVideo` method) to have full control over the MediaKeySystemConfiguration of the same name in the chosen key system [#1148]
+  - Add  `persistentState`  property in the `keySystems` option (given to the `loadVideo` method) to have full control over the MediaKeySystemConfiguration of the same name in the chosen key system [#1148]
+  - Add `keySystems[].onKeyOutputRestricted` and `keySystems[].onKeyInternalError` properties to configure the RxPlayer's behavior when a key switches to the status respectively `"output-restricted"` and `"internal-error"`
+  - Add `audioCapabilitiesConfig` and `videoCapabilitiesConfig` properties in the `keySystems` option (given to the `loadVideo` method)  to allow advanced configuration of respectively the "audioCapabilities" and "videoCapabilities" in the asked MediaKeySystemConfiguration [#1148]
+  - Add `ISegmentLoaderContext` public type for the first argument of the `segmentLoader` API
+  - Add `IRepresentationFilterRepresentation` public type for the first argument of the `representationFilter` API
+  - Add `IRepresentationContext` public type for the second argument of the `representationFilter` API
+  - Add `IManifestLoaderInfo` public type for the first argument of the `manifestLoader` API
+  - Add `IPeriodChangeEvent` public type to define the properties send through a `periodChange` event
+  - Add `IPeriod` public type to define a Period object returned by methods like `getAvailablePeriods` or `getCurrentPeriod`
+  - Add `IVideoTrackSwitchingMode` public type to define the type of the `switchingMode` property optionally given to `setAudioTrack`
+  - Add `IAudioRepresentationsSwitchingMode` public type to define the type of the `switchingMode` property optionally given to `lockAudioRepresentations`
+  - Add `IVideoRepresentationsSwitchingMode` public type to define the type of the `switchingMode` property optionally given to `lockAudioRepresentations`
+  - Add `IBrokenRepresentationsLockContext` public type to define the type sent as a payload of the `brokenRepresentationsLock` event
+  - Add `ITrackUpdateEventPayload` public type to define the type sent as a payload of the `trackUpdate` event
+  - Add `ILockedVideoRepresentationsSettings` public type to define the object that should be given to the new `lockVideoRepresentation` method
+  - Add `ILockedAudioRepresentationsSettings` public type to define the object that should be given to the new `lockAudioRepresentation` method
+  - Add `IAudioTrackSetting` public type to define the object that may be given to the `setAudioTrack` method
+  - Add `IVideoTrackSetting` public type to define the object that may be given to the `setVideoTrack` method
+  - Add `ITextTrackSetting` public type to define the object that may be given to the `setTextTrack` method
+
+### 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
+
+  - Remove dependency to RxJS, improving the debugging experience and preventing some uncaught Error from being thrown
+
+
+## v3.29.0 (2022-11-16)
 
 ### Features
 
@@ -12,7 +128,7 @@
 
 ### Deprecated
 
-  - DRM: Deprecate `keySystems[].throwOnLicenseExpiration` `loadVideo` option as this boolean can be replaced with more customability by the new `keySystems[].onKeyExpiration` `loadVideo` option [#1157]
+  - DRM: Deprecate `keySystems[].throwOnLicenseExpiration` `loadVideo` option as this boolean can be replaced with more customizability by the new `keySystems[].onKeyExpiration` `loadVideo` option [#1157]
 
 ### Bug fixes
 

package/FILES.md

@@ -167,7 +167,6 @@ What is exported there are functions to load:
   - Manifests/MPDs
   - video/audio segments
   - subtitles tracks
-  - image tracks
 
 For different streaming technologies.
 

package/VERSION

@@ -1 +1 @@
-4.0.0-alpha.2022110400
+4.0.0-beta.0

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

@@ -23,11 +23,9 @@ import { ICompatTextTrack } from "./browser_compatibility_types";
  *     undefined if no trackElement was added.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Boolean} hidden - If `true`, the text track will be hidden by
- * default. If `false`, the text track will be directly showing.
  * @returns {Object}
  */
-export default function addTextTrack(mediaElement: HTMLMediaElement, hidden: boolean): {
+export default function addTextTrack(mediaElement: HTMLMediaElement): {
     track: ICompatTextTrack;
     trackElement: HTMLTrackElement | undefined;
 };

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

@@ -23,12 +23,10 @@ import { isIEOrEdge } from "./browser_detection";
  *     undefined if no trackElement was added.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Boolean} hidden - If `true`, the text track will be hidden by
- * default. If `false`, the text track will be directly showing.
  * @returns {Object}
  */
-export default function addTextTrack(mediaElement, hidden) {
-    var _a, _b;
+export default function addTextTrack(mediaElement) {
+    var _a;
     var track;
     var trackElement;
     var kind = "subtitles";
@@ -36,15 +34,14 @@ export default function addTextTrack(mediaElement, hidden) {
         var tracksLength = mediaElement.textTracks.length;
         track = (tracksLength > 0 ? mediaElement.textTracks[tracksLength - 1] :
             mediaElement.addTextTrack(kind));
-        track.mode = hidden ? ((_a = track.HIDDEN) !== null && _a !== void 0 ? _a : "hidden") :
-            ((_b = track.SHOWING) !== null && _b !== void 0 ? _b : "showing");
+        track.mode = (_a = track.SHOWING) !== null && _a !== void 0 ? _a : "showing";
     }
     else {
         trackElement = document.createElement("track");
         mediaElement.appendChild(trackElement);
         track = trackElement.track;
         trackElement.kind = kind;
-        track.mode = hidden ? "hidden" : "showing";
+        track.mode = "showing";
     }
     return { track: track, trackElement: trackElement };
 }

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

@@ -22,7 +22,7 @@ interface ICompatMediaKeysConstructor {
  * Browser implementation of a VTTCue constructor.
  * TODO open TypeScript issue about it?
  */
-declare type ICompatVTTCueConstructor = new (start: number, end: number, cueText: string) => ICompatVTTCue;
+type ICompatVTTCueConstructor = new (start: number, end: number, cueText: string) => ICompatVTTCue;
 /** Browser implementation for a single VTTCue. */
 interface ICompatVTTCue {
     align: string;
@@ -52,15 +52,8 @@ interface ICompatTextTrack extends TextTrack {
  * functions for some "old" browsers.
  */
 interface ICompatDocument extends Document {
-    fullscreenElement: Element | null;
-    mozCancelFullScreen?: () => void;
-    mozFullScreenElement?: HTMLElement;
     mozHidden?: boolean;
-    msExitFullscreen?: () => void;
-    msFullscreenElement?: Element | null;
     msHidden?: boolean;
-    webkitExitFullscreen: () => void;
-    webkitFullscreenElement: Element | null;
     webkitHidden?: boolean;
 }
 /**

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

@@ -35,11 +35,16 @@ var isSamsungBrowser = !isNode &&
 var isTizen = !isNode &&
     /Tizen/.test(navigator.userAgent);
 var isWebOs = !isNode &&
-    /Web0S/.test(navigator.userAgent);
-var isWebOs2021 = !isNode &&
-    /WebOS.TV-2021/.test(navigator.userAgent);
-var isWebOs2022 = !isNode &&
-    /WebOS.TV-2022/.test(navigator.userAgent);
+    navigator.userAgent.indexOf("Web0S") >= 0;
+// Inspired form: http://webostv.developer.lge.com/discover/specifications/web-engine/
+// Note: even that page doesn't correspond to what we've actually seen in the
+// wild
+var isWebOs2021 = isWebOs &&
+    (/[Ww]eb[O0]S.TV-2021/.test(navigator.userAgent) ||
+        /[Cc]hr[o0]me\/79/.test(navigator.userAgent));
+var isWebOs2022 = isWebOs &&
+    (/[Ww]eb[O0]S.TV-2022/.test(navigator.userAgent) ||
+        /[Cc]hr[o0]me\/87/.test(navigator.userAgent));
 /** `true` on Safari on a PC platform (i.e. not iPhone / iPad etc.) */
 var isSafariDesktop = !isNode && (Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") >= 0 ||
     ((_b = (_a = window.safari) === null || _a === void 0 ? void 0 : _a.pushNotification) === null || _b === void 0 ? void 0 : _b.toString()) ===

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/close_session.js

@@ -28,7 +28,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

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/eme/custom_media_keys/index.d.ts

@@ -16,7 +16,7 @@
 import CustomMediaKeySystemAccess from "./../custom_key_system_access";
 import { ICustomMediaKeys, ICustomMediaKeySession } from "./types";
 /** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
-declare type ICompatRequestMediaKeySystemAccessFn = (keyType: string, config: MediaKeySystemConfiguration[]) => Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+type ICompatRequestMediaKeySystemAccessFn = (keyType: string, config: MediaKeySystemConfiguration[]) => Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
 declare let requestMediaKeySystemAccess: ICompatRequestMediaKeySystemAccessFn | null;
 /**
  * Set the given MediaKeys on the given HTMLMediaElement.

package/dist/_esm5.processed/compat/eme/custom_media_keys/webkit_media_keys_constructor.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-declare type IWebKitMediaKeys = unknown;
+type IWebKitMediaKeys = unknown;
 interface IWebKitMediaKeysConstructor {
     new (keySystem: string): IWebKitMediaKeys;
     isTypeSupported: (keyType: string) => boolean;

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

@@ -28,7 +28,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

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";
@@ -26,16 +21,13 @@ export interface IEventEmitterLike {
     addEventListener: (eventName: string, handler: () => void) => void;
     removeEventListener: (eventName: string, handler: () => void) => void;
 }
-export declare type IEventTargetLike = HTMLElement | IEventEmitterLike | IEventEmitter<unknown>;
+export type IEventTargetLike = HTMLElement | IEventEmitterLike | IEventEmitter<unknown>;
 /**
- * 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}
+ * Get video width from Picture-in-Picture window
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Object} pipWindow
+ * @returns {number}
  */
-declare function getPageActivityRef(stopListening: CancellationSignal): IReadOnlySharedReference<boolean>;
 export interface IPictureInPictureEvent {
     isEnabled: boolean;
     pipWindow: ICompatPictureInPictureWindow | null;
@@ -44,7 +36,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,116 +47,108 @@ 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>;
 /**
- * Get video width from HTML video element, or video estimated dimensions
- * when Picture-in-Picture is activated.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} pipStatusRef
+ * Get video width and height from the screen dimensions.
  * @param {Object} stopListening
  * @returns {Object}
  */
-declare function getVideoWidthRef(mediaElement: HTMLMediaElement, pipStatusRef: IReadOnlySharedReference<IPictureInPictureEvent>, stopListening: CancellationSignal): IReadOnlySharedReference<number>;
+declare function getScreenResolutionRef(stopListening: CancellationSignal): IReadOnlySharedReference<{
+    width: number | undefined;
+    height: number | undefined;
+    pixelRatio: number;
+}>;
 /**
+ * Get video width and height from HTML media element, or video estimated
+ * dimensions when Picture-in-Picture is activated.
  * @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}
+ * @param {Object} pipStatusRef
+ * @param {Object} stopListening
+ * @returns {Object}
  */
-declare const onSeeked$: (element: IEventTargetLike) => Observable<Event>;
+declare function getElementResolutionRef(mediaElement: HTMLMediaElement, pipStatusRef: IReadOnlySharedReference<IPictureInPictureEvent>, stopListening: CancellationSignal): IReadOnlySharedReference<{
+    width: number | undefined;
+    height: number | undefined;
+    pixelRatio: number;
+}>;
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
-declare const onEnded$: (element: IEventTargetLike) => Observable<Event>;
+declare const onLoadedMetadata: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
  */
-declare const onTimeUpdate$: (element: IEventTargetLike) => Observable<Event>;
+declare const onTimeUpdate: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
- * @param {HTMLElement} element
- * @returns {Observable}
+ * @param {TextTrackList} mediaElement
  */
-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 +162,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, getPictureOnPictureStateRef, getVideoVisibilityRef, getElementResolutionRef, getScreenResolutionRef, onEncrypted, onEnded, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };