rx-player 4.0.0-dev.2023120600 → 4.0.0-dev.2023121900

package/CHANGELOG.md

@@ -1,6 +1,8 @@
-# Changelog
+## v4.0.0-dev.2023121900 (2023-12-19)
 
-## v4.0.0-dev.2023120600 (2023-12-06)
+### Changes
+
+  - A `representationFilter`'s advertised `codec` has now been renamed to `codecs` and is an Array when defined [#1332]
 
 ### Features
 
@@ -13,8 +15,11 @@
 
   - Fix subtitles "blinking" in some specific conditions, especially with some DASH low-latency contents [#1314]
   - DASH: Fix Period overlap resolution logic for when the first Period is removed [#1311]
+  - TTML: Fix handling of the `tts:lineHeight` attribute [#1320]
   - Fix import of the `LOCAL_MANIFEST` experimental feature
   - Smooth: Rely on a defined `segmentLoader` when playing smooth streaming contents.
+  - Avoid very rarely skipping segments which initially were too big to be pushed due to memory limitations [#1323]
+  - Tizen (Samsung TVs): Try again to work around all potential issues that could arise due to tizen seeking back by itself [#1327]
 
 ### Other improvements
 
@@ -26,7 +31,178 @@
   - DEBUG_ELEMENT: always synchronize inventory of segments before rendering it [#1317]
   - Remove remaining RxPlayer dependency removing possibility of some application-side bundling errors [#1312]
   - Add cache when checking for codec support, improving performance on some devices and potentially working around some xbox bugs on long-lived pages [#1324]
+  - Add exception to text Garbage collection logic to avoid unnecessarily reload text segments frequently [#1325]
+  - Demo: Fix switching mode toggle [#1328]
   - Demo: Add possibility to see the debug element in the demo page
+  - Demo: Fix reporting of live position in demo page [#1313]
+
+
+## v4.0.0-beta.3 (2023-10-19)
+
+### Changes
+
+  - The `MediaError`'s `trackInfo` property is now an array renamed as `tracksInfo` and similar `MediaError` are grouped in one [#1264]
+  - The `manifestUpdateUrl` `loadVideo` option has been removed as it was unused [#1276]
+  - The `/dist` directory in the project has been removed [#1270]
+
+### Bug fixes
+
+  - Fix adaptive logic on some legacy Edge browsers [#1302]
+
+### Other improvements
+
+  - `newAvailablePeriods` is now sent lazily at the time new Periods are considered to improve performance [#1265]
+  - Implement better error messages by not repeating the Error Type in it [#1290]
+  - All import path to the RxPlayer now depend on the same RxPlayer modular build (and not just the minimal, as before) [#1301]
+
+
+## v4.0.0-beta.2 (2023-06-27)
+
+### Changes
+
+  - If all Representations from the current track become undecipherable, automatically switch to another track (also send a `trackUpdate` event) instead of stopping on error [#1234]
+  - Only send `MediaError` errors with the `NO_PLAYABLE_REPRESENTATION` error code when no Representation from all tracks of a given type can be played [#1234]
+
+### Features
+
+  - Add `representationListUpdate` event for when the list of available Representation for a current track changes [#1240]
+  - Add `"no-playable-representation"` as a `reason` for `trackUpdate` events when the track switch is due to encrypted Representations [#1234]
+
+### Other improvements
+
+  - DRM: Reload when playback is unexpectedly frozen with encrypted but only decipherable data in the buffer to work-around rare encryption-related issues [#1236]
+
+
+## v4.0.0-beta.1 (2023-03-08)
+
+### Bug fixes
+
+  - (v4.0.0-beta.0-only issue) Fix memory leak
+  - (v4.0.0-beta.0-only issue) Fix MediaSource duration when the maximum buffered end is inferior to current duration but superior to calculated duration
+  - (v4.0.0-beta.0-only issue) Fix `stopAtEnd` option by also switching to STOPPED state on ended
+  - (v4.0.0-beta.0-only issue) Fix some target's support by not relying on `Promise.prototype.finally` anymore [#1224]
+  - (v4.0.0-beta.0-only issue) For dynamic contents, always set a very high duration [#1220]
+  - (v4.0.0-beta.0-only issue) DRM: Fix fallbacking for an already-played content by checking key statuses initially linked to a MediaKeySession
+
+### Other improvements
+
+  - Based on the v3.30.0 of which it inherits all the features, bug fixes and other improvements
+
+
+## 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.32.1 (2023-10-19)

package/README.md

@@ -179,21 +179,11 @@ Demo pages for our previous versions are also available
 
 
 
-## Your questions ##############################################################
-
-You can ask directly your questions about the project on [our
-gitter](https://gitter.im/canalplus/rx-player).
-We will try our best to answer them as quickly as possible.
-
-
-
 ## Contribute ##################################################################
 
 Details on how to contribute is written in the [CONTRIBUTING.md
 file](./CONTRIBUTING.md) at the root of this repository.
 
-If you need more information, you can contact us via our [gitter
-room](https://gitter.im/canalplus/rx-player).
 
 
 ### Dependencies ###############################################################
@@ -213,7 +203,7 @@ Canal+ Group is a media company with many advanced needs when it comes to media
 playback: it provides both live and VoD stream with multiple encryption
 requirements, supports a very large panel of devices and has many other
 specificities (like adult content restrictions, ad-insertion, Peer-To-Peer
-integration...).
+integration, low-latency live streaming...).
 
 When the time came to switch from a plugin-based web player approach to an HTML5
 one back in 2015, no media player had the key features we wanted, and including
@@ -224,7 +214,7 @@ The R&D department of Canal+ Group thus started to work on a new featureful
 media-player: the RxPlayer. To both help and profit from the community, it also
 decided to share it to everyone under a permissive open-source licence.
 
-Now, more than 6 years later, the RxPlayer continues to evolve at the same fast
+Now, more than 8 years later, the RxPlayer continues to evolve at the same fast
 pace to include a lot of features and improvements you may not find in other
 media players.
 You can look at our
@@ -271,24 +261,3 @@ them. Amongst those:
     risks always low.
 
 \* In "directfile" mode, on compatible browsers
-
-
-## Target support ##############################################################
-
-Here is a basic list of supported platforms:
-
-|             | Chrome  |  IE [1] |  Edge  |  Firefox  |  Safari  |  Opera  |
-|-------------|:-------:|:-------:|:------:|:---------:|:--------:|:-------:|
-| Windows     |  >= 30  |  >= 11  |  >= 12 |   >= 42   |   >= 8   |  >= 25  |
-| OSX         |  >= 30  |    -    |    -   |   >= 42   |   >= 8   |  >= 25  |
-| Linux       |  >= 37  |    -    |    -   |   >= 42   |    -     |  >= 25  |
-| Android [2] |  >= 30  |    -    |    -   |   >= 42   |    -     |  >= 15  |
-| iOS         |   No    |    -    |    -   |    No     |    No    |    No   |
-
-[1] Only on Windows >= 8.
-
-[2] Android version >= 4.2
-
-And more. A good way to know if the browser should be supported by our player is
-to go on the page https://www.youtube.com/html5 and check for "Media Source
-Extensions" support.

package/VERSION

@@ -1 +1 @@
-4.0.0-dev.2023120600
+4.0.0-dev.2023121900

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

@@ -23,9 +23,11 @@ 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): {
+export default function addTextTrack(mediaElement: HTMLMediaElement, hidden: boolean): {
     track: ICompatTextTrack;
     trackElement: HTMLTrackElement | undefined;
 };

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

@@ -23,10 +23,12 @@ 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) {
-    var _a;
+export default function addTextTrack(mediaElement, hidden) {
+    var _a, _b;
     var track;
     var trackElement;
     var kind = "subtitles";
@@ -34,14 +36,15 @@ export default function addTextTrack(mediaElement) {
         var tracksLength = mediaElement.textTracks.length;
         track = (tracksLength > 0 ? mediaElement.textTracks[tracksLength - 1] :
             mediaElement.addTextTrack(kind));
-        track.mode = (_a = track.SHOWING) !== null && _a !== void 0 ? _a : "showing";
+        track.mode = hidden ? ((_a = track.HIDDEN) !== null && _a !== void 0 ? _a : "hidden") :
+            ((_b = track.SHOWING) !== null && _b !== void 0 ? _b : "showing");
     }
     else {
         trackElement = document.createElement("track");
         mediaElement.appendChild(trackElement);
         track = trackElement.track;
         trackElement.kind = kind;
-        track.mode = "showing";
+        track.mode = hidden ? "hidden" : "showing";
     }
     return { track: track, trackElement: trackElement };
 }

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

@@ -52,8 +52,15 @@ 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/event_listeners.d.ts

@@ -34,6 +34,15 @@ export type IEventTargetLike = HTMLElement | IEventEmitterLike | IEventEmitter<u
  * be triggered when that event is emitted on a given event target.
  */
 declare function createCompatibleEventListener(eventNames: string[], prefixes?: string[]): (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
+/**
+ * Returns a reference:
+ *   - Set to `true` when the current page is considered visible and active.
+ *   - Set to `false` otherwise.
+ * @param {Object} stopListening - `CancellationSignal` allowing to free the
+ * resources allocated to update this value.
+ * @returns {Object}
+ */
+declare function getPageActivityRef(stopListening: CancellationSignal): IReadOnlySharedReference<boolean>;
 export interface IPictureInPictureEvent {
     isEnabled: boolean;
     pipWindow: ICompatPictureInPictureWindow | null;
@@ -74,7 +83,11 @@ declare const onLoadedMetadata: (element: IEventTargetLike, listener: (event?: u
  */
 declare const onTimeUpdate: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
- * @param {TextTrackList} mediaElement
+ * @param {HTMLElement} element
+ */
+declare const onFullscreenChange: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
+/**
+ * @param {TextTrackList} textTrackList
  */
 declare const onTextTrackAdded: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
@@ -150,4 +163,4 @@ declare const onEnded: (element: IEventTargetLike, listener: (event?: unknown) =
  * emits
  */
 declare function addEventListener(elt: IEventEmitterLike, evt: string, listener: (x?: unknown) => void, stopListening: CancellationSignal): void;
-export { addEventListener, createCompatibleEventListener, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEnded, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };
+export { addEventListener, createCompatibleEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEnded, onFullscreenChange, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };

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

@@ -166,6 +166,35 @@ function getDocumentVisibilityRef(stopListening) {
     }, stopListening);
     return ref;
 }
+/**
+ * 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 getPageActivityRef(stopListening) {
+    var isDocVisibleRef = getDocumentVisibilityRef(stopListening);
+    var currentTimeout;
+    var ref = new SharedReference(true, stopListening);
+    stopListening.register(function () {
+        clearTimeout(currentTimeout);
+        currentTimeout = undefined;
+    });
+    isDocVisibleRef.onUpdate(function onDocVisibilityChange(isVisible) {
+        clearTimeout(currentTimeout); // clear potential previous timeout
+        currentTimeout = undefined;
+        if (!isVisible) {
+            var INACTIVITY_DELAY = config.getCurrent().INACTIVITY_DELAY;
+            currentTimeout = window.setTimeout(function () {
+                ref.setValueIfChanged(false);
+            }, INACTIVITY_DELAY);
+        }
+        ref.setValueIfChanged(true);
+    }, { clearSignal: stopListening, emitCurrentValue: true });
+    return ref;
+}
 /**
  * Get video width from Picture-in-Picture window
  * @param {HTMLMediaElement} mediaElement
@@ -303,7 +332,13 @@ var onLoadedMetadata = createCompatibleEventListener(["loadedmetadata"]);
  */
 var onTimeUpdate = createCompatibleEventListener(["timeupdate"]);
 /**
- * @param {TextTrackList} mediaElement
+ * @param {HTMLElement} element
+ */
+var onFullscreenChange = createCompatibleEventListener(["fullscreenchange", "FullscreenChange"], 
+// On IE11, fullscreen change events is called MSFullscreenChange
+BROWSER_PREFIXES.concat("MS"));
+/**
+ * @param {TextTrackList} textTrackList
  */
 var onTextTrackAdded = createCompatibleEventListener(["addtrack"]);
 /**
@@ -384,4 +419,4 @@ function addEventListener(elt, evt, listener, stopListening) {
         elt.removeEventListener(evt, listener);
     });
 }
-export { addEventListener, createCompatibleEventListener, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEnded, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };
+export { addEventListener, createCompatibleEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEnded, onFullscreenChange, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };

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

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Request fullScreen action on a given element.
+ * @param {HTMLElement} elt
+ */
+declare function requestFullscreen(element: HTMLMediaElement): void;
+/**
+ * Exit fullscreen if an element is currently in fullscreen.
+ */
+declare function exitFullscreen(): void;
+/**
+ * Returns true if an element in the document is being displayed in fullscreen
+ * mode;
+ * otherwise it's false.
+ * @returns {boolean}
+ */
+declare function isFullscreen(): boolean;
+export { requestFullscreen, exitFullscreen, isFullscreen, };

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

@@ -0,0 +1,78 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Request fullScreen action on a given element.
+ * @param {HTMLElement} elt
+ */
+function requestFullscreen(element) {
+    if (!isFullscreen()) {
+        var elt = element;
+        /* eslint-disable @typescript-eslint/unbound-method */
+        if (typeof elt.requestFullscreen === "function") {
+            /* eslint-enable @typescript-eslint/unbound-method */
+            /* eslint-disable @typescript-eslint/no-floating-promises */
+            elt.requestFullscreen();
+            /* eslint-enable @typescript-eslint/no-floating-promises */
+        }
+        else if (typeof elt.msRequestFullscreen === "function") {
+            elt.msRequestFullscreen();
+        }
+        else if (typeof elt.mozRequestFullScreen === "function") {
+            elt.mozRequestFullScreen();
+        }
+        else if (typeof elt.webkitRequestFullscreen === "function") {
+            elt.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
+        }
+    }
+}
+/**
+ * Exit fullscreen if an element is currently in fullscreen.
+ */
+function exitFullscreen() {
+    if (isFullscreen()) {
+        var doc = document;
+        /* eslint-disable @typescript-eslint/unbound-method */
+        if (typeof doc.exitFullscreen === "function") {
+            /* eslint-enable @typescript-eslint/unbound-method */
+            /* eslint-disable @typescript-eslint/no-floating-promises */
+            doc.exitFullscreen();
+            /* eslint-enable @typescript-eslint/no-floating-promises */
+        }
+        else if (typeof doc.msExitFullscreen === "function") {
+            doc.msExitFullscreen();
+        }
+        else if (typeof doc.mozCancelFullScreen === "function") {
+            doc.mozCancelFullScreen();
+        }
+        else if (typeof doc.webkitExitFullscreen === "function") {
+            doc.webkitExitFullscreen();
+        }
+    }
+}
+/**
+ * Returns true if an element in the document is being displayed in fullscreen
+ * mode;
+ * otherwise it's false.
+ * @returns {boolean}
+ */
+function isFullscreen() {
+    var doc = document;
+    return (doc.fullscreenElement != null ||
+        doc.mozFullScreenElement != null ||
+        doc.webkitFullscreenElement != null ||
+        doc.msFullscreenElement != null);
+}
+export { requestFullscreen, exitFullscreen, isFullscreen, };

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

@@ -22,9 +22,11 @@ import tryToChangeSourceBufferType, { ICompatSourceBuffer } from "./change_sourc
 import clearElementSrc from "./clear_element_src";
 import enableAudioTrack from "./enable_audio_track";
 import * as events from "./event_listeners";
+import { exitFullscreen, isFullscreen, requestFullscreen } from "./fullscreen";
 import getStartDate from "./get_start_date";
 import isCodecSupported from "./is_codec_supported";
 import isNode from "./is_node";
+import isOffline from "./is_offline";
 import isVTTCue from "./is_vtt_cue";
 import makeVTTCue from "./make_vtt_cue";
 import onHeightWidthChange from "./on_height_width_change";
@@ -34,4 +36,4 @@ import shouldUnsetMediaKeys from "./should_unset_media_keys";
 import shouldValidateMetadata from "./should_validate_metadata";
 import shouldWaitForDataBeforeLoaded from "./should_wait_for_data_before_loaded";
 import shouldWaitForHaveEnoughData from "./should_wait_for_have_enough_data";
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, canReuseMediaKeys, clearElementSrc, enableAudioTrack, events, getStartDate, ICompatTextTrack, ICompatVTTCue, ICompatSourceBuffer, isCodecSupported, isNode, isVTTCue, makeVTTCue, MediaSource_, onHeightWidthChange, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeySystemAccess, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, shouldWaitForHaveEnoughData, tryToChangeSourceBufferType, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, canReuseMediaKeys, clearElementSrc, enableAudioTrack, events, exitFullscreen, getStartDate, ICompatTextTrack, ICompatVTTCue, ICompatSourceBuffer, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, makeVTTCue, MediaSource_, onHeightWidthChange, requestFullscreen, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeySystemAccess, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, shouldWaitForHaveEnoughData, tryToChangeSourceBufferType, };

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

@@ -22,9 +22,11 @@ import tryToChangeSourceBufferType from "./change_source_buffer_type";
 import clearElementSrc from "./clear_element_src";
 import enableAudioTrack from "./enable_audio_track";
 import * as events from "./event_listeners";
+import { exitFullscreen, isFullscreen, requestFullscreen, } from "./fullscreen";
 import getStartDate from "./get_start_date";
 import isCodecSupported from "./is_codec_supported";
 import isNode from "./is_node";
+import isOffline from "./is_offline";
 import isVTTCue from "./is_vtt_cue";
 import makeVTTCue from "./make_vtt_cue";
 import onHeightWidthChange from "./on_height_width_change";
@@ -40,4 +42,4 @@ import shouldWaitForHaveEnoughData from "./should_wait_for_have_enough_data";
 // we  would prefer to disallow (both for the understandability of the code and
 // to better exploit tree shaking.
 patchWebkitSourceBuffer();
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, canReuseMediaKeys, clearElementSrc, enableAudioTrack, events, getStartDate, isCodecSupported, isNode, isVTTCue, makeVTTCue, MediaSource_, onHeightWidthChange, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeySystemAccess, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, shouldWaitForHaveEnoughData, tryToChangeSourceBufferType, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, canReuseMediaKeys, clearElementSrc, enableAudioTrack, events, exitFullscreen, getStartDate, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, makeVTTCue, MediaSource_, onHeightWidthChange, requestFullscreen, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeySystemAccess, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, shouldWaitForHaveEnoughData, tryToChangeSourceBufferType, };

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

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Some browsers have a builtin API to know if it's connected at least to a
+ * LAN network, at most to the internet.
+ *
+ * /!\ This feature can be dangerous as you can both have false positives and
+ * false negatives.
+ *
+ * False positives:
+ *   - you can still play local contents (on localhost) if isOffline == true
+ *   - on some browsers isOffline might be true even if we're connected to a LAN
+ *     or a router (it would mean we're just not able to connect to the
+ *     Internet). So we can eventually play LAN contents if isOffline == true
+ *
+ * False negatives:
+ *   - in some cases, we even might have isOffline at false when we do not have
+ *     any connection:
+ *       - in browsers that do not support the feature
+ *       - in browsers running in some virtualization softwares where the
+ *         network adapters are always connected.
+ *
+ * Use with these cases in mind.
+ * @returns {Boolean}
+ */
+export default function isOffline(): boolean;