rx-player 3.28.0 → 4.0.0-alpha.2022080900

package/.github/workflows/checks.yml

@@ -54,27 +54,29 @@ jobs:
     - run: node tests/integration/run.js --bchromehl
     - run: npm run test:memory
 
-  integration_windows:
+  # Windows seems to be a lot less stable for some reason.
+  # TODO debug?
+  # integration_windows:
 
-    runs-on: windows-latest
+  #   runs-on: windows-latest
 
-    strategy:
-      matrix:
-        node-version: [16.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+  #   strategy:
+  #     matrix:
+  #       node-version: [16.x]
+  #       # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm install
-    # Firefox seems to have issue with integration tests on GitHub actions only
-    # TODO to check
-    - run: node tests/integration/run.js --bchromehl
-    - run: npm run test:memory
+  #   steps:
+  #   - uses: actions/checkout@v2
+  #   - name: Use Node.js ${{ matrix.node-version }}
+  #     uses: actions/setup-node@v2
+  #     with:
+  #       node-version: ${{ matrix.node-version }}
+  #       cache: 'npm'
+  #   - run: npm install
+  #   # Firefox seems to have issue with integration tests on GitHub actions only
+  #   # TODO to check
+  #   - run: node tests/integration/run.js --bchromehl
+  #   - run: npm run test:memory
 
   # MacOS seems to be a lot less stable for some reason.
   # TODO debug?

package/CHANGELOG.md

@@ -25,6 +25,7 @@
 ### Other improvements
 
   - TTML: Add support for percent based thickness for textOutline in TTML Subtitles [#1108]
+  - Improve TypeScript's language servers auto import feature with the RxPlayer by better redirecting to the exported type [#1126]
   - If seeking after the last potential position, load last segments before ending [#1097]
   - The duration set on the media element is now only relative to the current chosen tracks (it was previously relative to all potential track). This allows to seek later when switching e.g. to a longer video track [#1102]
   - Errors coming from an HTMLMediaElement now have the browser's error message if it exists [#1112]

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 @@
-3.28.0
+4.0.0-alpha.2022080900

package/a.js

@@ -0,0 +1,373 @@
+// Cas les plus fréquents
+
+// Seulement mettre la piste courante en français
+// ----------------------------------------------
+//
+// Rien ne change:
+
+const choosenTrack = player.getAvailableAudioTracks()
+  .find((t) => t.normalized === "fra" && t.audioDescription !== true);
+if (choosenTrack !== undefined) {
+  player.setAudioTrack(choosenTrack.id);
+}
+
+// Mettre la piste francaise pour toutes les Periods
+// -------------------------------------------------
+//
+// Brancher l'event `"newAvailablePeriods"` pour les futures Periods anoncées
+// après mise à jour du Manifest et au changement de contenu et appeller
+// `setAudioTrack` pour toutes les Periods:
+
+player.addEventListener("newAvailablePeriods", (periods) => {
+  periods.forEach(setFrenchTrackForPeriod);
+});
+player.getAvailablePeriods()
+  .forEach(setFrenchTrackForPeriod);
+
+function setFrenchTrackForPeriod(periodInfo) {
+  const chosenTrack = player.getAvailableAudioTracks(periodInfo.id)
+    .find((t) => t.normalized === "fra" && t.audioDescription !== true);
+  if (choosenTrack !== undefined) {
+    player.setAudioTrack( { periodId: periodInfo.id,
+                            trackId: chosenTrack.id });
+  }
+}
+
+// Plus général: changer la piste pour toutes les Periods
+// ------------------------------------------------------
+//
+// Pareil, juste ajoutons un store simplifié:
+
+const SomeStore = {
+  language: "eng",
+  isAudioDescription: false,
+};
+
+player.addEventListener("newAvailablePeriods", (periods) => {
+  periods.forEach(setAudioTrackForPeriod);
+});
+
+function updateAllAudioTracks(newLanguage, newAudioDescriptionStatus) {
+  SomeStore.language = newLanguage;
+  SomeStore.isAudioDescription = newAudioDescriptionStatus;
+  player.getAvailablePeriods().forEach(setAudioTrackForPeriod);
+}
+
+function setAudioTrackForPeriod(periodInfo) {
+  const { language, isAudioDescription } = SomeStore;
+  const choosenTrack = player.getAvailableAudioTracks(periodInfo.id)
+    .find((t) =>
+      t.normalized === language &&
+      isAudioDescription ? t.audioDescription === true :
+                           t.audioDescription !== true);
+  if (choosenTrack !== undefined) {
+    player.setAudioTrack({
+      trackId: choosenTrack.id,
+      lockedRepresentations: [chosenTrack.representations[0].id]
+    }, periodInfo.id);
+  }
+}
+
+
+// Simplifier et optimiser ce cas fréquent pour le futur ?
+// -------------------------------------------------------
+//
+// Proposition d'un "defaultAudioTrackSelector" configurable pour définir la piste par
+// défaut:
+
+const SomeStore = {
+  language: "eng",
+  isAudioDescription: false,
+};
+
+function updateAllAudioTracks(newLanguage, newAudioDescriptionStatus) {
+  SomeStore.language = newLanguage;
+  SomeStore.isAudioDescription = newAudioDescriptionStatus;
+  player.setDefaultAudioTrackSelector(setAudioTrackForPeriod);
+}
+
+function setAudioTrackForPeriod(audioTracks, _periodInfo) {
+  const { language, isAudioDescription } = SomeStore;
+  const choosenTrack = audioTracks.find((t) =>
+      t.normalized === language &&
+      isAudioDescription ? t.audioDescription === true :
+                           t.audioDescription !== true);
+  if (choosenTrack === undefined) {
+    // preference not found, let the RxPlayer choose for us
+    return undefined;
+  }
+  // preference found: select it
+  return choosenTrack.id;
+}
+
+// => reset pour la Period courante ? second argument booléen
+// => persisté au changement de contenu ? oui
+// => autoriser un setAudioTrack pendant qu'un defaultAudioTrackSelector est actif ? oui
+
+player.hasDefaultAudioTrackSelector();
+player.removeDefaultAudioTrackSelector();
+
+
+// All APIs:
+
+player.getAvailableAudioTracks();
+player.getAvailableVideoTracks();
+player.getAvailableTextTracks();
+player.getAudioTrack();
+player.getVideoTrack();
+player.getTextTrack();
+player.setAudioTrack();
+player.setVideoTrack();
+player.setTextTrack();
+
+player.setDefaultAudioTrackSelector();
+player.setDefaultVideoTrackSelector();
+player.setDefaultTextTrackSelector();
+player.removeDefaultAudioTrackSelector();
+player.removeDefaultVideoTrackSelector();
+player.removeDefaultTextTrackSelector();
+player.hasDefaultAudioTrackSelector();
+player.hasDefaultVideoTrackSelector();
+player.hasDefaultTextTrackSelector();
+
+
+// ```
+// # Representation (quality) selection
+//
+// ## lockVideoRepresentations / lockAudioRepresentations
+
+
+player.setMaxVideoBitrate(1000);
+
+// For all future Periods and contents
+player.addEventListener("newAvailablePeriods", (periods) => {
+  periods.forEach((p) => limitVideoBitrate(p, 1000));
+});
+
+// If currently playing, for all Periods in the current content
+player.getAvailablePeriods()
+  .forEach((p) => limitVideoBitrate(p, 1000));
+
+// At each track change
+player.setAudioTrack({
+  trackId,
+  periodId,
+  lockedRepresentations: getLimited(p, 1000),
+});
+
+
+// Automatically filter which Representation will be played by default
+player.setAutoVideoRepresentationsLocker((videoTrack, _periodInfo) => {
+  const filtered = videoTrack.representations
+    .filter(rep => rep.bitrate !== undefined && rep.bitrate <= 1000)
+    .map(rep => rep.id);
+
+  if (filtered.length === 0) {
+    if (videoTrack.representations.length === 0) {
+      return;
+    }
+    const minBitrate = videoTrack.representations.sort((a, b) => {
+
+    });
+  }
+}, true);
+
+player.setDefaultVideoTrackSelector((videoTracks, _periodInfo) => {
+  const activeVideoTrack = videoTracks.find(v => v.active) ?? videoTracks[0];
+  const filtered = activeVideoTrack.representations
+    .filter(rep => rep.bitrate !== undefined && rep.bitrate <= 1000)
+    .map(rep => rep.id);
+
+  if (filtered.length === 0) {
+    if (activeVideoTrack.representations.length === 0) {
+      return;
+    }
+    const minBitrate = activeVideoTrack.representations.sort((a, b) => {
+
+    });
+  }
+}, true);
+
+// Powerful enough to remove the need of track preference APIs, bitrate APIs and the
+// representationFilter API which all have their issues (mostly, they are not flexible enough and had
+// some complex behavior when diving into the details).
+//
+// However simple use cases that were previously easy to configure through those APIs are much harder
+// with thhe new.
+
+
+// representationFilter
+//
+// If this function was used to filter out some audio and/or video
+// Representation (which is all cases we've seen), its behavior can be
+// reproduced by using the new Representations "locking" feature, which allows
+// to only allow some Representations from being played (see
+// `lockVideoRepresentations` / `lockAudioRepresentations`).
+//
+// The new Representations locking feature is also more powerful, allowing to
+// inspect all other Representations from the corresponding track - or even all
+// other tracks while the filter function is called.
+//
+// The easiest way of replacing `representationFilter` could be by locking
+// wanted Representations through a "default video/audio track selector" before
+// calling `loadVideo`.
+// This can be donethrough the `setDefaultVideoTrackSelector` and/or the
+// `setDefaultAudioTrackSelector` method, depending on if you want to limit the
+// video Representations or the audio Representations. The following examples
+// are going to show how this can be done for video tracks, but it can also be
+// applied on audio tracks with the corresponding alternative methods.
+
+// Only authorize some video Representations from being played on the default
+// video tracks chosen by the RxPlayer:
+player.setDefaultVideoTrackSelector((videoTracks, periodInfo) => {
+  // Note: The `videoTracks` array begins by the default video track
+  const filtered = videoTracks[0].representations.filter(representationFilter);
+  return {
+    periodId: periodInfo.id,
+    lockedRepresentations: filtered,
+    trackId: videoTracks[0].id,
+  };
+});
+
+// Note that this filter is persisted even through the next contents you will
+// play. If you want to remove it, you can call the
+// `removeDefaultVideoTrackSelector` method:
+player.removeDefaultVideoTrackSelector();
+
+// If switching the video track is possible in your application, don't forget to
+// also apply the filter there:
+function changeVideoTrack(periodId, videoTrack) {
+  const filtered = videoTrack.representations.filter(representationFilter);
+  player.setVideoTrack({
+    periodId,
+    lockedRepresentations: filtered,
+    trackId: videoTrack.id,
+  });
+}
+
+// And that's all! You should now always be filtering out video Representations
+// for all video tracks chosen.
+
+// Note that if you display Representations choice to the user in some ways, you
+// might also want to remove the choice from that list:
+function getAvailableVideoRepresentations() {
+  player.getVideoTrack()
+  if (videoTrack === null) {
+    return []; //"No video track currently");
+  }
+  return videoTrack.representations.filter(representationFilter);
+}
+
+// update the documentation:
+//   - setAudioTrack
+//   - setTextTrack
+//   - setVideoTrack
+//
+// Add the documentation:
+//   - getAvailablePeriods method
+//
+// Write tests
+//
+// representationChange event?
+
+// /!\ ChromeCast etc.
+// singleLicensePer: "periods"
+
+// test Samsung
+
+
+// Example: Know when the video Representations lock is enabled / disabled for
+// the Period currently being played
+
+let areVideoRepresentationsLocked = false;
+
+function updateAreVideoRepresentationsLocked() {
+ areVideoRepresentationsLocked =
+   rxPlayer.getLockedVideoRepresentations() !== null;
+}
+
+// Update it each time the video lock for the current Period is "broken"
+rxPlayer.addEventListener("brokenRepresentationsLock", (info) => {
+  const currentPeriod = rxPlayer.getCurrentPeriod();
+  if (
+    info.trackType === "video" &&
+    currentPeriod !== null && info.period.id === currentPeriod.id
+  ) {
+    updateAreVideoRepresentationsLocked();
+  }
+});
+
+// Update it each time the video track for the current Period changes, whether
+// it was done explicitely (through setVideoTrack/disableVideoTrack),
+// implicitely (the RxPlayer automatically switched by itself) or just because
+// a new Period is now being played.
+rxPlayer.addEventListener("videoTrackChange", () => {
+  updateAreVideoRepresentationsLocked();
+});
+
+// And update it each time the lock API are called for the current Period
+function lockVideoRepresentations(reps) {
+ rxPlayer.lockVideoRepresentations(reps);
+ updateAreVideoRepresentationsLocked();
+}
+function unlockVideoRepresentations() {
+ rxPlayer.unlockVideoRepresentations();
+ updateAreVideoRepresentationsLocked();
+}
+
+
+// Example: Know when the video Representations lock is enabled / disabled for
+// any Period
+
+// First let's consider a given period `id` named `PERIOD_ID`
+const PERIOD_ID = "<SOME_PERIOD_ID>";
+
+let areVideoRepresentationsLockedForPeriod = false;
+
+function updateAreVideoRepresentationsLocked() {
+ areVideoRepresentationsLockedForPeriod =
+   rxPlayer.getLockedVideoRepresentations(PERIOD_ID) !== null;
+}
+
+// Update it each time the video lock for the corresponding Period is "broken"
+rxPlayer.addEventListener("brokenRepresentationsLock", (info) => {
+  if (info.trackType === "video" && info.period.id === PERIOD_ID) {
+    updateAreVideoRepresentationsLocked();
+  }
+});
+
+// Update it each time the video track is voluntarly changed/disabled for that Period
+function setVideoTrackForPeriod(periodId, trackId) {
+  rxPlayer.setVideoTrack({ periodId, trackId });
+  if (periodId === PERIOD_ID) {
+    updateAreVideoRepresentationsLocked();
+  }
+}
+function disableVideoTrackForPeriod() {
+  rxPlayer.setVideoTrack({ periodId, trackId });
+  if (periodId === PERIOD_ID) {
+    updateAreVideoRepresentationsLocked();
+  }
+}
+
+// Update it each time, the RxPlayer decides to automatically change the video
+// track for that Period (extremely rare)
+rxPlayer.addEventListener("autoTrackSwitch", (info) => {
+  if (info.trackType === "video" && info.period.id === PERIOD_ID) {
+    updateAreVideoRepresentationsLocked();
+  }
+});
+
+// And update it each time the lock API are called for that Period
+function lockVideoRepresentations(periodId, representations) {
+ rxPlayer.lockVideoRepresentations({ periodId, representations });
+ if (periodId === PERIOD_ID) {
+  updateAreVideoRepresentationsLocked();
+ }
+}
+function unlockVideoRepresentations(periodId) {
+ rxPlayer.unlockVideoRepresentations(periodId);
+ if (periodId === PERIOD_ID) {
+  updateAreVideoRepresentationsLocked();
+ }
+}

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

@@ -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/eme/load_session.d.ts

@@ -18,14 +18,13 @@ import { ICustomMediaKeySession } from "./custom_media_keys";
  * Load a persistent session, based on its `sessionId`, on the given
  * MediaKeySession.
  *
- * Returns an Observable which emits:
- *   - true if the persistent MediaKeySession was found and loaded
- *   - false if no persistent MediaKeySession was found with that `sessionId`.
- * Then completes.
+ * Returns a Promise which resolves with:
+ *   - `true` if the persistent MediaKeySession was found and loaded
+ *   - `false` if no persistent MediaKeySession was found with that `sessionId`.
  *
- * The Observable throws if anything goes wrong in the process.
+ * The Promise rejects if anything goes wrong in the process.
  * @param {MediaKeySession} session
  * @param {string} sessionId
- * @returns {Observable}
+ * @returns {Promise.<boolean>}
  */
 export default function loadSession(session: MediaKeySession | ICustomMediaKeySession, sessionId: string): Promise<boolean>;

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

@@ -55,15 +55,14 @@ var EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
  * Load a persistent session, based on its `sessionId`, on the given
  * MediaKeySession.
  *
- * Returns an Observable which emits:
- *   - true if the persistent MediaKeySession was found and loaded
- *   - false if no persistent MediaKeySession was found with that `sessionId`.
- * Then completes.
+ * Returns a Promise which resolves with:
+ *   - `true` if the persistent MediaKeySession was found and loaded
+ *   - `false` if no persistent MediaKeySession was found with that `sessionId`.
  *
- * The Observable throws if anything goes wrong in the process.
+ * The Promise rejects if anything goes wrong in the process.
  * @param {MediaKeySession} session
  * @param {string} sessionId
- * @returns {Observable}
+ * @returns {Promise.<boolean>}
  */
 export default function loadSession(session, sessionId) {
     return __awaiter(this, void 0, void 0, function () {

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

@@ -27,15 +27,6 @@ export interface IEventEmitterLike {
     removeEventListener: (eventName: string, handler: () => void) => void;
 }
 export declare 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}
- */
-declare function getPageActivityRef(stopListening: CancellationSignal): IReadOnlySharedReference<boolean>;
 export interface IPictureInPictureEvent {
     isEnabled: boolean;
     pipWindow: ICompatPictureInPictureWindow | null;
@@ -91,11 +82,6 @@ declare const onEnded$: (element: IEventTargetLike) => Observable<Event>;
  * @returns {Observable}
  */
 declare const onTimeUpdate$: (element: IEventTargetLike) => Observable<Event>;
-/**
- * @param {HTMLElement} element
- * @returns {Observable}
- */
-declare const onFullscreenChange$: (element: IEventTargetLike) => Observable<Event>;
 /**
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
@@ -162,4 +148,4 @@ declare const onKeyStatusesChange$: (element: IEventTargetLike) => Observable<Ev
  * emits
  */
 declare function addEventListener(elt: IEventEmitterLike, evt: string, listener: (x?: unknown) => void, stopListening: CancellationSignal): void;
-export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked$, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };
+export { addEventListener, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked$, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };

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

@@ -142,36 +142,6 @@ function getDocumentVisibilityRef(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 = createSharedReference(true);
-    stopListening.register(function () {
-        clearTimeout(currentTimeout);
-        currentTimeout = undefined;
-        ref.finish();
-    });
-    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
@@ -332,13 +302,6 @@ var onEnded$ = compatibleListener(["ended"]);
  * @returns {Observable}
  */
 var onTimeUpdate$ = compatibleListener(["timeupdate"]);
-/**
- * @param {HTMLElement} element
- * @returns {Observable}
- */
-var onFullscreenChange$ = compatibleListener(["fullscreenchange", "FullscreenChange"], 
-// On IE11, fullscreen change events is called MSFullscreenChange
-BROWSER_PREFIXES.concat("MS"));
 /**
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
@@ -413,4 +376,4 @@ function addEventListener(elt, evt, listener, stopListening) {
         elt.removeEventListener(evt, listener);
     });
 }
-export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked$, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };
+export { addEventListener, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked$, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };

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

@@ -21,7 +21,6 @@ import tryToChangeSourceBufferType, { ICompatSourceBuffer } from "./change_sourc
 import clearElementSrc from "./clear_element_src";
 import { closeSession, CustomMediaKeySystemAccess, generateKeyRequest, getInitData, ICustomMediaKeys, ICustomMediaKeySession, ICustomMediaKeySystemAccess, loadSession, requestMediaKeySystemAccess, setMediaKeys } from "./eme";
 import * as events from "./event_listeners";
-import { exitFullscreen, isFullscreen, requestFullscreen } from "./fullscreen";
 import getStartDate from "./get_start_date";
 import hasEMEAPIs from "./has_eme_apis";
 import isCodecSupported from "./is_codec_supported";
@@ -38,4 +37,4 @@ import shouldUnsetMediaKeys from "./should_unset_media_keys";
 import shouldValidateMetadata from "./should_validate_metadata";
 import shouldWaitForDataBeforeLoaded from "./should_wait_for_data_before_loaded";
 import whenLoadedMetadata$ from "./when_loaded_metadata";
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, ICompatTextTrack, ICompatVTTCue, ICustomMediaKeySession, ICustomMediaKeySystemAccess, ICustomMediaKeys, ICompatSourceBuffer, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, ICompatTextTrack, ICompatVTTCue, ICustomMediaKeySession, ICustomMediaKeySystemAccess, ICustomMediaKeys, ICompatSourceBuffer, isCodecSupported, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, };

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

@@ -21,7 +21,6 @@ import tryToChangeSourceBufferType from "./change_source_buffer_type";
 import clearElementSrc from "./clear_element_src";
 import { closeSession, CustomMediaKeySystemAccess, generateKeyRequest, getInitData, loadSession, requestMediaKeySystemAccess, setMediaKeys, } from "./eme";
 import * as events from "./event_listeners";
-import { exitFullscreen, isFullscreen, requestFullscreen, } from "./fullscreen";
 import getStartDate from "./get_start_date";
 import hasEMEAPIs from "./has_eme_apis";
 import isCodecSupported from "./is_codec_supported";
@@ -44,4 +43,4 @@ import whenLoadedMetadata$ from "./when_loaded_metadata";
 // we  would prefer to disallow (both for the understandability of the code and
 // to better exploit tree shaking.
 patchWebkitSourceBuffer();
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, isCodecSupported, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, };