shaka-player 3.1.1 → 3.1.5

package/lib/media/gap_jumping_controller.js

@@ -154,8 +154,10 @@ shaka.media.GapJumpingController = class {
     }
     // Don't gap jump while paused, so that you don't constantly jump ahead
     // while paused on a livestream.  We make an exception for time 0, since we
-    // may be _required_ to seek on startup before play can begin.
-    if (this.video_.paused && this.video_.currentTime != 0) {
+    // may be _required_ to seek on startup before play can begin, but only if
+    // autoplay is enabled.
+    if (this.video_.paused && (this.video_.currentTime != 0 ||
+      (!this.video_.autoplay && this.video_.currentTime == 0))) {
       return;
     }
 
@@ -215,8 +217,10 @@ shaka.media.GapJumpingController = class {
       this.didFireLargeGap_ = true;
 
       // Event firing is synchronous.
-      const event = new shaka.util.FakeEvent(
-          'largegap', {'currentTime': currentTime, 'gapSize': jumpSize});
+      const data = new Map()
+          .set('currentTime', currentTime)
+          .set('gapSize', jumpSize);
+      const event = new shaka.util.FakeEvent('largegap', data);
       event.cancelable = true;
       this.onEvent_(event);
 

package/lib/media/media_source_engine.js

@@ -48,8 +48,7 @@ shaka.media.MediaSourceEngine = class {
    * @param {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)=}
    *    onMetadata
    */
-  constructor(video, closedCaptionParser, textDisplayer,
-      onMetadata) {
+  constructor(video, closedCaptionParser, textDisplayer, onMetadata) {
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 

package/lib/media/playhead.js

@@ -80,7 +80,7 @@ shaka.media.SrcEqualsPlayhead = class {
     // We listen for the loaded-data-event so that we know when we can
     // interact with |currentTime|.
     const onLoaded = () => {
-      if (this.startTime_ == null) {
+      if (this.startTime_ == null || this.startTime_ == 0) {
         this.started_ = true;
       } else {
         // Startup is complete only when the video element acknowledges the

package/lib/media/presentation_timeline.js

@@ -361,8 +361,10 @@ shaka.media.PresentationTimeline = class {
    */
   getSegmentAvailabilityEnd() {
     if (!this.isLive() && !this.isInProgress()) {
-      return this.duration_;
+      // It's a static manifest (can also be a dynamic->static conversion)
+      return this.maxSegmentEndTime_ || this.duration_;
     }
+    // Can be either live or "in-progress recording" (live with known duration)
     return Math.min(this.getLiveEdge_() + this.availabilityTimeOffset_,
         this.duration_);
   }

package/lib/media/segment_reference.js

@@ -153,6 +153,14 @@ shaka.media.SegmentReference = class {
     /** @type {number} */
     this.endTime = endTime;
 
+    /**
+     * The "true" end time of the segment, without considering the period end
+     * time.  This is necessary for thumbnail segments, where timing requires us
+     * to know the original segment duration as described in the manifest.
+     * @type {number}
+     */
+    this.trueEndTime = endTime;
+
     /** @type {function():!Array.<string>} */
     this.getUrisInner = uris;
 

package/lib/media/streaming_engine.js

@@ -317,8 +317,10 @@ shaka.media.StreamingEngine = class {
    * @param {shaka.extern.Variant} variant
    * @param {boolean=} clearBuffer
    * @param {number=} safeMargin
+   * @param {boolean=} force
+   *   If true, reload the variant even if it did not change.
    */
-  switchVariant(variant, clearBuffer = false, safeMargin = 0) {
+  switchVariant(variant, clearBuffer = false, safeMargin = 0, force = false) {
     this.currentVariant_ = variant;
 
     if (!this.startupComplete_) {
@@ -329,12 +331,12 @@ shaka.media.StreamingEngine = class {
     if (variant.video) {
       this.switchInternal_(
           variant.video, /* clearBuffer= */ clearBuffer,
-          /* safeMargin= */ safeMargin, /* force= */ false);
+          /* safeMargin= */ safeMargin, /* force= */ force);
     }
     if (variant.audio) {
       this.switchInternal_(
           variant.audio, /* clearBuffer= */ clearBuffer,
-          /* safeMargin= */ safeMargin, /* force= */ false);
+          /* safeMargin= */ safeMargin, /* force= */ force);
     }
   }
 
@@ -621,7 +623,7 @@ shaka.media.StreamingEngine = class {
 
         // Don't clear the buffer unless something is buffered.  This extra
         // check prevents extra, useless calls to clear the buffer.
-        if (somethingBuffered) {
+        if (somethingBuffered || mediaState.performingUpdate) {
           this.forceClearBuffer_(mediaState);
           streamCleared = true;
         }
@@ -975,7 +977,10 @@ shaka.media.StreamingEngine = class {
         unscaledBufferingGoal * this.bufferingGoalScale_;
 
     // Check if we've buffered to the end of the presentation.
-    if (timeNeeded >= this.manifest_.presentationTimeline.getDuration()) {
+    const timeUntilEnd =
+        this.manifest_.presentationTimeline.getDuration() - timeNeeded;
+    const oneMicrosecond = 1e-6;
+    if (timeUntilEnd < oneMicrosecond) {
       // We shouldn't rebuffer if the playhead is close to the end of the
       // presentation.
       shaka.log.debug(logPrefix, 'buffered to end of presentation');
@@ -1188,10 +1193,14 @@ shaka.media.StreamingEngine = class {
 
     mediaState.performingUpdate = true;
 
-    const initSourceBuffer = this.initSourceBuffer_(mediaState, reference);
-
-    shaka.log.v2(logPrefix, 'fetching segment');
     try {
+      await this.initSourceBuffer_(mediaState, reference);
+      this.destroyer_.ensureNotDestroyed();
+      if (this.fatalError_) {
+        return;
+      }
+
+      shaka.log.v2(logPrefix, 'fetching segment');
       const isMP4 = stream.mimeType == 'video/mp4' ||
               stream.mimeType == 'audio/mp4';
       const isReadableStreamSupported = window.ReadableStream;
@@ -1199,7 +1208,6 @@ shaka.media.StreamingEngine = class {
       if (this.config_.lowLatencyMode && isReadableStreamSupported && isMP4) {
         let remaining = new Uint8Array(0);
         const streamDataCallback = async (data) => {
-          await initSourceBuffer;
           this.destroyer_.ensureNotDestroyed();
           if (this.fatalError_) {
             return;
@@ -1237,7 +1245,7 @@ shaka.media.StreamingEngine = class {
             'ReadableStream is not supported by the browser.');
         }
         const fetchSegment = this.fetch_(mediaState, reference);
-        const results = await Promise.all([initSourceBuffer, fetchSegment]);
+        const result = await fetchSegment;
         this.destroyer_.ensureNotDestroyed();
         if (this.fatalError_) {
           return;
@@ -1254,7 +1262,7 @@ shaka.media.StreamingEngine = class {
           return;
         }
         await this.append_(
-            mediaState, presentationTime, stream, reference, results[1]);
+            mediaState, presentationTime, stream, reference, result);
       }
 
       this.destroyer_.ensureNotDestroyed();
@@ -1292,7 +1300,13 @@ shaka.media.StreamingEngine = class {
 
       mediaState.performingUpdate = false;
 
-      if (mediaState.type == ContentType.TEXT &&
+      if (error.code == shaka.util.Error.Code.OPERATION_ABORTED) {
+        // If the network slows down, abort the current fetch request and start
+        // a new one, and ignore the error message.
+        mediaState.performingUpdate = false;
+        mediaState.updateTimer = null;
+        this.scheduleUpdate_(mediaState, 0);
+      } else if (mediaState.type == ContentType.TEXT &&
           this.config_.ignoreTextStreamFailures) {
         if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS) {
           shaka.log.warning(logPrefix,
@@ -1302,12 +1316,6 @@ shaka.media.StreamingEngine = class {
               'Text stream failed to parse. Proceeding without it.');
         }
         this.mediaStates_.delete(ContentType.TEXT);
-      } else if (error.code == shaka.util.Error.Code.OPERATION_ABORTED) {
-        // If the network slows down, abort the current fetch request and start
-        // a new one, and ignore the error message.
-        mediaState.performingUpdate = false;
-        mediaState.updateTimer = null;
-        this.scheduleUpdate_(mediaState, 0);
       } else if (error.code == shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR) {
         this.handleQuotaExceeded_(mediaState, error);
       } else if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS &&
@@ -1657,7 +1665,8 @@ shaka.media.StreamingEngine = class {
 
         // Dispatch an event to notify the application about the emsg box.
         const eventName = shaka.Player.EventName.Emsg;
-        const event = new shaka.util.FakeEvent(eventName, {'detail': emsg});
+        const data = (new Map()).set('detail', emsg);
+        const event = new shaka.util.FakeEvent(eventName, data);
         this.playerInterface_.onEvent(event);
       }
     }

package/lib/net/networking_engine.js

@@ -544,7 +544,8 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
         }
 
         if (error.severity == shaka.util.Error.Severity.RECOVERABLE) {
-          const event = new shaka.util.FakeEvent('retry', {'error': error});
+          const data = (new Map()).set('error', error);
+          const event = new shaka.util.FakeEvent('retry', data);
           this.dispatchEvent(event);
 
           // Move to the next URI.

package/lib/player.js

@@ -596,7 +596,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       enterNode: (node, has, wants) => {
         this.dispatchEvent(this.makeEvent_(
             /* name= */ shaka.Player.EventName.OnStateChange,
-            /* data= */ {'state': node.name}));
+            /* data= */ (new Map()).set('state', node.name)));
 
         const action = actions.get(node);
         return action(has, wants);
@@ -627,7 +627,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       onIdle: (node) => {
         this.dispatchEvent(this.makeEvent_(
             /* name= */ shaka.Player.EventName.OnStateIdle,
-            /* data= */ {'state': node.name}));
+            /* data= */ (new Map()).set('state', node.name)));
       },
     };
 
@@ -647,7 +647,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
   /**
    * @param {!shaka.Player.EventName} name
-   * @param {Object=} data
+   * @param {Map.<string, Object>=} data
    * @return {!shaka.util.FakeEvent}
    * @private
    */
@@ -1155,6 +1155,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         'mpg': 'video/mpeg',
         'mpeg': 'video/mpeg',
         'm3u8': 'application/x-mpegurl',
+        'mpd': 'application/dash+xml',
         'mp3': 'audio/mpeg',
         'aac': 'audio/aac',
         'flac': 'audio/flac',
@@ -1285,6 +1286,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       has.mediaElement = null;
     }
 
+    if (this.adManager_) {
+      // The ad manager is specific to the video, so detach it too.
+      this.adManager_.release();
+    }
+
     // Clear our cached copy of the media element.
     this.video_ = null;
 
@@ -1844,6 +1850,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     this.currentTextLanguage_ = this.config_.preferredTextLanguage;
     this.currentTextRole_ = this.config_.preferredTextRole;
+    this.currentTextForced_ = this.config_.preferForcedSubs;
 
     shaka.Player.applyPlayRange_(this.manifest_.presentationTimeline,
         this.config_.playRangeStart,
@@ -1883,36 +1890,55 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.dispatchEvent(this.makeEvent_(shaka.Player.EventName.Streaming));
 
     // Pick the initial streams to play.
-    const initialVariant = this.chooseVariant_();
-    goog.asserts.assert(initialVariant, 'Must choose an initial variant!');
-    this.addVariantToSwitchHistory_(
-        initialVariant, /* fromAdaptation= */ true);
-    this.streamingEngine_.switchVariant(
-        initialVariant, /* clearBuffer= */ false, /* safeMargin= */ 0);
+    // however, we would skip switch to initial variant
+    // if user already pick variant track (via selectVariantTrack api)
+    let initialVariant = null;
+    const activeVariantTrack = this.getVariantTracks().find((t) => t.active);
+
+    if (!activeVariantTrack) {
+      initialVariant = this.chooseVariant_();
+      goog.asserts.assert(initialVariant, 'Must choose an initial variant!');
+      this.switchVariant_(initialVariant, /* fromAdaptation= */ true,
+          /* clearBuffer= */ false, /* safeMargin= */ 0);
+
+      // Now that we have initial streams, we may adjust the start time to align
+      // to a segment boundary.
+      if (this.config_.streaming.startAtSegmentBoundary) {
+        const startTime = this.playhead_.getTime();
+        const adjustedTime =
+            await this.adjustStartTime_(initialVariant, startTime);
+
+        this.playhead_.setStartTime(adjustedTime);
+      }
 
-    // Decide if text should be shown automatically.
-    const initialTextStream = this.chooseTextStream_();
-    if (initialTextStream) {
-      this.addTextStreamToSwitchHistory_(
-          initialTextStream, /* fromAdaptation= */ true);
+      // Since the first streams just became active, send an adaptation event.
+      this.onAdaptation_();
     }
 
-    this.setInitialTextState_(initialVariant, initialTextStream);
-    // Don't initialize with a text stream unless we should be streaming text.
-    if (initialTextStream && this.shouldStreamText_()) {
-      this.streamingEngine_.switchTextStream(initialTextStream);
-    }
+    // Decide if text should be shown automatically.
+    // similar to video/audio track, we would skip switch initial text track
+    // if user already pick text track (via selectTextTrack api)
+    const activeTextTrack = this.getTextTracks().find((t) => t.active);
 
-    // Now that we have initial streams, we may adjust the start time to align
-    // to a segment boundary.
-    if (this.config_.streaming.startAtSegmentBoundary) {
-      const startTime = this.playhead_.getTime();
-      const adjustedTime =
-          await this.adjustStartTime_(initialVariant, startTime);
+    if (!activeTextTrack) {
+      const initialTextStream = this.chooseTextStream_();
 
-      this.playhead_.setStartTime(adjustedTime);
+      if (initialTextStream) {
+        this.addTextStreamToSwitchHistory_(
+            initialTextStream, /* fromAdaptation= */ true);
+      }
+
+      if (initialVariant) {
+        this.setInitialTextState_(initialVariant, initialTextStream);
+      }
+
+      // Don't initialize with a text stream unless we should be streaming text.
+      if (initialTextStream && this.shouldStreamText_()) {
+        this.streamingEngine_.switchTextStream(initialTextStream);
+      }
     }
 
+
     // Start streaming content. This will start the flow of content down to
     // media source.
     await this.streamingEngine_.start();
@@ -1926,8 +1952,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.filterManifestByCurrentVariant_();
     // Dispatch a 'trackschanged' event now that all initial filtering is done.
     this.onTracksChanged_();
-    // Since the first streams just became active, send an adaptation event.
-    this.onAdaptation_();
 
     // Now that we've filtered out variants that aren't compatible with the
     // active one, update abr manager with filtered variants.
@@ -2046,6 +2070,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       decodingInfos: [],
     };
 
+    this.drmEngine_.setSrcEquals(/* srcEquals= */ true);
     await this.drmEngine_.initForPlayback(
         [variant], /* offlineSessionIds= */ []);
     await this.drmEngine_.attach(has.mediaElement);
@@ -2391,12 +2416,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     goog.asserts.assert(!endTime || startTime <= endTime,
         'Metadata start time should be less or equal to the end time!');
     const eventName = shaka.Player.EventName.Metadata;
-    const data = {
-      startTime: startTime,
-      endTime: endTime,
-      metadataType: metadataType,
-      payload: payload,
-    };
+    const data = new Map()
+        .set('startTime', startTime)
+        .set('endTime', endTime)
+        .set('metadataType', metadataType)
+        .set('payload', payload);
     this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
@@ -2458,7 +2482,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.abrManager_.segmentDownloaded(deltaTimeMs, bytesDownloaded);
       }
     };
-
     return new shaka.net.NetworkingEngine(onProgressUpdated_);
   }
 
@@ -3217,6 +3240,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
       const tracks = [];
 
+      let activeTracks = 0;
+
       // Convert each variant to a track.
       for (const variant of this.manifest_.variants) {
         if (!shaka.util.StreamUtils.isPlayable(variant)) {
@@ -3225,10 +3250,22 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
         const track = shaka.util.StreamUtils.variantToTrack(variant);
         track.active = variant == currentVariant;
+        if (!track.active && activeTracks != 1 && currentVariant != null &&
+          variant.video == currentVariant.video &&
+          variant.audio == currentVariant.audio) {
+          track.active = true;
+        }
+
+        if (track.active) {
+          activeTracks++;
+        }
 
         tracks.push(track);
       }
 
+      goog.asserts.assert(activeTracks <= 1,
+          'It should only have one active track');
+
       return tracks;
     } else if (this.video_ && this.video_.audioTracks) {
       // Safari's native HLS always shows a single element in videoTracks.
@@ -3333,9 +3370,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       const rows = parseInt(match[2], 10);
       const width = fullImageWidth / columns;
       const height = fullImageHeight / rows;
+      const totalImages = columns * rows;
+      const segmentDuration = reference.trueEndTime - reference.startTime;
+      const thumbnailDuration = segmentDuration / totalImages;
+      let thumbnailTime = reference.startTime;
       let positionX = 0;
       let positionY = 0;
-      const totalImages = columns * rows;
       // If the number of images in the segment is greater than 1, we have to
       // find the correct image. For that we will return to the app the
       // coordinates of the position of the correct image.
@@ -3343,21 +3383,23 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // Note: The time between images within the segment is always
       // equidistant.
       //
-      // Eg: Total images 5, tileLayout 5x1, segmentTime 5, thumbnailTime 2
+      // Eg: Total images 5, tileLayout 5x1, segmentDuration 5, thumbnailTime 2
       // positionX = 0.4 * fullImageWidth
       // positionY = 0
       if (totalImages > 1) {
-        const thumbnailTime = time - reference.startTime;
-        const segmentTime = reference.endTime - reference.startTime;
         const thumbnailPosition =
-            Math.floor(thumbnailTime * totalImages / segmentTime);
-        positionX = (thumbnailPosition % columns) / columns * fullImageWidth;
-        positionY = (thumbnailPosition % rows) / rows * fullImageHeight;
+            Math.floor((time - reference.startTime) / thumbnailDuration);
+        thumbnailTime = reference.startTime +
+            (thumbnailPosition * thumbnailDuration);
+        positionX = (thumbnailPosition % columns) * width;
+        positionY = Math.floor(thumbnailPosition / columns) * height;
       }
       return {
         height: height,
         positionX: positionX,
         positionY: positionY,
+        startTime: thumbnailTime,
+        duration: thumbnailDuration,
         uris: reference.getUris(),
         width: width,
       };
@@ -4773,7 +4815,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Surface the buffering event so that the app knows if/when we are
     // buffering.
     const eventName = shaka.Player.EventName.Buffering;
-    this.dispatchEvent(this.makeEvent_(eventName, {'buffering': isBuffering}));
+    const data = (new Map()).set('buffering', isBuffering);
+    this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
   /**
@@ -4958,6 +5001,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const currentVariant = this.streamingEngine_.getCurrentVariant();
     if (variant == currentVariant) {
       shaka.log.debug('Variant already selected.');
+      // If you want to clear the buffer, we force to reselect the same variant
+      if (clearBuffer) {
+        this.streamingEngine_.switchVariant(variant, clearBuffer, safeMargin,
+            /* force= */ true);
+      }
       return;
     }
 
@@ -4986,6 +5034,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // This will reset the "enabled" of other tracks to false.
     track.enabled = true;
 
+    // AirPlay does not reset the "enabled" of other tracks to false, so
+    // it must be changed by hand.
+    if (track.id !== currentTrack.id) {
+      currentTrack.enabled = false;
+    }
+
     const oldTrack =
       shaka.util.StreamUtils.html5AudioTrackToTrack(currentTrack);
     const newTrack =
@@ -5144,10 +5198,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   onVariantChanged_(from, to) {
     // Delay the 'variantchanged' event so StreamingEngine has time to absorb
     // the changes before the user tries to query it.
-    const event = this.makeEvent_(shaka.Player.EventName.VariantChanged, {
-      oldTrack: from,
-      newTrack: to,
-    });
+    const data = new Map()
+        .set('oldTrack', from)
+        .set('newTrack', to);
+    const event = this.makeEvent_(shaka.Player.EventName.VariantChanged, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -5170,10 +5224,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
   /** @private */
   onAbrStatusChanged_() {
-    const event = this.makeEvent_(shaka.Player.EventName.AbrStatusChanged, {
-      newStatus: this.config_.abr.enabled,
-    });
-    this.delayDispatchEvent_(event);
+    const data = (new Map()).set('newStatus', this.config_.abr.enabled);
+    this.delayDispatchEvent_(this.makeEvent_(
+        shaka.Player.EventName.AbrStatusChanged, data));
   }
 
   /**
@@ -5190,7 +5243,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     const eventName = shaka.Player.EventName.Error;
-    const event = this.makeEvent_(eventName, {'detail': error});
+    const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
     this.dispatchEvent(event);
     if (event.defaultPrevented) {
       error.handled = true;
@@ -5219,7 +5272,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       eventElement: region.eventElement,
     };
 
-    this.dispatchEvent(this.makeEvent_(eventName, {detail: clone}));
+    const data = (new Map()).set('detail', clone);
+    this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
   /**
@@ -6048,7 +6102,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v3.1.1-uncompiled';
+shaka.Player.version = 'v3.1.5-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/encryption_scheme.js

@@ -13,12 +13,14 @@ goog.require('shaka.polyfill');
  * @see https://wicg.github.io/encrypted-media-encryption-scheme/
  * @see https://github.com/w3c/encrypted-media/pull/457
  * @see https://github.com/google/eme-encryption-scheme-polyfill
+ * @export
  */
 shaka.polyfill.EncryptionScheme = class {
   /**
    * Install the polyfill if needed.
    *
    * @suppress {missingRequire}
+   * @export
    */
   static install() {
     EncryptionSchemePolyfills.install();

package/lib/polyfill/fullscreen.js

@@ -14,10 +14,12 @@ goog.require('shaka.polyfill');
  * Many browsers have prefixed fullscreen methods on Element and document.
  * See {@link https://mzl.la/2K0xcHo Using fullscreen mode} on MDN for more
  * information.
+ * @export
  */
 shaka.polyfill.Fullscreen = class {
   /**
    * Install the polyfill if needed.
+   * @export
    */
   static install() {
     if (!window.Document) {

package/lib/polyfill/mathround.js

@@ -11,10 +11,12 @@ goog.require('shaka.polyfill');
 /**
  * @summary A polyfill to patch math round bug on some browsers.
  * @see https://stackoverflow.com/q/12830742
+ * @export
  */
 shaka.polyfill.MathRound = class {
   /**
    * Install the polyfill if needed.
+   * @export
    */
   static install() {
     shaka.log.debug('mathRound.install');