shaka-player 3.1.4 → 3.3.0

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

@@ -35,6 +35,8 @@ shaka.text = {};
 shaka.ui = {};
 /** @const */
 shaka.util = {};
+/** @const */
+shaka.util.CmcdManager = {};
 
 /**
  * @summary Create an Event work-alike object based on the provided dictionary.
@@ -261,6 +263,7 @@ shaka.util.Error.Code = {
   'EXPIRED': 6014,
   'SERVER_CERTIFICATE_REQUIRED': 6015,
   'INIT_DATA_TRANSFORM_ERROR': 6016,
+  'SERVER_CERTIFICATE_REQUEST_FAILED': 6017,
   'LOAD_INTERRUPTED': 7000,
   'OPERATION_ABORTED': 7001,
   'NO_VIDEO_ELEMENT': 7002,
@@ -286,12 +289,156 @@ shaka.util.Error.Code = {
   'MISSING_STORAGE_CELL': 9013,
   'STORAGE_LIMIT_REACHED': 9014,
   'DOWNLOAD_SIZE_CALLBACK_ERROR': 9015,
+  'MODIFY_OPERATION_NOT_SUPPORTED': 9016,
   'CS_IMA_SDK_MISSING': 10000,
   'CS_AD_MANAGER_NOT_INITIALIZED': 10001,
   'SS_IMA_SDK_MISSING': 10002,
   'SS_AD_MANAGER_NOT_INITIALIZED': 10003,
   'CURRENT_DAI_REQUEST_NOT_FINISHED': 10004
 };
+/**
+ * @summary A set of language utility functions.
+ * @final
+ */
+shaka.util.LanguageUtils = class {
+  /**
+   * Check if |locale1| and |locale2| are locale-compatible.
+   * Locale-compatible is defined as all components in each locale match. Since
+   * we only respect the language and region components, we only check that
+   * the language and region components match.
+   * Examples:
+   *  Locale A | Locale B | Locale Compatible
+   *  ---------------------------------------
+   *  en-US    | en-US    | true
+   *  en       | en-US    | false
+   *  en-US    | en-CA    | false
+   * @param {string} locale1
+   * @param {string} locale2
+   * @return {boolean}
+   */
+  static areLocaleCompatible(locale1, locale2) {}
+  /**
+   * Check if |locale1| and |locale2| are language-compatible.
+   * Language compatible is when the language component of each locale matches.
+   * This means that no matter what region they have (or don't have) as long as
+   * the language components match, they are language-compatible.
+   * Examples:
+   *  Locale A | Locale B | Language-Compatible
+   *  -----------------------------------------
+   *  en-US    | en-US    | true
+   *  en-US    | en       | true
+   *  en-US    | en-CA    | true
+   *  en-CA    | fr-CA    | false
+   * @param {string} locale1
+   * @param {string} locale2
+   * @return {boolean}
+   */
+  static areLanguageCompatible(locale1, locale2) {}
+  /**
+   * Check if |possibleParent| is the parent locale of |possibleChild|. Because
+   * we do not support dialects, the parent-child relationship is a lot simpler.
+   * In a parent child relationship:
+   *    - The parent and child have the same language-component
+   *    - The parent has no region-component
+   *    - The child has a region-component
+   * Example:
+   *  Locale A | Locale B | Is A The parent of B?
+   *  --------------------------------------------
+   *  en-US    | en-US    | no
+   *  en-US    | en       | no
+   *  en       | en-US    | yes
+   *  en       | en       | no
+   *  en       | fr       | no
+   * @param {string} possibleParent
+   * @param {string} possibleChild
+   * @return {boolean}
+   */
+  static isParentOf(possibleParent, possibleChild) {}
+  /**
+   * Check if |localeA| shares the same parent with |localeB|. Since we don't
+   * support dialect, we will only look at language and region. For two locales
+   * to be siblings:
+   *    - Both must have language-components
+   *    - Both must have region-components
+   *    - Both must have the same language-component
+   * Example:
+   *  Locale A | Locale B | Siblings?
+   *  --------------------------------------------
+   *  en-US    | en-US    | yes
+   *  en-US    | en-CA    | yes
+   *  en-US    | en       | no
+   *  en       | en-US    | no
+   *  en       | en       | no
+   *  en       | fr       | no
+   * @param {string} localeA
+   * @param {string} localeB
+   * @return {boolean}
+   */
+  static isSiblingOf(localeA, localeB) {}
+  /**
+   * Normalize a locale. This will take a locale and canonicalize it to a state
+   * that we are prepared to work with.
+   * We only support with:
+   *   - language
+   *   - language-REGION
+   * If given a dialect, we will discard it. We will convert any 3-character
+   * codes to 2-character codes. We will force language codes to lowercase and
+   * region codes to uppercase.
+   * @param {string} locale
+   * @return {string}
+   */
+  static normalize(locale) {}
+  /**
+   * Check if two language codes are siblings. Language codes are siblings if
+   * they share the same base language while neither one is the base language.
+   * For example, "en-US" and "en-CA" are siblings but "en-US" and "en" are not
+   * siblings.
+   * @param {string} a
+   * @param {string} b
+   * @return {boolean}
+   */
+  static areSiblings(a, b) {}
+  /**
+   * Compute a numerical relatedness for language codes.  Language codes with a
+   * higher relatedness are a better match.  Unrelated language codes have a
+   * relatedness score of 0.
+   * @param {string} target
+   * @param {string} candidate
+   * @return {number}
+   */
+  static relatedness(target, candidate) {}
+  /**
+   * Get the normalized base language for a language code.
+   * @param {string} lang
+   * @return {string}
+   */
+  static getBase(lang) {}
+  /**
+   * Get the normalized language of the given text stream. Will return 'und' if
+   * a language is not found on the text stream.
+   * This should always be used to get the language from a text stream.
+   * @param {shaka.extern.Stream} stream
+   * @return {string}
+   */
+  static getLocaleForText(stream) {}
+  /**
+   * Get the normalized locale for the given variant. This will look through
+   * the variant to find the locale that represents the content in the variant.
+   * This will return 'und' if no language can be found.
+   * This should always be used to get the locale from a variant.
+   * @param {shaka.extern.Variant} variant
+   * @return {string}
+   */
+  static getLocaleForVariant(variant) {}
+  /**
+   * Find the locale in |searchSpace| that comes closest to |target|. If no
+   * locale is found to be close to |target|, then |null| will be returned.
+   * @param {string} target
+   * @param {!Iterable.<string>} searchSpace
+   * @return {?string}
+   */
+  static findClosestLocale(target, searchSpace) {}
+};
 /**
  * Localization system provided by the shaka ui library.
  * It can be used to store the various localized forms of
@@ -407,379 +554,28 @@ shaka.ui.Localization.LOCALE_CHANGED;
  */
 shaka.ui.Localization.LOCALE_UPDATED;
 /**
- * @summary A set of BufferSource utility functions.
+ * @implements {shaka.extern.Cue}
  */
-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}
-   */
-  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) {}
+shaka.text.Cue = class {
   /**
-   * Creates a DataView over the given buffer.
-   * @see toUint8
-   * @param {BufferSource} buffer
-   * @param {number=} offset
-   * @param {number=} length
-   * @return {!DataView}
+   * @param {number} startTime
+   * @param {number} endTime
+   * @param {string} payload
    */
-  static toDataView(buffer, offset, length) {}
+  constructor(startTime, endTime, payload) {}
 };
 /**
- * @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() {}
-};
+     * @override
+     */
+shaka.text.Cue.prototype.startTime;
 /**
-  * @summary DataViewReader abstracts a DataView object.
-  */
-shaka.util.DataViewReader = class {
-  /**
-   * @param {BufferSource} data
-   * @param {shaka.util.DataViewReader.Endianness} endianness The endianness.
-   */
-  constructor(data, endianness) {}
-  /**
-   * @return {boolean} True if the reader has more data, false otherwise.
-   */
-  hasMoreData() {}
-  /**
-   * Gets the current byte position.
-   * @return {number}
-   */
-  getPosition() {}
-  /**
-   * Gets the byte length of the DataView.
-   * @return {number}
-   */
-  getLength() {}
-  /**
-   * Reads an unsigned 8 bit integer, and advances the reader.
-   * @return {number} The integer.
-   */
-  readUint8() {}
-  /**
-   * Reads an unsigned 16 bit integer, and advances the reader.
-   * @return {number} The integer.
-   */
-  readUint16() {}
-  /**
-   * Reads an unsigned 32 bit integer, and advances the reader.
-   * @return {number} The integer.
-   */
-  readUint32() {}
-  /**
-   * Reads a signed 32 bit integer, and advances the reader.
-   * @return {number} The integer.
-   */
-  readInt32() {}
-  /**
-   * Reads an unsigned 64 bit integer, and advances the reader.
-   * @return {number} The integer.
-   */
-  readUint64() {}
-  /**
-   * Reads the specified number of raw bytes.
-   * @param {number} bytes The number of bytes to read.
-   * @return {!Uint8Array}
-   */
-  readBytes(bytes) {}
-  /**
-   * Skips the specified number of bytes.
-   * @param {number} bytes The number of bytes to skip.
-   */
-  skip(bytes) {}
-  /**
-   * Rewinds the specified number of bytes.
-   * @param {number} bytes The number of bytes to rewind.
-   */
-  rewind(bytes) {}
-  /**
-   * Seeks to a specified position.
-   * @param {number} position The desired byte position within the DataView.
-   */
-  seek(position) {}
-  /**
-   * Keeps reading until it reaches a byte that equals to zero.  The text is
-   * assumed to be UTF-8.
-   * @return {string}
-   */
-  readTerminatedString() {}
-};
+     * @override
+     */
+shaka.text.Cue.prototype.direction;
 /**
- * Endianness.
- * @enum {number}
- */
-shaka.util.DataViewReader.Endianness = {
-  'BIG_ENDIAN': 0,
-  'LITTLE_ENDIAN': 1
-};
-/**
- */
-shaka.util.Mp4Parser = class {
-  /** */
-  constructor() {}
-  /**
-   * Declare a box type as a Box.
-   * @param {string} type
-   * @param {!shaka.util.Mp4Parser.CallbackType} definition
-   * @return {!shaka.util.Mp4Parser}
-   */
-  box(type, definition) {}
-  /**
-   * Declare a box type as a Full Box.
-   * @param {string} type
-   * @param {!shaka.util.Mp4Parser.CallbackType} definition
-   * @return {!shaka.util.Mp4Parser}
-   */
-  fullBox(type, definition) {}
-  /**
-   * Stop parsing.  Useful for extracting information from partial segments and
-   * avoiding an out-of-bounds error once you find what you are looking for.
-   */
-  stop() {}
-  /**
-   * Parse the given data using the added callbacks.
-   * @param {!BufferSource} data
-   * @param {boolean=} partialOkay If true, allow reading partial payloads
-   *   from some boxes. If the goal is a child box, we can sometimes find it
-   *   without enough data to find all child boxes.
-   * @param {boolean=} stopOnPartial If true, stop reading if an incomplete
-   *   box is detected.
-   */
-  parse(data, partialOkay, stopOnPartial) {}
-  /**
-   * Parse the next box on the current level.
-   * @param {number} absStart The absolute start position in the original
-   *   byte array.
-   * @param {!shaka.util.DataViewReader} reader
-   * @param {boolean=} partialOkay If true, allow reading partial payloads
-   *   from some boxes. If the goal is a child box, we can sometimes find it
-   *   without enough data to find all child boxes.
-   * @param {boolean=} stopOnPartial If true, stop reading if an incomplete
-   *   box is detected.
-   */
-  parseNext(absStart, reader, partialOkay, stopOnPartial) {}
-  /**
-   * A callback that tells the Mp4 parser to treat the body of a box as a series
-   * of boxes. The number of boxes is limited by the size of the parent box.
-   * @param {!shaka.extern.ParsedBox} box
-   */
-  static children(box) {}
-  /**
-   * A callback that tells the Mp4 parser to treat the body of a box as a sample
-   * description. A sample description box has a fixed number of children. The
-   * number of children is represented by a 4 byte unsigned integer. Each child
-   * is a box.
-   * @param {!shaka.extern.ParsedBox} box
-   */
-  static sampleDescription(box) {}
-  /**
-   * Create a callback that tells the Mp4 parser to treat the body of a box as a
-   * binary blob and to parse the body's contents using the provided callback.
-   * @param {function(!Uint8Array)} callback
-   * @return {!shaka.util.Mp4Parser.CallbackType}
-   */
-  static allData(callback) {}
-  /**
-   * Convert an integer type from a box into an ascii string name.
-   * Useful for debugging.
-   * @param {number} type The type of the box, a uint32.
-   * @return {string}
-   */
-  static typeToString(type) {}
-  /**
-   * Find the header size of the box.
-   * Useful for modifying boxes in place or finding the exact offset of a field.
-   * @param {shaka.extern.ParsedBox} box
-   * @return {number}
-   */
-  static headerSize(box) {}
-};
-/**
- * @typedef {function(!shaka.extern.ParsedBox)}
- */
-shaka.util.Mp4Parser.CallbackType;
-/**
- * A timer allows a single function to be executed at a later time or at
- * regular intervals.
- * @final
- */
-shaka.util.Timer = class {
-  /**
-   * Create a new timer. A timer is committed to a single callback function.
-   * While there is no technical reason to do this, it is far easier to
-   * understand and use timers when they are connected to one functional idea.
-   * @param {function()} onTick
-   */
-  constructor(onTick) {}
-  /**
-   * Have the timer call |onTick| now.
-   * @return {!shaka.util.Timer}
-   */
-  tickNow() {}
-  /**
-   * Have the timer call |onTick| after |seconds| has elapsed unless |stop| is
-   * called first.
-   * @param {number} seconds
-   * @return {!shaka.util.Timer}
-   */
-  tickAfter(seconds) {}
-  /**
-   * Have the timer call |onTick| every |seconds| until |stop| is called.
-   * @param {number} seconds
-   * @return {!shaka.util.Timer}
-   */
-  tickEvery(seconds) {}
-  /**
-   * Stop the timer and clear the previous behaviour. The timer is still usable
-   * after calling |stop|.
-   */
-  stop() {}
-};
-/**
- * @summary A set of Uint8Array utility functions.
- */
-shaka.util.Uint8ArrayUtils = class {
-  /**
-   * Compare two Uint8Arrays for equality.
-   * @param {Uint8Array} arr1
-   * @param {Uint8Array} arr2
-   * @return {boolean}
-   * @deprecated
-   */
-  static equal(arr1, arr2) {}
-  /**
-   * 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) {}
-};
-/**
- * @implements {shaka.extern.Cue}
- */
-shaka.text.Cue = class {
-  /**
-   * @param {number} startTime
-   * @param {number} endTime
-   * @param {string} payload
-   */
-  constructor(startTime, endTime, payload) {}
-};
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.startTime;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.direction;
-/**
-     * @override
-     */
-shaka.text.Cue.prototype.endTime;
+     * @override
+     */
+shaka.text.Cue.prototype.endTime;
 /**
      * @override
      * @type {string}
@@ -847,6 +643,14 @@ shaka.text.Cue.prototype.backgroundImage;
      * @override
      */
 shaka.text.Cue.prototype.border;
+/**
+     * @override
+     */
+shaka.text.Cue.prototype.textStrokeColor;
+/**
+     * @override
+     */
+shaka.text.Cue.prototype.textStrokeWidth;
 /**
      * @override
      */
@@ -1085,6 +889,48 @@ shaka.text.CueRegion.scrollMode = {
   'NONE': '',
   'UP': 'up'
 };
+/**
+ * @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}
+   */
+  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) {}
+};
 /**
  * An interface to standardize how objects are destroyed.
  * @interface
@@ -1121,6 +967,108 @@ shaka.dependencies = class {
 shaka.dependencies.Allowed = {
   muxjs: 'muxjs'
 };
+/**
+ * @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 {
+  /**
+   * Compare two Uint8Arrays for equality.
+   * @param {Uint8Array} arr1
+   * @param {Uint8Array} arr2
+   * @return {boolean}
+   * @deprecated
+   */
+  static equal(arr1, arr2) {}
+  /**
+   * 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 Manages text parsers and cues.
  * @implements {shaka.util.IDestroyable}
@@ -1147,70 +1095,42 @@ shaka.text.TextEngine = class {
   destroy() {}
 };
 /**
- * An interface to standardize how objects release internal references
- * synchronously. If an object needs to asynchronously release references, then
- * it should use 'shaka.util.IDestroyable'.
- * @interface
- */
-shaka.util.IReleasable = class {
-  /**
-   * Request that this object release all internal references.
-   */
-  release() {}
-};
-/**
- * @summary
- * An EventManager maintains a collection of "event
- * bindings" between event targets and event listeners.
- * @implements {shaka.util.IReleasable}
+ * A timer allows a single function to be executed at a later time or at
+ * regular intervals.
+ * @final
  */
-shaka.util.EventManager = class {
-  /** */
-  constructor() {}
+shaka.util.Timer = class {
   /**
-   * Detaches all event listeners.
-   * @override
+   * Create a new timer. A timer is committed to a single callback function.
+   * While there is no technical reason to do this, it is far easier to
+   * understand and use timers when they are connected to one functional idea.
+   * @param {function()} onTick
    */
-  release() {}
+  constructor(onTick) {}
   /**
-   * Attaches an event listener to an event target.
-   * @param {EventTarget} target The event target.
-   * @param {string} type The event type.
-   * @param {shaka.util.EventManager.ListenerType} listener The event listener.
-   * @param {(boolean|!AddEventListenerOptions)=} options An object that
-   *    specifies characteristics about the event listener.
-   *    The passive option, if true, indicates that this function will never
-   *    call preventDefault(), which improves scrolling performance.
+   * Have the timer call |onTick| now.
+   * @return {!shaka.util.Timer}
    */
-  listen(target, type, listener, options) {}
+  tickNow() {}
   /**
-   * Attaches an event listener to an event target.  The listener will be
-   * removed when the first instance of the event is fired.
-   * @param {EventTarget} target The event target.
-   * @param {string} type The event type.
-   * @param {shaka.util.EventManager.ListenerType} listener The event listener.
-   * @param {(boolean|!AddEventListenerOptions)=} options An object that
-   *    specifies characteristics about the event listener.
-   *    The passive option, if true, indicates that this function will never
-   *    call preventDefault(), which improves scrolling performance.
+   * Have the timer call |onTick| after |seconds| has elapsed unless |stop| is
+   * called first.
+   * @param {number} seconds
+   * @return {!shaka.util.Timer}
    */
-  listenOnce(target, type, listener, options) {}
+  tickAfter(seconds) {}
   /**
-   * Detaches an event listener from an event target.
-   * @param {EventTarget} target The event target.
-   * @param {string} type The event type.
-   * @param {shaka.util.EventManager.ListenerType=} listener The event listener.
+   * Have the timer call |onTick| every |seconds| until |stop| is called.
+   * @param {number} seconds
+   * @return {!shaka.util.Timer}
    */
-  unlisten(target, type, listener) {}
+  tickEvery(seconds) {}
   /**
-   * Detaches all event listeners from all targets.
+   * Stop the timer and clear the previous behaviour. The timer is still usable
+   * after calling |stop|.
    */
-  removeAll() {}
+  stop() {}
 };
-/**
- * @typedef {function(!Event)}
- */
-shaka.util.EventManager.ListenerType;
 /**
  * @summary
  * <p>
@@ -1371,8 +1291,12 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
    * @param {function(number, number)=} onProgressUpdated Called when a progress
    *   event is triggered. Passed the duration, in milliseconds, that the
    *   request took, and the number of bytes transferred.
+   * @param {shaka.net.NetworkingEngine.OnHeadersReceived=} onHeadersReceived
+   *   Called when the headers are received for a download.
+   * @param {shaka.net.NetworkingEngine.OnDownloadFailed=} onDownloadFailed
+   *   Called when a download fails, for any reason.
    */
-  constructor(onProgressUpdated) {}
+  constructor(onProgressUpdated, onHeadersReceived, onDownloadFailed) {}
   /**
    * @param {boolean} forceHTTPS
    */
@@ -1497,7 +1421,8 @@ shaka.net.NetworkingEngine.RequestType = {
   'SEGMENT': 1,
   'LICENSE': 2,
   'APP': 3,
-  'TIMING': 4
+  'TIMING': 4,
+  'SERVER_CERTIFICATE': 5
 };
 /**
  * Priority level for network scheme plugins.
@@ -1510,6 +1435,92 @@ shaka.net.NetworkingEngine.PluginPriority = {
   'PREFERRED': 2,
   'APPLICATION': 3
 };
+/**
+ * @typedef {function(
+ *    !Object.<string, string>,
+ *    !shaka.extern.Request,
+ *    !shaka.net.NetworkingEngine.RequestType)}
+ * @description
+ * A callback function that passes the shaka.extern.HeadersReceived along to
+ * the player, plus some extra data.
+ */
+shaka.net.NetworkingEngine.OnHeadersReceived;
+/**
+ * @typedef {function(
+ *    !shaka.extern.Request,
+ *    ?shaka.util.Error,
+ *    number,
+ *    boolean)}
+ * @description
+ * A callback function that notifies the player when a download fails, for any
+ * reason (e.g. even if the download was aborted).
+ */
+shaka.net.NetworkingEngine.OnDownloadFailed;
+/**
+ * An interface to standardize how objects release internal references
+ * synchronously. If an object needs to asynchronously release references, then
+ * it should use 'shaka.util.IDestroyable'.
+ * @interface
+ */
+shaka.util.IReleasable = class {
+  /**
+   * Request that this object release all internal references.
+   */
+  release() {}
+};
+/**
+ * @summary
+ * An EventManager maintains a collection of "event
+ * bindings" between event targets and event listeners.
+ * @implements {shaka.util.IReleasable}
+ */
+shaka.util.EventManager = class {
+  /** */
+  constructor() {}
+  /**
+   * Detaches all event listeners.
+   * @override
+   */
+  release() {}
+  /**
+   * Attaches an event listener to an event target.
+   * @param {EventTarget} target The event target.
+   * @param {string} type The event type.
+   * @param {shaka.util.EventManager.ListenerType} listener The event listener.
+   * @param {(boolean|!AddEventListenerOptions)=} options An object that
+   *    specifies characteristics about the event listener.
+   *    The passive option, if true, indicates that this function will never
+   *    call preventDefault(), which improves scrolling performance.
+   */
+  listen(target, type, listener, options) {}
+  /**
+   * Attaches an event listener to an event target.  The listener will be
+   * removed when the first instance of the event is fired.
+   * @param {EventTarget} target The event target.
+   * @param {string} type The event type.
+   * @param {shaka.util.EventManager.ListenerType} listener The event listener.
+   * @param {(boolean|!AddEventListenerOptions)=} options An object that
+   *    specifies characteristics about the event listener.
+   *    The passive option, if true, indicates that this function will never
+   *    call preventDefault(), which improves scrolling performance.
+   */
+  listenOnce(target, type, listener, options) {}
+  /**
+   * Detaches an event listener from an event target.
+   * @param {EventTarget} target The event target.
+   * @param {string} type The event type.
+   * @param {shaka.util.EventManager.ListenerType=} listener The event listener.
+   */
+  unlisten(target, type, listener) {}
+  /**
+   * Detaches all event listeners from all targets.
+   */
+  removeAll() {}
+};
+/**
+ * @typedef {function(!Event)}
+ */
+shaka.util.EventManager.ListenerType;
 /**
  * @summary A set of FairPlay utility functions.
  */
@@ -1563,6 +1574,176 @@ shaka.media.ManifestParser = class {
    */
   static unregisterParserByMime(mimeType) {}
 };
+/**
+  * @summary DataViewReader abstracts a DataView object.
+  */
+shaka.util.DataViewReader = class {
+  /**
+   * @param {BufferSource} data
+   * @param {shaka.util.DataViewReader.Endianness} endianness The endianness.
+   */
+  constructor(data, endianness) {}
+  /**
+   * @return {boolean} True if the reader has more data, false otherwise.
+   */
+  hasMoreData() {}
+  /**
+   * Gets the current byte position.
+   * @return {number}
+   */
+  getPosition() {}
+  /**
+   * Gets the byte length of the DataView.
+   * @return {number}
+   */
+  getLength() {}
+  /**
+   * Reads an unsigned 8 bit integer, and advances the reader.
+   * @return {number} The integer.
+   */
+  readUint8() {}
+  /**
+   * Reads an unsigned 16 bit integer, and advances the reader.
+   * @return {number} The integer.
+   */
+  readUint16() {}
+  /**
+   * Reads an unsigned 32 bit integer, and advances the reader.
+   * @return {number} The integer.
+   */
+  readUint32() {}
+  /**
+   * Reads a signed 32 bit integer, and advances the reader.
+   * @return {number} The integer.
+   */
+  readInt32() {}
+  /**
+   * Reads an unsigned 64 bit integer, and advances the reader.
+   * @return {number} The integer.
+   */
+  readUint64() {}
+  /**
+   * Reads the specified number of raw bytes.
+   * @param {number} bytes The number of bytes to read.
+   * @return {!Uint8Array}
+   */
+  readBytes(bytes) {}
+  /**
+   * Skips the specified number of bytes.
+   * @param {number} bytes The number of bytes to skip.
+   */
+  skip(bytes) {}
+  /**
+   * Rewinds the specified number of bytes.
+   * @param {number} bytes The number of bytes to rewind.
+   */
+  rewind(bytes) {}
+  /**
+   * Seeks to a specified position.
+   * @param {number} position The desired byte position within the DataView.
+   */
+  seek(position) {}
+  /**
+   * Keeps reading until it reaches a byte that equals to zero.  The text is
+   * assumed to be UTF-8.
+   * @return {string}
+   */
+  readTerminatedString() {}
+};
+/**
+ * Endianness.
+ * @enum {number}
+ */
+shaka.util.DataViewReader.Endianness = {
+  'BIG_ENDIAN': 0,
+  'LITTLE_ENDIAN': 1
+};
+/**
+ */
+shaka.util.Mp4Parser = class {
+  /** */
+  constructor() {}
+  /**
+   * Declare a box type as a Box.
+   * @param {string} type
+   * @param {!shaka.util.Mp4Parser.CallbackType} definition
+   * @return {!shaka.util.Mp4Parser}
+   */
+  box(type, definition) {}
+  /**
+   * Declare a box type as a Full Box.
+   * @param {string} type
+   * @param {!shaka.util.Mp4Parser.CallbackType} definition
+   * @return {!shaka.util.Mp4Parser}
+   */
+  fullBox(type, definition) {}
+  /**
+   * Stop parsing.  Useful for extracting information from partial segments and
+   * avoiding an out-of-bounds error once you find what you are looking for.
+   */
+  stop() {}
+  /**
+   * Parse the given data using the added callbacks.
+   * @param {!BufferSource} data
+   * @param {boolean=} partialOkay If true, allow reading partial payloads
+   *   from some boxes. If the goal is a child box, we can sometimes find it
+   *   without enough data to find all child boxes.
+   * @param {boolean=} stopOnPartial If true, stop reading if an incomplete
+   *   box is detected.
+   */
+  parse(data, partialOkay, stopOnPartial) {}
+  /**
+   * Parse the next box on the current level.
+   * @param {number} absStart The absolute start position in the original
+   *   byte array.
+   * @param {!shaka.util.DataViewReader} reader
+   * @param {boolean=} partialOkay If true, allow reading partial payloads
+   *   from some boxes. If the goal is a child box, we can sometimes find it
+   *   without enough data to find all child boxes.
+   * @param {boolean=} stopOnPartial If true, stop reading if an incomplete
+   *   box is detected.
+   */
+  parseNext(absStart, reader, partialOkay, stopOnPartial) {}
+  /**
+   * A callback that tells the Mp4 parser to treat the body of a box as a series
+   * of boxes. The number of boxes is limited by the size of the parent box.
+   * @param {!shaka.extern.ParsedBox} box
+   */
+  static children(box) {}
+  /**
+   * A callback that tells the Mp4 parser to treat the body of a box as a sample
+   * description. A sample description box has a fixed number of children. The
+   * number of children is represented by a 4 byte unsigned integer. Each child
+   * is a box.
+   * @param {!shaka.extern.ParsedBox} box
+   */
+  static sampleDescription(box) {}
+  /**
+   * Create a callback that tells the Mp4 parser to treat the body of a box as a
+   * binary blob and to parse the body's contents using the provided callback.
+   * @param {function(!Uint8Array)} callback
+   * @return {!shaka.util.Mp4Parser.CallbackType}
+   */
+  static allData(callback) {}
+  /**
+   * Convert an integer type from a box into an ascii string name.
+   * Useful for debugging.
+   * @param {number} type The type of the box, a uint32.
+   * @return {string}
+   */
+  static typeToString(type) {}
+  /**
+   * Find the header size of the box.
+   * Useful for modifying boxes in place or finding the exact offset of a field.
+   * @param {shaka.extern.ParsedBox} box
+   * @return {number}
+   */
+  static headerSize(box) {}
+};
+/**
+ * @typedef {function(!shaka.extern.ParsedBox)}
+ */
+shaka.util.Mp4Parser.CallbackType;
 /**
  * Creates an InitSegmentReference, which provides the location to an
  * initialization segment.
@@ -1573,11 +1754,13 @@ shaka.media.InitSegmentReference = class {
    *   of the resource containing the segment.
    * @param {number} startByte The offset from the start of the resource to the
    *   start of the segment.
-   * @param {?number} endByte The offset from the start of the resource to the
-   *   end of the segment, inclusive.  A value of null indicates that the
+   * @param {?number} endByte The offset from the start of the resource
+   *   to the end of the segment, inclusive.  A value of null indicates that the
    *   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.
    */
-  constructor(uris, startByte, endByte) {}
+  constructor(uris, startByte, endByte, mediaQuality) {}
   /**
    * Returns the offset from the start of the resource to the
    * start of the segment.
@@ -1633,9 +1816,13 @@ shaka.media.SegmentReference = class {
    *   presentation.  Any content from after this time will be removed by
    *   MediaSource.
    * @param {!Array.<!shaka.media.SegmentReference>=} partialReferences
-       A list of SegmentReferences for the partial segments.
+   *   A list of SegmentReferences for the partial segments.
+   * @param {?string=} tilesLayout
+   *   The value is a grid-item-dimension consisting of two positive decimal
+   *   integers in the format: column-x-row ('4x3'). It describes the
+   *   arrangement of Images in a Grid. The minimum valid LAYOUT is '1x1'.
    */
-  constructor(startTime, endTime, uris, startByte, endByte, initSegmentReference, timestampOffset, appendWindowStart, appendWindowEnd, partialReferences) {}
+  constructor(startTime, endTime, uris, startByte, endByte, initSegmentReference, timestampOffset, appendWindowStart, appendWindowEnd, partialReferences, tilesLayout) {}
   /**
    * Creates and returns the URIs of the resource containing the segment.
    * @return {!Array.<string>}
@@ -1664,6 +1851,11 @@ shaka.media.SegmentReference = class {
    * @return {?number}
    */
   getEndByte() {}
+  /**
+   * Returns the segment's tiles layout. Only defined in image segments.
+   * @return {?string}
+   */
+  getTilesLayout() {}
 };
 /**
  * PresentationTimeline.
@@ -2099,6 +2291,46 @@ 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}
+ */
+shaka.util.CmcdManager.StreamingFormat = {
+  DASH: 'd',
+  HLS: 'h',
+  SMOOTH: 's',
+  OTHER: 'o'
+};
 /**  */
 shaka.util.ConfigUtils = class {
   /**
@@ -2238,6 +2470,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {!Promise}
    */
   unload(initializeMediaSource) {}
+  /**
+   * Provides a way to update the stream start position during the media loading
+   * process. Can for example be called from the <code>manifestparsed</code>
+   * event handler to update the start position based on information in the
+   * manifest.
+   * @param {number} startTime
+   */
+  updateStartTime(startTime) {}
   /**
    * Tell the player to load the content at <code>assetUri</code> and start
    * playback at <code>startTime</code>. Before calling <code>load</code>,
@@ -2285,6 +2525,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {shaka.extern.PlayerConfiguration}
    */
   getConfiguration() {}
+  /**
+   * Returns the ratio of video length buffered compared to buffering Goal
+   * @return {number}
+   */
+  getBufferFullness() {}
   /**
    * Reset configuration to default.
    */
@@ -2347,6 +2592,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {{start: number, end: number}}
    */
   seekRange() {}
+  /**
+   * Go to live in a live stream.
+   */
+  goToLive() {}
   /**
    * Get the key system currently used by EME. If EME is not being used, this
    * will return an empty string. If the player has not loaded content, this
@@ -2528,6 +2777,17 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {boolean}
    */
   isTextTrackVisible() {}
+  /**
+   * Return a list of chapters tracks.
+   * @return {!Array.<shaka.extern.Track>}
+   */
+  getChaptersTracks() {}
+  /**
+   * This returns the list of chapters.
+   * @param {string} language
+   * @return {!Array.<shaka.extern.Chapter>}
+   */
+  getChapters(language) {}
   /**
    * Enable or disable the text displayer.  If the player is in an unloaded
    * state, the request will be applied next time content is loaded.
@@ -2591,6 +2851,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {!Promise.<shaka.extern.Track>}
    */
   addTextTrackAsync(uri, language, kind, mimeType, codec, label, forced) {}
+  /**
+   * Adds the given chapters track to the loaded manifest.  <code>load()</code>
+   * must resolve before calling.  The presentation must have a duration.
+   * This returns the created track.
+   * @param {string} uri
+   * @param {string} language
+   * @param {string=} mimeType
+   * @return {!Promise.<shaka.extern.Track>}
+   */
+  addChaptersTrack(uri, language, mimeType) {}
   /**
    * Set the maximum resolution that the platform's hardware can handle.
    * This will be called automatically by <code>shaka.cast.CastReceiver</code>
@@ -2717,6 +2987,10 @@ shaka.ads.ClientSideAd = class {
    * @override
    */
   isMuted() {}
+  /**
+   * @override
+   */
+  isLinear() {}
   /**
    * @override
    */
@@ -2799,6 +3073,10 @@ shaka.ads.ServerSideAd = class {
    * @override
    */
   isMuted() {}
+  /**
+   * @override
+   */
+  isLinear() {}
   /**
    * @override
    */
@@ -2863,6 +3141,11 @@ shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
    * @override
    */
   replaceServerSideAdTagParameters(adTagParameters) {}
+  /**
+   * @return {!Array.<!shaka.extern.AdCuePoint>}
+   * @override
+   */
+  getServerSideCuePoints() {}
   /**
    * @return {shaka.extern.AdsStats}
    * @override
@@ -3264,9 +3547,11 @@ shaka.net.HttpFetchPlugin = class {
    * @param {shaka.net.NetworkingEngine.RequestType} requestType
    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
    *   progress event happened.
+   * @param {shaka.extern.HeadersReceived} headersReceived Called when the
+   *   headers for the download are received, but before the body is.
    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
    */
-  static parse(uri, request, requestType, progressUpdated) {}
+  static parse(uri, request, requestType, progressUpdated, headersReceived) {}
   /**
    * Determine if the Fetch API is supported in the browser. Note: this is
    * deliberately exposed as a method to allow the client app to use the same
@@ -3285,9 +3570,11 @@ shaka.net.HttpXHRPlugin = class {
    * @param {shaka.net.NetworkingEngine.RequestType} requestType
    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
    *   progress event happened.
+   * @param {shaka.extern.HeadersReceived} headersReceived Called when the
+   *   headers for the download are received, but before the body is.
    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
    */
-  static parse(uri, request, requestType, progressUpdated) {}
+  static parse(uri, request, requestType, progressUpdated, headersReceived) {}
 };
 /**
  * StorageMuxer is responsible for managing StorageMechanisms and addressing
@@ -3478,6 +3765,20 @@ shaka.polyfill = class {
    */
   static register(polyfill, priority) {}
 };
+/**
+ * @summary A polyfill to add support for the ARIAMixin interface mixin, for
+ * browsers that do not implement it (e.g. Firefox).
+ * Note that IE also does not support ARIAMixin, but this polyfill does not work
+ * for that platform, as it relies on getters and setters.
+ * @see https://w3c.github.io/aria/#ARIAMixin
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Element
+ */
+shaka.polyfill.Aria = class {
+  /**
+   * Install the polyfill if needed.
+   */
+  static install() {}
+};
 /**
  * @summary A polyfill to add support for EncryptionScheme queries in EME.
  * @see https://wicg.github.io/encrypted-media-encryption-scheme/
@@ -3600,6 +3901,15 @@ shaka.polyfill.PiPWebkit = class {
    */
   static install() {}
 };
+/**
+ * @summary A polyfill to provide window.crypto.randomUUID in all browsers.
+ */
+shaka.polyfill.RandomUUID = class {
+  /**
+   * Install the polyfill if needed.
+   */
+  static install() {}
+};
 /**
  * @summary A polyfill to provide navigator.storage.estimate in old
  * webkit browsers.
@@ -3739,8 +4049,8 @@ shaka.text.SrtTextParser = class {
   parseMedia(data, time) {}
   /**
    * Convert a SRT format to WebVTT
-   * @param {!string} data
-   * @return {!string}
+   * @param {string} data
+   * @return {string}
    */
   static srt2webvtt(data) {}
 };
@@ -3849,6 +4159,22 @@ shaka.ui.BigPlayButton = class extends shaka.ui.PlayButton {
    */
   constructor(parent, controls) {}
 };
+/**
+ * @extends {shaka.ui.Element}
+ * @final
+ */
+shaka.ui.ContextMenu = class extends shaka.ui.Element {
+  /**
+   * @param {!HTMLElement} parent
+   * @param {!shaka.ui.Controls} controls
+   */
+  constructor(parent, controls) {}
+  /**
+   * @param {string} name
+   * @param {!shaka.extern.IUIElement.Factory} factory
+   */
+  static registerElement(name, factory) {}
+};
 /**
  * A range element, built to work across browsers.
  * In particular, getting styles to work right on IE requires a specific
@@ -4312,6 +4638,17 @@ shaka.ui.Spacer = class extends shaka.ui.Element {
    */
   constructor(parent, controls) {}
 };
+/**
+ * @extends {shaka.ui.Element}
+ * @final
+ */
+shaka.ui.StatisticsButton = class extends shaka.ui.Element {
+  /**
+   * @param {!HTMLElement} parent
+   * @param {!shaka.ui.Controls} controls
+   */
+  constructor(parent, controls) {}
+};
 /**
  * @extends {shaka.ui.SettingsMenu}
  * @final