shaka-player 4.10.13 → 4.11.0

package/lib/util/player_configuration.js

@@ -32,6 +32,7 @@ shaka.util.PlayerConfiguration = class {
     // This is a relatively safe default in the absence of clues from the
     // browser.  For slower connections, the default estimate may be too high.
     const bandwidthEstimate = 1e6; // 1Mbps
+    const minBytes = 16e3;
 
     let abrMaxHeight = Infinity;
 
@@ -162,7 +163,6 @@ shaka.util.PlayerConfiguration = class {
         ignoreManifestProgramDateTimeForTypes: [],
         mediaPlaylistFullMimeType:
             'video/mp2t; codecs="avc1.42E01E, mp4a.40.2"',
-        useSafariBehaviorForLive: true,
         liveSegmentsDelay: 3,
         sequenceMode: shaka.util.Platform.supportsSequenceMode(),
         ignoreManifestTimestampsInSegmentsMode: false,
@@ -225,6 +225,7 @@ shaka.util.PlayerConfiguration = class {
       autoLowLatencyMode: false,
       forceHTTP: false,
       forceHTTPS: false,
+      minBytesForProgressEvents: minBytes,
       preferNativeHls: false,
       updateIntervalSeconds: 1,
       dispatchAllEmsgBoxes: false,
@@ -341,7 +342,7 @@ shaka.util.PlayerConfiguration = class {
       },
       advanced: {
         minTotalBytes: 128e3,
-        minBytes: 16e3,
+        minBytes,
         fastHalfLife: 2,
         slowHalfLife: 5,
       },
@@ -352,6 +353,7 @@ shaka.util.PlayerConfiguration = class {
       safeMarginSwitch: 0,
       cacheLoadThreshold: 20,
       minTimeToSwitch: shaka.util.Platform.isApple() ? 0.5 : 0,
+      preferNetworkInformationBandwidth: false,
     };
 
     const cmcd = {

package/lib/util/stream_utils.js

@@ -118,9 +118,33 @@ shaka.util.StreamUtils = class {
       validAudioStreamsMap.set(groupId, validAudioStreams);
     }
 
+    // Keys based in MimeUtils.getNormalizedCodec. Lower is better
+    const videoCodecPreference = {
+      'vp8': 1,
+      'avc': 1,
+      'dovi-avc': 0.95,
+      'vp9': 0.9,
+      'vp09': 0.9,
+      'hevc': 0.85,
+      'dovi-hevc': 0.8,
+      'av01': 0.75,
+      'dovi-av1': 0.7,
+      'vvc': 0.65,
+    };
+
     const videoStreams = Array.from(videoStreamsSet)
         .sort((v1, v2) => {
-          if (!v1.bandwidth || !v2.bandwidth) {
+          if (!v1.bandwidth || !v2.bandwidth || v1.bandwidth == v2.bandwidth) {
+            if (v1.codecs && v2.codecs && v1.codecs != v2.codecs &&
+                v1.width == v2.width) {
+              const v1Codecs = MimeUtils.getNormalizedCodec(v1.codecs);
+              const v2Codecs = MimeUtils.getNormalizedCodec(v2.codecs);
+              if (v1Codecs != v2Codecs) {
+                const indexV1 = videoCodecPreference[v1Codecs] || 1;
+                const indexV2 = videoCodecPreference[v2Codecs] || 1;
+                return indexV1 - indexV2;
+              }
+            }
             return v1.width - v2.width;
           }
           return v1.bandwidth - v2.bandwidth;
@@ -1480,7 +1504,7 @@ shaka.util.StreamUtils = class {
     // in DASH this information comes at the stream level and not at the
     // segment level.
     if (stream.segmentIndex) {
-      reference = stream.segmentIndex.get(0);
+      reference = stream.segmentIndex.earliestReference();
     }
     let layout = stream.tilesLayout;
     if (reference) {
@@ -1860,6 +1884,37 @@ shaka.util.StreamUtils = class {
   }
 
 
+  /**
+   * Set the best iframe stream to the original stream.
+   *
+   * @param {!shaka.extern.Stream} stream
+   * @param {!Array.<!shaka.extern.Stream>} iFrameStreams
+   */
+  static setBetterIFrameStream(stream, iFrameStreams) {
+    if (!iFrameStreams.length) {
+      return;
+    }
+    const validStreams = iFrameStreams.filter((iFrameStream) =>
+      shaka.util.MimeUtils.getNormalizedCodec(stream.codecs) ==
+      shaka.util.MimeUtils.getNormalizedCodec(iFrameStream.codecs))
+        .sort((a, b) => {
+          if (!a.bandwidth || !b.bandwidth || a.bandwidth == b.bandwidth) {
+            return (a.width || 0) - (b.width || 0);
+          }
+          return a.bandwidth - b.bandwidth;
+        });
+    stream.trickModeVideo = validStreams[0];
+    if (validStreams.length > 1) {
+      const sameResolutionStream = validStreams.find((iFrameStream) =>
+        stream.width == iFrameStream.width &&
+        stream.height == iFrameStream.height);
+      if (sameResolutionStream) {
+        stream.trickModeVideo = sameResolutionStream;
+      }
+    }
+  }
+
+
   /**
    * Returns a string of a variant, with the attribute values of its audio
    * and/or video streams for log printing.

package/lib/util/tXml.js

@@ -62,7 +62,8 @@ shaka.util.TXml = class {
     if (!expectedRootElemName && result.length) {
       return result[0];
     }
-    const rootNode = result.find((n) => n.tagName === expectedRootElemName);
+    const rootNode = result.find((n) =>
+      expectedRootElemName.split(',').includes(n.tagName));
     if (rootNode) {
       return rootNode;
     }

package/lib/util/text_parser.js

@@ -131,4 +131,50 @@ shaka.util.TextParser = class {
       };
     }
   }
+
+  /**
+   * Parses a time.
+   *
+   * @return {?number}
+   */
+  parseTime() {
+    const results = this.readRegex(shaka.util.TextParser.timeFormat_);
+    if (results == null) {
+      return null;
+    }
+    // This capture is optional, but will still be in the array as undefined,
+    // in which case it is 0.
+    const hours = Number(results[1]) || 0;
+    const minutes = Number(results[2]);
+    const seconds = Number(results[3]);
+    const milliseconds = Number(results[6]) || 0;
+    if (minutes > 59 || seconds > 59) {
+      return null;
+    }
+
+    return (milliseconds / 1000) + seconds + (minutes * 60) + (hours * 3600);
+  }
+
+  /**
+   * Parses a time from string.
+   *
+   * @param {?string} time
+   * @return {?number}
+   */
+  static parseTime(time) {
+    if (!time) {
+      return null;
+    }
+    const parser = new shaka.util.TextParser(time);
+    return parser.parseTime();
+  }
 };
+
+/**
+ * @const
+ * @private {!RegExp}
+ * @example 00:00.000 or 00:00:00.000 or 0:00:00.000 or
+ * 00:00.00 or 00:00:00.00 or 0:00:00.00 or 00:00:00
+ */
+shaka.util.TextParser.timeFormat_ =
+    /(?:(\d{1,}):)?(\d{2}):(\d{2})((\.(\d{1,3})))?/g;

package/lib/util/ts_parser.js

@@ -6,6 +6,7 @@
 
 goog.provide('shaka.util.TsParser');
 
+goog.require('goog.asserts');
 goog.require('shaka.Deprecate');
 goog.require('shaka.log');
 goog.require('shaka.util.ExpGolomb');
@@ -862,7 +863,8 @@ shaka.util.TsParser = class {
   /**
    * Return the video information
    *
-   * @return {{height: ?string, width: ?string, codec: ?string}}
+   * @return {{height: ?string, width: ?string, codec: ?string,
+   *           frameRate: ?string}}
    * @export
    */
   getVideoInfo() {
@@ -872,10 +874,32 @@ shaka.util.TsParser = class {
     return this.getAvcInfo_();
   }
 
+  /**
+   * @return {?string}
+   * @private
+   */
+  getFrameRate_() {
+    const timescale = shaka.util.TsParser.Timescale;
+    const videoData = this.getVideoData();
+    if (videoData.length > 1) {
+      const firstPts = videoData[0].pts;
+      goog.asserts.assert(typeof(firstPts) == 'number',
+          'Should be an number!');
+      const secondPts = videoData[1].pts;
+      goog.asserts.assert(typeof(secondPts) == 'number',
+          'Should be an number!');
+      if (!isNaN(secondPts - firstPts)) {
+        return String(1 / (secondPts - firstPts) * timescale);
+      }
+    }
+    return null;
+  }
+
   /**
    * Return the video information for AVC
    *
-   * @return {{height: ?string, width: ?string, codec: ?string}}
+   * @return {{height: ?string, width: ?string, codec: ?string,
+   *           frameRate: ?string}}
    * @private
    */
   getAvcInfo_() {
@@ -884,6 +908,7 @@ shaka.util.TsParser = class {
       height: null,
       width: null,
       codec: null,
+      frameRate: null,
     };
     const videoNalus = this.getVideoNalus();
     if (!videoNalus.length) {
@@ -995,6 +1020,7 @@ shaka.util.TsParser = class {
         frameCropLeftOffset * 2 - frameCropRightOffset * 2);
     videoInfo.codec = 'avc1.' + this.byteToHex_(profileIdc) +
         this.byteToHex_(profileCompatibility) + this.byteToHex_(levelIdc);
+    videoInfo.frameRate = this.getFrameRate_();
 
     return videoInfo;
   }
@@ -1002,7 +1028,8 @@ shaka.util.TsParser = class {
   /**
    * Return the video information for HVC
    *
-   * @return {{height: ?string, width: ?string, codec: ?string}}
+   * @return {{height: ?string, width: ?string, codec: ?string,
+   *           frameRate: ?string}}
    * @private
    */
   getHvcInfo_() {
@@ -1011,6 +1038,7 @@ shaka.util.TsParser = class {
       height: null,
       width: null,
       codec: null,
+      frameRate: null,
     };
     const videoNalus = this.getVideoNalus();
     if (!videoNalus.length) {
@@ -1135,6 +1163,7 @@ shaka.util.TsParser = class {
           generalConstraintIndicatorFlags1.toString(16).toUpperCase();
     }
     videoInfo.codec = codec;
+    videoInfo.frameRate = this.getFrameRate_();
 
     return videoInfo;
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.10.13",
+  "version": "4.11.0",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [

package/shaka-player.uncompiled.js

@@ -33,7 +33,6 @@ goog.require('shaka.offline.OfflineManifestParser');
 goog.require('shaka.offline.OfflineScheme');
 goog.require('shaka.offline.Storage');
 goog.require('shaka.offline.indexeddb.StorageMechanism');
-goog.require('shaka.polyfill.AbortController');
 goog.require('shaka.polyfill.Aria');
 goog.require('shaka.polyfill.EncryptionScheme');
 goog.require('shaka.polyfill.Fullscreen');
@@ -90,6 +89,7 @@ goog.require('shaka.ui.AdStatisticsButton');
 goog.require('shaka.ui.AirPlayButton');
 goog.require('shaka.ui.BigPlayButton');
 goog.require('shaka.ui.CastButton');
+goog.require('shaka.ui.ChapterSelection');
 goog.require('shaka.ui.ContextMenu');
 goog.require('shaka.ui.Element');
 goog.require('shaka.ui.FastForwardButton');

package/ui/chapter_selection.js

@@ -0,0 +1,179 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+
+goog.provide('shaka.ui.ChapterSelection');
+
+goog.require('shaka.ui.Controls');
+goog.require('shaka.ui.Enums');
+goog.require('shaka.ui.Locales');
+goog.require('shaka.ui.Localization');
+goog.require('shaka.ui.OverflowMenu');
+goog.require('shaka.ui.SettingsMenu');
+goog.require('shaka.ui.Utils');
+goog.require('shaka.util.Dom');
+goog.requireType('shaka.ui.Controls');
+
+/**
+ * @extends {shaka.ui.SettingsMenu}
+ * @final
+ * @export
+ */
+shaka.ui.ChapterSelection = class extends shaka.ui.SettingsMenu {
+  /**
+   * @param {!HTMLElement} parent
+   * @param {!shaka.ui.Controls} controls
+   */
+  constructor(parent, controls) {
+    super(parent, controls, shaka.ui.Enums.MaterialDesignIcons.CHAPTER);
+
+    this.button.classList.add('shaka-chapter-button');
+    this.menu.classList.add('shaka-chapters');
+    this.button.classList.add('shaka-tooltip-status');
+
+    /** @type {!Array<shaka.extern.Chapter>} */
+    this.chapters_ = [];
+
+    this.chaptersLanguage_ = 'und';
+
+    this.eventManager.listen(
+        this.localization, shaka.ui.Localization.LOCALE_UPDATED, () => {
+          this.updateLocalizedStrings_();
+          this.updateChapters_();
+        });
+
+    this.eventManager.listen(
+        this.localization, shaka.ui.Localization.LOCALE_CHANGED, () => {
+          this.updateLocalizedStrings_();
+          this.updateChapters_();
+        });
+
+    this.eventManager.listen(this.player, 'unloading', () => {
+      this.deletePreviousChapters_();
+      this.chaptersLanguage_ = 'und';
+      this.chapters_ = [];
+    });
+
+    this.eventManager.listen(this.player, 'trackschanged', () => {
+      this.updateChapters_();
+    });
+
+    // Set up all the strings in the user's preferred language.
+    this.updateLocalizedStrings_();
+
+    this.updateChapters_();
+  }
+
+  /**
+   * @private
+   */
+  updateLocalizedStrings_() {
+    const LocIds = shaka.ui.Locales.Ids;
+
+    this.backButton.ariaLabel = this.localization.resolve(LocIds.BACK);
+    this.button.ariaLabel = this.localization.resolve(LocIds.CHAPTERS);
+    this.nameSpan.textContent = this.localization.resolve(LocIds.CHAPTERS);
+    this.backSpan.textContent = this.localization.resolve(LocIds.CHAPTERS);
+  }
+
+  /**
+   * @private
+   */
+  deletePreviousChapters_() {
+    // 1. Save the back to menu button
+    const backButton = shaka.ui.Utils.getFirstDescendantWithClassName(
+        this.menu, 'shaka-back-to-overflow-button');
+
+    // 2. Remove everything
+    shaka.util.Dom.removeAllChildren(this.menu);
+
+    // 3. Add the backTo Menu button back
+    this.menu.appendChild(backButton);
+
+    // 4. Hidden button
+    shaka.ui.Utils.setDisplay(this.button, false);
+  }
+
+  /**
+   * @private
+   */
+  updateChapters_() {
+    /**
+     * Does a value compare on chapters.
+     * @param {shaka.extern.Chapter} a
+     * @param {shaka.extern.Chapter} b
+     * @return {boolean}
+     */
+    const chaptersEqual = (a, b) => {
+      return (!a && !b) || (a.id === b.id && a.title === b.title &&
+          a.startTime === b.startTime && a.endTime === b.endTime);
+    };
+
+    let nextLanguage = 'und';
+    /** @type {!Array<shaka.extern.Chapter>} */
+    let nextChapters = [];
+
+    const currentLocales = this.localization.getCurrentLocales();
+    for (const locale of Array.from(currentLocales)) {
+      nextLanguage = locale;
+      nextChapters = this.player.getChapters(nextLanguage);
+      if (nextChapters.length) {
+        break;
+      }
+    }
+    if (!nextChapters.length) {
+      nextLanguage = 'und';
+      nextChapters = this.player.getChapters(nextLanguage);
+    }
+
+    const languageChanged = nextLanguage !== this.chaptersLanguage_;
+    const chaptersChanged = this.chapters_.length !== nextChapters.length ||
+      !this.chapters_.some((c, idx) => {
+        const n = nextChapters.at(idx);
+        return chaptersEqual(c, n) ||
+          nextChapters.some((n) => chaptersEqual(c, n));
+      });
+
+    this.chaptersLanguage_ = nextLanguage;
+    this.chapters_ = nextChapters;
+    if (!nextChapters.length) {
+      this.deletePreviousChapters_();
+    } else if (languageChanged || chaptersChanged) {
+      for (const chapter of this.chapters_) {
+        const button = shaka.util.Dom.createButton();
+        const span = shaka.util.Dom.createHTMLElement('span');
+        span.classList.add('shaka-chapter');
+        span.textContent = chapter.title;
+        button.appendChild(span);
+
+        this.eventManager.listen(button, 'click', () => {
+          this.video.currentTime = chapter.startTime;
+        });
+
+        this.menu.appendChild(button);
+      }
+      shaka.ui.Utils.setDisplay(this.button, true);
+      shaka.ui.Utils.focusOnTheChosenItem(this.menu);
+    }
+  }
+};
+
+/**
+ * @implements {shaka.extern.IUIElement.Factory}
+ * @final
+ */
+shaka.ui.ChapterSelection.Factory = class {
+  /** @override */
+  create(rootElement, controls) {
+    return new shaka.ui.ChapterSelection(rootElement, controls);
+  }
+};
+
+shaka.ui.OverflowMenu.registerElement(
+    'chapter', new shaka.ui.ChapterSelection.Factory());
+
+shaka.ui.Controls.registerElement(
+    'chapter', new shaka.ui.ChapterSelection.Factory());

package/ui/controls.js

@@ -181,6 +181,7 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
     // Configure and create the layout of the controls
     this.configure(this.config_);
     this.addEventListeners_();
+    this.setupMediaSession_();
 
     /**
      * The pressed keys set is used to record which keys are currently pressed
@@ -274,6 +275,8 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
     this.localization_ = null;
     this.pressedKeys_.clear();
 
+    this.removeMediaSession_();
+
     // FakeEventTarget implements IReleasable
     super.release();
   }
@@ -1235,6 +1238,154 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
   }
 
 
+  /**
+   * @private
+   */
+  setupMediaSession_() {
+    if (!this.config_.setupMediaSession || !navigator.mediaSession) {
+      return;
+    }
+    const addMediaSessionHandler = (type, callback) => {
+      try {
+        navigator.mediaSession.setActionHandler(type, (details) => {
+          callback(details);
+        });
+      } catch (error) {
+        shaka.log.warning(
+            `The "${type}" media session action is not supported.`);
+      }
+    };
+    const updatePositionState = () => {
+      const seekRange = this.player_.seekRange();
+      let duration = seekRange.end - seekRange.start;
+      const position = parseFloat(
+          (this.video_.currentTime - seekRange.start).toFixed(2));
+      if (this.player_.isLive() && Math.abs(duration - position) < 1) {
+        // Positive infinity indicates media without a defined end, such as a
+        // live stream.
+        duration = Infinity;
+      }
+      try {
+        if ((this.ad_ && this.ad_.isLinear())) {
+          navigator.mediaSession.setPositionState();
+        } else {
+          navigator.mediaSession.setPositionState({
+            duration: Math.max(0, duration),
+            playbackRate: this.video_.playbackRate,
+            position: Math.max(0, position),
+          });
+        }
+      } catch (error) {
+        shaka.log.warning(
+            'setPositionState in media session is not supported.');
+      }
+    };
+    const commonHandler = (details) => {
+      const keyboardSeekDistance = this.config_.keyboardSeekDistance;
+      const seekRange = this.player_.seekRange();
+      switch (details.action) {
+        case 'pause':
+          this.onPlayPauseClick_();
+          break;
+        case 'play':
+          this.onPlayPauseClick_();
+          break;
+        case 'seekbackward':
+          if (!this.ad_ || !this.ad_.isLinear()) {
+            this.seek_(this.seekBar_.getValue() -
+                (details.seekOffset || keyboardSeekDistance));
+          }
+          break;
+        case 'seekforward':
+          if (!this.ad_ || !this.ad_.isLinear()) {
+            this.seek_(this.seekBar_.getValue() +
+                (details.seekOffset || keyboardSeekDistance));
+          }
+          break;
+        case 'seekto':
+          if (!this.ad_ || !this.ad_.isLinear()) {
+            this.seek_(seekRange.start + details.seekTime);
+          }
+          break;
+        case 'stop':
+          this.player_.unload();
+          break;
+        case 'enterpictureinpicture':
+          if (!this.ad_ || !this.ad_.isLinear()) {
+            this.togglePiP();
+          }
+          break;
+      }
+    };
+
+    addMediaSessionHandler('pause', commonHandler);
+    addMediaSessionHandler('play', commonHandler);
+    addMediaSessionHandler('seekbackward', commonHandler);
+    addMediaSessionHandler('seekforward', commonHandler);
+    addMediaSessionHandler('seekto', commonHandler);
+    addMediaSessionHandler('stop', commonHandler);
+    addMediaSessionHandler('enterpictureinpicture', commonHandler);
+
+    this.eventManager_.listen(this.video_, 'timeupdate', () => {
+      updatePositionState();
+    });
+
+    this.eventManager_.listen(this.player_, 'metadata', (event) => {
+      const payload = event['payload'];
+      if (!payload) {
+        return;
+      }
+      let title;
+      if (payload['key'] == 'TIT2' && payload['data']) {
+        title = payload['data'];
+      }
+      let imageUrl;
+      if (payload['key'] == 'APIC' && payload['mimeType'] == '-->') {
+        imageUrl = payload['data'];
+      }
+      if (navigator.mediaSession.metadata && title) {
+        navigator.mediaSession.metadata.title = title;
+      }
+      if (imageUrl) {
+        const video = /** @type {HTMLVideoElement} */ (this.localVideo_);
+        if (imageUrl != video.poster) {
+          video.poster = imageUrl;
+        }
+        if (navigator.mediaSession.metadata) {
+          navigator.mediaSession.metadata.artwork = [{src: imageUrl}];
+        }
+      }
+    });
+  }
+
+
+  /**
+   * @private
+   */
+  removeMediaSession_() {
+    if (!this.config_.setupMediaSession || !navigator.mediaSession) {
+      return;
+    }
+    try {
+      navigator.mediaSession.setPositionState();
+    } catch (error) {}
+
+    const disableMediaSessionHandler = (type) => {
+      try {
+        navigator.mediaSession.setActionHandler(type, null);
+      } catch (error) {}
+    };
+
+    disableMediaSessionHandler('pause');
+    disableMediaSessionHandler('play');
+    disableMediaSessionHandler('seekbackward');
+    disableMediaSessionHandler('seekforward');
+    disableMediaSessionHandler('seekto');
+    disableMediaSessionHandler('stop');
+    disableMediaSessionHandler('enterpictureinpicture');
+  }
+
+
   /**
    * When a mobile device is rotated to landscape layout, and the video is
    * loaded, make the demo app go into fullscreen.

package/ui/enums.js

@@ -47,4 +47,5 @@ shaka.ui.Enums.MaterialDesignIcons = {
   'RECENTER_VR': 'control_camera',
   'TOGGLE_STEREOSCOPIC': '3d_rotation',
   'DOWNLOAD': 'download',
+  'CHAPTER': 'bookmarks',
 };

package/ui/externs/ui.js

@@ -96,7 +96,8 @@ shaka.extern.UIVolumeBarColors;
  *   tapSeekDistance: number,
  *   refreshTickInSeconds: number,
  *   displayInVrMode: boolean,
- *   defaultVrProjectionMode: string
+ *   defaultVrProjectionMode: string,
+ *   setupMediaSession: boolean
  * }}
  *
  * @property {!Array.<string>} controlPanelElements
@@ -247,6 +248,11 @@ shaka.extern.UIVolumeBarColors;
  *   Indicate the default VR projection mode.
  *   Possible values: <code>'equirectangular'</code> or <code>'cubemap'</code>.
  *   Defaults to <code>'equirectangular'</code>.
+ * @property {boolean} setupMediaSession
+ *   If true, MediaSession controls will be managed by the UI. It will also use
+ *   the ID3 APIC and TIT2 as image and title in Media Session, and ID3 APIC
+ *   will also be used to change video poster.
+ *   Defaults to true.
  * @exportDoc
  */
 shaka.extern.UIConfiguration;

package/ui/less/containers.less

@@ -22,10 +22,9 @@
   }
 
   /* Set the fonts for all other content. */
-  * {
-    font-family: Roboto-Regular, Roboto, sans-serif, TengwarTelcontar;
-    -webkit-font-smoothing: antialiased;
-  }
+  font-family: Roboto, sans-serif, TengwarTelcontar;
+  font-weight: normal;
+  -webkit-font-smoothing: antialiased;
 }
 
 /* Each browser has a different prefixed pseudo-class for fullscreened elements.