shaka-player 3.1.2 → 3.1.6

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

@@ -8,16 +8,19 @@ goog.provide('shaka.media.RegionObserver');
 
 goog.require('shaka.media.IPlayheadObserver');
 goog.require('shaka.media.RegionTimeline');
+goog.require('shaka.util.EventManager');
+goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.FakeEventTarget');
 
 
 /**
  * The region observer watches a region timeline and playhead, and fires events
- * (onEnter, onExit, and onSkip) as the playhead moves.
+ * ('enter', 'exit', 'skip') as the playhead moves.
  *
  * @implements {shaka.media.IPlayheadObserver}
  * @final
  */
-shaka.media.RegionObserver = class {
+shaka.media.RegionObserver = class extends shaka.util.FakeEventTarget {
   /**
    * Create a region observer for the given timeline. The observer does not
    * own the timeline, only uses it. This means that the observer should NOT
@@ -26,6 +29,8 @@ shaka.media.RegionObserver = class {
    * @param {!shaka.media.RegionTimeline} timeline
    */
   constructor(timeline) {
+    super();
+
     /** @private {shaka.media.RegionTimeline} */
     this.timeline_ = timeline;
 
@@ -39,13 +44,6 @@ shaka.media.RegionObserver = class {
      */
     this.oldPosition_ = new Map();
 
-    /** @private {shaka.media.RegionObserver.EventListener} */
-    this.onEnter_ = (region, seeking) => {};
-    /** @private {shaka.media.RegionObserver.EventListener} */
-    this.onExit_ = (region, seeking) => {};
-    /** @private {shaka.media.RegionObserver.EventListener} */
-    this.onSkip_ = (region, seeking) => {};
-
     // To make the rules easier to read, alias all the relative positions.
     const RelativePosition = shaka.media.RegionObserver.RelativePosition_;
     const BEFORE_THE_REGION = RelativePosition.BEFORE_THE_REGION;
@@ -62,39 +60,48 @@ shaka.media.RegionObserver = class {
       {
         weWere: null,
         weAre: IN_THE_REGION,
-        invoke: (region, seeking) => this.onEnter_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('enter', region, seeking),
       },
       {
         weWere: BEFORE_THE_REGION,
         weAre: IN_THE_REGION,
-        invoke: (region, seeking) => this.onEnter_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('enter', region, seeking),
       },
       {
         weWere: AFTER_THE_REGION,
         weAre: IN_THE_REGION,
-        invoke: (region, seeking) => this.onEnter_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('enter', region, seeking),
       },
       {
         weWere: IN_THE_REGION,
         weAre: BEFORE_THE_REGION,
-        invoke: (region, seeking) => this.onExit_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('exit', region, seeking),
       },
       {
         weWere: IN_THE_REGION,
         weAre: AFTER_THE_REGION,
-        invoke: (region, seeking) => this.onExit_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('exit', region, seeking),
       },
       {
         weWere: BEFORE_THE_REGION,
         weAre: AFTER_THE_REGION,
-        invoke: (region, seeking) => this.onSkip_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('skip', region, seeking),
       },
       {
         weWere: AFTER_THE_REGION,
         weAre: BEFORE_THE_REGION,
-        invoke: (region, seeking) => this.onSkip_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('skip', region, seeking),
       },
     ];
+
+    /** @private {shaka.util.EventManager} */
+    this.eventManager_ = new shaka.util.EventManager();
+
+    this.eventManager_.listen(this.timeline_, 'regionremove', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
+      this.oldPosition_.delete(region);
+    });
   }
 
   /** @override */
@@ -105,11 +112,10 @@ shaka.media.RegionObserver = class {
     // needed.
     this.oldPosition_.clear();
 
-    // Clear the callbacks so that we don't hold onto any references external
-    // to this class.
-    this.onEnter_ = (region, seeking) => {};
-    this.onExit_ = (region, seeking) => {};
-    this.onSkip_ = (region, seeking) => {};
+    this.eventManager_.release();
+    this.eventManager_ = null;
+
+    super.release();
   }
 
   /** @override */
@@ -134,20 +140,20 @@ shaka.media.RegionObserver = class {
   }
 
   /**
-   * Set all the listeners. This overrides any previous calls to |setListeners|.
+   * Dispatch events of the given type.  All event types in this class have the
+   * same parameters: region and seeking.
    *
-   * @param {shaka.media.RegionObserver.EventListener} onEnter
-   *    The callback for when we move from outside a region to inside a region.
-   * @param {shaka.media.RegionObserver.EventListener} onExit
-   *    The callback for when we move from inside a region to outside a region.
-   * @param {shaka.media.RegionObserver.EventListener} onSkip
-   *    The callback for when we move from before to after a region or from
-   *    after to before a region.
+   * @param {string} eventType
+   * @param {shaka.extern.TimelineRegionInfo} region
+   * @param {boolean} seeking
+   * @private
    */
-  setListeners(onEnter, onExit, onSkip) {
-    this.onEnter_ = onEnter;
-    this.onExit_ = onExit;
-    this.onSkip_ = onSkip;
+  onEvent_(eventType, region, seeking) {
+    const event = new shaka.util.FakeEvent(eventType, new Map([
+      ['region', region],
+      ['seeking', seeking],
+    ]));
+    this.dispatchEvent(event);
   }
 
   /**

package/lib/media/region_timeline.js

@@ -6,26 +6,30 @@
 
 goog.provide('shaka.media.RegionTimeline');
 
+goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.FakeEventTarget');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.Timer');
 
 
 /**
  * The region timeline is a set of unique timeline region info entries. When
- * a new entry is added, the |onAddRegion| callback will be called.
+ * a new entry is added, the 'regionadd' event will be fired.  When an entry is
+ * deleted, the 'regionremove' event will be fired.
  *
  * @implements {shaka.util.IReleasable}
  * @final
  */
-shaka.media.RegionTimeline = class {
+shaka.media.RegionTimeline = class extends shaka.util.FakeEventTarget {
   /**
    * @param {!function():{start: number, end: number}} getSeekRange
    */
   constructor(getSeekRange) {
-    /** @private {function(shaka.extern.TimelineRegionInfo)} */
-    this.onAddRegion_ = (region) => {};
+    super();
+
     /** @private {!Set.<shaka.extern.TimelineRegionInfo>} */
     this.regions_ = new Set();
+
     /** @private {!function():{start: number, end: number}} */
     this.getSeekRange_ = getSeekRange;
 
@@ -44,22 +48,9 @@ shaka.media.RegionTimeline = class {
 
   /** @override */
   release() {
-    // Prevent us from holding onto any external references via the callback.
-    this.onAddRegion_ = (region) => {};
     this.regions_.clear();
     this.filterTimer_.stop();
-  }
-
-  /**
-   * Set the callbacks for events. This will override any previous calls to
-   * |setListeners|.
-   *
-   * @param {function(shaka.extern.TimelineRegionInfo)} onAddRegion
-   *    Set the callback for when we add a new region. This callback will only
-   *    be called when a region is unique (we reject duplicate regions).
-   */
-  setListeners(onAddRegion) {
-    this.onAddRegion_ = onAddRegion;
+    super.release();
   }
 
   /**
@@ -72,7 +63,10 @@ shaka.media.RegionTimeline = class {
     // instead of making the parser track it.
     if (similarRegion == null) {
       this.regions_.add(region);
-      this.onAddRegion_(region);
+      const event = new shaka.util.FakeEvent('regionadd', new Map([
+        ['region', region],
+      ]));
+      this.dispatchEvent(event);
     }
   }
 
@@ -89,6 +83,10 @@ shaka.media.RegionTimeline = class {
       // reson to store or process them.
       if (region.endTime < seekRange.start) {
         this.regions_.delete(region);
+        const event = new shaka.util.FakeEvent('regionremove', new Map([
+          ['region', region],
+        ]));
+        this.dispatchEvent(event);
       }
     }
   }

package/lib/media/streaming_engine.js

@@ -623,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;
         }
@@ -977,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');
@@ -1641,7 +1644,7 @@ shaka.media.StreamingEngine = class {
     // See DASH sec. 5.10.3.3.1
     // If a DASH client detects an event message box with a scheme that is not
     // defined in MPD, the client is expected to ignore it.
-    if (emsgSchemeIdUris.includes(schemeId)) {
+    if (emsgSchemeIdUris && emsgSchemeIdUris.includes(schemeId)) {
       // See DASH sec. 5.10.4.1
       // A special scheme in DASH used to signal manifest updates.
       if (schemeId == 'urn:mpeg:dash:event:2012') {
@@ -1662,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

@@ -222,6 +222,10 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     this.destroyed_ = true;
     this.requestFilters_.clear();
     this.responseFilters_.clear();
+
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     return this.operationManager_.destroy();
   }
 
@@ -544,7 +548,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/offline/storage.js

@@ -477,23 +477,22 @@ shaka.offline.Storage = class {
    * @private
    */
   async filterManifest_(manifest, drmEngine, config) {
-    const StreamUtils = shaka.util.StreamUtils;
-
     // Filter the manifest based on the restrictions given in the player
     // configuration.
     const maxHwRes = {width: Infinity, height: Infinity};
-    StreamUtils.filterByRestrictions(manifest, config.restrictions, maxHwRes);
+    shaka.util.StreamUtils.filterByRestrictions(
+        manifest, config.restrictions, maxHwRes);
 
     // Filter the manifest based on what we know media source will be able to
     // play later (no point storing something we can't play).
     if (config.useMediaCapabilities) {
-      StreamUtils.filterManifestByMediaCapabilities(
+      await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
           manifest, config.offline.usePersistentLicense);
     } else {
-      StreamUtils.filterManifestByMediaSource(manifest);
+      shaka.util.StreamUtils.filterManifestByMediaSource(manifest);
       // Filter the manifest based on what we know our drm system will support
       // playing later.
-      StreamUtils.filterManifestByDrm(manifest, drmEngine);
+      shaka.util.StreamUtils.filterManifestByDrm(manifest, drmEngine);
     }
 
     // Gather all tracks.
@@ -501,23 +500,23 @@ shaka.offline.Storage = class {
 
     // Choose the codec that has the lowest average bandwidth.
     const preferredAudioChannelCount = config.preferredAudioChannelCount;
-    StreamUtils.chooseCodecsAndFilterManifest(
+    shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
         manifest, preferredAudioChannelCount);
 
     for (const variant of manifest.variants) {
       goog.asserts.assert(
-          StreamUtils.isPlayable(variant),
+          shaka.util.StreamUtils.isPlayable(variant),
           'We should have already filtered by "is playable"');
 
-      allTracks.push(StreamUtils.variantToTrack(variant));
+      allTracks.push(shaka.util.StreamUtils.variantToTrack(variant));
     }
 
     for (const text of manifest.textStreams) {
-      allTracks.push(StreamUtils.textStreamToTrack(text));
+      allTracks.push(shaka.util.StreamUtils.textStreamToTrack(text));
     }
 
     for (const image of manifest.imageStreams) {
-      allTracks.push(StreamUtils.imageStreamToTrack(image));
+      allTracks.push(shaka.util.StreamUtils.imageStreamToTrack(image));
     }
 
     // Let the application choose which tracks to store.

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
    */
@@ -726,6 +726,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       await this.networkingEngine_.destroy();
       this.networkingEngine_ = null;
     }
+
+    // FakeEventTarget implements IReleasable
+    super.release();
   }
 
   /**
@@ -1155,6 +1158,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 +1289,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;
 
@@ -1621,8 +1630,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // initialize it now even through it appears a little out-of-place.
     this.regionTimeline_ =
         new shaka.media.RegionTimeline(() => this.seekRange());
-    this.regionTimeline_.setListeners(/* onRegionAdded= */ (region) => {
+    this.regionTimeline_.addEventListener('regionadd', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
       this.onRegionEvent_(shaka.Player.EventName.TimelineRegionAdded, region);
+
       if (this.adManager_) {
         this.adManager_.onDashTimedMetadata(region);
       }
@@ -2064,6 +2076,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);
@@ -2409,12 +2422,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));
   }
 
@@ -2476,7 +2488,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.abrManager_.segmentDownloaded(deltaTimeMs, bytesDownloaded);
       }
     };
-
     return new shaka.net.NetworkingEngine(onProgressUpdated_);
   }
 
@@ -2514,21 +2525,31 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Create the region observer. This will allow us to notify the app when we
     // move in and out of timeline regions.
     const regionObserver = new shaka.media.RegionObserver(this.regionTimeline_);
-    const onEnterRegion = (region, seeking) => {
+
+    regionObserver.addEventListener('enter', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
       this.onRegionEvent_(shaka.Player.EventName.TimelineRegionEnter, region);
-    };
-    const onExitRegion = (region, seeking) => {
+    });
+
+    regionObserver.addEventListener('exit', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
       this.onRegionEvent_(shaka.Player.EventName.TimelineRegionExit, region);
-    };
-    const onSkipRegion = (region, seeking) => {
+    });
+
+    regionObserver.addEventListener('skip', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
+      /** @type {boolean} */
+      const seeking = event['seeking'];
       // If we are seeking, we don't want to surface the enter/exit events since
       // they didn't play through them.
       if (!seeking) {
         this.onRegionEvent_(shaka.Player.EventName.TimelineRegionEnter, region);
         this.onRegionEvent_(shaka.Player.EventName.TimelineRegionExit, region);
       }
-    };
-    regionObserver.setListeners(onEnterRegion, onExitRegion, onSkipRegion);
+    });
 
     // Now that we have all our observers, create a manager for them.
     const manager = new shaka.media.PlayheadObserverManager(this.video_);
@@ -3235,6 +3256,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)) {
@@ -3243,10 +3266,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.
@@ -4796,7 +4831,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));
   }
 
   /**
@@ -5178,10 +5214,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);
   }
 
@@ -5204,10 +5240,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));
   }
 
   /**
@@ -5224,7 +5259,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;
@@ -5253,7 +5288,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));
   }
 
   /**
@@ -6082,7 +6118,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.2-uncompiled';
+shaka.Player.version = 'v3.1.6-uncompiled';  // x-release-please-version
 
 // 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) {