shaka-player 3.1.4 → 3.1.7

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;
         }
@@ -669,7 +669,7 @@ shaka.media.StreamingEngine = class {
 
     if (mediaState.waitingToClearBuffer) {
       // May not be performing an update, but an update will still happen.
-      // See: https://github.com/google/shaka-player/issues/334
+      // See: https://github.com/shaka-project/shaka-player/issues/334
       shaka.log.debug(logPrefix, 'clear: already waiting');
       return;
     }
@@ -909,9 +909,9 @@ shaka.media.StreamingEngine = class {
       // buffering forever at the end.
       // We should only do this if the duration needs to shrink.
       // Growing it by less than 1ms can actually cause buffering on
-      // replay, as in https://github.com/google/shaka-player/issues/979
+      // replay, as in https://github.com/shaka-project/shaka-player/issues/979
       // On some platforms, this can spuriously be 0, so ignore this case.
-      // https://github.com/google/shaka-player/issues/1967,
+      // https://github.com/shaka-project/shaka-player/issues/1967,
       const duration = this.playerInterface_.mediaSourceEngine.getDuration();
       if (duration != 0 &&
           duration < this.manifest_.presentationTimeline.getDuration()) {
@@ -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') {
@@ -1699,7 +1702,7 @@ shaka.media.StreamingEngine = class {
     const bufferedBehind = presentationTime - startTime;
 
     const overflow = bufferedBehind - bufferBehind;
-    // See: https://github.com/google/shaka-player/issues/2982
+    // See: https://github.com/shaka-project/shaka-player/issues/2982
     if (overflow <= 0.01) {
       shaka.log.v2(logPrefix,
           'buffer behind okay:',
@@ -2038,7 +2041,7 @@ shaka.media.StreamingEngine.MediaState_;
  * of the Period.
  *
  * NOTE: This was increased as part of the solution to
- * https://github.com/google/shaka-player/issues/1281
+ * https://github.com/shaka-project/shaka-player/issues/1281
  *
  * @const {number}
  * @private
@@ -2052,7 +2055,7 @@ shaka.media.StreamingEngine.APPEND_WINDOW_START_FUDGE_ = 0.1;
  * the Period.  This rounding error could then create an artificial gap and a
  * stutter when the gap-jumping logic takes over.
  *
- * https://github.com/google/shaka-player/issues/1597
+ * https://github.com/shaka-project/shaka-player/issues/1597
  *
  * @const {number}
  * @private

package/lib/media/time_ranges_utils.js

@@ -6,8 +6,6 @@
 
 goog.provide('shaka.media.TimeRangesUtils');
 
-goog.require('shaka.util.Iterables');
-
 
 /**
  * @summary A set of utility functions for dealing with TimeRanges objects.
@@ -157,7 +155,7 @@ shaka.media.TimeRangesUtils = class {
       return [];
     }
     const ret = [];
-    for (const i of shaka.util.Iterables.range(b.length)) {
+    for (let i = 0; i < b.length; i++) {
       ret.push({start: b.start(i), end: b.end(i)});
     }
     return ret;

package/lib/media/video_wrapper.js

@@ -141,7 +141,7 @@ shaka.media.VideoWrapper = class {
     // TODO: Need further investigation why it happens. Before and after
     // setting the current time, video.readyState is 1, video.paused is true,
     // and video.buffered's TimeRanges length is 0.
-    // See: https://github.com/google/shaka-player/issues/1298
+    // See: https://github.com/shaka-project/shaka-player/issues/1298
     this.mover_.moveTo(
         this.video_.currentTime == 0 ?
         startTime :

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();
   }
 
@@ -417,7 +421,7 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     }
 
     // Schemes are meant to be case-insensitive.
-    // See https://github.com/google/shaka-player/issues/2173
+    // See https://github.com/shaka-project/shaka-player/issues/2173
     // and https://tools.ietf.org/html/rfc3986#section-3.1
     scheme = scheme.toLowerCase();
 

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.
@@ -601,10 +600,10 @@ shaka.offline.Storage = class {
       storage, drmEngine, manifest, uri, metadata, config, downloader) {
     const pendingContent = shaka.offline.StoredContentUtils.fromManifest(
         uri, manifest, /* size= */ 0, metadata);
-    // In https://github.com/google/shaka-player/issues/2652, we found that this
-    // callback would be removed by the compiler if we reference the config in
-    // the onProgress closure below.  Reading it into a local variable first
-    // seems to work around this apparent compiler bug.
+    // In https://github.com/shaka-project/shaka-player/issues/2652, we found
+    // that this callback would be removed by the compiler if we reference the
+    // config in the onProgress closure below.  Reading it into a local
+    // variable first seems to work around this apparent compiler bug.
     const progressCallback = config.offline.progressCallback;
 
     const onProgress = (progress, size) => {

package/lib/player.js

@@ -726,6 +726,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       await this.networkingEngine_.destroy();
       this.networkingEngine_ = null;
     }
+
+    // FakeEventTarget implements IReleasable
+    super.release();
   }
 
   /**
@@ -1627,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);
       }
@@ -2114,6 +2120,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     this.playhead_ = new shaka.media.SrcEqualsPlayhead(has.mediaElement);
 
+    // This flag is used below in the language preference setup and
+    // track-management to check if this load was canceled before the necessary
+    // events fired.
+    let unloaded = false;
+    this.cleanupOnUnload_.push(() => {
+      unloaded = true;
+    });
+
     if (has.startTime != null) {
       this.playhead_.setStartTime(has.startTime);
     }
@@ -2141,7 +2155,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // Wait for the 'loadedmetadata' event to measure load() latency, but only
     // if preload is set in a way that would result in this event firing
-    // automatically.  See https://github.com/google/shaka-player/issues/2483
+    // automatically.
+    // See https://github.com/shaka-project/shaka-player/issues/2483
     if (this.video_.preload != 'none') {
       this.eventManager_.listenOnce(this.video_, 'loadedmetadata', () => {
         const now = Date.now() / 1000;
@@ -2164,6 +2179,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
     if (this.video_.textTracks) {
       this.eventManager_.listen(this.video_.textTracks, 'addtrack', (e) => {
+        // If we have moved on to another piece of content while waiting for
+        // the above event, we should not process tracks here.
+        if (unloaded) {
+          return;
+        }
+
         this.onTracksChanged_();
         this.processTimedMetadataSrcEqls_(/** @type {!TrackEvent} */(e));
       });
@@ -2205,13 +2226,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           fullyLoaded.resolve();
         });
 
-    // This flag is used below in the language preference setup to check if this
-    // load was canceled before the necessary events fire.
-    let unloaded = false;
-    this.cleanupOnUnload_.push(() => {
-      unloaded = true;
-    });
-
     // We can't switch to preferred languages, though, until the data is loaded.
     shaka.util.MediaReadyState.waitForReadyState(this.video_,
         HTMLMediaElement.HAVE_CURRENT_DATA,
@@ -2369,12 +2383,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // In Safari the initial assignment does not always work, so we schedule
     // this process to be repeated several times to ensure that it has been put
     // in the correct mode.
-    new shaka.util.Timer(() => {
+    const timer = new shaka.util.Timer(() => {
       const textTracks = this.getMetadataTracks_();
       for (const textTrack of textTracks) {
         textTrack.mode = 'hidden';
       }
-    }).tickNow().tickAfter(/* seconds= */ 0.5);
+    }).tickNow().tickAfter(0.5);
+
+    this.cleanupOnUnload_.push(() => {
+      timer.stop();
+    });
   }
 
 
@@ -2519,21 +2537,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_);
@@ -3439,7 +3467,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.streamingEngine_.switchTextStream(stream);
       this.onTextChanged_();
 
-      // Workaround for https://github.com/google/shaka-player/issues/1299
+      // Workaround for
+      // https://github.com/shaka-project/shaka-player/issues/1299
       // When track is selected, back-propagate the language to
       // currentTextLanguage_.
       this.currentTextLanguage_ = stream.language;
@@ -3515,7 +3544,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.switchVariant_(variant, /* fromAdaptation= */ false, clearBuffer,
           safeMargin);
 
-      // Workaround for https://github.com/google/shaka-player/issues/1299
+      // Workaround for
+      // https://github.com/shaka-project/shaka-player/issues/1299
       // When track is selected, back-propagate the language to
       // currentAudioLanguage_.
       this.currentAdaptationSetCriteria_ = new shaka.media.ExampleBasedCriteria(
@@ -4838,7 +4868,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // If the playback rate changes while seeking, Edge will cache the playback
     // rate and use it after seeking.
     //
-    // https://github.com/google/shaka-player/issues/951
+    // https://github.com/shaka-project/shaka-player/issues/951
     if (newRate == 0) {
       return;
     }
@@ -6102,7 +6132,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.4-uncompiled';
+shaka.Player.version = 'v3.1.7-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/all.js

@@ -7,7 +7,6 @@
 goog.provide('shaka.polyfill');
 
 goog.require('shaka.log');
-goog.require('shaka.util.Iterables');
 
 
 /**
@@ -40,8 +39,8 @@ shaka.polyfill = class {
    */
   static register(polyfill, priority) {
     const newItem = {priority: priority || 0, callback: polyfill};
-    const enumerate = (it) => shaka.util.Iterables.enumerate(it);
-    for (const {i, item} of enumerate(shaka.polyfill.polyfills_)) {
+    for (let i = 0; i < shaka.polyfill.polyfills_.length; i++) {
+      const item = shaka.polyfill.polyfills_[i];
       if (item.priority < newItem.priority) {
         shaka.polyfill.polyfills_.splice(i, 0, newItem);
         return;

package/lib/polyfill/encryption_scheme.js

@@ -12,7 +12,7 @@ goog.require('shaka.polyfill');
  * @summary A polyfill to add support for EncryptionScheme queries in EME.
  * @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
+ * @see https://github.com/shaka-project/eme-encryption-scheme-polyfill
  * @export
  */
 shaka.polyfill.EncryptionScheme = class {