shaka-player 3.1.6 → 3.1.7

package/lib/hls/hls_parser.js

@@ -29,7 +29,6 @@ goog.require('shaka.util.DataViewReader');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.Functional');
-goog.require('shaka.util.Iterables');
 goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
@@ -885,7 +884,7 @@ shaka.hls.HlsParser = class {
       // the content. This means that if the content changes profiles, it should
       // include both. Since all known browsers support changing profiles
       // without any other work, just ignore them.  See also:
-      // https://github.com/google/shaka-player/issues/1817
+      // https://github.com/shaka-project/shaka-player/issues/1817
       const shortCodec = shaka.util.MimeUtils.getCodecBase(codec);
       if (!seen.has(shortCodec)) {
         ret.push(codec);
@@ -1653,8 +1652,8 @@ shaka.hls.HlsParser = class {
     // Create SegmentReferences for the partial segments.
     const partialSegmentRefs = [];
     if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
-      const enumerate = (it) => shaka.util.Iterables.enumerate(it);
-      for (const {i, item} of enumerate(hlsSegment.partialSegments)) {
+      for (let i = 0; i < hlsSegment.partialSegments.length; i++) {
+        const item = hlsSegment.partialSegments[i];
         const pPreviousReference = i == 0 ?
           previousReference : partialSegmentRefs[partialSegmentRefs.length - 1];
         const pStartTime = (i == 0) ? startTime : pPreviousReference.endTime;
@@ -1675,6 +1674,9 @@ shaka.hls.HlsParser = class {
             this.parseByteRange_(pPreviousReference, pByterange);
         }
         const pUri = item.getAttributeValue('URI');
+        if (!pUri) {
+          continue;
+        }
         const pAbsoluteUri = shaka.hls.Utils.constructAbsoluteUri(
             absoluteMediaPlaylistUri, pUri);
 
@@ -1860,9 +1862,9 @@ shaka.hls.HlsParser = class {
         // With delta updates, the DISCONTINUITY may be skipped. Check if
         // the discontintuity Sequence Number based on the media sequence
         // number.
-        while (discontinuityToMediaSequence.has(discontintuitySequenceNum + 1)
-            && discontinuityToMediaSequence.get(discontintuitySequenceNum + 1) <
-            position) {
+        const disconMap = discontinuityToMediaSequence;
+        while (disconMap.has(discontintuitySequenceNum + 1) &&
+            disconMap.get(discontintuitySequenceNum + 1) < position) {
           discontintuitySequenceNum++;
         }
       }
@@ -1873,8 +1875,8 @@ shaka.hls.HlsParser = class {
     /** @type {!Array.<!shaka.media.SegmentReference>} */
     const references = [];
 
-    const enumerate = (it) => shaka.util.Iterables.enumerate(it);
-    for (const {i, item} of enumerate(hlsSegments)) {
+    for (let i = 0; i < hlsSegments.length; i++) {
+      const item = hlsSegments[i];
       const previousReference = references[references.length - 1];
       const startTime = (i == 0) ? firstStartTime :
         previousReference.endTime;

package/lib/hls/manifest_text_parser.js

@@ -13,7 +13,6 @@ goog.require('shaka.hls.Segment');
 goog.require('shaka.hls.Tag');
 goog.require('shaka.hls.Utils');
 goog.require('shaka.util.Error');
-goog.require('shaka.util.Iterables');
 goog.require('shaka.util.StringUtils');
 goog.require('shaka.util.TextParser');
 
@@ -82,8 +81,9 @@ shaka.hls.ManifestTextParser = class {
     const tags = [];
     // Initialize to "true" to skip the first element.
     skip = true;
-    const enumerate = (it) => shaka.util.Iterables.enumerate(it);
-    for (const {i, item: line, next} of enumerate(lines)) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const next = lines[i + 1];
       // Skip comments
       if (shaka.hls.Utils.isComment(line) || skip) {
         skip = false;

package/lib/media/adaptation_set.js

@@ -8,7 +8,6 @@ goog.provide('shaka.media.AdaptationSet');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
-goog.require('shaka.util.Iterables');
 goog.require('shaka.util.MimeUtils');
 
 
@@ -215,7 +214,7 @@ shaka.media.AdaptationSet = class {
     codecsA.sort();
     codecsB.sort();
 
-    for (const i of shaka.util.Iterables.range(codecsA.length)) {
+    for (let i = 0; i < codecsA.length; i++) {
       if (codecsA[i] != codecsB[i]) {
         return false;
       }

package/lib/media/closed_caption_parser.js

@@ -11,7 +11,6 @@ goog.require('shaka.cea.CeaDecoder');
 goog.require('shaka.cea.Mp4CeaParser');
 goog.require('shaka.util.BufferUtils');
 goog.requireType('shaka.cea.ICaptionDecoder');
-goog.requireType('shaka.cea.ICaptionDecoder.ClosedCaption');
 goog.requireType('shaka.cea.ICeaParser');
 
 

package/lib/media/content_workarounds.js

@@ -31,7 +31,7 @@ shaka.media.ContentWorkarounds = class {
    *
    * @param {!BufferSource} initSegmentBuffer
    * @return {!Uint8Array}
-   * @see https://github.com/google/shaka-player/issues/2759
+   * @see https://github.com/shaka-project/shaka-player/issues/2759
    */
   static fakeEncryption(initSegmentBuffer) {
     const ContentWorkarounds = shaka.media.ContentWorkarounds;
@@ -283,7 +283,7 @@ shaka.media.ContentWorkarounds = class {
  *
  * @const {!shaka.util.Lazy.<!Uint8Array>}
  * @private
- * @see https://github.com/google/shaka-player/issues/2759
+ * @see https://github.com/shaka-project/shaka-player/issues/2759
  */
 shaka.media.ContentWorkarounds.CANNED_SINF_BOX_ =
     new shaka.util.Lazy(() => new Uint8Array([

package/lib/media/drm_engine.js

@@ -616,7 +616,7 @@ shaka.media.DrmEngine = class {
     // first MIME type even if the others are supported.  To work around this,
     // we say that Edge supports everything.
     //
-    // See https://github.com/google/shaka-player/issues/1495 for details.
+    // See https://github.com/shaka-project/shaka-player/issues/1495 for details.
     if (shaka.util.Platform.isLegacyEdge()) {
       return true;
     }
@@ -628,7 +628,8 @@ shaka.media.DrmEngine = class {
       // Some Tizen devices seem to misreport AC-3 support.  This works around
       // the issue, by falling back to EC-3, which seems to be supported on the
       // same devices and be correctly reported in all cases we have observed.
-      // See https://github.com/google/shaka-player/issues/2989 for details.
+      // See https://github.com/shaka-project/shaka-player/issues/2989 for
+      // details.
       const fallback = contentType.replace('ac-3', 'ec-3');
       return this.supportedTypes_.has(contentType) ||
              this.supportedTypes_.has(fallback);

package/lib/media/media_source_engine.js

@@ -830,7 +830,8 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   setTimestampOffset_(contentType, timestampOffset) {
-    // Work around for https://github.com/google/shaka-player/issues/1281:
+    // Work around for
+    // https://github.com/shaka-project/shaka-player/issues/1281:
     // TODO(https://bit.ly/2ttKiBU): follow up when this is fixed in Edge
     if (timestampOffset < 0) {
       // Try to prevent rounding errors in Edge from removing the first
@@ -1100,7 +1101,7 @@ shaka.media.MediaSourceEngine = class {
     // then insert fake encryption metadata for init segments that lack it.
     // The MP4 requirement is because we can currently only do this
     // transformation on MP4 containers.
-    // See: https://github.com/google/shaka-player/issues/2759
+    // See: https://github.com/shaka-project/shaka-player/issues/2759
     if (isInitSegment &&
         encryptionExpected &&
         shaka.util.Platform.requiresEncryptionInfoInAllInitSegments() &&

package/lib/media/mp4_segment_index_parser.js

@@ -11,8 +11,6 @@ goog.require('shaka.log');
 goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.util.Error');
-goog.require('shaka.util.Functional');
-goog.require('shaka.util.Iterables');
 goog.require('shaka.util.Mp4Parser');
 
 
@@ -123,8 +121,7 @@ shaka.media.Mp4SegmentIndexParser = class {
     let unscaledStartTime = earliestPresentationTime;
     let startByte = sidxOffset + box.size + firstOffset;
 
-    for (const _ of shaka.util.Iterables.range(referenceCount)) {
-      shaka.util.Functional.ignored(_);
+    for (let i = 0; i < referenceCount; i++) {
       // |chunk| is 1 bit for |referenceType|, and 31 bits for |referenceSize|.
       const chunk = box.reader.readUint32();
       const referenceType = (chunk & 0x80000000) >>> 31;

package/lib/media/playhead.js

@@ -256,7 +256,7 @@ shaka.media.MediaSourcePlayhead = class {
     // We don't buffer when the livestream video is paused and the playhead time
     // is out of the seek range; thus, we do not clamp the current time when the
     // video is paused.
-    // https://github.com/google/shaka-player/issues/1121
+    // https://github.com/shaka-project/shaka-player/issues/1121
     if (this.mediaElement_.readyState > 0 && !this.mediaElement_.paused) {
       return this.clampTime_(time);
     }
@@ -362,7 +362,7 @@ shaka.media.MediaSourcePlayhead = class {
    * presentation duration.  Seeking to or starting at duration does not work
    * consistently across browsers.
    *
-   * @see https://github.com/google/shaka-player/issues/979
+   * @see https://github.com/shaka-project/shaka-player/issues/979
    * @param {number} time
    * @return {number} The adjusted seek time.
    * @private

package/lib/media/presentation_timeline.js

@@ -355,14 +355,23 @@ shaka.media.PresentationTimeline = class {
    * starting after this time should be assumed to be unavailable.
    *
    * @return {number} The current segment availability end time, in seconds,
-   *   relative to the start of the presentation.  Always returns the
-   *   presentation's duration for video-on-demand.
+   *   relative to the start of the presentation.  For VOD, the availability
+   *   end time is the content's duration.  If the Player's playRangeEnd
+   *   configuration is used, this can override the duration.
    * @export
    */
   getSegmentAvailabilityEnd() {
     if (!this.isLive() && !this.isInProgress()) {
       // It's a static manifest (can also be a dynamic->static conversion)
-      return this.maxSegmentEndTime_ || this.duration_;
+      if (this.maxSegmentEndTime_) {
+        // If we know segment times, use the min of that and duration.
+        // Note that the playRangeEnd configuration changes this.duration_.
+        // See https://github.com/shaka-project/shaka-player/issues/4026
+        return Math.min(this.maxSegmentEndTime_, this.duration_);
+      } else {
+        // If we don't have segment times, use duration.
+        return this.duration_;
+      }
     }
     // Can be either live or "in-progress recording" (live with known duration)
     return Math.min(this.getLiveEdge_() + this.availabilityTimeOffset_,
@@ -389,10 +398,11 @@ shaka.media.PresentationTimeline = class {
     // For VOD, the offset and end time are ignored, and we just return the
     // earliest segment time.  All segments are "safe" in VOD.  However, we
     // should round up to the nearest millisecond to avoid issues like
-    // https://github.com/google/shaka-player/issues/2831, in which we tried to
-    // seek repeatedly to catch up to the seek range, and never actually
-    // "arrived" within it.  The video's currentTime is not as accurate as the
-    // JS number representing the earliest segment time for some content.
+    // https://github.com/shaka-project/shaka-player/issues/2831, in which we
+    // tried to seek repeatedly to catch up to the seek range, and never
+    // actually "arrived" within it.  The video's currentTime is not as
+    // accurate as the JS number representing the earliest segment time for
+    // some content.
     if (this.segmentAvailabilityDuration_ == Infinity) {
       return Math.ceil(earliestSegmentTime * 1e3) / 1e3;
     }
@@ -407,7 +417,7 @@ shaka.media.PresentationTimeline = class {
     // Add the offset to the availability start to ensure that we don't fall
     // outside the availability window while we buffer; we don't need to add the
     // offset to earliestSegmentTime since that won't change over time.
-    // Also see: https://github.com/google/shaka-player/issues/692
+    // Also see: https://github.com/shaka-project/shaka-player/issues/692
     const desiredStart =
         Math.min(availabilityStart + offset, this.getSeekRangeEnd());
     return Math.max(earliestSegmentTime, desiredStart);

package/lib/media/streaming_engine.js

@@ -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()) {
@@ -1702,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:',
@@ -2041,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
@@ -2055,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

@@ -421,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

@@ -600,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

@@ -2120,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);
     }
@@ -2147,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;
@@ -2170,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));
       });
@@ -2211,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,
@@ -2375,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();
+    });
   }
 
 
@@ -3455,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;
@@ -3531,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(
@@ -4854,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;
     }
@@ -6118,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.6-uncompiled';  // x-release-please-version
+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 {

package/lib/polyfill/media_capabilities.js

@@ -29,12 +29,12 @@ shaka.polyfill.MediaCapabilities = class {
     // TODO: re-evaluate MediaCapabilities in the future versions of Chromecast.
     // Since MediaCapabilities implementation is buggy in Apple browsers, we
     // should always install polyfill for Apple browsers.
-    // See: https://github.com/google/shaka-player/issues/3530
+    // See: https://github.com/shaka-project/shaka-player/issues/3530
     // TODO: re-evaluate MediaCapabilities in the future versions of Apple
     // Browsers.
     // Since MediaCapabilities implementation is buggy in PS5 browsers, we
     // should always install polyfill for PS5 browsers.
-    // See: https://github.com/google/shaka-player/issues/3582
+    // See: https://github.com/shaka-project/shaka-player/issues/3582
     // TODO: re-evaluate MediaCapabilities in the future versions of PS5
     // Browsers.
     if (!shaka.util.Platform.isChromecast() &&
@@ -54,7 +54,7 @@ shaka.polyfill.MediaCapabilities = class {
 
     // Keep the patched MediaCapabilities object from being garbage-collected in
     // Safari.
-    // See https://github.com/google/shaka-player/issues/3696#issuecomment-1009472718
+    // See https://github.com/shaka-project/shaka-player/issues/3696#issuecomment-1009472718
     shaka.polyfill.MediaCapabilities.originalMcap =
         navigator.mediaCapabilities;
 

package/lib/polyfill/mediasource.js

@@ -39,7 +39,7 @@ shaka.polyfill.MediaSource = class {
       shaka.polyfill.MediaSource.patchCastIsTypeSupported_();
     } else if (safariVersion) {
       // TS content is broken on Safari in general.
-      // See https://github.com/google/shaka-player/issues/743
+      // See https://github.com/shaka-project/shaka-player/issues/743
       // and https://bugs.webkit.org/show_bug.cgi?id=165342
       shaka.polyfill.MediaSource.rejectTsContent_();
 

package/lib/routing/walker.js

@@ -5,7 +5,6 @@
  */
 
 goog.provide('shaka.routing.Walker');
-goog.provide('shaka.routing.Walker.Implementation');
 
 goog.require('goog.asserts');
 goog.require('shaka.routing.Node');
@@ -81,7 +80,7 @@ shaka.routing.Walker = class {
      * new work is added (and this is not null) it can be resolved. The only
      * time when this should be non-null is when we are waiting for more work.
      *
-     * @private {shaka.util.PublicPromise}
+     * @private {?shaka.util.PublicPromise}
      */
     this.waitForWork_ = null;
 
@@ -91,7 +90,7 @@ shaka.routing.Walker = class {
     /** @private {?shaka.routing.Walker.ActiveRoute_} */
     this.currentRoute_ = null;
 
-    /** @private {shaka.util.AbortableOperation} */
+    /** @private {?shaka.util.AbortableOperation} */
     this.currentStep_ = null;
 
     /**

package/lib/text/cue.js

@@ -282,7 +282,7 @@ shaka.text.Cue = class {
     // Compare the start time, end time and payload of the cues first for
     // performance optimization.  We can avoid the more expensive recursive
     // checks if the top-level properties don't match.
-    // See: https://github.com/google/shaka-player/issues/3018
+    // See: https://github.com/shaka-project/shaka-player/issues/3018
     if (cue1.startTime != cue2.startTime || cue1.endTime != cue2.endTime ||
       cue1.payload != cue2.payload) {
       return false;

package/lib/text/simple_text_displayer.js

@@ -178,7 +178,8 @@ shaka.text.SimpleTextDisplayer = class {
         // The browser will display cues with identical time ranges from the
         // bottom up.  Reversing the order of equal cues means the first one
         // parsed will be at the top, as you would expect.
-        // See https://github.com/google/shaka-player/issues/848 for more info.
+        // See https://github.com/shaka-project/shaka-player/issues/848 for
+        // more info.
         // However, this ordering behavior is part of VTTCue's "line" field.
         // Some platforms don't have a real VTTCue and use a polyfill instead.
         // When VTTCue is polyfilled or does not support "line", we should _not_

package/lib/text/text_engine.js

@@ -12,7 +12,7 @@ goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Functional');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.MimeUtils');
-goog.requireType('shaka.cea.ICaptionDecoder.ClosedCaption');
+goog.requireType('shaka.cea.ICaptionDecoder');
 
 
 // TODO: revisit this when Closure Compiler supports partially-exported classes.

package/lib/text/ttml_text_parser.js

@@ -536,8 +536,10 @@ shaka.text.TtmlTextParser = class {
 
       cue.textAlign = Cue.textAlign[align.toUpperCase()];
     } else {
-      // Default value is START: https://bit.ly/32OGmvo
-      cue.textAlign = Cue.textAlign.START;
+      // Default value is START in the TTML spec: https://bit.ly/32OGmvo
+      // But to make the subtitle render consitent with other players and the
+      // shaka.text.Cue we use CENTER
+      cue.textAlign = Cue.textAlign.CENTER;
     }
 
     const displayAlign = TtmlTextParser.getStyleAttribute_(
@@ -559,7 +561,7 @@ shaka.text.TtmlTextParser = class {
     // Background color should not be set on a container.  If this is a nested
     // cue, you can set the background.  If it's a top-level that happens to
     // also be a leaf, you can set the background.
-    // See https://github.com/google/shaka-player/issues/2623
+    // See https://github.com/shaka-project/shaka-player/issues/2623
     // This used to be handled in the displayer, but that is confusing.  The Cue
     // structure should reflect what you want to happen in the displayer, and
     // the displayer shouldn't have to know about TTML.
@@ -919,8 +921,9 @@ shaka.text.TtmlTextParser = class {
     let ret = null;
     const XmlUtils = shaka.util.XmlUtils;
     while (element) {
-      ret = nsName ? XmlUtils.getAttributeNS(element, nsName, attributeName)
-                   : element.getAttribute(attributeName);
+      ret = nsName ?
+          XmlUtils.getAttributeNS(element, nsName, attributeName) :
+          element.getAttribute(attributeName);
       if (ret) {
         break;
       }

package/lib/text/ui_text_displayer.js

@@ -108,7 +108,7 @@ shaka.text.UITextDisplayer = class {
   append(cues) {
     // Clone the cues list for performace optimization. We can avoid the cues
     // list growing during the comparisons for duplicate cues.
-    // See: https://github.com/google/shaka-player/issues/3018
+    // See: https://github.com/shaka-project/shaka-player/issues/3018
     const cuesList = [...this.cues_];
     for (const cue of cues) {
       // When a VTT cue spans a segment boundary, the cue will be duplicated