shaka-player 4.10.12 → 4.10.13

package/lib/dash/dash_parser.js

@@ -30,6 +30,7 @@ goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Networking');
+goog.require('shaka.util.ObjectUtils');
 goog.require('shaka.util.OperationManager');
 goog.require('shaka.util.PeriodCombiner');
 goog.require('shaka.util.PlayerConfiguration');
@@ -93,12 +94,19 @@ shaka.dash.DashParser = class {
 
     /**
      * A map of IDs to Stream objects.
-     * ID: Period@id,AdaptationSet@id,@Representation@id
-     * e.g.: '1,5,23'
+     * ID: Period@id,Representation@id
+     * e.g.: '1,23'
      * @private {!Object.<string, !shaka.extern.Stream>}
      */
     this.streamMap_ = {};
 
+    /**
+     * A map of Period IDs to Stream Map IDs.
+     * Use to have direct access to streamMap key.
+     * @private {!Object.<string, !Array<string>>}
+     */
+    this.indexStreamMap_ = {};
+
     /**
      * A map of period ids to their durations
      * @private {!Object.<string, number>}
@@ -256,6 +264,7 @@ shaka.dash.DashParser = class {
     this.manifestUris_ = [];
     this.manifest_ = null;
     this.streamMap_ = {};
+    this.indexStreamMap_ = {};
     this.contextCache_.clear();
     this.manifestPatchContext_ = {
       mpdId: '',
@@ -653,7 +662,7 @@ shaka.dash.DashParser = class {
     }
 
     this.manifestPatchContext_.type = mpdType;
-
+    this.cleanStreamMap_();
     /** @type {!shaka.media.PresentationTimeline} */
     let presentationTimeline;
     if (this.manifest_) {
@@ -734,7 +743,8 @@ shaka.dash.DashParser = class {
     };
 
     this.gapCount_ = 0;
-    const periodsAndDuration = this.parsePeriods_(context, getBaseUris, mpd);
+    const periodsAndDuration = this.parsePeriods_(
+        context, getBaseUris, mpd, /* newPeriod= */ false);
     const duration = periodsAndDuration.duration;
     const periods = periodsAndDuration.periods;
 
@@ -1013,7 +1023,7 @@ shaka.dash.DashParser = class {
     };
 
     const periodsAndDuration = this.parsePeriods_(context,
-        this.manifestPatchContext_.getBaseUris, periods);
+        this.manifestPatchContext_.getBaseUris, periods, /* newPeriod= */ true);
 
     return periodsAndDuration.periods;
   }
@@ -1033,6 +1043,10 @@ shaka.dash.DashParser = class {
         this.contextCache_.delete(contextId);
       }
     }
+    const newPeriods = this.lastManifestUpdatePeriodIds_.filter((pID) => {
+      return pID !== periodId;
+    });
+    this.lastManifestUpdatePeriodIds_ = newPeriods;
   }
 
   /**
@@ -1274,6 +1288,7 @@ shaka.dash.DashParser = class {
    * @param {shaka.dash.DashParser.Context} context
    * @param {function():!Array.<string>} getBaseUris
    * @param {!shaka.extern.xml.Node} mpd
+   * @param {!boolean} newPeriod
    * @return {{
    *   periods: !Array.<shaka.extern.Period>,
    *   duration: ?number,
@@ -1281,7 +1296,7 @@ shaka.dash.DashParser = class {
    * }}
    * @private
    */
-  parsePeriods_(context, getBaseUris, mpd) {
+  parsePeriods_(context, getBaseUris, mpd, newPeriod) {
     const TXml = shaka.util.TXml;
     let presentationDuration = context.mediaPresentationDuration;
 
@@ -1413,8 +1428,18 @@ shaka.dash.DashParser = class {
       prevEnd = start + periodDuration;
     } // end of period parsing loop
 
-    // Replace previous seen periods with the current one.
-    this.lastManifestUpdatePeriodIds_ = periods.map((el) => el.id);
+    if (newPeriod) {
+      // append new period from the patch manifest
+      for (const el of periods) {
+        const periodID = el.id;
+        if (!this.lastManifestUpdatePeriodIds_.includes(periodID)) {
+          this.lastManifestUpdatePeriodIds_.push(periodID);
+        }
+      }
+    } else {
+      // Replace previous seen periods with the current one.
+      this.lastManifestUpdatePeriodIds_ = periods.map((el) => el.id);
+    }
 
     if (presentationDuration != null) {
       if (prevEnd != null) {
@@ -1442,6 +1467,26 @@ shaka.dash.DashParser = class {
     }
   }
 
+  /**
+   * Clean StreamMap Object to remove reference of deleted Stream Object
+   * @private
+   */
+  cleanStreamMap_() {
+    const oldPeriodIds = Object.keys(this.indexStreamMap_);
+    if (oldPeriodIds.length === this.lastManifestUpdatePeriodIds_.length) {
+      return;
+    }
+    const diffPeriodsIDs = oldPeriodIds.filter((pId) => {
+      return !this.lastManifestUpdatePeriodIds_.includes(pId);
+    });
+    for (const pId of diffPeriodsIDs) {
+      for (const contextId of this.indexStreamMap_[pId]) {
+        delete this.streamMap_[contextId];
+      }
+      delete this.indexStreamMap_[pId];
+    }
+  }
+
   /**
    * Parses a Period XML element.  Unlike the other parse methods, this is not
    * given the Node; it is given a PeriodInfo structure.  Also, partial parsing
@@ -1458,6 +1503,7 @@ shaka.dash.DashParser = class {
     const TXml = shaka.util.TXml;
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
+    goog.asserts.assert(periodInfo.node, 'periodInfo.node should exist');
     context.period = this.createFrame_(periodInfo.node, null, getBaseUris);
     context.periodInfo = periodInfo;
     context.period.availabilityTimeOffset = context.availabilityTimeOffset;
@@ -2221,7 +2267,12 @@ shaka.dash.DashParser = class {
     };
 
     if (contextId && context.dynamic && !this.streamMap_[contextId]) {
+      const periodId = context.period.id || '';
+      if (!this.indexStreamMap_[periodId]) {
+        this.indexStreamMap_[periodId] = [];
+      }
       this.streamMap_[contextId] = stream;
+      this.indexStreamMap_[periodId].push(contextId);
     }
 
     return stream;
@@ -2235,45 +2286,29 @@ shaka.dash.DashParser = class {
    * @private
    */
   cloneContext_(context) {
-    const contextClone = /** @type {!shaka.dash.DashParser.Context} */({});
-
-    for (const k of Object.keys(context)) {
-      if (['period', 'adaptationSet', 'representation'].includes(k)) {
-        /** @type {shaka.dash.DashParser.InheritanceFrame} */
-        const frameRef = context[k];
-        contextClone[k] = {
-          segmentBase: null,
-          segmentList: null,
-          segmentTemplate: frameRef.segmentTemplate,
-          getBaseUris: frameRef.getBaseUris,
-          width: frameRef.width,
-          height: frameRef.height,
-          contentType: frameRef.contentType,
-          mimeType: frameRef.mimeType,
-          language: frameRef.language,
-          codecs: frameRef.codecs,
-          frameRate: frameRef.frameRate,
-          pixelAspectRatio: frameRef.pixelAspectRatio,
-          emsgSchemeIdUris: frameRef.emsgSchemeIdUris,
-          id: frameRef.id,
-          position: frameRef.position,
-          numChannels: frameRef.numChannels,
-          audioSamplingRate: frameRef.audioSamplingRate,
-          availabilityTimeOffset: frameRef.availabilityTimeOffset,
-          initialization: frameRef.initialization,
-        };
-      } else if (k == 'periodInfo') {
-        /** @type {shaka.dash.DashParser.PeriodInfo} */
-        const frameRef = context[k];
-        contextClone[k] = {
-          start: frameRef.start,
-          duration: frameRef.duration,
-          node: null,
-          isLastPeriod: frameRef.isLastPeriod,
-        };
-      } else {
-        contextClone[k] = context[k];
+    /**
+     * @param {?shaka.dash.DashParser.InheritanceFrame} frame
+     * @return {?shaka.dash.DashParser.InheritanceFrame}
+     */
+    const cloneFrame = (frame) => {
+      if (!frame) {
+        return null;
       }
+      const clone = shaka.util.ObjectUtils.shallowCloneObject(frame);
+      clone.segmentBase = null;
+      clone.segmentList = null;
+      clone.segmentTemplate = shaka.util.TXml.cloneNode(clone.segmentTemplate);
+      return clone;
+    };
+    const contextClone = shaka.util.ObjectUtils.shallowCloneObject(context);
+    contextClone.period = cloneFrame(contextClone.period);
+    contextClone.adaptationSet = cloneFrame(contextClone.adaptationSet);
+    contextClone.representation = cloneFrame(contextClone.representation);
+
+    if (contextClone.periodInfo) {
+      contextClone.periodInfo =
+        shaka.util.ObjectUtils.shallowCloneObject(contextClone.periodInfo);
+      contextClone.periodInfo.node = null;
     }
 
     return contextClone;
@@ -3137,7 +3172,7 @@ shaka.dash.DashParser.Context;
  * @typedef {{
  *   start: number,
  *   duration: ?number,
- *   node: !shaka.extern.xml.Node,
+ *   node: ?shaka.extern.xml.Node,
  *   isLastPeriod: boolean
  * }}
  *
@@ -3149,7 +3184,7 @@ shaka.dash.DashParser.Context;
  * @property {?number} duration
  *   The duration of the period; or null if the duration is not given.  This
  *   will be non-null for all periods except the last.
- * @property {!shaka.extern.xml.Node} node
+ * @property {?shaka.extern.xml.Node} node
  *   The XML Node for the Period.
  * @property {boolean} isLastPeriod
  *   Whether this Period is the last one in the manifest.

package/lib/media/streaming_engine.js

@@ -73,6 +73,13 @@ shaka.media.StreamingEngine = class {
     /** @private {?shaka.extern.StreamingConfiguration} */
     this.config_ = null;
 
+    /**
+     * Retains a reference to the function used to close SegmentIndex objects
+     * for streams which were switched away from during an ongoing update_().
+     * @private {!Map.<string, !function()>}
+     */
+    this.deferredCloseSegmentIndex_ = new Map();
+
     /** @private {number} */
     this.bufferingGoalScale_ = 1;
 
@@ -504,6 +511,24 @@ shaka.media.StreamingEngine = class {
   }
 
 
+  /**
+   * Handles deferred releases of old SegmentIndexes for the mediaState's
+   * content type from a previous update.
+   * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
+   * @private
+   */
+  handleDeferredCloseSegmentIndexes_(mediaState) {
+    for (const [key, value] of this.deferredCloseSegmentIndex_.entries()) {
+      const streamId = /** @type {string} */ (key);
+      const closeSegmentIndex = /** @type {!function()} */ (value);
+      if (streamId.includes(mediaState.type)) {
+        closeSegmentIndex();
+        this.deferredCloseSegmentIndex_.delete(streamId);
+      }
+    }
+  }
+
+
   /**
    * Switches to the given Stream. |stream| may be from any Variant.
    *
@@ -576,7 +601,23 @@ shaka.media.StreamingEngine = class {
     // Do not close segment indexes we are prefetching.
     if (!this.audioPrefetchMap_.has(mediaState.stream)) {
       if (mediaState.stream.closeSegmentIndex) {
-        mediaState.stream.closeSegmentIndex();
+        if (mediaState.performingUpdate) {
+          const oldStreamTag =
+              shaka.media.StreamingEngine.logPrefix_(mediaState);
+          if (!this.deferredCloseSegmentIndex_.has(oldStreamTag)) {
+            // The ongoing update is still using the old stream's segment
+            // reference information.
+            // If we close the old stream now, the update will not complete
+            // correctly.
+            // The next onUpdate_() for this content type will resume the
+            // closeSegmentIndex() operation for the old stream once the ongoing
+            // update has finished, then immediately create a new segment index.
+            this.deferredCloseSegmentIndex_.set(
+                oldStreamTag, mediaState.stream.closeSegmentIndex);
+          }
+        } else {
+          mediaState.stream.closeSegmentIndex();
+        }
       }
     }
 
@@ -1169,6 +1210,13 @@ shaka.media.StreamingEngine = class {
       return;
     }
 
+    // If stream switches happened during the previous update_() for this
+    // content type, close out the old streams that were switched away from.
+    // Even if we had switched away from the active stream 'A' during the
+    // update_(), e.g. (A -> B -> A), closing 'A' is permissible here since we
+    // will immediately re-create it in the logic below.
+    this.handleDeferredCloseSegmentIndexes_(mediaState);
+
     // Make sure the segment index exists. If not, create the segment index.
     if (!mediaState.stream.segmentIndex) {
       const thisStream = mediaState.stream;
@@ -1455,14 +1503,11 @@ shaka.media.StreamingEngine = class {
         mediaState.stream.segmentIndex,
         'segment index should have been generated already');
 
-    const currentSegment = mediaState.segmentIterator ?
-        mediaState.segmentIterator.current() : null;
-
-    if (currentSegment) {
+    if (mediaState.segmentIterator) {
       // Something is buffered from the same Stream.  Use the current position
       // in the segment index.  This is updated via next() after each segment is
       // appended.
-      return currentSegment;
+      return mediaState.segmentIterator.current();
     } else if (mediaState.lastSegmentReference || bufferEnd) {
       // Something is buffered from another Stream.
       const time = mediaState.lastSegmentReference ?
@@ -2755,6 +2800,10 @@ shaka.media.StreamingEngine = class {
     this.destroyer_.ensureNotDestroyed();
     // Try to recover from network errors
     if (error.category === shaka.util.Error.Category.NETWORK) {
+      if (mediaState.restoreStreamAfterTrickPlay) {
+        this.setTrickPlay(/* on= */ false);
+        return;
+      }
       const maxDisabledTime = this.getDisabledTime_(error);
       error.handled = this.playerInterface_.disableStream(
           mediaState.stream, maxDisabledTime);

package/lib/player.js

@@ -4454,9 +4454,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * beginning or end of the seekable range for the content.
    *
    * @param {number} rate
+   * @param {boolean=} useTrickPlayTrack
    * @export
    */
-  trickPlay(rate) {
+  trickPlay(rate, useTrickPlayTrack = true) {
     // A playbackRate of 0 is used internally when we are in a buffering state,
     // and doesn't make sense for trick play.  If you set a rate of 0 for trick
     // play, we will reject it and issue a warning.  If it happens during a
@@ -4478,7 +4479,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     if (this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
       this.abrManager_.playbackRateChanged(rate);
-      this.streamingEngine_.setTrickPlay(Math.abs(rate) > 1);
+      this.streamingEngine_.setTrickPlay(
+          useTrickPlayTrack && Math.abs(rate) > 1);
     }
     if (this.isLive()) {
       this.trickPlayEventManager_.listen(this.video_, 'timeupdate', () => {
@@ -5561,6 +5563,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
+      this.stats_.addBytesDownloaded(NaN);
       this.stats_.setResolution(
           /* width= */ element.videoWidth || NaN,
           /* height= */ element.videoHeight || NaN);
@@ -6502,7 +6505,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           shaka.log.debug('Buffer fullness ratio (' + bufferFullness + ') ' +
             'is less than the vodDynamicPlaybackRateBufferRatio (' +
             bufferThreshold + '). Updating playbackRate to ' + minPlaybackRate);
-          this.trickPlay(minPlaybackRate);
+          this.trickPlay(minPlaybackRate, /* useTrickPlayTrack= */ false);
         }
       } else if (bufferFullness == 1) {
         if (playbackRate !== this.playRateController_.getDefaultRate()) {
@@ -6629,7 +6632,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           timeSinceLastRebuffer + 's) ' +
           'is less than the live sync panicThreshold (' + panicThreshold +
           's). Updating playbackRate to ' + minPlaybackRate);
-        this.trickPlay(minPlaybackRate);
+        this.trickPlay(minPlaybackRate, /* useTrickPlayTrack= */ false);
       }
     } else if (maxLatency && maxPlaybackRate &&
       (latency - offset) > maxLatency) {
@@ -6637,7 +6640,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         shaka.log.debug('Latency (' + latency + 's) is greater than ' +
           'live sync maxLatency (' + maxLatency + 's). ' +
           'Updating playbackRate to ' + maxPlaybackRate);
-        this.trickPlay(maxPlaybackRate);
+        this.trickPlay(maxPlaybackRate, /* useTrickPlayTrack= */ false);
       }
       this.targetLatencyReached_ = null;
     } else if (minLatency && minPlaybackRate &&
@@ -6646,7 +6649,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         shaka.log.debug('Latency (' + latency + 's) is smaller than ' +
           'live sync minLatency (' + minLatency + 's). ' +
           'Updating playbackRate to ' + minPlaybackRate);
-        this.trickPlay(minPlaybackRate);
+        this.trickPlay(minPlaybackRate, /* useTrickPlayTrack= */ false);
       }
       this.targetLatencyReached_ = null;
     } else if (playbackRate !== this.playRateController_.getDefaultRate()) {
@@ -7257,19 +7260,32 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (hasAltStream) {
       let didDisableStream = false;
 
+      let isTrickModeVideo = false;
+
       for (const variant of this.manifest_.variants) {
         const candidate = variant[stream.type];
 
-        if (candidate && candidate.id === stream.id) {
+        if (!candidate) {
+          continue;
+        }
+
+        if (candidate.id === stream.id) {
           variant.disabledUntilTime = (Date.now() / 1000) + disableTime;
           didDisableStream = true;
 
           shaka.log.v2(
               'Disabled stream ' + stream.type + ':' + stream.id +
               ' for ' + disableTime + ' seconds...');
+        } else if (candidate.trickModeVideo &&
+            candidate.trickModeVideo.id == stream.id) {
+          isTrickModeVideo = true;
         }
       }
 
+      if (!didDisableStream && isTrickModeVideo) {
+        return false;
+      }
+
       goog.asserts.assert(didDisableStream, 'Must have disabled stream');
 
       this.checkVariantsTimer_.tickEvery(1);
@@ -7832,7 +7848,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.10.12' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.10.13' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/util/periods.js

@@ -890,26 +890,33 @@ shaka.util.PeriodCombiner = class {
         // Create a fresh output stream for trick-mode playback.
         output.trickModeVideo = shaka.util.PeriodCombiner.cloneStream_(
             input.trickModeVideo);
-        // TODO: fix the createSegmentIndex function for trickModeVideo.
-        // The trick-mode tracks in multi-period content should have trick-mode
-        // segment indexes whenever available, rather than only regular-mode
-        // segment indexes.
+        output.trickModeVideo.matchedStreams = [];
         output.trickModeVideo.createSegmentIndex = () => {
-          // Satisfy the compiler about the type.
-          goog.asserts.assert(
-              output.segmentIndex instanceof shaka.media.MetaSegmentIndex,
-              'The stream should have a MetaSegmentIndex.');
-          output.trickModeVideo.segmentIndex = output.segmentIndex.clone();
+          if (output.trickModeVideo.segmentIndex) {
+            return Promise.resolve();
+          }
+          const segmentIndex = new shaka.media.MetaSegmentIndex();
+          goog.asserts.assert(output.trickModeVideo.matchedStreams,
+              'trickmode matched streams should exist');
+          for (const stream of output.trickModeVideo.matchedStreams) {
+            goog.asserts.assert(stream.segmentIndex,
+                'trickmode segment index should exist');
+            segmentIndex.appendSegmentIndex(stream.segmentIndex);
+          }
+          output.trickModeVideo.segmentIndex = segmentIndex;
+
           return Promise.resolve();
         };
       }
 
       // Concatenate the trick mode input onto the trick mode output.
+      output.trickModeVideo.matchedStreams.push(input.trickModeVideo);
       shaka.util.PeriodCombiner.concatenateStreams_(
           output.trickModeVideo, input.trickModeVideo);
     } else if (output.trickModeVideo) {
       // We have a trick mode output, but no input from this Period.  Fill it in
       // from the standard input Stream.
+      output.trickModeVideo.matchedStreams.push(input);
       shaka.util.PeriodCombiner.concatenateStreams_(
           output.trickModeVideo, input);
     }

package/lib/util/tXml.js

@@ -6,6 +6,7 @@
 
 goog.provide('shaka.util.TXml');
 
+goog.require('shaka.util.ObjectUtils');
 goog.require('shaka.util.StringUtils');
 goog.require('shaka.log');
 
@@ -71,24 +72,37 @@ shaka.util.TXml = class {
   }
 
   /**
-   * Parse some data
+   * Get namespace based on schema
    * @param {string} schema
    * @return {string}
    */
   static getKnownNameSpace(schema) {
-    if (shaka.util.TXml.knownNameSpaces_.has(schema)) {
-      return shaka.util.TXml.knownNameSpaces_.get(schema);
+    if (shaka.util.TXml.uriToNameSpace_.has(schema)) {
+      return shaka.util.TXml.uriToNameSpace_.get(schema);
     }
     return '';
   }
 
   /**
-   * Parse some data
+   * Get schema based on namespace
+   * @param {string} NS
+   * @return {string}
+   */
+  static getKnownSchema(NS) {
+    if (shaka.util.TXml.nameSpaceToUri_.has(NS)) {
+      return shaka.util.TXml.nameSpaceToUri_.get(NS);
+    }
+    return '';
+  }
+
+  /**
+   * Sets NS <-> schema bidirectional mapping
    * @param {string} schema
    * @param {string} NS
    */
   static setKnownNameSpace(schema, NS) {
-    shaka.util.TXml.knownNameSpaces_.set(schema, NS);
+    shaka.util.TXml.uriToNameSpace_.set(schema, NS);
+    shaka.util.TXml.nameSpaceToUri_.set(NS, schema);
   }
 
   /**
@@ -873,7 +887,12 @@ shaka.util.TXml = class {
    */
   static txmlNodeToDomElement(node) {
     const TXml = shaka.util.TXml;
-    const element = document.createElementNS('', node.tagName);
+    let namespace = '';
+    const parts = node.tagName.split(':');
+    if (parts.length > 0) {
+      namespace = TXml.getKnownSchema(parts[0]);
+    }
+    const element = document.createElementNS(namespace, node.tagName);
 
     for (const k in node.attributes) {
       const v = node.attributes[k];
@@ -892,9 +911,41 @@ shaka.util.TXml = class {
 
     return element;
   }
+
+  /**
+   * Clones node and its children recursively. Skips parent.
+   * @param {?shaka.extern.xml.Node} node
+   * @return {?shaka.extern.xml.Node}
+   */
+  static cloneNode(node) {
+    if (!node) {
+      return null;
+    }
+    /** @type {!shaka.extern.xml.Node} */
+    const clone = {
+      tagName: node.tagName,
+      attributes: shaka.util.ObjectUtils.shallowCloneObject(node.attributes),
+      children: [],
+      parent: null,
+    };
+    for (const child of node.children) {
+      if (typeof child === 'string') {
+        clone.children.push(child);
+      } else {
+        const clonedChild = shaka.util.TXml.cloneNode(child);
+        clonedChild.parent = clone;
+        clone.children.push(clonedChild);
+      }
+    }
+    return clone;
+  }
 };
 
-shaka.util.TXml.knownNameSpaces_ = new Map([]);
+/** @private {!Map<string, string>} */
+shaka.util.TXml.uriToNameSpace_ = new Map();
+
+/** @private {!Map<string, string>} */
+shaka.util.TXml.nameSpaceToUri_ = new Map();
 
 
 /**

package/package.json

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