shaka-player 4.3.11 → 4.4.1

package/dist/shaka-player.ui.externs.js

@@ -20,6 +20,8 @@ shaka.ads = {};
 /** @const */
 shaka.cast = {};
 /** @const */
+shaka.cea = {};
+/** @const */
 shaka.config = {};
 /** @const */
 shaka.dash = {};
@@ -30,12 +32,18 @@ shaka.lcevc = {};
 /** @const */
 shaka.media = {};
 /** @const */
+shaka.media.SegmentPrefetch = {};
+/** @const */
+shaka.mss = {};
+/** @const */
 shaka.net = {};
 /** @const */
 shaka.offline = {};
 /** @const */
 shaka.text = {};
 /** @const */
+shaka.transmuxer = {};
+/** @const */
 shaka.ui = {};
 /** @const */
 shaka.util = {};
@@ -239,6 +247,9 @@ shaka.util.Error.Code = {
   'QUOTA_EXCEEDED_ERROR': 3017,
   'TRANSMUXING_FAILED': 3018,
   'CONTENT_TRANSFORMATION_FAILED': 3019,
+  'MSS_MISSING_DATA_FOR_TRANSMUXING': 3020,
+  'MSS_TRANSMUXING_CODEC_UNKNOWN': 3021,
+  'MSS_TRANSMUXING_FAILED': 3022,
   'UNABLE_TO_GUESS_MANIFEST_TYPE': 4000,
   'DASH_INVALID_XML': 4001,
   'DASH_NO_SEGMENT_INFO': 4002,
@@ -274,6 +285,8 @@ shaka.util.Error.Code = {
   'HLS_AES_128_INVALID_IV_LENGTH': 4043,
   'HLS_AES_128_INVALID_KEY_LENGTH': 4044,
   'CANNOT_ADD_EXTERNAL_THUMBNAILS_TO_LIVE_STREAM': 4045,
+  'MSS_INVALID_XML': 4046,
+  'MSS_LIVE_CONTENT_NOT_SUPPORTED': 4047,
   'STREAMING_ENGINE_STARTUP_INVALID_STATE': 5006,
   'NO_RECOGNIZED_KEY_SYSTEMS': 6000,
   'REQUESTED_KEY_SYSTEM_CONFIG_UNAVAILABLE': 6001,
@@ -291,6 +304,8 @@ shaka.util.Error.Code = {
   'SERVER_CERTIFICATE_REQUIRED': 6015,
   'INIT_DATA_TRANSFORM_ERROR': 6016,
   'SERVER_CERTIFICATE_REQUEST_FAILED': 6017,
+  'MIN_HDCP_VERSION_NOT_MATCH': 6018,
+  'ERROR_CHECKING_HDCP_VERSION': 6019,
   'LOAD_INTERRUPTED': 7000,
   'OPERATION_ABORTED': 7001,
   'NO_VIDEO_ELEMENT': 7002,
@@ -573,7 +588,95 @@ shaka.ui.Localization.LOCALE_CHANGED;
  */
 shaka.ui.Localization.LOCALE_UPDATED;
 /**
- * @implements {shaka.extern.Cue}
+ * @summary A set of BufferSource utility functions.
+ */
+shaka.util.BufferUtils = class {
+  /**
+   * Compare two buffers for equality.  For buffers of different types, this
+   * compares the underlying buffers as binary data.
+   * @param {?BufferSource} arr1
+   * @param {?BufferSource} arr2
+   * @return {boolean}
+   * @suppress {strictMissingProperties}
+   */
+  static equal(arr1, arr2) {}
+  /**
+   * Gets an ArrayBuffer that contains the data from the given TypedArray.  Note
+   * this will allocate a new ArrayBuffer if the object is a partial view of
+   * the data.
+   * @param {!BufferSource} view
+   * @return {!ArrayBuffer}
+   */
+  static toArrayBuffer(view) {}
+  /**
+   * Creates a new Uint8Array view on the same buffer.  This clamps the values
+   * to be within the same view (i.e. you can't use this to move past the end
+   * of the view, even if the underlying buffer is larger).  However, you can
+   * pass a negative offset to access the data before the view.
+   * @param {BufferSource} data
+   * @param {number=} offset The offset from the beginning of this data's view
+   *   to start the new view at.
+   * @param {number=} length The byte length of the new view.
+   * @return {!Uint8Array}
+   */
+  static toUint8(data, offset, length) {}
+  /**
+   * Creates a DataView over the given buffer.
+   * @see toUint8
+   * @param {BufferSource} buffer
+   * @param {number=} offset
+   * @param {number=} length
+   * @return {!DataView}
+   */
+  static toDataView(buffer, offset, length) {}
+};
+/**
+ * The IClosedCaptionParser defines the interface to provide all operations for
+ * parsing the closed captions embedded in Dash videos streams.
+ * TODO: Remove this interface and move method definitions
+ * directly to ClosedCaptonParser.
+ * @interface
+ */
+shaka.media.IClosedCaptionParser = class {
+};
+/**
+ * Closed Caption Parser provides all operations for parsing the closed captions
+ * embedded in Dash videos streams.
+ * @implements {shaka.media.IClosedCaptionParser}
+ * @final
+ */
+shaka.media.ClosedCaptionParser = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {}
+  /**
+   * @param {string} mimeType
+   * @param {!shaka.extern.CeaParserPlugin} plugin
+   */
+  static registerParser(mimeType, plugin) {}
+  /**
+   * @param {string} mimeType
+   */
+  static unregisterParser(mimeType) {}
+  /**
+   * @param {string} mimeType
+   * @return {?shaka.extern.CeaParserPlugin}
+   */
+  static findParser(mimeType) {}
+  /**
+   * @param {!shaka.extern.CaptionDecoderPlugin} plugin
+   */
+  static registerDecoder(plugin) {}
+  /**
+   */
+  static unregisterDecoder() {}
+  /**
+   * @return {?shaka.extern.CaptionDecoderPlugin}
+   */
+  static findDecoder() {}
+};
+/**
  */
 shaka.text.Cue = class {
   /**
@@ -582,153 +685,21 @@ shaka.text.Cue = class {
    * @param {string} payload
    */
   constructor(startTime, endTime, payload) {}
+  /**
+   * Create a copy of the cue with the same properties.
+   * @return {!shaka.text.Cue}
+   * @suppress {checkTypes} since we must use [] and "in" with a struct type.
+   */
+  clone() {}
+  /**
+   * Check if two Cues have all the same values in all properties.
+   * @param {!shaka.text.Cue} cue1
+   * @param {!shaka.text.Cue} cue2
+   * @return {boolean}
+   * @suppress {checkTypes} since we must use [] and "in" with a struct type.
+   */
+  static equal(cue1, cue2) {}
 };
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.startTime;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.direction;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.endTime;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.payload;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.region;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.position;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.positionAlign;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.size;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.textAlign;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.writingMode;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.lineInterpretation;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.line;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.lineHeight;
-/**
-     * Line Alignment is set to start by default.
-     * @override
-     */
-shaka.text.Cue.prototype.lineAlign;
-/**
-     * Set the captions at the bottom of the text container by default.
-     * @override
-     */
-shaka.text.Cue.prototype.displayAlign;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.color;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.backgroundColor;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.backgroundImage;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.border;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.textShadow;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.textStrokeColor;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.textStrokeWidth;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.fontSize;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.fontWeight;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.fontStyle;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.fontFamily;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.letterSpacing;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.linePadding;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.opacity;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.textDecoration;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.wrapLine;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.id;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.nestedCues;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.isContainer;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.lineBreak;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.cellResolution;
 /**
  * @enum {string}
  */
@@ -795,14 +766,14 @@ shaka.text.Cue.lineAlign = {
  * @enum {string}
  */
 shaka.text.Cue.defaultTextColor = {
-  'white': '#FFF',
-  'lime': '#0F0',
-  'cyan': '#0FF',
-  'red': '#F00',
-  'yellow': '#FF0',
-  'magenta': '#F0F',
-  'blue': '#00F',
-  'black': '#000'
+  'white': 'white',
+  'lime': 'lime',
+  'cyan': 'cyan',
+  'red': 'red',
+  'yellow': 'yellow',
+  'magenta': 'magenta',
+  'blue': 'blue',
+  'black': 'black'
 };
 /**
  * Default text background color according to
@@ -810,14 +781,14 @@ shaka.text.Cue.defaultTextColor = {
  * @enum {string}
  */
 shaka.text.Cue.defaultTextBackgroundColor = {
-  'bg_white': '#FFF',
-  'bg_lime': '#0F0',
-  'bg_cyan': '#0FF',
-  'bg_red': '#F00',
-  'bg_yellow': '#FF0',
-  'bg_magenta': '#F0F',
-  'bg_blue': '#00F',
-  'bg_black': '#000'
+  'bg_white': 'white',
+  'bg_lime': 'lime',
+  'bg_cyan': 'cyan',
+  'bg_red': 'red',
+  'bg_yellow': 'yellow',
+  'bg_magenta': 'magenta',
+  'bg_blue': 'blue',
+  'bg_black': 'black'
 };
 /**
  * In CSS font weight can be a number, where 400 is normal and 700 is bold.
@@ -845,57 +816,11 @@ shaka.text.Cue.textDecoration = {
   'OVERLINE': 'overline'
 };
 /**
- * @implements {shaka.extern.CueRegion}
- * @struct
  */
 shaka.text.CueRegion = class {
   /** */
   constructor() {}
 };
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.id;
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.viewportAnchorX;
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.viewportAnchorY;
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.regionAnchorX;
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.regionAnchorY;
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.width;
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.height;
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.heightUnits;
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.widthUnits;
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.viewportAnchorUnits;
-/**
-     * @override
-     */
-shaka.text.CueRegion.prototype.scroll;
 /**
  * @enum {number}
  */
@@ -912,58 +837,100 @@ shaka.text.CueRegion.scrollMode = {
   'UP': 'up'
 };
 /**
- * @summary A set of BufferSource utility functions.
+ * An interface to standardize how objects are destroyed.
+ * @interface
  */
-shaka.util.BufferUtils = class {
+shaka.util.IDestroyable = class {
   /**
-   * Compare two buffers for equality.  For buffers of different types, this
-   * compares the underlying buffers as binary data.
-   * @param {?BufferSource} arr1
-   * @param {?BufferSource} arr2
-   * @return {boolean}
-   * @suppress {strictMissingProperties}
+   * Request that this object be destroyed, releasing all resources and shutting
+   * down all operations. Returns a Promise which is resolved when destruction
+   * is complete. This Promise should never be rejected.
+   * @return {!Promise}
    */
-  static equal(arr1, arr2) {}
+  destroy() {}
+};
+/**
+ * @summary Manages transmuxer plugins.
+ * @implements {shaka.util.IDestroyable}
+ */
+shaka.transmuxer.TransmuxerEngine = class {
   /**
-   * Gets an ArrayBuffer that contains the data from the given TypedArray.  Note
-   * this will allocate a new ArrayBuffer if the object is a partial view of
-   * the data.
-   * @param {!BufferSource} view
-   * @return {!ArrayBuffer}
+   * @override
    */
-  static toArrayBuffer(view) {}
+  destroy() {}
   /**
-   * Creates a new Uint8Array view on the same buffer.  This clamps the values
-   * to be within the same view (i.e. you can't use this to move past the end
-   * of the view, even if the underlying buffer is larger).  However, you can
-   * pass a negative offset to access the data before the view.
-   * @param {BufferSource} data
-   * @param {number=} offset The offset from the beginning of this data's view
-   *   to start the new view at.
-   * @param {number=} length The byte length of the new view.
-   * @return {!Uint8Array}
+   * @param {string} mimeType
+   * @param {!shaka.extern.TransmuxerPlugin} plugin
+   * @param {number} priority
    */
-  static toUint8(data, offset, length) {}
+  static registerTransmuxer(mimeType, plugin, priority) {}
   /**
-   * Creates a DataView over the given buffer.
-   * @see toUint8
-   * @param {BufferSource} buffer
-   * @param {number=} offset
-   * @param {number=} length
-   * @return {!DataView}
+   * @param {string} mimeType
+   * @param {number} priority
    */
-  static toDataView(buffer, offset, length) {}
+  static unregisterTransmuxer(mimeType, priority) {}
+  /**
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {?shaka.extern.TransmuxerPlugin}
+   */
+  static findTransmuxer(mimeType, contentType) {}
 };
 /**
- * An interface to standardize how objects are destroyed.
- * @interface
+ * Priority level for transmuxer plugins.
+ * If multiple plugins are provided for the same mime type, only the
+ * highest-priority one is used.
+ * @enum {number}
  */
-shaka.util.IDestroyable = class {
+shaka.transmuxer.TransmuxerEngine.PluginPriority = {
+  'FALLBACK': 1,
+  'PREFERRED_SECONDARY': 2,
+  'PREFERRED': 3,
+  'APPLICATION': 4
+};
+/**
+ * @summary A set of utility functions for dealing with MIME types.
+ */
+shaka.util.MimeUtils = class {
   /**
-   * Request that this object be destroyed, releasing all resources and shutting
-   * down all operations. Returns a Promise which is resolved when destruction
-   * is complete. This Promise should never be rejected.
-   * @return {!Promise}
+   * Takes a MIME type and optional codecs string and produces the full MIME
+   * type. Also remove the codecs for raw formats.
+   * @param {string} mimeType
+   * @param {string=} codecs
+   * @return {string}
+   */
+  static getFullType(mimeType, codecs) {}
+  /**
+   * Takes a MIME type and optional codecs string and produces the full MIME
+   * type.
+   * @param {string} mimeType
+   * @param {string=} codecs
+   * @return {string}
+   */
+  static getFullTypeWithAllCodecs(mimeType, codecs) {}
+};
+/**
+ * @summary Manages text parsers and cues.
+ * @implements {shaka.util.IDestroyable}
+ */
+shaka.text.TextEngine = class {
+  /** @param {shaka.extern.TextDisplayer} displayer */
+  constructor(displayer) {}
+  /**
+   * @param {string} mimeType
+   * @param {!shaka.extern.TextParserPlugin} plugin
+   */
+  static registerParser(mimeType, plugin) {}
+  /**
+   * @param {string} mimeType
+   */
+  static unregisterParser(mimeType) {}
+  /**
+   * @return {?shaka.extern.TextParserPlugin}
+   */
+  static findParser(mimeType) {}
+  /**
+   * @override
    */
   destroy() {}
 };
@@ -1005,159 +972,20 @@ shaka.util.Timer = class {
   stop() {}
 };
 /**
- * @namespace shaka.util.StringUtils
- * @summary A set of string utility functions.
- */
-shaka.util.StringUtils = class {
-  /**
-   * Creates a string from the given buffer as UTF-8 encoding.
-   * @param {?BufferSource} data
-   * @return {string}
-   */
-  static fromUTF8(data) {}
-  /**
-   * Creates a string from the given buffer as UTF-16 encoding.
-   * @param {?BufferSource} data
-   * @param {boolean} littleEndian
-         true to read little endian, false to read big.
-   * @param {boolean=} noThrow true to avoid throwing in cases where we may
-   *     expect invalid input.  If noThrow is true and the data has an odd
-   *     length,it will be truncated.
-   * @return {string}
-   */
-  static fromUTF16(data, littleEndian, noThrow) {}
-  /**
-   * Creates a string from the given buffer, auto-detecting the encoding that is
-   * being used.  If it cannot detect the encoding, it will throw an exception.
-   * @param {?BufferSource} data
-   * @return {string}
-   */
-  static fromBytesAutoDetect(data) {}
-  /**
-   * Creates a ArrayBuffer from the given string, converting to UTF-8 encoding.
-   * @param {string} str
-   * @return {!ArrayBuffer}
-   */
-  static toUTF8(str) {}
-  /**
-   * Creates a ArrayBuffer from the given string, converting to UTF-16 encoding.
-   * @param {string} str
-   * @param {boolean} littleEndian
-   * @return {!ArrayBuffer}
-   */
-  static toUTF16(str, littleEndian) {}
-  /**
-   * Resets the fromCharCode method's implementation.
-   * For debug use.
-   */
-  static resetFromCharCode() {}
-};
-/**
- * @summary A set of Uint8Array utility functions.
- */
-shaka.util.Uint8ArrayUtils = class {
-  /**
-   * Convert a buffer to a base64 string. The output will be standard
-   * alphabet as opposed to base64url safe alphabet.
-   * @param {BufferSource} data
-   * @return {string}
-   */
-  static toStandardBase64(data) {}
-  /**
-   * Convert a buffer to a base64 string.  The output will always use the
-   * alternate encoding/alphabet also known as "base64url".
-   * @param {BufferSource} data
-   * @param {boolean=} padding If true, pad the output with equals signs.
-   *   Defaults to true.
-   * @return {string}
-   */
-  static toBase64(data, padding) {}
-  /**
-   * Convert a base64 string to a Uint8Array.  Accepts either the standard
-   * alphabet or the alternate "base64url" alphabet.
-   * @param {string} str
-   * @return {!Uint8Array}
-   */
-  static fromBase64(str) {}
-  /**
-   * Convert a hex string to a Uint8Array.
-   * @param {string} str
-   * @return {!Uint8Array}
-   */
-  static fromHex(str) {}
-  /**
-   * Convert a buffer to a hex string.
-   * @param {BufferSource} data
-   * @return {string}
-   */
-  static toHex(data) {}
-  /**
-   * Concatenate buffers.
-   * @param {...BufferSource} varArgs
-   * @return {!Uint8Array}
-   */
-  static concat(...varArgs) {}
-};
-/**
+ * @summary A set of utility functions for dealing with Streams and Manifests.
  */
-shaka.dependencies = class {
-  /**
-   * Registers a new dependency.
-   * @param {shaka.dependencies.Allowed} key which is used for retrieving a
-   *   dependency
-   * @param {?} dep a dependency
-   */
-  static add(key, dep) {}
+shaka.util.StreamUtils = class {
   /**
-   * Check if we have a dependency for the key.
-   * @param {shaka.dependencies.Allowed} key key
+   * @param {shaka.extern.Variant} variant
+   * @param {shaka.extern.Restrictions} restrictions
+   *   Configured restrictions from the user.
+   * @param {{width: number, height: number}} maxHwRes
+   *   The maximum resolution the hardware can handle.
+   *   This is applied separately from user restrictions because the setting
+   *   should not be easily replaced by the user's configuration.
    * @return {boolean}
    */
-  static has(key) {}
-};
-/**
- * @enum {string}
- */
-shaka.dependencies.Allowed = {
-  muxjs: 'muxjs'
-};
-/**
- * @summary A set of utility functions for dealing with MIME types.
- */
-shaka.util.MimeUtils = class {
-  /**
-   * Takes a MIME type and optional codecs string and produces the full MIME
-   * type.
-   * @param {string} mimeType
-   * @param {string=} codecs
-   * @return {string}
-   */
-  static getFullType(mimeType, codecs) {}
-};
-/**
- * @summary Manages text parsers and cues.
- * @implements {shaka.util.IDestroyable}
- */
-shaka.text.TextEngine = class {
-  /** @param {shaka.extern.TextDisplayer} displayer */
-  constructor(displayer) {}
-  /**
-   * @param {string} mimeType
-   * @param {!shaka.extern.TextParserPlugin} plugin
-   */
-  static registerParser(mimeType, plugin) {}
-  /**
-   * @param {string} mimeType
-   */
-  static unregisterParser(mimeType) {}
-  /**
-   * @return {?shaka.extern.TextParserPlugin}
-   */
-  static findParser(mimeType) {}
-  /**
-   * @override
-   */
-  destroy() {}
+  static meetsRestrictions(variant, restrictions, maxHwRes) {}
 };
 /**
  * @summary
@@ -1341,8 +1169,10 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
    *   Called when the headers are received for a download.
    * @param {shaka.net.NetworkingEngine.OnDownloadFailed=} onDownloadFailed
    *   Called when a download fails, for any reason.
+   * @param {shaka.net.NetworkingEngine.OnRequest=} onRequest
+   *   Called when a request is made
    */
-  constructor(onProgressUpdated, onHeadersReceived, onDownloadFailed) {}
+  constructor(onProgressUpdated, onHeadersReceived, onDownloadFailed, onRequest) {}
   /**
    * @param {boolean} forceHTTPS
    */
@@ -1417,9 +1247,10 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
    * Makes a network request and returns the resulting data.
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
    * @return {!shaka.net.NetworkingEngine.PendingRequest}
    */
-  request(type, request) {}
+  request(type, request, context) {}
 };
 /**
  * A wrapper class for the number of bytes remaining to be downloaded for the
@@ -1471,6 +1302,22 @@ shaka.net.NetworkingEngine.RequestType = {
   'SERVER_CERTIFICATE': 5,
   'KEY': 6
 };
+/**
+ * A more advanced form of the RequestType structure, meant to describe
+ * sub-types of basic request types.
+ * For example, an INIT_SEGMENT is a sub-type of SEGMENT.
+ * This is meant to allow for more specificity to be added to the request type
+ * data, without breaking backwards compatibility.
+ * @enum {number}
+ */
+shaka.net.NetworkingEngine.AdvancedRequestType = {
+  'INIT_SEGMENT': 0,
+  'MEDIA_SEGMENT': 1,
+  'MEDIA_PLAYLIST': 2,
+  'MASTER_PLAYLIST': 3,
+  'MPD': 4,
+  'MSS': 5
+};
 /**
  * Priority level for network scheme plugins.
  * If multiple plugins are provided for the same scheme, only the
@@ -1503,6 +1350,15 @@ shaka.net.NetworkingEngine.OnHeadersReceived;
  * reason (e.g. even if the download was aborted).
  */
 shaka.net.NetworkingEngine.OnDownloadFailed;
+/**
+ * @typedef {function(
+ *    !shaka.net.NetworkingEngine.RequestType,
+ *    !shaka.extern.Request,
+ *    (shaka.extern.RequestContext|undefined))}
+ * @description
+ * A callback function called on every request
+ */
+shaka.net.NetworkingEngine.OnRequest;
 /**
  * @summary
  * An EventManager maintains a collection of "event
@@ -1556,6 +1412,54 @@ shaka.util.EventManager = class {
  * @typedef {function(!Event)}
  */
 shaka.util.EventManager.ListenerType;
+/**
+ * @namespace shaka.util.StringUtils
+ * @summary A set of string utility functions.
+ */
+shaka.util.StringUtils = class {
+  /**
+   * Creates a string from the given buffer as UTF-8 encoding.
+   * @param {?BufferSource} data
+   * @return {string}
+   */
+  static fromUTF8(data) {}
+  /**
+   * Creates a string from the given buffer as UTF-16 encoding.
+   * @param {?BufferSource} data
+   * @param {boolean} littleEndian
+         true to read little endian, false to read big.
+   * @param {boolean=} noThrow true to avoid throwing in cases where we may
+   *     expect invalid input.  If noThrow is true and the data has an odd
+   *     length,it will be truncated.
+   * @return {string}
+   */
+  static fromUTF16(data, littleEndian, noThrow) {}
+  /**
+   * Creates a string from the given buffer, auto-detecting the encoding that is
+   * being used.  If it cannot detect the encoding, it will throw an exception.
+   * @param {?BufferSource} data
+   * @return {string}
+   */
+  static fromBytesAutoDetect(data) {}
+  /**
+   * Creates a ArrayBuffer from the given string, converting to UTF-8 encoding.
+   * @param {string} str
+   * @return {!ArrayBuffer}
+   */
+  static toUTF8(str) {}
+  /**
+   * Creates a ArrayBuffer from the given string, converting to UTF-16 encoding.
+   * @param {string} str
+   * @param {boolean} littleEndian
+   * @return {!ArrayBuffer}
+   */
+  static toUTF16(str, littleEndian) {}
+  /**
+   * Resets the fromCharCode method's implementation.
+   * For debug use.
+   */
+  static resetFromCharCode() {}
+};
 /**
   * @summary DataViewReader abstracts a DataView object.
   */
@@ -1734,6 +1638,52 @@ shaka.util.Mp4Parser = class {
  * @typedef {function(!shaka.extern.ParsedBox)}
  */
 shaka.util.Mp4Parser.CallbackType;
+/**
+ * @summary A set of Uint8Array utility functions.
+ */
+shaka.util.Uint8ArrayUtils = class {
+  /**
+   * Convert a buffer to a base64 string. The output will be standard
+   * alphabet as opposed to base64url safe alphabet.
+   * @param {BufferSource} data
+   * @return {string}
+   */
+  static toStandardBase64(data) {}
+  /**
+   * Convert a buffer to a base64 string.  The output will always use the
+   * alternate encoding/alphabet also known as "base64url".
+   * @param {BufferSource} data
+   * @param {boolean=} padding If true, pad the output with equals signs.
+   *   Defaults to true.
+   * @return {string}
+   */
+  static toBase64(data, padding) {}
+  /**
+   * Convert a base64 string to a Uint8Array.  Accepts either the standard
+   * alphabet or the alternate "base64url" alphabet.
+   * @param {string} str
+   * @return {!Uint8Array}
+   */
+  static fromBase64(str) {}
+  /**
+   * Convert a hex string to a Uint8Array.
+   * @param {string} str
+   * @return {!Uint8Array}
+   */
+  static fromHex(str) {}
+  /**
+   * Convert a buffer to a hex string.
+   * @param {BufferSource} data
+   * @return {string}
+   */
+  static toHex(data) {}
+  /**
+   * Concatenate buffers.
+   * @param {...BufferSource} varArgs
+   * @return {!Uint8Array}
+   */
+  static concat(...varArgs) {}
+};
 /**
  * @summary An interface to register manifest parsers.
  */
@@ -1758,6 +1708,13 @@ shaka.media.ManifestParser = class {
    */
   static unregisterParserByMime(mimeType) {}
 };
+/**
+ * @enum {string}
+ */
+shaka.media.ManifestParser.AccessibilityPurpose = {
+  VISUALLY_IMPAIRED: 'visually impaired',
+  HARD_OF_HEARING: 'hard of hearing'
+};
 /**
  * Creates an InitSegmentReference, which provides the location to an
  * initialization segment.
@@ -1773,9 +1730,10 @@ shaka.media.InitSegmentReference = class {
    *   segment extends to the end of the resource.
    * @param {null|shaka.extern.MediaQualityInfo=} mediaQuality Information about
    *   the quality of the media associated with this init segment.
-   * @param {number=} timescale
+   * @param {(null|number)=} timescale
+   * @param {(null|BufferSource)=} segmentData
    */
-  constructor(uris, startByte, endByte, mediaQuality, timescale) {}
+  constructor(uris, startByte, endByte, mediaQuality, timescale, segmentData) {}
   /**
    * Returns the offset from the start of the resource to the
    * start of the segment.
@@ -1909,6 +1867,26 @@ shaka.media.SegmentReference = class {
    * @return {boolean}
    */
   isPreload() {}
+  /**
+   * Mark the reference as non-independent.
+   */
+  markAsNonIndependent() {}
+  /**
+   * Returns true if the segment is independent.
+   * @return {boolean}
+   */
+  isIndependent() {}
+  /**
+   * Mark the reference as byterange optimization.
+   * The "byterange optimization" means that it is playable using MP4 low
+   * latency streaming with chunked data.
+   */
+  markAsByterangeOptimization() {}
+  /**
+   * Returns true if the segment has a byterange optimization.
+   * @return {boolean}
+   */
+  hasByterangeOptimization() {}
   /**
    * Set the segment's thumbnail sprite.
    * @param {shaka.media.SegmentReference.ThumbnailSprite} thumbnailSprite
@@ -1969,6 +1947,26 @@ shaka.util.Id3Utils = class {
    * @return {!Array.<shaka.extern.MetadataFrame>}
    */
   static getID3Frames(id3Data) {}
+  /**
+   * Returns any adjacent ID3 tags found in data starting at offset, as one
+   * block of data
+   * @param {Uint8Array} id3Data - The ID3 data containing one or more ID3 tags
+   * @param {number=} offset - The offset at which to start searching
+   * @return {!Uint8Array}
+   */
+  static getID3Data(id3Data, offset) {}
+};
+/**
+ * @summary
+ * Parser for exponential Golomb codes, a variable-bitwidth number encoding
+ * scheme used by h264.
+ * Based on https://github.com/videojs/mux.js/blob/main/lib/utils/exp-golomb.js
+ */
+shaka.util.ExpGolomb = class {
+  /**
+   * @param {!Uint8Array} data
+   */
+  constructor(data) {}
 };
 /**
  * @see https://en.wikipedia.org/wiki/MPEG_transport_stream
@@ -1976,7 +1974,77 @@ shaka.util.Id3Utils = class {
 shaka.util.TsParser = class {
   /** */
   constructor() {}
+  /**
+   * Clear previous data
+   */
+  clearData() {}
+  /**
+   * Parse the given data
+   * @param {Uint8Array} data
+   * @return {!shaka.util.TsParser}
+   */
+  parse(data) {}
+  /**
+   * Parse AVC Nalus
+   * The code is based on hls.js
+   * Credit to https://github.com/video-dev/hls.js/blob/master/src/demux/tsdemuxer.ts
+   * @param {shaka.extern.MPEG_PES} pes
+   * @param {?shaka.extern.MPEG_PES=} nextPes
+   * @return {!Array.<shaka.extern.VideoNalu>}
+   */
+  parseAvcNalus(pes, nextPes) {}
+  /**
+   * Return the ID3 metadata
+   * @return {!Array.<shaka.extern.ID3Metadata>}
+   */
+  getMetadata() {}
+  /**
+   * Return the audio data
+   * @return {!Array.<shaka.extern.MPEG_PES>}
+   */
+  getAudioData() {}
+  /**
+   * Return the audio data
+   * @return {!Array.<shaka.extern.MPEG_PES>}
+   */
+  getVideoData() {}
+  /**
+   * Return the start time for the audio and video
+   * @return {{audio: ?number, video: ?number}}
+   */
+  getStartTime() {}
+  /**
+   * Return the audio and video codecs
+   * @return {{audio: ?string, video: ?string}}
+   */
+  getCodecs() {}
+  /**
+   * Return the video data
+   * @return {!Array.<shaka.extern.VideoNalu>}
+   */
+  getVideoNalus() {}
+  /**
+   * Return the video resolution
+   * @return {{height: ?string, width: ?string}}
+   */
+  getVideoResolution() {}
+  /**
+   * Check if the passed data corresponds to an MPEG2-TS
+   * @param {Uint8Array} data
+   * @return {boolean}
+   */
+  static probe(data) {}
+  /**
+   * Returns the synchronization offset
+   * @param {Uint8Array} data
+   * @return {number}
+   */
+  static syncOffset(data) {}
 };
+/**
+ * @const {number}
+ */
+shaka.util.TsParser.Timescale;
 /**
  * @summary
  *  lcevcDil - (MPEG-5 Part 2 LCEVC - Decoder Integration Layer) provides
@@ -2070,6 +2138,14 @@ shaka.media.PresentationTimeline = class {
    * @return {number}
    */
   getDelay() {}
+  /**
+   * Gives PresentationTimeline a Stream's timeline so it can size and position
+   * the segment availability window, and account for missing segment
+   * information.
+   * @param {!Array.<shaka.media.PresentationTimeline.TimeRange>} timeline
+   * @param {number} startOffset
+   */
+  notifyTimeRange(timeline, startOffset) {}
   /**
    * Gives PresentationTimeline an array of segments so it can size and position
    * the segment availability window, and account for missing segment
@@ -2179,6 +2255,22 @@ shaka.media.PresentationTimeline = class {
    */
   setAvailabilityTimeOffset(offset) {}
 };
+/**
+ * @typedef {{
+ *   start: number,
+ *   unscaledStart: number,
+ *   end: number
+ * }}
+ * @description
+ * Defines a time range of a media segment.  Times are in seconds.
+ * @property {number} start
+ *   The start time of the range.
+ * @property {number} unscaledStart
+ *   The start time of the range in representation timescale units.
+ * @property {number} end
+ *   The end time (exclusive) of the range.
+ */
+shaka.media.PresentationTimeline.TimeRange;
 /**
  * SegmentIndex.
  * @implements {shaka.util.IReleasable}
@@ -2265,9 +2357,14 @@ shaka.media.SegmentIndex = class {
   updateEvery(interval, updateCallback) {}
   /**
    * Returns a new iterator that initially points to the segment that contains
-   * the given time.  Like the normal iterator, next() must be called first to
-   * get to the first element. Returns null if we do not find a segment at the
+   * the given time, or the nearest independent segment before it.
+   * Like the normal iterator, next() must be called first to get to the first
+   * element. Returns null if we do not find a segment at the
    * requested time.
+   * The first segment returned by the iterator _MUST_ be an independent
+   * segment.  Assumes that only partial references can be dependent, based on
+   * RFC 8216 rev 13, section 8.1: "Each (non-Partial) Media Segment in a Media
+   * Playlist will contain at least one independent frame."
    * @param {number} time
    * @return {?shaka.media.SegmentIterator}
    */
@@ -2353,6 +2450,16 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
    */
   updateEvery(interval, updateCallback) {}
 };
+/**
+ * @typedef {function(
+ *  !(shaka.media.InitSegmentReference|shaka.media.SegmentReference),
+ *  shaka.extern.Stream,
+ *  ?function(BufferSource):!Promise=
+ * ):!shaka.net.NetworkingEngine.PendingRequest}
+ * @description
+ * A callback function that fetches a segment.
+ */
+shaka.media.SegmentPrefetch.FetchDispatcher;
 /**
  * A text displayer plugin using the browser's native VTTCue interface.
  * @implements {shaka.extern.TextDisplayer}
@@ -2428,37 +2535,6 @@ shaka.text.UITextDisplayer = class {
  */
 shaka.text.WebVttGenerator = class {
 };
-/**
- * @typedef {{
- *   type: string,
- *   init: boolean,
- *   duration: number,
- *   mimeType: string,
- *   codecs: string,
- *   bandwidth: (number|undefined)
- * }}
- * @property {string} type
- *   The media type
- * @property {boolean} init
- *   Flag indicating whether the segment is an init segment
- * @property {number} duration
- *   The duration of the segment in seconds
- * @property {string} mimeType
- *   The segment's mime type
- * @property {string} codecs
- *   The segment's codecs
- * @property {(number|undefined)} bandwidth
- *   The segment's variation bandwidth
- */
-shaka.util.CmcdManager.SegmentInfo;
-/**
- * @typedef {{
- *   format: shaka.util.CmcdManager.StreamingFormat
- * }}
- * @property {shaka.util.CmcdManager.StreamingFormat} format
- *   The manifest's stream format
- */
-shaka.util.CmcdManager.ManifestInfo;
 /**
  * @enum {string}
  */
@@ -2546,30 +2622,48 @@ shaka.util.FairPlayUtils = class {
    * @param {?shaka.extern.DrmInfo} drmInfo
    */
   static conaxInitDataTransform(initData, initDataType, drmInfo) {}
+  /**
+   * ExpressPlay initDataTransform configuration.
+   * @param {!Uint8Array} initData
+   * @param {string} initDataType
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   */
+  static expressplayInitDataTransform(initData, initDataType, drmInfo) {}
   /**
    * Verimatrix FairPlay request.
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
    */
-  static verimatrixFairPlayRequest(type, request) {}
+  static verimatrixFairPlayRequest(type, request, context) {}
   /**
    * EZDRM FairPlay request.
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
    */
-  static ezdrmFairPlayRequest(type, request) {}
+  static ezdrmFairPlayRequest(type, request, context) {}
   /**
    * Conax FairPlay request.
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
    */
-  static conaxFairPlayRequest(type, request) {}
+  static conaxFairPlayRequest(type, request, context) {}
+  /**
+   * ExpressPlay FairPlay request.
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
+   */
+  static expressplayFairPlayRequest(type, request, context) {}
   /**
    * Common FairPlay response transform for some DRMs providers.
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Response} response
+   * @param {shaka.extern.RequestContext=} context
    */
-  static commonFairPlayResponse(type, response) {}
+  static commonFairPlayResponse(type, response, context) {}
 };
 /**
  * @final
@@ -2765,6 +2859,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {shaka.Player.LoadMode}
    */
   getLoadMode() {}
+  /**
+   * Get the current manifest type.
+   * @return {?string}
+   */
+  getManifestType() {}
   /**
    * Get the media element that the player is currently using to play loaded
    * content. If the player has not loaded content, this will return
@@ -2844,6 +2943,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {number}
    */
   getExpiration() {}
+  /**
+   * Returns the active sessions metadata
+   * @return {!Array.<shaka.extern.DrmSessionMetadata>}
+   */
+  getActiveSessionsMetadata() {}
   /**
    * Gets a map of EME key ID to the current key status.
    * @return {!Object<string, string>}
@@ -2981,8 +3085,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @param {string} language
    * @param {string=} role
    * @param {number=} channelsCount
+   * @param {number=} safeMargin
    */
-  selectAudioLanguage(language, role, channelsCount) {}
+  selectAudioLanguage(language, role, channelsCount, safeMargin) {}
   /**
    * Sets the current text language and current text role to the selected
    * language and role, and chooses a new variant if need be. If the player has
@@ -2997,8 +3102,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * label uniquely identifies an audio stream, so all the variants
    * are expected to have the same variant.audio.
    * @param {string} label
+   * @param {boolean=} clearBuffer Optional clear buffer or not when
+   *  switch to new variant
+   *  Defaults to true if not provided
+   * @param {number=} safeMargin Optional amount of buffer (in seconds) to
+   *   retain when clearing the buffer.
+   *   Defaults to 0 if not provided. Ignored if clearBuffer is false.
    */
-  selectVariantsByLabel(label) {}
+  selectVariantsByLabel(label, clearBuffer, safeMargin) {}
   /**
    * Check if the text displayer is enabled.
    * @return {boolean}
@@ -3240,6 +3351,42 @@ shaka.ads.ClientSideAd = class {
    * @override
    */
   getDescription() {}
+  /**
+   * @override
+   */
+  getVastMediaBitrate() {}
+  /**
+   * @override
+   */
+  getVastMediaHeight() {}
+  /**
+   * @override
+   */
+  getVastMediaWidth() {}
+  /**
+   * @override
+   */
+  getAdId() {}
+  /**
+   * @override
+   */
+  getCreativeAdId() {}
+  /**
+   * @override
+   */
+  getAdvertiserName() {}
+  /**
+   * @override
+   */
+  getMediaUrl() {}
+  /**
+   * @override
+   */
+  getTimeOffset() {}
+  /**
+   * @override
+   */
+  getPodIndex() {}
   /**
    * @override
    */
@@ -3334,6 +3481,42 @@ shaka.ads.ServerSideAd = class {
    * @override
    */
   getDescription() {}
+  /**
+   * @override
+   */
+  getVastMediaBitrate() {}
+  /**
+   * @override
+   */
+  getVastMediaHeight() {}
+  /**
+   * @override
+   */
+  getVastMediaWidth() {}
+  /**
+   * @override
+   */
+  getAdId() {}
+  /**
+   * @override
+   */
+  getCreativeAdId() {}
+  /**
+   * @override
+   */
+  getAdvertiserName() {}
+  /**
+   * @override
+   */
+  getMediaUrl() {}
+  /**
+   * @override
+   */
+  getTimeOffset() {}
+  /**
+   * @override
+   */
+  getPodIndex() {}
   /**
    * @override
    */
@@ -3354,7 +3537,11 @@ shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
   /**
    * @override
    */
-  initClientSide(adContainer, video) {}
+  configure(config) {}
+  /**
+   * @override
+   */
+  initClientSide(adContainer, video, adsRenderingSettings) {}
   /**
    * @override
    */
@@ -3367,6 +3554,10 @@ shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
    * @override
    */
   requestClientSideAds(imaRequest) {}
+  /**
+   * @override
+   */
+  updateClientSideAdsRenderingSettings(adsRenderingSettings) {}
   /**
    * @override
    */
@@ -3547,6 +3738,11 @@ shaka.ads.AdManager.AD_METADATA;
  * @const {string}
  */
 shaka.ads.AdManager.AD_RECOVERABLE_ERROR;
+/**
+ * The event name for when the ad manager dispatch errors.
+ * @const {string}
+ */
+shaka.ads.AdManager.AD_ERROR;
 /**
  * The event name for when the client side SDK signalled its readiness
  * to play a VPAID ad or an ad rule.
@@ -3694,19 +3890,70 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
    * Should be called from an appDataCallback.
    * @param {string} imageUrl
    */
-  setContentImage(imageUrl) {}
+  setContentImage(imageUrl) {}
+  /**
+   * Set the Cast content's artist.
+   * Also sets the metadata type to music.
+   * Should be called from an appDataCallback.
+   * @param {string} artist
+   */
+  setContentArtist(artist) {}
+  /**
+   * Destroys the underlying Player, then terminates the cast receiver app.
+   * @override
+   */
+  destroy() {}
+};
+/**
+ * CEA-X08 captions decoder.
+ * @implements {shaka.extern.ICaptionDecoder}
+ */
+shaka.cea.CeaDecoder = class {
+  /** */
+  constructor() {}
+};
+/**
+ * MPEG4 stream parser used for extracting 708 closed captions data.
+ * @implements {shaka.extern.ICeaParser}
+ */
+shaka.cea.Mp4CeaParser = class {
+  /** */
+  constructor() {}
+};
+/**
+ * MPEG TS CEA parser.
+ * @implements {shaka.extern.ICeaParser}
+ */
+shaka.cea.TsCeaParser = class {
+  /** */
+  constructor() {}
+};
+/**
+ * A utility to combine streams across periods.
+ * @implements {shaka.util.IReleasable}
+ * @final
+ */
+shaka.util.PeriodCombiner = class {
+  /** */
+  constructor() {}
+  /**
+   * @return {!Array.<shaka.extern.Variant>}
+   */
+  getVariants() {}
   /**
-   * Set the Cast content's artist.
-   * Also sets the metadata type to music.
-   * Should be called from an appDataCallback.
-   * @param {string} artist
+   * @return {!Array.<shaka.extern.Stream>}
+  */
+  getTextStreams() {}
+  /**
+   * @return {!Array.<shaka.extern.Stream>}
    */
-  setContentArtist(artist) {}
+  getImageStreams() {}
   /**
-   * Destroys the underlying Player, then terminates the cast receiver app.
-   * @override
+   * @param {!Array.<shaka.extern.Period>} periods
+   * @param {boolean} isDynamic
+   * @return {!Promise}
    */
-  destroy() {}
+  combinePeriods(periods, isDynamic) {}
 };
 /**
  * Creates a new DASH parser.
@@ -3736,6 +3983,30 @@ shaka.dash.DashParser = class {
    */
   onExpirationUpdated(sessionId, expiration) {}
 };
+/**
+ */
+shaka.dependencies = class {
+  /**
+   * Registers a new dependency.
+   * @param {shaka.dependencies.Allowed} key which is used for retrieving a
+   *   dependency
+   * @param {?} dep a dependency
+   */
+  static add(key, dep) {}
+  /**
+   * Check if we have a dependency for the key.
+   * @param {shaka.dependencies.Allowed} key key
+   * @return {boolean}
+   */
+  static has(key) {}
+};
+/**
+ * @enum {string}
+ */
+shaka.dependencies.Allowed = {
+  muxjs: 'muxjs',
+  ISOBoxer: 'ISOBoxer'
+};
 /**
  * @summary A networking plugin to handle data URIs.
  * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/data_URIs
@@ -3781,6 +4052,34 @@ shaka.hls.HlsParser = class {
    */
   onExpirationUpdated(sessionId, expiration) {}
 };
+/**
+ * Creates a new MSS parser.
+ * @implements {shaka.extern.ManifestParser}
+ */
+shaka.mss.MssParser = class {
+  /** Creates a new MSS parser. */
+  constructor() {}
+  /**
+   * @override
+   */
+  configure(config) {}
+  /**
+   * @override
+   */
+  start(uri, playerInterface) {}
+  /**
+   * @override
+   */
+  stop() {}
+  /**
+   * @override
+   */
+  update() {}
+  /**
+   * @override
+   */
+  onExpirationUpdated(sessionId, expiration) {}
+};
 /**
  * @summary A networking plugin to handle http and https URIs via the Fetch API.
  */
@@ -4070,11 +4369,20 @@ shaka.polyfill.MediaCapabilities = class {
 };
 /**
  * A copy of the MediaCapabilities instance, to prevent Safari from
- * garbage-collecting the polyfilled method on it.  We make it public and export
+ * garbage-collecting the polyfilled method on it. We make it public and export
  * it to ensure that it is not stripped out by the compiler.
  * @type {MediaCapabilities}
  */
 shaka.polyfill.MediaCapabilities.originalMcap;
+/**
+ * A cache that stores the MediaKeySystemAccess result of calling
+ * `navigator.requestMediaKeySystemAccess` by a key combination of
+ * video/audio codec and key system string.
+ * @type {(Object<(!string), (!MediaKeySystemAccess)>)}
+ */
+shaka.polyfill.MediaCapabilities.memoizedMediaKeySystemAccessRequests_ = {
+
+};
 /**
  * @summary A polyfill to patch MSE bugs.
  */
@@ -4355,6 +4663,270 @@ shaka.text.SsaTextParser = class {
    */
   parseMedia(data, time) {}
 };
+/**
+ * @implements {shaka.extern.Transmuxer}
+ */
+shaka.transmuxer.AacTransmuxer = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {}
+  /**
+   * @override
+   */
+  destroy() {}
+  /**
+   * Check if the mime type and the content type is supported.
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   */
+  isSupported(mimeType, contentType) {}
+  /**
+   * @override
+   */
+  convertCodecs(contentType, mimeType) {}
+  /**
+   * @override
+   */
+  getOrginalMimeType() {}
+  /**
+   * @override
+   */
+  transmux(data, stream, reference, duration) {}
+};
+/**
+ * @implements {shaka.extern.Transmuxer}
+ */
+shaka.transmuxer.Ac3Transmuxer = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {}
+  /**
+   * @override
+   */
+  destroy() {}
+  /**
+   * Check if the mime type and the content type is supported.
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   */
+  isSupported(mimeType, contentType) {}
+  /**
+   * @override
+   */
+  convertCodecs(contentType, mimeType) {}
+  /**
+   * @override
+   */
+  getOrginalMimeType() {}
+  /**
+   * @override
+   */
+  transmux(data, stream, reference, duration) {}
+};
+/**
+ * @implements {shaka.extern.Transmuxer}
+ */
+shaka.transmuxer.Ec3Transmuxer = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {}
+  /**
+   * @override
+   */
+  destroy() {}
+  /**
+   * Check if the mime type and the content type is supported.
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   */
+  isSupported(mimeType, contentType) {}
+  /**
+   * @override
+   */
+  convertCodecs(contentType, mimeType) {}
+  /**
+   * @override
+   */
+  getOrginalMimeType() {}
+  /**
+   * @override
+   */
+  transmux(data, stream, reference, duration) {}
+};
+/**
+ * @implements {shaka.extern.Transmuxer}
+ */
+shaka.transmuxer.Mp3Transmuxer = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {}
+  /**
+   * @override
+   */
+  destroy() {}
+  /**
+   * Check if the mime type and the content type is supported.
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   */
+  isSupported(mimeType, contentType) {}
+  /**
+   * @override
+   */
+  convertCodecs(contentType, mimeType) {}
+  /**
+   * @override
+   */
+  getOrginalMimeType() {}
+  /**
+   * @override
+   */
+  transmux(data, stream, reference, duration) {}
+};
+/**
+ * @implements {shaka.extern.Transmuxer}
+ */
+shaka.transmuxer.MpegTsTransmuxer = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {}
+  /**
+   * @override
+   */
+  destroy() {}
+  /**
+   * Check if the mime type and the content type is supported.
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   */
+  isSupported(mimeType, contentType) {}
+  /**
+   * @override
+   */
+  convertCodecs(contentType, mimeType) {}
+  /**
+   * @override
+   */
+  getOrginalMimeType() {}
+  /**
+   * @override
+   */
+  transmux(data) {}
+};
+/**
+ * @implements {shaka.extern.Transmuxer}
+ */
+shaka.transmuxer.MssTransmuxer = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {}
+  /**
+   * @override
+   */
+  destroy() {}
+  /**
+   * Check if the mime type and the content type is supported.
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   */
+  isSupported(mimeType, contentType) {}
+  /**
+   * @override
+   */
+  convertCodecs(contentType, mimeType) {}
+  /**
+   * @override
+   */
+  getOrginalMimeType() {}
+  /**
+   * @override
+   */
+  transmux(data, stream, reference) {}
+};
+/**
+ * @implements {shaka.extern.Transmuxer}
+ */
+shaka.transmuxer.MuxjsTransmuxer = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {}
+  /**
+   * @override
+   */
+  destroy() {}
+  /**
+   * Check if the mime type and the content type is supported.
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   */
+  isSupported(mimeType, contentType) {}
+  /**
+   * @override
+   */
+  convertCodecs(contentType, mimeType) {}
+  /**
+   * @override
+   */
+  getOrginalMimeType() {}
+  /**
+   * @override
+   */
+  transmux(data) {}
+};
+/**
+ * @implements {shaka.extern.Transmuxer}
+ */
+shaka.transmuxer.TsTransmuxer = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {}
+  /**
+   * @override
+   */
+  destroy() {}
+  /**
+   * Check if the mime type and the content type is supported.
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   */
+  isSupported(mimeType, contentType) {}
+  /**
+   * @override
+   */
+  convertCodecs(contentType, mimeType) {}
+  /**
+   * @override
+   */
+  getOrginalMimeType() {}
+  /**
+   * @override
+   */
+  transmux(data, stream, reference, duration, contentType) {}
+};
 /**
  * @implements {shaka.extern.IUIElement}
  * @abstract