shaka-player 4.0.1 → 4.0.4

package/lib/media/media_source_engine.js

@@ -10,6 +10,7 @@ goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.media.ContentWorkarounds');
 goog.require('shaka.media.IClosedCaptionParser');
+goog.require('shaka.media.SegmentReference');
 goog.require('shaka.media.TimeRangesUtils');
 goog.require('shaka.media.Transmuxer');
 goog.require('shaka.text.TextEngine');
@@ -466,13 +467,13 @@ shaka.media.MediaSourceEngine = class {
    */
   getBufferedInfo() {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
-    const TimeRangeUtils = shaka.media.TimeRangesUtils;
+    const TimeRangesUtils = shaka.media.TimeRangesUtils;
 
     const info = {
-      total: TimeRangeUtils.getBufferedInfo(this.video_.buffered),
-      audio: TimeRangeUtils.getBufferedInfo(
+      total: TimeRangesUtils.getBufferedInfo(this.video_.buffered),
+      audio: TimeRangesUtils.getBufferedInfo(
           this.getBuffered_(ContentType.AUDIO)),
-      video: TimeRangeUtils.getBufferedInfo(
+      video: TimeRangesUtils.getBufferedInfo(
           this.getBuffered_(ContentType.VIDEO)),
       text: [],
     };
@@ -516,15 +517,14 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {!BufferSource} data
-   * @param {?number} startTime relative to the start of the presentation
-   * @param {?number} endTime relative to the start of the presentation
+   * @param {?shaka.media.SegmentReference} reference The segment reference
+   *   we are appending, or null for init segments
    * @param {?boolean} hasClosedCaptions True if the buffer contains CEA closed
-   * captions
+   *   captions
    * @param {boolean=} seeked True if we just seeked
    * @return {!Promise}
    */
-  async appendBuffer(
-      contentType, data, startTime, endTime, hasClosedCaptions, seeked) {
+  async appendBuffer(contentType, data, reference, hasClosedCaptions, seeked) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     if (contentType == ContentType.TEXT) {
@@ -533,7 +533,10 @@ shaka.media.MediaSourceEngine = class {
         const offset = await this.textSequenceModeOffset_;
         this.textEngine_.setTimestampOffset(offset);
       }
-      await this.textEngine_.appendBuffer(data, startTime, endTime);
+      await this.textEngine_.appendBuffer(
+          data,
+          reference ? reference.startTime : null,
+          reference ? reference.endTime : null);
       return;
     }
 
@@ -549,7 +552,10 @@ shaka.media.MediaSourceEngine = class {
       if (transmuxedData.metadata) {
         const timestampOffset =
             this.sourceBuffers_[contentType].timestampOffset;
-        this.onMetadata_(transmuxedData.metadata, timestampOffset, endTime);
+        this.onMetadata_(
+            transmuxedData.metadata,
+            timestampOffset,
+            reference ? reference.endTime : null);
       }
       // This doesn't work for native TS support (ex. Edge/Chromecast),
       // since no transmuxing is needed for native TS.
@@ -559,7 +565,10 @@ shaka.media.MediaSourceEngine = class {
         const closedCaptions = this.textEngine_
             .convertMuxjsCaptionsToShakaCaptions(transmuxedData.captions);
         this.textEngine_.storeAndAppendClosedCaptions(
-            closedCaptions, startTime, endTime, videoOffset);
+            closedCaptions,
+            reference ? reference.startTime : null,
+            reference ? reference.endTime : null,
+            videoOffset);
       }
 
       data = transmuxedData.data;
@@ -569,7 +578,7 @@ shaka.media.MediaSourceEngine = class {
       }
       // If it is the init segment for closed captions, initialize the closed
       // caption parser.
-      if (startTime == null && endTime == null) {
+      if (!reference) {
         this.captionParser_.init(data);
       } else {
         const closedCaptions = this.captionParser_.parseFrom(data);
@@ -577,18 +586,21 @@ shaka.media.MediaSourceEngine = class {
           const videoOffset =
             this.sourceBuffers_[ContentType.VIDEO].timestampOffset;
           this.textEngine_.storeAndAppendClosedCaptions(
-              closedCaptions, startTime, endTime, videoOffset);
+              closedCaptions,
+              reference.startTime,
+              reference.endTime,
+              videoOffset);
         }
       }
     }
 
-    data = this.workAroundBrokenPlatforms_(data, startTime, contentType);
+    data = this.workAroundBrokenPlatforms_(
+        data, reference ? reference.startTime : null, contentType);
 
     const sourceBuffer = this.sourceBuffers_[contentType];
     const SEQUENCE = shaka.media.MediaSourceEngine.SourceBufferMode_.SEQUENCE;
 
-    if (this.sequenceMode_ && sourceBuffer.mode != SEQUENCE &&
-        startTime != null) {
+    if (this.sequenceMode_ && sourceBuffer.mode != SEQUENCE && reference) {
       // This is the first media segment to be appended to a SourceBuffer in
       // sequence mode.  We set the mode late so that we can trick MediaSource
       // into extracting a timestamp for us to align text segments in sequence
@@ -623,7 +635,7 @@ shaka.media.MediaSourceEngine = class {
         // segments.
         const mediaStartTime = shaka.media.TimeRangesUtils.bufferStart(
             this.getBuffered_(contentType));
-        const textOffset = (startTime || 0) - (mediaStartTime || 0);
+        const textOffset = (reference.startTime || 0) - (mediaStartTime || 0);
         this.textSequenceModeOffset_.resolve(textOffset);
 
         // Finally, clear the buffer.
@@ -636,22 +648,43 @@ shaka.media.MediaSourceEngine = class {
       sourceBuffer.mode = SEQUENCE;
     }
 
-    if (startTime != null && this.sequenceMode_ &&
-        contentType != ContentType.TEXT) {
+    if (reference && this.sequenceMode_ && contentType != ContentType.TEXT) {
       // In sequence mode, for non-text streams, if we just cleared the buffer
       // and are performing an unbuffered seek, we need to set a new
       // timestampOffset on the sourceBuffer.
       if (seeked) {
-        const timestampOffset = /** @type {number} */ (startTime);
+        const timestampOffset = reference.startTime;
         this.enqueueOperation_(
             contentType,
             () => this.setTimestampOffset_(contentType, timestampOffset));
       }
     }
 
-    await this.enqueueOperation_(
-        contentType,
-        () => this.append_(contentType, data));
+    let bufferedBefore = null;
+
+    await this.enqueueOperation_(contentType, () => {
+      if (goog.DEBUG && reference) {
+        bufferedBefore = this.getBuffered_(contentType);
+      }
+      this.append_(contentType, data);
+    });
+
+    if (goog.DEBUG && reference) {
+      const bufferedAfter = this.getBuffered_(contentType);
+      const newBuffered = shaka.media.TimeRangesUtils.computeAddedRange(
+          bufferedBefore, bufferedAfter);
+      if (newBuffered) {
+        const segmentDuration = reference.endTime - reference.startTime;
+        if (Math.abs(newBuffered.start - reference.startTime) >
+            segmentDuration / 2) {
+          shaka.log.error('Possible encoding problem detected!',
+              'Unexpected buffered range for reference', reference,
+              'from URIs', reference.getUris(),
+              'should be', {start: reference.startTime, end: reference.endTime},
+              'but got', newBuffered);
+        }
+      }
+    }
   }
 
   /**

package/lib/media/presentation_timeline.js

@@ -93,6 +93,9 @@ shaka.media.PresentationTimeline = class {
      * @private {number}
      */
     this.availabilityTimeOffset_ = 0;
+
+    /** @private {boolean} */
+    this.startTimeLocked_ = false;
   }
 
 
@@ -229,7 +232,8 @@ shaka.media.PresentationTimeline = class {
     this.maxSegmentEndTime_ =
         Math.max(this.maxSegmentEndTime_, lastReferenceEndTime);
 
-    if (this.presentationStartTime_ != null && this.autoCorrectDrift_) {
+    if (this.presentationStartTime_ != null && this.autoCorrectDrift_ &&
+        !this.startTimeLocked_) {
       // Since we have explicit segment end times, calculate a presentation
       // start based on them.  This start time accounts for drift.
       // Date.now() is in milliseconds, from which we compute "now" in seconds.
@@ -243,6 +247,25 @@ shaka.media.PresentationTimeline = class {
   }
 
 
+  /**
+   * Lock the presentation timeline's start time.  After this is called, no
+   * further adjustments to presentationStartTime_ will be permitted.
+   *
+   * This should be called after all Periods have been parsed, and all calls to
+   * notifySegments() from the initial manifest parse have been made.
+   *
+   * Without this, we can get assertion failures in SegmentIndex for certain
+   * DAI content.  If DAI adds ad segments to the manifest faster than
+   * real-time, adjustments to presentationStartTime_ can cause availability
+   * windows to jump around on updates.
+   *
+   * @export
+   */
+  lockStartTime() {
+    this.startTimeLocked_ = true;
+  }
+
+
   /**
    * Gives PresentationTimeline a Stream's minimum segment start time.
    *

package/lib/media/segment_index.js

@@ -94,6 +94,25 @@ shaka.media.SegmentIndex = class {
   }
 
 
+  /**
+   * Return the earliest reference, or null if empty.
+   * @return {shaka.media.SegmentReference}
+   */
+  earliestReference() {
+    return this.references[0] || null;
+  }
+
+
+  /**
+   * Drop the first N references.
+   * Used in early HLS synchronization, and does not count as eviction.
+   * @param {number} n
+   */
+  dropFirstReferences(n) {
+    this.references.splice(0, n);
+  }
+
+
   /**
    * Finds the position of the segment for the given time, in seconds, relative
    * to the start of the presentation.  Returns the position of the segment
@@ -166,7 +185,13 @@ shaka.media.SegmentIndex = class {
       for (const ref of this.references) {
         ref.startTime += offset;
         ref.endTime += offset;
-        ref.timestampOffset += offset;
+        ref.trueEndTime += offset;
+
+        for (const partial of ref.partialReferences) {
+          partial.startTime += offset;
+          partial.endTime += offset;
+          partial.trueEndTime += offset;
+        }
       }
     }
   }

package/lib/media/segment_reference.js

@@ -160,8 +160,9 @@ shaka.media.SegmentReference = class {
    *  If not provided, the duration should be automatically calculated based on
    *  the duration of the reference.
    * @param {?number=} syncTime
-   *  A time value, expressed in the same scale as the start and end time, which
-   *  is used to synchronize between streams.
+   *  A time value, expressed in seconds since 1970, which is used to
+   *  synchronize between streams.  Both produced and consumed by the HLS
+   *  parser.  Other components should not need this value.
    * @param {shaka.media.SegmentReference.Status=} status
    *  The segment status is used to indicate that a segment does not exist or is
    *  not available.
@@ -221,7 +222,13 @@ shaka.media.SegmentReference = class {
     /** @type {?number} */
     this.tileDuration = tileDuration;
 
-    /** @type {?number} */
+    /**
+     * A time value, expressed in seconds since 1970, which is used to
+     * synchronize between streams.  Both produced and consumed by the HLS
+     * parser.  Other components should not need this value.
+     *
+     * @type {?number}
+     */
     this.syncTime = syncTime;
 
     /** @type {shaka.media.SegmentReference.Status} */

package/lib/media/streaming_engine.js

@@ -1548,8 +1548,8 @@ shaka.media.StreamingEngine = class {
             const hasClosedCaptions = mediaState.stream.closedCaptions &&
                 mediaState.stream.closedCaptions.size > 0;
             await this.playerInterface_.mediaSourceEngine.appendBuffer(
-                mediaState.type, initSegment, /* startTime= */ null,
-                /* endTime= */ null, hasClosedCaptions);
+                mediaState.type, initSegment, /* reference= */ null,
+                hasClosedCaptions);
           } catch (error) {
             mediaState.lastInitSegmentReference = null;
             throw error;
@@ -1602,8 +1602,7 @@ shaka.media.StreamingEngine = class {
     await this.playerInterface_.mediaSourceEngine.appendBuffer(
         mediaState.type,
         segment,
-        reference.syncTime == null ? reference.startTime : reference.syncTime,
-        reference.endTime,
+        reference,
         hasClosedCaptions,
         seeked);
     this.destroyer_.ensureNotDestroyed();

package/lib/media/time_ranges_utils.js

@@ -155,4 +155,50 @@ shaka.media.TimeRangesUtils = class {
     }
     return ret;
   }
+
+  /**
+   * This operation can be potentially EXPENSIVE and should only be done in
+   * debug builds for debugging purposes.
+   *
+   * @param {TimeRanges} oldRanges
+   * @param {TimeRanges} newRanges
+   * @return {?shaka.extern.BufferedRange} The last added range,
+   *   chronologically by presentation time.
+   */
+  static computeAddedRange(oldRanges, newRanges) {
+    const TimeRangesUtils = shaka.media.TimeRangesUtils;
+
+    if (!oldRanges || !oldRanges.length) {
+      return null;
+    }
+    if (!newRanges || !newRanges.length) {
+      return TimeRangesUtils.getBufferedInfo(newRanges).pop();
+    }
+
+    const newRangesReversed =
+        TimeRangesUtils.getBufferedInfo(newRanges).reverse();
+    const oldRangesReversed =
+        TimeRangesUtils.getBufferedInfo(oldRanges).reverse();
+    for (const newRange of newRangesReversed) {
+      let foundOverlap = false;
+
+      for (const oldRange of oldRangesReversed) {
+        if (oldRange.end >= newRange.start && oldRange.end <= newRange.end) {
+          foundOverlap = true;
+
+          // If the new range goes beyond the corresponding old one, the
+          // difference is newly-added.
+          if (newRange.end > oldRange.end) {
+            return {start: oldRange.end, end: newRange.end};
+          }
+        }
+      }
+
+      if (!foundOverlap) {
+        return newRange;
+      }
+    }
+
+    return null;
+  }
 };

package/lib/player.js

@@ -6450,7 +6450,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.0.1-uncompiled';
+shaka.Player.version = 'v4.0.4-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/media_capabilities.js

@@ -37,9 +37,12 @@ shaka.polyfill.MediaCapabilities = class {
     // See: https://github.com/shaka-project/shaka-player/issues/3582
     // TODO: re-evaluate MediaCapabilities in the future versions of PS5
     // Browsers.
+    // Since MediaCapabilities implementation does not exist in PS4 browsers, we
+    // should always install polyfill.
     let canUseNativeMCap = true;
     if (shaka.util.Platform.isApple() ||
         shaka.util.Platform.isPS5() ||
+        shaka.util.Platform.isPS4() ||
         shaka.util.Platform.isChromecast()) {
       canUseNativeMCap = false;
     }

package/lib/polyfill/videoplaybackquality.js

@@ -7,6 +7,7 @@
 goog.provide('shaka.polyfill.VideoPlaybackQuality');
 
 goog.require('shaka.polyfill');
+goog.require('shaka.util.Platform');
 
 
 /**
@@ -33,7 +34,8 @@ shaka.polyfill.VideoPlaybackQuality = class {
       return;
     }
 
-    if ('webkitDroppedFrameCount' in proto) {
+    if ('webkitDroppedFrameCount' in proto ||
+        shaka.util.Platform.isWebOS3()) {
       proto.getVideoPlaybackQuality =
           shaka.polyfill.VideoPlaybackQuality.webkit_;
     }

package/lib/util/mime_utils.js

@@ -8,6 +8,7 @@ goog.provide('shaka.util.MimeUtils');
 
 goog.require('shaka.dependencies');
 goog.require('shaka.media.Transmuxer');
+goog.require('shaka.util.ManifestParserUtils');
 
 /**
  * @summary A set of utility functions for dealing with MIME types.
@@ -34,6 +35,8 @@ shaka.util.MimeUtils = class {
   /**
    * Takes a MIME type and a codecs string and produces the full MIME
    * type. If it's a transport stream, convert its codecs to MP4 codecs.
+   * Otherwise for multiplexed content, convert the video MIME types to
+   * their audio equivalents if the content type is audio.
    *
    * @param {string} mimeType
    * @param {string} codecs
@@ -42,13 +45,19 @@ shaka.util.MimeUtils = class {
    */
   static getFullOrConvertedType(mimeType, codecs, contentType) {
     const fullMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    if (!shaka.dependencies.muxjs() ||
-        !shaka.media.Transmuxer.isTsContainer(fullMimeType)) {
-      return fullMimeType;
+    if (shaka.media.Transmuxer.isTsContainer(fullMimeType)) {
+      if (shaka.dependencies.muxjs()) {
+        return shaka.media.Transmuxer.convertTsCodecs(
+            contentType, fullMimeType);
+      }
+    } else if (contentType == ContentType.AUDIO) {
+      // video/mp2t is the correct mime type for TS audio, so only replace the
+      // word "video" with "audio" for non-TS audio content.
+      return fullMimeType.replace('video', 'audio');
     }
-
-    return shaka.media.Transmuxer.convertTsCodecs(contentType, fullMimeType);
+    return fullMimeType;
   }
 
 

package/lib/util/platform.js

@@ -197,7 +197,9 @@ shaka.util.Platform = class {
    */
   static isApple() {
     return !!navigator.vendor && navigator.vendor.includes('Apple') &&
-        !shaka.util.Platform.isTizen();
+        !shaka.util.Platform.isTizen() &&
+        !shaka.util.Platform.isEOS() &&
+        !shaka.util.Platform.isPS4();
   }
 
   /**
@@ -213,6 +215,13 @@ shaka.util.Platform = class {
     return shaka.util.Platform.userAgentContains_('PlayStation 5');
   }
 
+  /**
+   * Check if the current platform is Playstation 4.
+   */
+  static isPS4() {
+    return shaka.util.Platform.userAgentContains_('PlayStation 4');
+  }
+
   /**
    * Returns a major version number for Safari, or Safari-based iOS browsers.
    *
@@ -260,6 +269,15 @@ shaka.util.Platform = class {
     return !!shaka.util.Platform.safariVersion();
   }
 
+  /**
+   * Check if the current platform is an EOS set-top box.
+   *
+   * @return {boolean}
+   */
+  static isEOS() {
+    return shaka.util.Platform.userAgentContains_('PC=EOS');
+  }
+
   /**
    * Guesses if the platform is a mobile one (iOS or Android).
    *

package/lib/util/stream_utils.js

@@ -1008,6 +1008,7 @@ shaka.util.StreamUtils = class {
       track.channelsCount = audio.channelsCount;
       track.audioSamplingRate = audio.audioSamplingRate;
       track.audioBandwidth = audio.bandwidth || null;
+      track.spatialAudio = audio.spatialAudio;
       track.label = audio.label;
       track.audioRoles = audio.roles;
     }

package/lib/util/string_utils.js

@@ -11,6 +11,7 @@ goog.require('shaka.log');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.Lazy');
+goog.require('shaka.util.Platform');
 
 
 /**
@@ -36,19 +37,38 @@ shaka.util.StringUtils = class {
     if (uint8[0] == 0xef && uint8[1] == 0xbb && uint8[2] == 0xbf) {
       uint8 = uint8.subarray(3);
     }
-
-    // Use the TextDecoder interface to decode the text.  This has the advantage
-    // compared to the previously-standard decodeUriComponent that it will
-    // continue parsing even if it finds an invalid UTF8 character, rather than
-    // stop and throw an error.
-    const utf8decoder = new TextDecoder();
-    const decoded = utf8decoder.decode(uint8);
-    if (decoded.includes('\uFFFD')) {
-      shaka.log.alwaysError('Decoded string contains an "unknown character" ' +
-                            'codepoint.  That probably means the UTF8 ' +
-                            'encoding was incorrect!');
+    if (window.TextDecoder && !shaka.util.Platform.isPS4()) {
+      // Use the TextDecoder interface to decode the text.  This has the
+      // advantage compared to the previously-standard decodeUriComponent that
+      // it will continue parsing even if it finds an invalid UTF8 character,
+      // rather than stop and throw an error.
+      const utf8decoder = new TextDecoder();
+      const decoded = utf8decoder.decode(uint8);
+      if (decoded.includes('\uFFFD')) {
+        shaka.log.alwaysError('Decoded string contains an "unknown character' +
+                              '" codepoint.  That probably means the UTF8 ' +
+                              'encoding was incorrect!');
+      }
+      return decoded;
+    } else {
+      // http://stackoverflow.com/a/13691499
+      const utf8 = shaka.util.StringUtils.fromCharCode(uint8);
+      // This converts each character in the string to an escape sequence.  If
+      // the character is in the ASCII range, it is not converted; otherwise it
+      // is converted to a URI escape sequence.
+      // Example: '\x67\x35\xe3\x82\xac' -> 'g#%E3%82%AC'
+      const escaped = escape(utf8);
+      // Decode the escaped sequence.  This will interpret UTF-8 sequences into
+      // the correct character.
+      // Example: 'g#%E3%82%AC' -> 'g#€'
+      try {
+        return decodeURIComponent(escaped);
+      } catch (e) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL, shaka.util.Error.Category.TEXT,
+            shaka.util.Error.Code.BAD_ENCODING);
+      }
     }
-    return decoded;
   }
 
 
@@ -141,8 +161,30 @@ shaka.util.StringUtils = class {
    * @export
    */
   static toUTF8(str) {
-    const utf8Encoder = new TextEncoder();
-    return shaka.util.BufferUtils.toArrayBuffer(utf8Encoder.encode(str));
+    if (window.TextEncoder && !shaka.util.Platform.isPS4()) {
+      const utf8Encoder = new TextEncoder();
+      return shaka.util.BufferUtils.toArrayBuffer(utf8Encoder.encode(str));
+    } else {
+      // http://stackoverflow.com/a/13691499
+      // Converts the given string to a URI encoded string.  If a character
+      // falls in the ASCII range, it is not converted; otherwise it will be
+      // converted to a series of URI escape sequences according to UTF-8.
+      // Example: 'g#€' -> 'g#%E3%82%AC'
+      const encoded = encodeURIComponent(str);
+      // Convert each escape sequence individually into a character.  Each
+      // escape sequence is interpreted as a code-point, so if an escape
+      // sequence happens to be part of a multi-byte sequence, each byte will
+      // be converted to a single character.
+      // Example: 'g#%E3%82%AC' -> '\x67\x35\xe3\x82\xac'
+      const utf8 = unescape(encoded);
+
+      const result = new Uint8Array(utf8.length);
+      for (let i = 0; i < utf8.length; i++) {
+        const item = utf8[i];
+        result[i] = item.charCodeAt(0);
+      }
+      return shaka.util.BufferUtils.toArrayBuffer(result);
+    }
   }
 
 

package/maintained-branches.md

@@ -0,0 +1,15 @@
+# Maintained Shaka Player Branches
+
+We are currently maintaining the following branches of Shaka Player:
+
+ - v4.1 (latest)
+ - v4.0 (previous)
+ - v3.3 (LTS until April 30, 2023)
+ - v3.2 (in use by the Cast Application Framework)
+
+Other branches are no longer receiving bug fixes, and we recommend you upgrade
+to a maintained branch.  For details on upgrading, please see our
+[upgrade guide](https://shaka-player-demo.appspot.com/docs/api/tutorial-upgrade.html).
+
+For more information on how these branches are chosen, please refer to our
+[Branch Maintenance Policy](https://shaka-project.github.io/maintenance/shaka-player.html#branch-maintenance-policy).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.0.1",
+  "version": "4.0.4",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [
@@ -27,7 +27,6 @@
     "eslint-config-google": "^0.14.0",
     "eslint-plugin-shaka-rules": "file:./build/eslint-plugin-shaka-rules",
     "esprima": "^4.0.1",
-    "fastestsmallesttextencoderdecoder": "^1.0.22",
     "fontfaceonload": "^1.0.2",
     "google-closure-compiler-java": "^20220301.0.0",
     "google-closure-deps": "https://gitpkg.now.sh/google/closure-library/closure-deps?d7736da6",
@@ -50,7 +49,7 @@
     "less": "https://gitpkg.now.sh/joeyparrish/less.js/packages/less?28c63a43",
     "less-plugin-clean-css": "github:austingardner/less-plugin-clean-css#4e9e77bf",
     "material-design-lite": "^1.3.0",
-    "mux.js": "^5.14.1",
+    "mux.js": "^6.2.0",
     "open-sans-fonts": "^1.6.2",
     "postcss-less": "^6.0.0",
     "pwacompat": "^2.0.17",
@@ -71,7 +70,6 @@
       "dialog-polyfill/dist/dialog-polyfill.js",
       "eme-encryption-scheme-polyfill/index.js",
       "es6-promise-polyfill/promise.min.js",
-      "fastestsmallesttextencoderdecoder/EncoderDecoderTogether.min.js",
       "google-closure-library/closure/goog/base.js",
       "less/dist/less.js",
       "material-design-lite/dist/material.indigo-blue.min.css",
@@ -96,7 +94,7 @@
     "prepublishOnly": "python build/checkversion.py && python build/all.py --force"
   },
   "dependencies": {
-    "eme-encryption-scheme-polyfill": "^2.0.3"
+    "eme-encryption-scheme-polyfill": "^2.0.5"
   },
   "engines": {
     "node": ">=14"