{"version":3,"file":"js/chunk-vendors-6f20bd38.3e9a3882.js","mappings":"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","sources":["webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/byte-helpers.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/codecs.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/mp4-helpers.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/opus-helpers.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/ebml-helpers.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/nal-helpers.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/containers.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/decode-b64-to-uint8-array.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/id3-helpers.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/media-types.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/resolve-url.js","webpack://microsoft-academy/./node_modules/@videojs/vhs-utils/es/stream.js","webpack://microsoft-academy/./node_modules/@videojs/xhr/lib/http-handler.js","webpack://microsoft-academy/./node_modules/@videojs/xhr/lib/index.js","webpack://microsoft-academy/./node_modules/videojs-vtt.js/lib/browser-index.js","webpack://microsoft-academy/./node_modules/videojs-vtt.js/lib/vtt.js","webpack://microsoft-academy/./node_modules/videojs-vtt.js/lib/vttcue.js","webpack://microsoft-academy/./node_modules/videojs-vtt.js/lib/vttregion.js"],"sourcesContent":["import window from 'global/window'; // const log2 = Math.log2 ? Math.log2 : (x) => (Math.log(x) / Math.log(2));\n\nvar repeat = function repeat(str, len) {\n  var acc = '';\n\n  while (len--) {\n    acc += str;\n  }\n\n  return acc;\n}; // count the number of bits it would take to represent a number\n// we used to do this with log2 but BigInt does not support builtin math\n// Math.ceil(log2(x));\n\n\nexport var countBits = function countBits(x) {\n  return x.toString(2).length;\n}; // count the number of whole bytes it would take to represent a number\n\nexport var countBytes = function countBytes(x) {\n  return Math.ceil(countBits(x) / 8);\n};\nexport var padStart = function padStart(b, len, str) {\n  if (str === void 0) {\n    str = ' ';\n  }\n\n  return (repeat(str, len) + b.toString()).slice(-len);\n};\nexport var isTypedArray = function isTypedArray(obj) {\n  return ArrayBuffer.isView(obj);\n};\nexport var toUint8 = function toUint8(bytes) {\n  if (bytes instanceof Uint8Array) {\n    return bytes;\n  }\n\n  if (!Array.isArray(bytes) && !isTypedArray(bytes) && !(bytes instanceof ArrayBuffer)) {\n    // any non-number or NaN leads to empty uint8array\n    // eslint-disable-next-line\n    if (typeof bytes !== 'number' || typeof bytes === 'number' && bytes !== bytes) {\n      bytes = 0;\n    } else {\n      bytes = [bytes];\n    }\n  }\n\n  return new Uint8Array(bytes && bytes.buffer || bytes, bytes && bytes.byteOffset || 0, bytes && bytes.byteLength || 0);\n};\nexport var toHexString = function toHexString(bytes) {\n  bytes = toUint8(bytes);\n  var str = '';\n\n  for (var i = 0; i < bytes.length; i++) {\n    str += padStart(bytes[i].toString(16), 2, '0');\n  }\n\n  return str;\n};\nexport var toBinaryString = function toBinaryString(bytes) {\n  bytes = toUint8(bytes);\n  var str = '';\n\n  for (var i = 0; i < bytes.length; i++) {\n    str += padStart(bytes[i].toString(2), 8, '0');\n  }\n\n  return str;\n};\nvar BigInt = window.BigInt || Number;\nvar BYTE_TABLE = [BigInt('0x1'), BigInt('0x100'), BigInt('0x10000'), BigInt('0x1000000'), BigInt('0x100000000'), BigInt('0x10000000000'), BigInt('0x1000000000000'), BigInt('0x100000000000000'), BigInt('0x10000000000000000')];\nexport var ENDIANNESS = function () {\n  var a = new Uint16Array([0xFFCC]);\n  var b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);\n\n  if (b[0] === 0xFF) {\n    return 'big';\n  }\n\n  if (b[0] === 0xCC) {\n    return 'little';\n  }\n\n  return 'unknown';\n}();\nexport var IS_BIG_ENDIAN = ENDIANNESS === 'big';\nexport var IS_LITTLE_ENDIAN = ENDIANNESS === 'little';\nexport var bytesToNumber = function bytesToNumber(bytes, _temp) {\n  var _ref = _temp === void 0 ? {} : _temp,\n      _ref$signed = _ref.signed,\n      signed = _ref$signed === void 0 ? false : _ref$signed,\n      _ref$le = _ref.le,\n      le = _ref$le === void 0 ? false : _ref$le;\n\n  bytes = toUint8(bytes);\n  var fn = le ? 'reduce' : 'reduceRight';\n  var obj = bytes[fn] ? bytes[fn] : Array.prototype[fn];\n  var number = obj.call(bytes, function (total, byte, i) {\n    var exponent = le ? i : Math.abs(i + 1 - bytes.length);\n    return total + BigInt(byte) * BYTE_TABLE[exponent];\n  }, BigInt(0));\n\n  if (signed) {\n    var max = BYTE_TABLE[bytes.length] / BigInt(2) - BigInt(1);\n    number = BigInt(number);\n\n    if (number > max) {\n      number -= max;\n      number -= max;\n      number -= BigInt(2);\n    }\n  }\n\n  return Number(number);\n};\nexport var numberToBytes = function numberToBytes(number, _temp2) {\n  var _ref2 = _temp2 === void 0 ? {} : _temp2,\n      _ref2$le = _ref2.le,\n      le = _ref2$le === void 0 ? false : _ref2$le;\n\n  // eslint-disable-next-line\n  if (typeof number !== 'bigint' && typeof number !== 'number' || typeof number === 'number' && number !== number) {\n    number = 0;\n  }\n\n  number = BigInt(number);\n  var byteCount = countBytes(number);\n  var bytes = new Uint8Array(new ArrayBuffer(byteCount));\n\n  for (var i = 0; i < byteCount; i++) {\n    var byteIndex = le ? i : Math.abs(i + 1 - bytes.length);\n    bytes[byteIndex] = Number(number / BYTE_TABLE[i] & BigInt(0xFF));\n\n    if (number < 0) {\n      bytes[byteIndex] = Math.abs(~bytes[byteIndex]);\n      bytes[byteIndex] -= i === 0 ? 1 : 2;\n    }\n  }\n\n  return bytes;\n};\nexport var bytesToString = function bytesToString(bytes) {\n  if (!bytes) {\n    return '';\n  } // TODO: should toUint8 handle cases where we only have 8 bytes\n  // but report more since this is a Uint16+ Array?\n\n\n  bytes = Array.prototype.slice.call(bytes);\n  var string = String.fromCharCode.apply(null, toUint8(bytes));\n\n  try {\n    return decodeURIComponent(escape(string));\n  } catch (e) {// if decodeURIComponent/escape fails, we are dealing with partial\n    // or full non string data. Just return the potentially garbled string.\n  }\n\n  return string;\n};\nexport var stringToBytes = function stringToBytes(string, stringIsBytes) {\n  if (typeof string !== 'string' && string && typeof string.toString === 'function') {\n    string = string.toString();\n  }\n\n  if (typeof string !== 'string') {\n    return new Uint8Array();\n  } // If the string already is bytes, we don't have to do this\n  // otherwise we do this so that we split multi length characters\n  // into individual bytes\n\n\n  if (!stringIsBytes) {\n    string = unescape(encodeURIComponent(string));\n  }\n\n  var view = new Uint8Array(string.length);\n\n  for (var i = 0; i < string.length; i++) {\n    view[i] = string.charCodeAt(i);\n  }\n\n  return view;\n};\nexport var concatTypedArrays = function concatTypedArrays() {\n  for (var _len = arguments.length, buffers = new Array(_len), _key = 0; _key < _len; _key++) {\n    buffers[_key] = arguments[_key];\n  }\n\n  buffers = buffers.filter(function (b) {\n    return b && (b.byteLength || b.length) && typeof b !== 'string';\n  });\n\n  if (buffers.length <= 1) {\n    // for 0 length we will return empty uint8\n    // for 1 length we return the first uint8\n    return toUint8(buffers[0]);\n  }\n\n  var totalLen = buffers.reduce(function (total, buf, i) {\n    return total + (buf.byteLength || buf.length);\n  }, 0);\n  var tempBuffer = new Uint8Array(totalLen);\n  var offset = 0;\n  buffers.forEach(function (buf) {\n    buf = toUint8(buf);\n    tempBuffer.set(buf, offset);\n    offset += buf.byteLength;\n  });\n  return tempBuffer;\n};\n/**\n * Check if the bytes \"b\" are contained within bytes \"a\".\n *\n * @param {Uint8Array|Array} a\n *        Bytes to check in\n *\n * @param {Uint8Array|Array} b\n *        Bytes to check for\n *\n * @param {Object} options\n *        options\n *\n * @param {Array|Uint8Array} [offset=0]\n *        offset to use when looking at bytes in a\n *\n * @param {Array|Uint8Array} [mask=[]]\n *        mask to use on bytes before comparison.\n *\n * @return {boolean}\n *         If all bytes in b are inside of a, taking into account\n *         bit masks.\n */\n\nexport var bytesMatch = function bytesMatch(a, b, _temp3) {\n  var _ref3 = _temp3 === void 0 ? {} : _temp3,\n      _ref3$offset = _ref3.offset,\n      offset = _ref3$offset === void 0 ? 0 : _ref3$offset,\n      _ref3$mask = _ref3.mask,\n      mask = _ref3$mask === void 0 ? [] : _ref3$mask;\n\n  a = toUint8(a);\n  b = toUint8(b); // ie 11 does not support uint8 every\n\n  var fn = b.every ? b.every : Array.prototype.every;\n  return b.length && a.length - offset >= b.length && // ie 11 doesn't support every on uin8\n  fn.call(b, function (bByte, i) {\n    var aByte = mask[i] ? mask[i] & a[offset + i] : a[offset + i];\n    return bByte === aByte;\n  });\n};\nexport var sliceBytes = function sliceBytes(src, start, end) {\n  if (Uint8Array.prototype.slice) {\n    return Uint8Array.prototype.slice.call(src, start, end);\n  }\n\n  return new Uint8Array(Array.prototype.slice.call(src, start, end));\n};\nexport var reverseBytes = function reverseBytes(src) {\n  if (src.reverse) {\n    return src.reverse();\n  }\n\n  return Array.prototype.reverse.call(src);\n};","import window from 'global/window';\nvar regexs = {\n  // to determine mime types\n  mp4: /^(av0?1|avc0?[1234]|vp0?9|flac|opus|mp3|mp4a|mp4v|stpp.ttml.im1t)/,\n  webm: /^(vp0?[89]|av0?1|opus|vorbis)/,\n  ogg: /^(vp0?[89]|theora|flac|opus|vorbis)/,\n  // to determine if a codec is audio or video\n  video: /^(av0?1|avc0?[1234]|vp0?[89]|hvc1|hev1|theora|mp4v)/,\n  audio: /^(mp4a|flac|vorbis|opus|ac-[34]|ec-3|alac|mp3|speex|aac)/,\n  text: /^(stpp.ttml.im1t)/,\n  // mux.js support regex\n  muxerVideo: /^(avc0?1)/,\n  muxerAudio: /^(mp4a)/,\n  // match nothing as muxer does not support text right now.\n  // there cannot never be a character before the start of a string\n  // so this matches nothing.\n  muxerText: /a^/\n};\nvar mediaTypes = ['video', 'audio', 'text'];\nvar upperMediaTypes = ['Video', 'Audio', 'Text'];\n/**\n * Replace the old apple-style `avc1.<dd>.<dd>` codec string with the standard\n * `avc1.<hhhhhh>`\n *\n * @param {string} codec\n *        Codec string to translate\n * @return {string}\n *         The translated codec string\n */\n\nexport var translateLegacyCodec = function translateLegacyCodec(codec) {\n  if (!codec) {\n    return codec;\n  }\n\n  return codec.replace(/avc1\\.(\\d+)\\.(\\d+)/i, function (orig, profile, avcLevel) {\n    var profileHex = ('00' + Number(profile).toString(16)).slice(-2);\n    var avcLevelHex = ('00' + Number(avcLevel).toString(16)).slice(-2);\n    return 'avc1.' + profileHex + '00' + avcLevelHex;\n  });\n};\n/**\n * Replace the old apple-style `avc1.<dd>.<dd>` codec strings with the standard\n * `avc1.<hhhhhh>`\n *\n * @param {string[]} codecs\n *        An array of codec strings to translate\n * @return {string[]}\n *         The translated array of codec strings\n */\n\nexport var translateLegacyCodecs = function translateLegacyCodecs(codecs) {\n  return codecs.map(translateLegacyCodec);\n};\n/**\n * Replace codecs in the codec string with the old apple-style `avc1.<dd>.<dd>` to the\n * standard `avc1.<hhhhhh>`.\n *\n * @param {string} codecString\n *        The codec string\n * @return {string}\n *         The codec string with old apple-style codecs replaced\n *\n * @private\n */\n\nexport var mapLegacyAvcCodecs = function mapLegacyAvcCodecs(codecString) {\n  return codecString.replace(/avc1\\.(\\d+)\\.(\\d+)/i, function (match) {\n    return translateLegacyCodecs([match])[0];\n  });\n};\n/**\n * @typedef {Object} ParsedCodecInfo\n * @property {number} codecCount\n *           Number of codecs parsed\n * @property {string} [videoCodec]\n *           Parsed video codec (if found)\n * @property {string} [videoObjectTypeIndicator]\n *           Video object type indicator (if found)\n * @property {string|null} audioProfile\n *           Audio profile\n */\n\n/**\n * Parses a codec string to retrieve the number of codecs specified, the video codec and\n * object type indicator, and the audio profile.\n *\n * @param {string} [codecString]\n *        The codec string to parse\n * @return {ParsedCodecInfo}\n *         Parsed codec info\n */\n\nexport var parseCodecs = function parseCodecs(codecString) {\n  if (codecString === void 0) {\n    codecString = '';\n  }\n\n  var codecs = codecString.split(',');\n  var result = [];\n  codecs.forEach(function (codec) {\n    codec = codec.trim();\n    var codecType;\n    mediaTypes.forEach(function (name) {\n      var match = regexs[name].exec(codec.toLowerCase());\n\n      if (!match || match.length <= 1) {\n        return;\n      }\n\n      codecType = name; // maintain codec case\n\n      var type = codec.substring(0, match[1].length);\n      var details = codec.replace(type, '');\n      result.push({\n        type: type,\n        details: details,\n        mediaType: name\n      });\n    });\n\n    if (!codecType) {\n      result.push({\n        type: codec,\n        details: '',\n        mediaType: 'unknown'\n      });\n    }\n  });\n  return result;\n};\n/**\n * Returns a ParsedCodecInfo object for the default alternate audio playlist if there is\n * a default alternate audio playlist for the provided audio group.\n *\n * @param {Object} master\n *        The master playlist\n * @param {string} audioGroupId\n *        ID of the audio group for which to find the default codec info\n * @return {ParsedCodecInfo}\n *         Parsed codec info\n */\n\nexport var codecsFromDefault = function codecsFromDefault(master, audioGroupId) {\n  if (!master.mediaGroups.AUDIO || !audioGroupId) {\n    return null;\n  }\n\n  var audioGroup = master.mediaGroups.AUDIO[audioGroupId];\n\n  if (!audioGroup) {\n    return null;\n  }\n\n  for (var name in audioGroup) {\n    var audioType = audioGroup[name];\n\n    if (audioType.default && audioType.playlists) {\n      // codec should be the same for all playlists within the audio type\n      return parseCodecs(audioType.playlists[0].attributes.CODECS);\n    }\n  }\n\n  return null;\n};\nexport var isVideoCodec = function isVideoCodec(codec) {\n  if (codec === void 0) {\n    codec = '';\n  }\n\n  return regexs.video.test(codec.trim().toLowerCase());\n};\nexport var isAudioCodec = function isAudioCodec(codec) {\n  if (codec === void 0) {\n    codec = '';\n  }\n\n  return regexs.audio.test(codec.trim().toLowerCase());\n};\nexport var isTextCodec = function isTextCodec(codec) {\n  if (codec === void 0) {\n    codec = '';\n  }\n\n  return regexs.text.test(codec.trim().toLowerCase());\n};\nexport var getMimeForCodec = function getMimeForCodec(codecString) {\n  if (!codecString || typeof codecString !== 'string') {\n    return;\n  }\n\n  var codecs = codecString.toLowerCase().split(',').map(function (c) {\n    return translateLegacyCodec(c.trim());\n  }); // default to video type\n\n  var type = 'video'; // only change to audio type if the only codec we have is\n  // audio\n\n  if (codecs.length === 1 && isAudioCodec(codecs[0])) {\n    type = 'audio';\n  } else if (codecs.length === 1 && isTextCodec(codecs[0])) {\n    // text uses application/<container> for now\n    type = 'application';\n  } // default the container to mp4\n\n\n  var container = 'mp4'; // every codec must be able to go into the container\n  // for that container to be the correct one\n\n  if (codecs.every(function (c) {\n    return regexs.mp4.test(c);\n  })) {\n    container = 'mp4';\n  } else if (codecs.every(function (c) {\n    return regexs.webm.test(c);\n  })) {\n    container = 'webm';\n  } else if (codecs.every(function (c) {\n    return regexs.ogg.test(c);\n  })) {\n    container = 'ogg';\n  }\n\n  return type + \"/\" + container + \";codecs=\\\"\" + codecString + \"\\\"\";\n};\nexport var browserSupportsCodec = function browserSupportsCodec(codecString) {\n  if (codecString === void 0) {\n    codecString = '';\n  }\n\n  return window.MediaSource && window.MediaSource.isTypeSupported && window.MediaSource.isTypeSupported(getMimeForCodec(codecString)) || false;\n};\nexport var muxerSupportsCodec = function muxerSupportsCodec(codecString) {\n  if (codecString === void 0) {\n    codecString = '';\n  }\n\n  return codecString.toLowerCase().split(',').every(function (codec) {\n    codec = codec.trim(); // any match is supported.\n\n    for (var i = 0; i < upperMediaTypes.length; i++) {\n      var type = upperMediaTypes[i];\n\n      if (regexs[\"muxer\" + type].test(codec)) {\n        return true;\n      }\n    }\n\n    return false;\n  });\n};\nexport var DEFAULT_AUDIO_CODEC = 'mp4a.40.2';\nexport var DEFAULT_VIDEO_CODEC = 'avc1.4d400d';","import { stringToBytes, toUint8, bytesMatch, bytesToString, toHexString, padStart, bytesToNumber } from './byte-helpers.js';\nimport { getAvcCodec, getHvcCodec, getAv1Codec } from './codec-helpers.js';\nimport { parseOpusHead } from './opus-helpers.js';\n\nvar normalizePath = function normalizePath(path) {\n  if (typeof path === 'string') {\n    return stringToBytes(path);\n  }\n\n  if (typeof path === 'number') {\n    return path;\n  }\n\n  return path;\n};\n\nvar normalizePaths = function normalizePaths(paths) {\n  if (!Array.isArray(paths)) {\n    return [normalizePath(paths)];\n  }\n\n  return paths.map(function (p) {\n    return normalizePath(p);\n  });\n};\n\nvar DESCRIPTORS;\nexport var parseDescriptors = function parseDescriptors(bytes) {\n  bytes = toUint8(bytes);\n  var results = [];\n  var i = 0;\n\n  while (bytes.length > i) {\n    var tag = bytes[i];\n    var size = 0;\n    var headerSize = 0; // tag\n\n    headerSize++;\n    var byte = bytes[headerSize]; // first byte\n\n    headerSize++;\n\n    while (byte & 0x80) {\n      size = (byte & 0x7F) << 7;\n      byte = bytes[headerSize];\n      headerSize++;\n    }\n\n    size += byte & 0x7F;\n\n    for (var z = 0; z < DESCRIPTORS.length; z++) {\n      var _DESCRIPTORS$z = DESCRIPTORS[z],\n          id = _DESCRIPTORS$z.id,\n          parser = _DESCRIPTORS$z.parser;\n\n      if (tag === id) {\n        results.push(parser(bytes.subarray(headerSize, headerSize + size)));\n        break;\n      }\n    }\n\n    i += size + headerSize;\n  }\n\n  return results;\n};\nDESCRIPTORS = [{\n  id: 0x03,\n  parser: function parser(bytes) {\n    var desc = {\n      tag: 0x03,\n      id: bytes[0] << 8 | bytes[1],\n      flags: bytes[2],\n      size: 3,\n      dependsOnEsId: 0,\n      ocrEsId: 0,\n      descriptors: [],\n      url: ''\n    }; // depends on es id\n\n    if (desc.flags & 0x80) {\n      desc.dependsOnEsId = bytes[desc.size] << 8 | bytes[desc.size + 1];\n      desc.size += 2;\n    } // url\n\n\n    if (desc.flags & 0x40) {\n      var len = bytes[desc.size];\n      desc.url = bytesToString(bytes.subarray(desc.size + 1, desc.size + 1 + len));\n      desc.size += len;\n    } // ocr es id\n\n\n    if (desc.flags & 0x20) {\n      desc.ocrEsId = bytes[desc.size] << 8 | bytes[desc.size + 1];\n      desc.size += 2;\n    }\n\n    desc.descriptors = parseDescriptors(bytes.subarray(desc.size)) || [];\n    return desc;\n  }\n}, {\n  id: 0x04,\n  parser: function parser(bytes) {\n    // DecoderConfigDescriptor\n    var desc = {\n      tag: 0x04,\n      oti: bytes[0],\n      streamType: bytes[1],\n      bufferSize: bytes[2] << 16 | bytes[3] << 8 | bytes[4],\n      maxBitrate: bytes[5] << 24 | bytes[6] << 16 | bytes[7] << 8 | bytes[8],\n      avgBitrate: bytes[9] << 24 | bytes[10] << 16 | bytes[11] << 8 | bytes[12],\n      descriptors: parseDescriptors(bytes.subarray(13))\n    };\n    return desc;\n  }\n}, {\n  id: 0x05,\n  parser: function parser(bytes) {\n    // DecoderSpecificInfo\n    return {\n      tag: 0x05,\n      bytes: bytes\n    };\n  }\n}, {\n  id: 0x06,\n  parser: function parser(bytes) {\n    // SLConfigDescriptor\n    return {\n      tag: 0x06,\n      bytes: bytes\n    };\n  }\n}];\n/**\n * find any number of boxes by name given a path to it in an iso bmff\n * such as mp4.\n *\n * @param {TypedArray} bytes\n *        bytes for the iso bmff to search for boxes in\n *\n * @param {Uint8Array[]|string[]|string|Uint8Array} name\n *        An array of paths or a single path representing the name\n *        of boxes to search through in bytes. Paths may be\n *        uint8 (character codes) or strings.\n *\n * @param {boolean} [complete=false]\n *        Should we search only for complete boxes on the final path.\n *        This is very useful when you do not want to get back partial boxes\n *        in the case of streaming files.\n *\n * @return {Uint8Array[]}\n *         An array of the end paths that we found.\n */\n\nexport var findBox = function findBox(bytes, paths, complete) {\n  if (complete === void 0) {\n    complete = false;\n  }\n\n  paths = normalizePaths(paths);\n  bytes = toUint8(bytes);\n  var results = [];\n\n  if (!paths.length) {\n    // short-circuit the search for empty paths\n    return results;\n  }\n\n  var i = 0;\n\n  while (i < bytes.length) {\n    var size = (bytes[i] << 24 | bytes[i + 1] << 16 | bytes[i + 2] << 8 | bytes[i + 3]) >>> 0;\n    var type = bytes.subarray(i + 4, i + 8); // invalid box format.\n\n    if (size === 0) {\n      break;\n    }\n\n    var end = i + size;\n\n    if (end > bytes.length) {\n      // this box is bigger than the number of bytes we have\n      // and complete is set, we cannot find any more boxes.\n      if (complete) {\n        break;\n      }\n\n      end = bytes.length;\n    }\n\n    var data = bytes.subarray(i + 8, end);\n\n    if (bytesMatch(type, paths[0])) {\n      if (paths.length === 1) {\n        // this is the end of the path and we've found the box we were\n        // looking for\n        results.push(data);\n      } else {\n        // recursively search for the next box along the path\n        results.push.apply(results, findBox(data, paths.slice(1), complete));\n      }\n    }\n\n    i = end;\n  } // we've finished searching all of bytes\n\n\n  return results;\n};\n/**\n * Search for a single matching box by name in an iso bmff format like\n * mp4. This function is useful for finding codec boxes which\n * can be placed arbitrarily in sample descriptions depending\n * on the version of the file or file type.\n *\n * @param {TypedArray} bytes\n *        bytes for the iso bmff to search for boxes in\n *\n * @param {string|Uint8Array} name\n *        The name of the box to find.\n *\n * @return {Uint8Array[]}\n *         a subarray of bytes representing the name boxed we found.\n */\n\nexport var findNamedBox = function findNamedBox(bytes, name) {\n  name = normalizePath(name);\n\n  if (!name.length) {\n    // short-circuit the search for empty paths\n    return bytes.subarray(bytes.length);\n  }\n\n  var i = 0;\n\n  while (i < bytes.length) {\n    if (bytesMatch(bytes.subarray(i, i + name.length), name)) {\n      var size = (bytes[i - 4] << 24 | bytes[i - 3] << 16 | bytes[i - 2] << 8 | bytes[i - 1]) >>> 0;\n      var end = size > 1 ? i + size : bytes.byteLength;\n      return bytes.subarray(i + 4, end);\n    }\n\n    i++;\n  } // we've finished searching all of bytes\n\n\n  return bytes.subarray(bytes.length);\n};\n\nvar parseSamples = function parseSamples(data, entrySize, parseEntry) {\n  if (entrySize === void 0) {\n    entrySize = 4;\n  }\n\n  if (parseEntry === void 0) {\n    parseEntry = function parseEntry(d) {\n      return bytesToNumber(d);\n    };\n  }\n\n  var entries = [];\n\n  if (!data || !data.length) {\n    return entries;\n  }\n\n  var entryCount = bytesToNumber(data.subarray(4, 8));\n\n  for (var i = 8; entryCount; i += entrySize, entryCount--) {\n    entries.push(parseEntry(data.subarray(i, i + entrySize)));\n  }\n\n  return entries;\n};\n\nexport var buildFrameTable = function buildFrameTable(stbl, timescale) {\n  var keySamples = parseSamples(findBox(stbl, ['stss'])[0]);\n  var chunkOffsets = parseSamples(findBox(stbl, ['stco'])[0]);\n  var timeToSamples = parseSamples(findBox(stbl, ['stts'])[0], 8, function (entry) {\n    return {\n      sampleCount: bytesToNumber(entry.subarray(0, 4)),\n      sampleDelta: bytesToNumber(entry.subarray(4, 8))\n    };\n  });\n  var samplesToChunks = parseSamples(findBox(stbl, ['stsc'])[0], 12, function (entry) {\n    return {\n      firstChunk: bytesToNumber(entry.subarray(0, 4)),\n      samplesPerChunk: bytesToNumber(entry.subarray(4, 8)),\n      sampleDescriptionIndex: bytesToNumber(entry.subarray(8, 12))\n    };\n  });\n  var stsz = findBox(stbl, ['stsz'])[0]; // stsz starts with a 4 byte sampleSize which we don't need\n\n  var sampleSizes = parseSamples(stsz && stsz.length && stsz.subarray(4) || null);\n  var frames = [];\n\n  for (var chunkIndex = 0; chunkIndex < chunkOffsets.length; chunkIndex++) {\n    var samplesInChunk = void 0;\n\n    for (var i = 0; i < samplesToChunks.length; i++) {\n      var sampleToChunk = samplesToChunks[i];\n      var isThisOne = chunkIndex + 1 >= sampleToChunk.firstChunk && (i + 1 >= samplesToChunks.length || chunkIndex + 1 < samplesToChunks[i + 1].firstChunk);\n\n      if (isThisOne) {\n        samplesInChunk = sampleToChunk.samplesPerChunk;\n        break;\n      }\n    }\n\n    var chunkOffset = chunkOffsets[chunkIndex];\n\n    for (var _i = 0; _i < samplesInChunk; _i++) {\n      var frameEnd = sampleSizes[frames.length]; // if we don't have key samples every frame is a keyframe\n\n      var keyframe = !keySamples.length;\n\n      if (keySamples.length && keySamples.indexOf(frames.length + 1) !== -1) {\n        keyframe = true;\n      }\n\n      var frame = {\n        keyframe: keyframe,\n        start: chunkOffset,\n        end: chunkOffset + frameEnd\n      };\n\n      for (var k = 0; k < timeToSamples.length; k++) {\n        var _timeToSamples$k = timeToSamples[k],\n            sampleCount = _timeToSamples$k.sampleCount,\n            sampleDelta = _timeToSamples$k.sampleDelta;\n\n        if (frames.length <= sampleCount) {\n          // ms to ns\n          var lastTimestamp = frames.length ? frames[frames.length - 1].timestamp : 0;\n          frame.timestamp = lastTimestamp + sampleDelta / timescale * 1000;\n          frame.duration = sampleDelta;\n          break;\n        }\n      }\n\n      frames.push(frame);\n      chunkOffset += frameEnd;\n    }\n  }\n\n  return frames;\n};\nexport var addSampleDescription = function addSampleDescription(track, bytes) {\n  var codec = bytesToString(bytes.subarray(0, 4));\n\n  if (track.type === 'video') {\n    track.info = track.info || {};\n    track.info.width = bytes[28] << 8 | bytes[29];\n    track.info.height = bytes[30] << 8 | bytes[31];\n  } else if (track.type === 'audio') {\n    track.info = track.info || {};\n    track.info.channels = bytes[20] << 8 | bytes[21];\n    track.info.bitDepth = bytes[22] << 8 | bytes[23];\n    track.info.sampleRate = bytes[28] << 8 | bytes[29];\n  }\n\n  if (codec === 'avc1') {\n    var avcC = findNamedBox(bytes, 'avcC'); // AVCDecoderConfigurationRecord\n\n    codec += \".\" + getAvcCodec(avcC);\n    track.info.avcC = avcC; // TODO: do we need to parse all this?\n\n    /* {\n      configurationVersion: avcC[0],\n      profile: avcC[1],\n      profileCompatibility: avcC[2],\n      level: avcC[3],\n      lengthSizeMinusOne: avcC[4] & 0x3\n    };\n     let spsNalUnitCount = avcC[5] & 0x1F;\n    const spsNalUnits = track.info.avc.spsNalUnits = [];\n     // past spsNalUnitCount\n    let offset = 6;\n     while (spsNalUnitCount--) {\n      const nalLen = avcC[offset] << 8 | avcC[offset + 1];\n       spsNalUnits.push(avcC.subarray(offset + 2, offset + 2 + nalLen));\n       offset += nalLen + 2;\n    }\n    let ppsNalUnitCount = avcC[offset];\n    const ppsNalUnits = track.info.avc.ppsNalUnits = [];\n     // past ppsNalUnitCount\n    offset += 1;\n     while (ppsNalUnitCount--) {\n      const nalLen = avcC[offset] << 8 | avcC[offset + 1];\n       ppsNalUnits.push(avcC.subarray(offset + 2, offset + 2 + nalLen));\n       offset += nalLen + 2;\n    }*/\n    // HEVCDecoderConfigurationRecord\n  } else if (codec === 'hvc1' || codec === 'hev1') {\n    codec += \".\" + getHvcCodec(findNamedBox(bytes, 'hvcC'));\n  } else if (codec === 'mp4a' || codec === 'mp4v') {\n    var esds = findNamedBox(bytes, 'esds');\n    var esDescriptor = parseDescriptors(esds.subarray(4))[0];\n    var decoderConfig = esDescriptor && esDescriptor.descriptors.filter(function (_ref) {\n      var tag = _ref.tag;\n      return tag === 0x04;\n    })[0];\n\n    if (decoderConfig) {\n      // most codecs do not have a further '.'\n      // such as 0xa5 for ac-3 and 0xa6 for e-ac-3\n      codec += '.' + toHexString(decoderConfig.oti);\n\n      if (decoderConfig.oti === 0x40) {\n        codec += '.' + (decoderConfig.descriptors[0].bytes[0] >> 3).toString();\n      } else if (decoderConfig.oti === 0x20) {\n        codec += '.' + decoderConfig.descriptors[0].bytes[4].toString();\n      } else if (decoderConfig.oti === 0xdd) {\n        codec = 'vorbis';\n      }\n    } else if (track.type === 'audio') {\n      codec += '.40.2';\n    } else {\n      codec += '.20.9';\n    }\n  } else if (codec === 'av01') {\n    // AV1DecoderConfigurationRecord\n    codec += \".\" + getAv1Codec(findNamedBox(bytes, 'av1C'));\n  } else if (codec === 'vp09') {\n    // VPCodecConfigurationRecord\n    var vpcC = findNamedBox(bytes, 'vpcC'); // https://www.webmproject.org/vp9/mp4/\n\n    var profile = vpcC[0];\n    var level = vpcC[1];\n    var bitDepth = vpcC[2] >> 4;\n    var chromaSubsampling = (vpcC[2] & 0x0F) >> 1;\n    var videoFullRangeFlag = (vpcC[2] & 0x0F) >> 3;\n    var colourPrimaries = vpcC[3];\n    var transferCharacteristics = vpcC[4];\n    var matrixCoefficients = vpcC[5];\n    codec += \".\" + padStart(profile, 2, '0');\n    codec += \".\" + padStart(level, 2, '0');\n    codec += \".\" + padStart(bitDepth, 2, '0');\n    codec += \".\" + padStart(chromaSubsampling, 2, '0');\n    codec += \".\" + padStart(colourPrimaries, 2, '0');\n    codec += \".\" + padStart(transferCharacteristics, 2, '0');\n    codec += \".\" + padStart(matrixCoefficients, 2, '0');\n    codec += \".\" + padStart(videoFullRangeFlag, 2, '0');\n  } else if (codec === 'theo') {\n    codec = 'theora';\n  } else if (codec === 'spex') {\n    codec = 'speex';\n  } else if (codec === '.mp3') {\n    codec = 'mp4a.40.34';\n  } else if (codec === 'msVo') {\n    codec = 'vorbis';\n  } else if (codec === 'Opus') {\n    codec = 'opus';\n    var dOps = findNamedBox(bytes, 'dOps');\n    track.info.opus = parseOpusHead(dOps); // TODO: should this go into the webm code??\n    // Firefox requires a codecDelay for opus playback\n    // see https://bugzilla.mozilla.org/show_bug.cgi?id=1276238\n\n    track.info.codecDelay = 6500000;\n  } else {\n    codec = codec.toLowerCase();\n  }\n  /* eslint-enable */\n  // flac, ac-3, ec-3, opus\n\n\n  track.codec = codec;\n};\nexport var parseTracks = function parseTracks(bytes, frameTable) {\n  if (frameTable === void 0) {\n    frameTable = true;\n  }\n\n  bytes = toUint8(bytes);\n  var traks = findBox(bytes, ['moov', 'trak'], true);\n  var tracks = [];\n  traks.forEach(function (trak) {\n    var track = {\n      bytes: trak\n    };\n    var mdia = findBox(trak, ['mdia'])[0];\n    var hdlr = findBox(mdia, ['hdlr'])[0];\n    var trakType = bytesToString(hdlr.subarray(8, 12));\n\n    if (trakType === 'soun') {\n      track.type = 'audio';\n    } else if (trakType === 'vide') {\n      track.type = 'video';\n    } else {\n      track.type = trakType;\n    }\n\n    var tkhd = findBox(trak, ['tkhd'])[0];\n\n    if (tkhd) {\n      var view = new DataView(tkhd.buffer, tkhd.byteOffset, tkhd.byteLength);\n      var tkhdVersion = view.getUint8(0);\n      track.number = tkhdVersion === 0 ? view.getUint32(12) : view.getUint32(20);\n    }\n\n    var mdhd = findBox(mdia, ['mdhd'])[0];\n\n    if (mdhd) {\n      // mdhd is a FullBox, meaning it will have its own version as the first byte\n      var version = mdhd[0];\n      var index = version === 0 ? 12 : 20;\n      track.timescale = (mdhd[index] << 24 | mdhd[index + 1] << 16 | mdhd[index + 2] << 8 | mdhd[index + 3]) >>> 0;\n    }\n\n    var stbl = findBox(mdia, ['minf', 'stbl'])[0];\n    var stsd = findBox(stbl, ['stsd'])[0];\n    var descriptionCount = bytesToNumber(stsd.subarray(4, 8));\n    var offset = 8; // add codec and codec info\n\n    while (descriptionCount--) {\n      var len = bytesToNumber(stsd.subarray(offset, offset + 4));\n      var sampleDescriptor = stsd.subarray(offset + 4, offset + 4 + len);\n      addSampleDescription(track, sampleDescriptor);\n      offset += 4 + len;\n    }\n\n    if (frameTable) {\n      track.frameTable = buildFrameTable(stbl, track.timescale);\n    } // codec has no sub parameters\n\n\n    tracks.push(track);\n  });\n  return tracks;\n};\nexport var parseMediaInfo = function parseMediaInfo(bytes) {\n  var mvhd = findBox(bytes, ['moov', 'mvhd'], true)[0];\n\n  if (!mvhd || !mvhd.length) {\n    return;\n  }\n\n  var info = {}; // ms to ns\n  // mvhd v1 has 8 byte duration and other fields too\n\n  if (mvhd[0] === 1) {\n    info.timestampScale = bytesToNumber(mvhd.subarray(20, 24));\n    info.duration = bytesToNumber(mvhd.subarray(24, 32));\n  } else {\n    info.timestampScale = bytesToNumber(mvhd.subarray(12, 16));\n    info.duration = bytesToNumber(mvhd.subarray(16, 20));\n  }\n\n  info.bytes = mvhd;\n  return info;\n};","export var OPUS_HEAD = new Uint8Array([// O, p, u, s\n0x4f, 0x70, 0x75, 0x73, // H, e, a, d\n0x48, 0x65, 0x61, 0x64]); // https://wiki.xiph.org/OggOpus\n// https://vfrmaniac.fushizen.eu/contents/opus_in_isobmff.html\n// https://opus-codec.org/docs/opusfile_api-0.7/structOpusHead.html\n\nexport var parseOpusHead = function parseOpusHead(bytes) {\n  var view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  var version = view.getUint8(0); // version 0, from mp4, does not use littleEndian.\n\n  var littleEndian = version !== 0;\n  var config = {\n    version: version,\n    channels: view.getUint8(1),\n    preSkip: view.getUint16(2, littleEndian),\n    sampleRate: view.getUint32(4, littleEndian),\n    outputGain: view.getUint16(8, littleEndian),\n    channelMappingFamily: view.getUint8(10)\n  };\n\n  if (config.channelMappingFamily > 0 && bytes.length > 10) {\n    config.streamCount = view.getUint8(11);\n    config.twoChannelStreamCount = view.getUint8(12);\n    config.channelMapping = [];\n\n    for (var c = 0; c < config.channels; c++) {\n      config.channelMapping.push(view.getUint8(13 + c));\n    }\n  }\n\n  return config;\n};\nexport var setOpusHead = function setOpusHead(config) {\n  var size = config.channelMappingFamily <= 0 ? 11 : 12 + config.channels;\n  var view = new DataView(new ArrayBuffer(size));\n  var littleEndian = config.version !== 0;\n  view.setUint8(0, config.version);\n  view.setUint8(1, config.channels);\n  view.setUint16(2, config.preSkip, littleEndian);\n  view.setUint32(4, config.sampleRate, littleEndian);\n  view.setUint16(8, config.outputGain, littleEndian);\n  view.setUint8(10, config.channelMappingFamily);\n\n  if (config.channelMappingFamily > 0) {\n    view.setUint8(11, config.streamCount);\n    config.channelMapping.foreach(function (cm, i) {\n      view.setUint8(12 + i, cm);\n    });\n  }\n\n  return new Uint8Array(view.buffer);\n};","import { toUint8, bytesToNumber, bytesMatch, bytesToString, numberToBytes, padStart } from './byte-helpers';\nimport { getAvcCodec, getHvcCodec, getAv1Codec } from './codec-helpers.js'; // relevant specs for this parser:\n// https://matroska-org.github.io/libebml/specs.html\n// https://www.matroska.org/technical/elements.html\n// https://www.webmproject.org/docs/container/\n\nexport var EBML_TAGS = {\n  EBML: toUint8([0x1A, 0x45, 0xDF, 0xA3]),\n  DocType: toUint8([0x42, 0x82]),\n  Segment: toUint8([0x18, 0x53, 0x80, 0x67]),\n  SegmentInfo: toUint8([0x15, 0x49, 0xA9, 0x66]),\n  Tracks: toUint8([0x16, 0x54, 0xAE, 0x6B]),\n  Track: toUint8([0xAE]),\n  TrackNumber: toUint8([0xd7]),\n  DefaultDuration: toUint8([0x23, 0xe3, 0x83]),\n  TrackEntry: toUint8([0xAE]),\n  TrackType: toUint8([0x83]),\n  FlagDefault: toUint8([0x88]),\n  CodecID: toUint8([0x86]),\n  CodecPrivate: toUint8([0x63, 0xA2]),\n  VideoTrack: toUint8([0xe0]),\n  AudioTrack: toUint8([0xe1]),\n  // Not used yet, but will be used for live webm/mkv\n  // see https://www.matroska.org/technical/basics.html#block-structure\n  // see https://www.matroska.org/technical/basics.html#simpleblock-structure\n  Cluster: toUint8([0x1F, 0x43, 0xB6, 0x75]),\n  Timestamp: toUint8([0xE7]),\n  TimestampScale: toUint8([0x2A, 0xD7, 0xB1]),\n  BlockGroup: toUint8([0xA0]),\n  BlockDuration: toUint8([0x9B]),\n  Block: toUint8([0xA1]),\n  SimpleBlock: toUint8([0xA3])\n};\n/**\n * This is a simple table to determine the length\n * of things in ebml. The length is one based (starts at 1,\n * rather than zero) and for every zero bit before a one bit\n * we add one to length. We also need this table because in some\n * case we have to xor all the length bits from another value.\n */\n\nvar LENGTH_TABLE = [128, 64, 32, 16, 8, 4, 2, 1];\n\nvar getLength = function getLength(byte) {\n  var len = 1;\n\n  for (var i = 0; i < LENGTH_TABLE.length; i++) {\n    if (byte & LENGTH_TABLE[i]) {\n      break;\n    }\n\n    len++;\n  }\n\n  return len;\n}; // length in ebml is stored in the first 4 to 8 bits\n// of the first byte. 4 for the id length and 8 for the\n// data size length. Length is measured by converting the number to binary\n// then 1 + the number of zeros before a 1 is encountered starting\n// from the left.\n\n\nvar getvint = function getvint(bytes, offset, removeLength, signed) {\n  if (removeLength === void 0) {\n    removeLength = true;\n  }\n\n  if (signed === void 0) {\n    signed = false;\n  }\n\n  var length = getLength(bytes[offset]);\n  var valueBytes = bytes.subarray(offset, offset + length); // NOTE that we do **not** subarray here because we need to copy these bytes\n  // as they will be modified below to remove the dataSizeLen bits and we do not\n  // want to modify the original data. normally we could just call slice on\n  // uint8array but ie 11 does not support that...\n\n  if (removeLength) {\n    valueBytes = Array.prototype.slice.call(bytes, offset, offset + length);\n    valueBytes[0] ^= LENGTH_TABLE[length - 1];\n  }\n\n  return {\n    length: length,\n    value: bytesToNumber(valueBytes, {\n      signed: signed\n    }),\n    bytes: valueBytes\n  };\n};\n\nvar normalizePath = function normalizePath(path) {\n  if (typeof path === 'string') {\n    return path.match(/.{1,2}/g).map(function (p) {\n      return normalizePath(p);\n    });\n  }\n\n  if (typeof path === 'number') {\n    return numberToBytes(path);\n  }\n\n  return path;\n};\n\nvar normalizePaths = function normalizePaths(paths) {\n  if (!Array.isArray(paths)) {\n    return [normalizePath(paths)];\n  }\n\n  return paths.map(function (p) {\n    return normalizePath(p);\n  });\n};\n\nvar getInfinityDataSize = function getInfinityDataSize(id, bytes, offset) {\n  if (offset >= bytes.length) {\n    return bytes.length;\n  }\n\n  var innerid = getvint(bytes, offset, false);\n\n  if (bytesMatch(id.bytes, innerid.bytes)) {\n    return offset;\n  }\n\n  var dataHeader = getvint(bytes, offset + innerid.length);\n  return getInfinityDataSize(id, bytes, offset + dataHeader.length + dataHeader.value + innerid.length);\n};\n/**\n * Notes on the EBLM format.\n *\n * EBLM uses \"vints\" tags. Every vint tag contains\n * two parts\n *\n * 1. The length from the first byte. You get this by\n *    converting the byte to binary and counting the zeros\n *    before a 1. Then you add 1 to that. Examples\n *    00011111 = length 4 because there are 3 zeros before a 1.\n *    00100000 = length 3 because there are 2 zeros before a 1.\n *    00000011 = length 7 because there are 6 zeros before a 1.\n *\n * 2. The bits used for length are removed from the first byte\n *    Then all the bytes are merged into a value. NOTE: this\n *    is not the case for id ebml tags as there id includes\n *    length bits.\n *\n */\n\n\nexport var findEbml = function findEbml(bytes, paths) {\n  paths = normalizePaths(paths);\n  bytes = toUint8(bytes);\n  var results = [];\n\n  if (!paths.length) {\n    return results;\n  }\n\n  var i = 0;\n\n  while (i < bytes.length) {\n    var id = getvint(bytes, i, false);\n    var dataHeader = getvint(bytes, i + id.length);\n    var dataStart = i + id.length + dataHeader.length; // dataSize is unknown or this is a live stream\n\n    if (dataHeader.value === 0x7f) {\n      dataHeader.value = getInfinityDataSize(id, bytes, dataStart);\n\n      if (dataHeader.value !== bytes.length) {\n        dataHeader.value -= dataStart;\n      }\n    }\n\n    var dataEnd = dataStart + dataHeader.value > bytes.length ? bytes.length : dataStart + dataHeader.value;\n    var data = bytes.subarray(dataStart, dataEnd);\n\n    if (bytesMatch(paths[0], id.bytes)) {\n      if (paths.length === 1) {\n        // this is the end of the paths and we've found the tag we were\n        // looking for\n        results.push(data);\n      } else {\n        // recursively search for the next tag inside of the data\n        // of this one\n        results = results.concat(findEbml(data, paths.slice(1)));\n      }\n    }\n\n    var totalLength = id.length + dataHeader.length + data.length; // move past this tag entirely, we are not looking for it\n\n    i += totalLength;\n  }\n\n  return results;\n}; // see https://www.matroska.org/technical/basics.html#block-structure\n\nexport var decodeBlock = function decodeBlock(block, type, timestampScale, clusterTimestamp) {\n  var duration;\n\n  if (type === 'group') {\n    duration = findEbml(block, [EBML_TAGS.BlockDuration])[0];\n\n    if (duration) {\n      duration = bytesToNumber(duration);\n      duration = 1 / timestampScale * duration * timestampScale / 1000;\n    }\n\n    block = findEbml(block, [EBML_TAGS.Block])[0];\n    type = 'block'; // treat data as a block after this point\n  }\n\n  var dv = new DataView(block.buffer, block.byteOffset, block.byteLength);\n  var trackNumber = getvint(block, 0);\n  var timestamp = dv.getInt16(trackNumber.length, false);\n  var flags = block[trackNumber.length + 2];\n  var data = block.subarray(trackNumber.length + 3); // pts/dts in seconds\n\n  var ptsdts = 1 / timestampScale * (clusterTimestamp + timestamp) * timestampScale / 1000; // return the frame\n\n  var parsed = {\n    duration: duration,\n    trackNumber: trackNumber.value,\n    keyframe: type === 'simple' && flags >> 7 === 1,\n    invisible: (flags & 0x08) >> 3 === 1,\n    lacing: (flags & 0x06) >> 1,\n    discardable: type === 'simple' && (flags & 0x01) === 1,\n    frames: [],\n    pts: ptsdts,\n    dts: ptsdts,\n    timestamp: timestamp\n  };\n\n  if (!parsed.lacing) {\n    parsed.frames.push(data);\n    return parsed;\n  }\n\n  var numberOfFrames = data[0] + 1;\n  var frameSizes = [];\n  var offset = 1; // Fixed\n\n  if (parsed.lacing === 2) {\n    var sizeOfFrame = (data.length - offset) / numberOfFrames;\n\n    for (var i = 0; i < numberOfFrames; i++) {\n      frameSizes.push(sizeOfFrame);\n    }\n  } // xiph\n\n\n  if (parsed.lacing === 1) {\n    for (var _i = 0; _i < numberOfFrames - 1; _i++) {\n      var size = 0;\n\n      do {\n        size += data[offset];\n        offset++;\n      } while (data[offset - 1] === 0xFF);\n\n      frameSizes.push(size);\n    }\n  } // ebml\n\n\n  if (parsed.lacing === 3) {\n    // first vint is unsinged\n    // after that vints are singed and\n    // based on a compounding size\n    var _size = 0;\n\n    for (var _i2 = 0; _i2 < numberOfFrames - 1; _i2++) {\n      var vint = _i2 === 0 ? getvint(data, offset) : getvint(data, offset, true, true);\n      _size += vint.value;\n      frameSizes.push(_size);\n      offset += vint.length;\n    }\n  }\n\n  frameSizes.forEach(function (size) {\n    parsed.frames.push(data.subarray(offset, offset + size));\n    offset += size;\n  });\n  return parsed;\n}; // VP9 Codec Feature Metadata (CodecPrivate)\n// https://www.webmproject.org/docs/container/\n\nvar parseVp9Private = function parseVp9Private(bytes) {\n  var i = 0;\n  var params = {};\n\n  while (i < bytes.length) {\n    var id = bytes[i] & 0x7f;\n    var len = bytes[i + 1];\n    var val = void 0;\n\n    if (len === 1) {\n      val = bytes[i + 2];\n    } else {\n      val = bytes.subarray(i + 2, i + 2 + len);\n    }\n\n    if (id === 1) {\n      params.profile = val;\n    } else if (id === 2) {\n      params.level = val;\n    } else if (id === 3) {\n      params.bitDepth = val;\n    } else if (id === 4) {\n      params.chromaSubsampling = val;\n    } else {\n      params[id] = val;\n    }\n\n    i += 2 + len;\n  }\n\n  return params;\n};\n\nexport var parseTracks = function parseTracks(bytes) {\n  bytes = toUint8(bytes);\n  var decodedTracks = [];\n  var tracks = findEbml(bytes, [EBML_TAGS.Segment, EBML_TAGS.Tracks, EBML_TAGS.Track]);\n\n  if (!tracks.length) {\n    tracks = findEbml(bytes, [EBML_TAGS.Tracks, EBML_TAGS.Track]);\n  }\n\n  if (!tracks.length) {\n    tracks = findEbml(bytes, [EBML_TAGS.Track]);\n  }\n\n  if (!tracks.length) {\n    return decodedTracks;\n  }\n\n  tracks.forEach(function (track) {\n    var trackType = findEbml(track, EBML_TAGS.TrackType)[0];\n\n    if (!trackType || !trackType.length) {\n      return;\n    } // 1 is video, 2 is audio, 17 is subtitle\n    // other values are unimportant in this context\n\n\n    if (trackType[0] === 1) {\n      trackType = 'video';\n    } else if (trackType[0] === 2) {\n      trackType = 'audio';\n    } else if (trackType[0] === 17) {\n      trackType = 'subtitle';\n    } else {\n      return;\n    } // todo parse language\n\n\n    var decodedTrack = {\n      rawCodec: bytesToString(findEbml(track, [EBML_TAGS.CodecID])[0]),\n      type: trackType,\n      codecPrivate: findEbml(track, [EBML_TAGS.CodecPrivate])[0],\n      number: bytesToNumber(findEbml(track, [EBML_TAGS.TrackNumber])[0]),\n      defaultDuration: bytesToNumber(findEbml(track, [EBML_TAGS.DefaultDuration])[0]),\n      default: findEbml(track, [EBML_TAGS.FlagDefault])[0],\n      rawData: track\n    };\n    var codec = '';\n\n    if (/V_MPEG4\\/ISO\\/AVC/.test(decodedTrack.rawCodec)) {\n      codec = \"avc1.\" + getAvcCodec(decodedTrack.codecPrivate);\n    } else if (/V_MPEGH\\/ISO\\/HEVC/.test(decodedTrack.rawCodec)) {\n      codec = \"hev1.\" + getHvcCodec(decodedTrack.codecPrivate);\n    } else if (/V_MPEG4\\/ISO\\/ASP/.test(decodedTrack.rawCodec)) {\n      if (decodedTrack.codecPrivate) {\n        codec = 'mp4v.20.' + decodedTrack.codecPrivate[4].toString();\n      } else {\n        codec = 'mp4v.20.9';\n      }\n    } else if (/^V_THEORA/.test(decodedTrack.rawCodec)) {\n      codec = 'theora';\n    } else if (/^V_VP8/.test(decodedTrack.rawCodec)) {\n      codec = 'vp8';\n    } else if (/^V_VP9/.test(decodedTrack.rawCodec)) {\n      if (decodedTrack.codecPrivate) {\n        var _parseVp9Private = parseVp9Private(decodedTrack.codecPrivate),\n            profile = _parseVp9Private.profile,\n            level = _parseVp9Private.level,\n            bitDepth = _parseVp9Private.bitDepth,\n            chromaSubsampling = _parseVp9Private.chromaSubsampling;\n\n        codec = 'vp09.';\n        codec += padStart(profile, 2, '0') + \".\";\n        codec += padStart(level, 2, '0') + \".\";\n        codec += padStart(bitDepth, 2, '0') + \".\";\n        codec += \"\" + padStart(chromaSubsampling, 2, '0'); // Video -> Colour -> Ebml name\n\n        var matrixCoefficients = findEbml(track, [0xE0, [0x55, 0xB0], [0x55, 0xB1]])[0] || [];\n        var videoFullRangeFlag = findEbml(track, [0xE0, [0x55, 0xB0], [0x55, 0xB9]])[0] || [];\n        var transferCharacteristics = findEbml(track, [0xE0, [0x55, 0xB0], [0x55, 0xBA]])[0] || [];\n        var colourPrimaries = findEbml(track, [0xE0, [0x55, 0xB0], [0x55, 0xBB]])[0] || []; // if we find any optional codec parameter specify them all.\n\n        if (matrixCoefficients.length || videoFullRangeFlag.length || transferCharacteristics.length || colourPrimaries.length) {\n          codec += \".\" + padStart(colourPrimaries[0], 2, '0');\n          codec += \".\" + padStart(transferCharacteristics[0], 2, '0');\n          codec += \".\" + padStart(matrixCoefficients[0], 2, '0');\n          codec += \".\" + padStart(videoFullRangeFlag[0], 2, '0');\n        }\n      } else {\n        codec = 'vp9';\n      }\n    } else if (/^V_AV1/.test(decodedTrack.rawCodec)) {\n      codec = \"av01.\" + getAv1Codec(decodedTrack.codecPrivate);\n    } else if (/A_ALAC/.test(decodedTrack.rawCodec)) {\n      codec = 'alac';\n    } else if (/A_MPEG\\/L2/.test(decodedTrack.rawCodec)) {\n      codec = 'mp2';\n    } else if (/A_MPEG\\/L3/.test(decodedTrack.rawCodec)) {\n      codec = 'mp3';\n    } else if (/^A_AAC/.test(decodedTrack.rawCodec)) {\n      if (decodedTrack.codecPrivate) {\n        codec = 'mp4a.40.' + (decodedTrack.codecPrivate[0] >>> 3).toString();\n      } else {\n        codec = 'mp4a.40.2';\n      }\n    } else if (/^A_AC3/.test(decodedTrack.rawCodec)) {\n      codec = 'ac-3';\n    } else if (/^A_PCM/.test(decodedTrack.rawCodec)) {\n      codec = 'pcm';\n    } else if (/^A_MS\\/ACM/.test(decodedTrack.rawCodec)) {\n      codec = 'speex';\n    } else if (/^A_EAC3/.test(decodedTrack.rawCodec)) {\n      codec = 'ec-3';\n    } else if (/^A_VORBIS/.test(decodedTrack.rawCodec)) {\n      codec = 'vorbis';\n    } else if (/^A_FLAC/.test(decodedTrack.rawCodec)) {\n      codec = 'flac';\n    } else if (/^A_OPUS/.test(decodedTrack.rawCodec)) {\n      codec = 'opus';\n    }\n\n    decodedTrack.codec = codec;\n    decodedTracks.push(decodedTrack);\n  });\n  return decodedTracks.sort(function (a, b) {\n    return a.number - b.number;\n  });\n};\nexport var parseData = function parseData(data, tracks) {\n  var allBlocks = [];\n  var segment = findEbml(data, [EBML_TAGS.Segment])[0];\n  var timestampScale = findEbml(segment, [EBML_TAGS.SegmentInfo, EBML_TAGS.TimestampScale])[0]; // in nanoseconds, defaults to 1ms\n\n  if (timestampScale && timestampScale.length) {\n    timestampScale = bytesToNumber(timestampScale);\n  } else {\n    timestampScale = 1000000;\n  }\n\n  var clusters = findEbml(segment, [EBML_TAGS.Cluster]);\n\n  if (!tracks) {\n    tracks = parseTracks(segment);\n  }\n\n  clusters.forEach(function (cluster, ci) {\n    var simpleBlocks = findEbml(cluster, [EBML_TAGS.SimpleBlock]).map(function (b) {\n      return {\n        type: 'simple',\n        data: b\n      };\n    });\n    var blockGroups = findEbml(cluster, [EBML_TAGS.BlockGroup]).map(function (b) {\n      return {\n        type: 'group',\n        data: b\n      };\n    });\n    var timestamp = findEbml(cluster, [EBML_TAGS.Timestamp])[0] || 0;\n\n    if (timestamp && timestamp.length) {\n      timestamp = bytesToNumber(timestamp);\n    } // get all blocks then sort them into the correct order\n\n\n    var blocks = simpleBlocks.concat(blockGroups).sort(function (a, b) {\n      return a.data.byteOffset - b.data.byteOffset;\n    });\n    blocks.forEach(function (block, bi) {\n      var decoded = decodeBlock(block.data, block.type, timestampScale, timestamp);\n      allBlocks.push(decoded);\n    });\n  });\n  return {\n    tracks: tracks,\n    blocks: allBlocks\n  };\n};","import { bytesMatch, toUint8 } from './byte-helpers.js';\nexport var NAL_TYPE_ONE = toUint8([0x00, 0x00, 0x00, 0x01]);\nexport var NAL_TYPE_TWO = toUint8([0x00, 0x00, 0x01]);\nexport var EMULATION_PREVENTION = toUint8([0x00, 0x00, 0x03]);\n/**\n * Expunge any \"Emulation Prevention\" bytes from a \"Raw Byte\n * Sequence Payload\"\n *\n * @param data {Uint8Array} the bytes of a RBSP from a NAL\n * unit\n * @return {Uint8Array} the RBSP without any Emulation\n * Prevention Bytes\n */\n\nexport var discardEmulationPreventionBytes = function discardEmulationPreventionBytes(bytes) {\n  var positions = [];\n  var i = 1; // Find all `Emulation Prevention Bytes`\n\n  while (i < bytes.length - 2) {\n    if (bytesMatch(bytes.subarray(i, i + 3), EMULATION_PREVENTION)) {\n      positions.push(i + 2);\n      i++;\n    }\n\n    i++;\n  } // If no Emulation Prevention Bytes were found just return the original\n  // array\n\n\n  if (positions.length === 0) {\n    return bytes;\n  } // Create a new array to hold the NAL unit data\n\n\n  var newLength = bytes.length - positions.length;\n  var newData = new Uint8Array(newLength);\n  var sourceIndex = 0;\n\n  for (i = 0; i < newLength; sourceIndex++, i++) {\n    if (sourceIndex === positions[0]) {\n      // Skip this byte\n      sourceIndex++; // Remove this position index\n\n      positions.shift();\n    }\n\n    newData[i] = bytes[sourceIndex];\n  }\n\n  return newData;\n};\nexport var findNal = function findNal(bytes, dataType, types, nalLimit) {\n  if (nalLimit === void 0) {\n    nalLimit = Infinity;\n  }\n\n  bytes = toUint8(bytes);\n  types = [].concat(types);\n  var i = 0;\n  var nalStart;\n  var nalsFound = 0; // keep searching until:\n  // we reach the end of bytes\n  // we reach the maximum number of nals they want to seach\n  // NOTE: that we disregard nalLimit when we have found the start\n  // of the nal we want so that we can find the end of the nal we want.\n\n  while (i < bytes.length && (nalsFound < nalLimit || nalStart)) {\n    var nalOffset = void 0;\n\n    if (bytesMatch(bytes.subarray(i), NAL_TYPE_ONE)) {\n      nalOffset = 4;\n    } else if (bytesMatch(bytes.subarray(i), NAL_TYPE_TWO)) {\n      nalOffset = 3;\n    } // we are unsynced,\n    // find the next nal unit\n\n\n    if (!nalOffset) {\n      i++;\n      continue;\n    }\n\n    nalsFound++;\n\n    if (nalStart) {\n      return discardEmulationPreventionBytes(bytes.subarray(nalStart, i));\n    }\n\n    var nalType = void 0;\n\n    if (dataType === 'h264') {\n      nalType = bytes[i + nalOffset] & 0x1f;\n    } else if (dataType === 'h265') {\n      nalType = bytes[i + nalOffset] >> 1 & 0x3f;\n    }\n\n    if (types.indexOf(nalType) !== -1) {\n      nalStart = i + nalOffset;\n    } // nal header is 1 length for h264, and 2 for h265\n\n\n    i += nalOffset + (dataType === 'h264' ? 1 : 2);\n  }\n\n  return bytes.subarray(0, 0);\n};\nexport var findH264Nal = function findH264Nal(bytes, type, nalLimit) {\n  return findNal(bytes, 'h264', type, nalLimit);\n};\nexport var findH265Nal = function findH265Nal(bytes, type, nalLimit) {\n  return findNal(bytes, 'h265', type, nalLimit);\n};","import { toUint8, bytesMatch } from './byte-helpers.js';\nimport { findBox } from './mp4-helpers.js';\nimport { findEbml, EBML_TAGS } from './ebml-helpers.js';\nimport { getId3Offset } from './id3-helpers.js';\nimport { findH264Nal, findH265Nal } from './nal-helpers.js';\nvar CONSTANTS = {\n  // \"webm\" string literal in hex\n  'webm': toUint8([0x77, 0x65, 0x62, 0x6d]),\n  // \"matroska\" string literal in hex\n  'matroska': toUint8([0x6d, 0x61, 0x74, 0x72, 0x6f, 0x73, 0x6b, 0x61]),\n  // \"fLaC\" string literal in hex\n  'flac': toUint8([0x66, 0x4c, 0x61, 0x43]),\n  // \"OggS\" string literal in hex\n  'ogg': toUint8([0x4f, 0x67, 0x67, 0x53]),\n  // ac-3 sync byte, also works for ec-3 as that is simply a codec\n  // of ac-3\n  'ac3': toUint8([0x0b, 0x77]),\n  // \"RIFF\" string literal in hex used for wav and avi\n  'riff': toUint8([0x52, 0x49, 0x46, 0x46]),\n  // \"AVI\" string literal in hex\n  'avi': toUint8([0x41, 0x56, 0x49]),\n  // \"WAVE\" string literal in hex\n  'wav': toUint8([0x57, 0x41, 0x56, 0x45]),\n  // \"ftyp3g\" string literal in hex\n  '3gp': toUint8([0x66, 0x74, 0x79, 0x70, 0x33, 0x67]),\n  // \"ftyp\" string literal in hex\n  'mp4': toUint8([0x66, 0x74, 0x79, 0x70]),\n  // \"styp\" string literal in hex\n  'fmp4': toUint8([0x73, 0x74, 0x79, 0x70]),\n  // \"ftypqt\" string literal in hex\n  'mov': toUint8([0x66, 0x74, 0x79, 0x70, 0x71, 0x74]),\n  // moov string literal in hex\n  'moov': toUint8([0x6D, 0x6F, 0x6F, 0x76]),\n  // moof string literal in hex\n  'moof': toUint8([0x6D, 0x6F, 0x6F, 0x66])\n};\nvar _isLikely = {\n  aac: function aac(bytes) {\n    var offset = getId3Offset(bytes);\n    return bytesMatch(bytes, [0xFF, 0x10], {\n      offset: offset,\n      mask: [0xFF, 0x16]\n    });\n  },\n  mp3: function mp3(bytes) {\n    var offset = getId3Offset(bytes);\n    return bytesMatch(bytes, [0xFF, 0x02], {\n      offset: offset,\n      mask: [0xFF, 0x06]\n    });\n  },\n  webm: function webm(bytes) {\n    var docType = findEbml(bytes, [EBML_TAGS.EBML, EBML_TAGS.DocType])[0]; // check if DocType EBML tag is webm\n\n    return bytesMatch(docType, CONSTANTS.webm);\n  },\n  mkv: function mkv(bytes) {\n    var docType = findEbml(bytes, [EBML_TAGS.EBML, EBML_TAGS.DocType])[0]; // check if DocType EBML tag is matroska\n\n    return bytesMatch(docType, CONSTANTS.matroska);\n  },\n  mp4: function mp4(bytes) {\n    // if this file is another base media file format, it is not mp4\n    if (_isLikely['3gp'](bytes) || _isLikely.mov(bytes)) {\n      return false;\n    } // if this file starts with a ftyp or styp box its mp4\n\n\n    if (bytesMatch(bytes, CONSTANTS.mp4, {\n      offset: 4\n    }) || bytesMatch(bytes, CONSTANTS.fmp4, {\n      offset: 4\n    })) {\n      return true;\n    } // if this file starts with a moof/moov box its mp4\n\n\n    if (bytesMatch(bytes, CONSTANTS.moof, {\n      offset: 4\n    }) || bytesMatch(bytes, CONSTANTS.moov, {\n      offset: 4\n    })) {\n      return true;\n    }\n  },\n  mov: function mov(bytes) {\n    return bytesMatch(bytes, CONSTANTS.mov, {\n      offset: 4\n    });\n  },\n  '3gp': function gp(bytes) {\n    return bytesMatch(bytes, CONSTANTS['3gp'], {\n      offset: 4\n    });\n  },\n  ac3: function ac3(bytes) {\n    var offset = getId3Offset(bytes);\n    return bytesMatch(bytes, CONSTANTS.ac3, {\n      offset: offset\n    });\n  },\n  ts: function ts(bytes) {\n    if (bytes.length < 189 && bytes.length >= 1) {\n      return bytes[0] === 0x47;\n    }\n\n    var i = 0; // check the first 376 bytes for two matching sync bytes\n\n    while (i + 188 < bytes.length && i < 188) {\n      if (bytes[i] === 0x47 && bytes[i + 188] === 0x47) {\n        return true;\n      }\n\n      i += 1;\n    }\n\n    return false;\n  },\n  flac: function flac(bytes) {\n    var offset = getId3Offset(bytes);\n    return bytesMatch(bytes, CONSTANTS.flac, {\n      offset: offset\n    });\n  },\n  ogg: function ogg(bytes) {\n    return bytesMatch(bytes, CONSTANTS.ogg);\n  },\n  avi: function avi(bytes) {\n    return bytesMatch(bytes, CONSTANTS.riff) && bytesMatch(bytes, CONSTANTS.avi, {\n      offset: 8\n    });\n  },\n  wav: function wav(bytes) {\n    return bytesMatch(bytes, CONSTANTS.riff) && bytesMatch(bytes, CONSTANTS.wav, {\n      offset: 8\n    });\n  },\n  'h264': function h264(bytes) {\n    // find seq_parameter_set_rbsp\n    return findH264Nal(bytes, 7, 3).length;\n  },\n  'h265': function h265(bytes) {\n    // find video_parameter_set_rbsp or seq_parameter_set_rbsp\n    return findH265Nal(bytes, [32, 33], 3).length;\n  }\n}; // get all the isLikely functions\n// but make sure 'ts' is above h264 and h265\n// but below everything else as it is the least specific\n\nvar isLikelyTypes = Object.keys(_isLikely) // remove ts, h264, h265\n.filter(function (t) {\n  return t !== 'ts' && t !== 'h264' && t !== 'h265';\n}) // add it back to the bottom\n.concat(['ts', 'h264', 'h265']); // make sure we are dealing with uint8 data.\n\nisLikelyTypes.forEach(function (type) {\n  var isLikelyFn = _isLikely[type];\n\n  _isLikely[type] = function (bytes) {\n    return isLikelyFn(toUint8(bytes));\n  };\n}); // export after wrapping\n\nexport var isLikely = _isLikely; // A useful list of file signatures can be found here\n// https://en.wikipedia.org/wiki/List_of_file_signatures\n\nexport var detectContainerForBytes = function detectContainerForBytes(bytes) {\n  bytes = toUint8(bytes);\n\n  for (var i = 0; i < isLikelyTypes.length; i++) {\n    var type = isLikelyTypes[i];\n\n    if (isLikely[type](bytes)) {\n      return type;\n    }\n  }\n\n  return '';\n}; // fmp4 is not a container\n\nexport var isLikelyFmp4MediaSegment = function isLikelyFmp4MediaSegment(bytes) {\n  return findBox(bytes, ['moof']).length > 0;\n};","import window from 'global/window';\n\nvar atob = function atob(s) {\n  return window.atob ? window.atob(s) : Buffer.from(s, 'base64').toString('binary');\n};\n\nexport default function decodeB64ToUint8Array(b64Text) {\n  var decodedString = atob(b64Text);\n  var array = new Uint8Array(decodedString.length);\n\n  for (var i = 0; i < decodedString.length; i++) {\n    array[i] = decodedString.charCodeAt(i);\n  }\n\n  return array;\n}","import { toUint8, bytesMatch } from './byte-helpers.js';\nvar ID3 = toUint8([0x49, 0x44, 0x33]);\nexport var getId3Size = function getId3Size(bytes, offset) {\n  if (offset === void 0) {\n    offset = 0;\n  }\n\n  bytes = toUint8(bytes);\n  var flags = bytes[offset + 5];\n  var returnSize = bytes[offset + 6] << 21 | bytes[offset + 7] << 14 | bytes[offset + 8] << 7 | bytes[offset + 9];\n  var footerPresent = (flags & 16) >> 4;\n\n  if (footerPresent) {\n    return returnSize + 20;\n  }\n\n  return returnSize + 10;\n};\nexport var getId3Offset = function getId3Offset(bytes, offset) {\n  if (offset === void 0) {\n    offset = 0;\n  }\n\n  bytes = toUint8(bytes);\n\n  if (bytes.length - offset < 10 || !bytesMatch(bytes, ID3, {\n    offset: offset\n  })) {\n    return offset;\n  }\n\n  offset += getId3Size(bytes, offset); // recursive check for id3 tags as some files\n  // have multiple ID3 tag sections even though\n  // they should not.\n\n  return getId3Offset(bytes, offset);\n};","var MPEGURL_REGEX = /^(audio|video|application)\\/(x-|vnd\\.apple\\.)?mpegurl/i;\nvar DASH_REGEX = /^application\\/dash\\+xml/i;\n/**\n * Returns a string that describes the type of source based on a video source object's\n * media type.\n *\n * @see {@link https://dev.w3.org/html5/pf-summary/video.html#dom-source-type|Source Type}\n *\n * @param {string} type\n *        Video source object media type\n * @return {('hls'|'dash'|'vhs-json'|null)}\n *         VHS source type string\n */\n\nexport var simpleTypeFromSourceType = function simpleTypeFromSourceType(type) {\n  if (MPEGURL_REGEX.test(type)) {\n    return 'hls';\n  }\n\n  if (DASH_REGEX.test(type)) {\n    return 'dash';\n  } // Denotes the special case of a manifest object passed to http-streaming instead of a\n  // source URL.\n  //\n  // See https://en.wikipedia.org/wiki/Media_type for details on specifying media types.\n  //\n  // In this case, vnd stands for vendor, video.js for the organization, VHS for this\n  // project, and the +json suffix identifies the structure of the media type.\n\n\n  if (type === 'application/vnd.videojs.vhs+json') {\n    return 'vhs-json';\n  }\n\n  return null;\n};","import URLToolkit from 'url-toolkit';\nimport window from 'global/window';\nvar DEFAULT_LOCATION = 'http://example.com';\n\nvar resolveUrl = function resolveUrl(baseUrl, relativeUrl) {\n  // return early if we don't need to resolve\n  if (/^[a-z]+:/i.test(relativeUrl)) {\n    return relativeUrl;\n  } // if baseUrl is a data URI, ignore it and resolve everything relative to window.location\n\n\n  if (/^data:/.test(baseUrl)) {\n    baseUrl = window.location && window.location.href || '';\n  } // IE11 supports URL but not the URL constructor\n  // feature detect the behavior we want\n\n\n  var nativeURL = typeof window.URL === 'function';\n  var protocolLess = /^\\/\\//.test(baseUrl); // remove location if window.location isn't available (i.e. we're in node)\n  // and if baseUrl isn't an absolute url\n\n  var removeLocation = !window.location && !/\\/\\//i.test(baseUrl); // if the base URL is relative then combine with the current location\n\n  if (nativeURL) {\n    baseUrl = new window.URL(baseUrl, window.location || DEFAULT_LOCATION);\n  } else if (!/\\/\\//i.test(baseUrl)) {\n    baseUrl = URLToolkit.buildAbsoluteURL(window.location && window.location.href || '', baseUrl);\n  }\n\n  if (nativeURL) {\n    var newUrl = new URL(relativeUrl, baseUrl); // if we're a protocol-less url, remove the protocol\n    // and if we're location-less, remove the location\n    // otherwise, return the url unmodified\n\n    if (removeLocation) {\n      return newUrl.href.slice(DEFAULT_LOCATION.length);\n    } else if (protocolLess) {\n      return newUrl.href.slice(newUrl.protocol.length);\n    }\n\n    return newUrl.href;\n  }\n\n  return URLToolkit.buildAbsoluteURL(baseUrl, relativeUrl);\n};\n\nexport default resolveUrl;","/**\n * @file stream.js\n */\n\n/**\n * A lightweight readable stream implemention that handles event dispatching.\n *\n * @class Stream\n */\nvar Stream = /*#__PURE__*/function () {\n  function Stream() {\n    this.listeners = {};\n  }\n  /**\n   * Add a listener for a specified event type.\n   *\n   * @param {string} type the event name\n   * @param {Function} listener the callback to be invoked when an event of\n   * the specified type occurs\n   */\n\n\n  var _proto = Stream.prototype;\n\n  _proto.on = function on(type, listener) {\n    if (!this.listeners[type]) {\n      this.listeners[type] = [];\n    }\n\n    this.listeners[type].push(listener);\n  }\n  /**\n   * Remove a listener for a specified event type.\n   *\n   * @param {string} type the event name\n   * @param {Function} listener  a function previously registered for this\n   * type of event through `on`\n   * @return {boolean} if we could turn it off or not\n   */\n  ;\n\n  _proto.off = function off(type, listener) {\n    if (!this.listeners[type]) {\n      return false;\n    }\n\n    var index = this.listeners[type].indexOf(listener); // TODO: which is better?\n    // In Video.js we slice listener functions\n    // on trigger so that it does not mess up the order\n    // while we loop through.\n    //\n    // Here we slice on off so that the loop in trigger\n    // can continue using it's old reference to loop without\n    // messing up the order.\n\n    this.listeners[type] = this.listeners[type].slice(0);\n    this.listeners[type].splice(index, 1);\n    return index > -1;\n  }\n  /**\n   * Trigger an event of the specified type on this stream. Any additional\n   * arguments to this function are passed as parameters to event listeners.\n   *\n   * @param {string} type the event name\n   */\n  ;\n\n  _proto.trigger = function trigger(type) {\n    var callbacks = this.listeners[type];\n\n    if (!callbacks) {\n      return;\n    } // Slicing the arguments on every invocation of this method\n    // can add a significant amount of overhead. Avoid the\n    // intermediate object creation for the common case of a\n    // single callback argument\n\n\n    if (arguments.length === 2) {\n      var length = callbacks.length;\n\n      for (var i = 0; i < length; ++i) {\n        callbacks[i].call(this, arguments[1]);\n      }\n    } else {\n      var args = Array.prototype.slice.call(arguments, 1);\n      var _length = callbacks.length;\n\n      for (var _i = 0; _i < _length; ++_i) {\n        callbacks[_i].apply(this, args);\n      }\n    }\n  }\n  /**\n   * Destroys the stream and cleans up.\n   */\n  ;\n\n  _proto.dispose = function dispose() {\n    this.listeners = {};\n  }\n  /**\n   * Forwards all `data` events on this stream to the destination stream. The\n   * destination stream should provide a method `push` to receive the data\n   * events as they arrive.\n   *\n   * @param {Stream} destination the stream that will receive all `data` events\n   * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options\n   */\n  ;\n\n  _proto.pipe = function pipe(destination) {\n    this.on('data', function (data) {\n      destination.push(data);\n    });\n  };\n\n  return Stream;\n}();\n\nexport { Stream as default };","\"use strict\";\n\nvar window = require('global/window');\n\nvar httpResponseHandler = function httpResponseHandler(callback, decodeResponseBody) {\n  if (decodeResponseBody === void 0) {\n    decodeResponseBody = false;\n  }\n\n  return function (err, response, responseBody) {\n    // if the XHR failed, return that error\n    if (err) {\n      callback(err);\n      return;\n    } // if the HTTP status code is 4xx or 5xx, the request also failed\n\n\n    if (response.statusCode >= 400 && response.statusCode <= 599) {\n      var cause = responseBody;\n\n      if (decodeResponseBody) {\n        if (window.TextDecoder) {\n          var charset = getCharset(response.headers && response.headers['content-type']);\n\n          try {\n            cause = new TextDecoder(charset).decode(responseBody);\n          } catch (e) {}\n        } else {\n          cause = String.fromCharCode.apply(null, new Uint8Array(responseBody));\n        }\n      }\n\n      callback({\n        cause: cause\n      });\n      return;\n    } // otherwise, request succeeded\n\n\n    callback(null, responseBody);\n  };\n};\n\nfunction getCharset(contentTypeHeader) {\n  if (contentTypeHeader === void 0) {\n    contentTypeHeader = '';\n  }\n\n  return contentTypeHeader.toLowerCase().split(';').reduce(function (charset, contentType) {\n    var _contentType$split = contentType.split('='),\n        type = _contentType$split[0],\n        value = _contentType$split[1];\n\n    if (type.trim() === 'charset') {\n      return value.trim();\n    }\n\n    return charset;\n  }, 'utf-8');\n}\n\nmodule.exports = httpResponseHandler;","\"use strict\";\n\nvar window = require(\"global/window\");\n\nvar _extends = require(\"@babel/runtime/helpers/extends\");\n\nvar isFunction = require('is-function');\n\ncreateXHR.httpHandler = require('./http-handler.js');\n/**\n * @license\n * slighly modified parse-headers 2.0.2 <https://github.com/kesla/parse-headers/>\n * Copyright (c) 2014 David Björklund\n * Available under the MIT license\n * <https://github.com/kesla/parse-headers/blob/master/LICENCE>\n */\n\nvar parseHeaders = function parseHeaders(headers) {\n  var result = {};\n\n  if (!headers) {\n    return result;\n  }\n\n  headers.trim().split('\\n').forEach(function (row) {\n    var index = row.indexOf(':');\n    var key = row.slice(0, index).trim().toLowerCase();\n    var value = row.slice(index + 1).trim();\n\n    if (typeof result[key] === 'undefined') {\n      result[key] = value;\n    } else if (Array.isArray(result[key])) {\n      result[key].push(value);\n    } else {\n      result[key] = [result[key], value];\n    }\n  });\n  return result;\n};\n\nmodule.exports = createXHR; // Allow use of default import syntax in TypeScript\n\nmodule.exports.default = createXHR;\ncreateXHR.XMLHttpRequest = window.XMLHttpRequest || noop;\ncreateXHR.XDomainRequest = \"withCredentials\" in new createXHR.XMLHttpRequest() ? createXHR.XMLHttpRequest : window.XDomainRequest;\nforEachArray([\"get\", \"put\", \"post\", \"patch\", \"head\", \"delete\"], function (method) {\n  createXHR[method === \"delete\" ? \"del\" : method] = function (uri, options, callback) {\n    options = initParams(uri, options, callback);\n    options.method = method.toUpperCase();\n    return _createXHR(options);\n  };\n});\n\nfunction forEachArray(array, iterator) {\n  for (var i = 0; i < array.length; i++) {\n    iterator(array[i]);\n  }\n}\n\nfunction isEmpty(obj) {\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) return false;\n  }\n\n  return true;\n}\n\nfunction initParams(uri, options, callback) {\n  var params = uri;\n\n  if (isFunction(options)) {\n    callback = options;\n\n    if (typeof uri === \"string\") {\n      params = {\n        uri: uri\n      };\n    }\n  } else {\n    params = _extends({}, options, {\n      uri: uri\n    });\n  }\n\n  params.callback = callback;\n  return params;\n}\n\nfunction createXHR(uri, options, callback) {\n  options = initParams(uri, options, callback);\n  return _createXHR(options);\n}\n\nfunction _createXHR(options) {\n  if (typeof options.callback === \"undefined\") {\n    throw new Error(\"callback argument missing\");\n  }\n\n  var called = false;\n\n  var callback = function cbOnce(err, response, body) {\n    if (!called) {\n      called = true;\n      options.callback(err, response, body);\n    }\n  };\n\n  function readystatechange() {\n    if (xhr.readyState === 4) {\n      setTimeout(loadFunc, 0);\n    }\n  }\n\n  function getBody() {\n    // Chrome with requestType=blob throws errors arround when even testing access to responseText\n    var body = undefined;\n\n    if (xhr.response) {\n      body = xhr.response;\n    } else {\n      body = xhr.responseText || getXml(xhr);\n    }\n\n    if (isJson) {\n      try {\n        body = JSON.parse(body);\n      } catch (e) {}\n    }\n\n    return body;\n  }\n\n  function errorFunc(evt) {\n    clearTimeout(timeoutTimer);\n\n    if (!(evt instanceof Error)) {\n      evt = new Error(\"\" + (evt || \"Unknown XMLHttpRequest Error\"));\n    }\n\n    evt.statusCode = 0;\n    return callback(evt, failureResponse);\n  } // will load the data & process the response in a special response object\n\n\n  function loadFunc() {\n    if (aborted) return;\n    var status;\n    clearTimeout(timeoutTimer);\n\n    if (options.useXDR && xhr.status === undefined) {\n      //IE8 CORS GET successful response doesn't have a status field, but body is fine\n      status = 200;\n    } else {\n      status = xhr.status === 1223 ? 204 : xhr.status;\n    }\n\n    var response = failureResponse;\n    var err = null;\n\n    if (status !== 0) {\n      response = {\n        body: getBody(),\n        statusCode: status,\n        method: method,\n        headers: {},\n        url: uri,\n        rawRequest: xhr\n      };\n\n      if (xhr.getAllResponseHeaders) {\n        //remember xhr can in fact be XDR for CORS in IE\n        response.headers = parseHeaders(xhr.getAllResponseHeaders());\n      }\n    } else {\n      err = new Error(\"Internal XMLHttpRequest Error\");\n    }\n\n    return callback(err, response, response.body);\n  }\n\n  var xhr = options.xhr || null;\n\n  if (!xhr) {\n    if (options.cors || options.useXDR) {\n      xhr = new createXHR.XDomainRequest();\n    } else {\n      xhr = new createXHR.XMLHttpRequest();\n    }\n  }\n\n  var key;\n  var aborted;\n  var uri = xhr.url = options.uri || options.url;\n  var method = xhr.method = options.method || \"GET\";\n  var body = options.body || options.data;\n  var headers = xhr.headers = options.headers || {};\n  var sync = !!options.sync;\n  var isJson = false;\n  var timeoutTimer;\n  var failureResponse = {\n    body: undefined,\n    headers: {},\n    statusCode: 0,\n    method: method,\n    url: uri,\n    rawRequest: xhr\n  };\n\n  if (\"json\" in options && options.json !== false) {\n    isJson = true;\n    headers[\"accept\"] || headers[\"Accept\"] || (headers[\"Accept\"] = \"application/json\"); //Don't override existing accept header declared by user\n\n    if (method !== \"GET\" && method !== \"HEAD\") {\n      headers[\"content-type\"] || headers[\"Content-Type\"] || (headers[\"Content-Type\"] = \"application/json\"); //Don't override existing accept header declared by user\n\n      body = JSON.stringify(options.json === true ? body : options.json);\n    }\n  }\n\n  xhr.onreadystatechange = readystatechange;\n  xhr.onload = loadFunc;\n  xhr.onerror = errorFunc; // IE9 must have onprogress be set to a unique function.\n\n  xhr.onprogress = function () {// IE must die\n  };\n\n  xhr.onabort = function () {\n    aborted = true;\n  };\n\n  xhr.ontimeout = errorFunc;\n  xhr.open(method, uri, !sync, options.username, options.password); //has to be after open\n\n  if (!sync) {\n    xhr.withCredentials = !!options.withCredentials;\n  } // Cannot set timeout with sync request\n  // not setting timeout on the xhr object, because of old webkits etc. not handling that correctly\n  // both npm's request and jquery 1.x use this kind of timeout, so this is being consistent\n\n\n  if (!sync && options.timeout > 0) {\n    timeoutTimer = setTimeout(function () {\n      if (aborted) return;\n      aborted = true; //IE9 may still call readystatechange\n\n      xhr.abort(\"timeout\");\n      var e = new Error(\"XMLHttpRequest timeout\");\n      e.code = \"ETIMEDOUT\";\n      errorFunc(e);\n    }, options.timeout);\n  }\n\n  if (xhr.setRequestHeader) {\n    for (key in headers) {\n      if (headers.hasOwnProperty(key)) {\n        xhr.setRequestHeader(key, headers[key]);\n      }\n    }\n  } else if (options.headers && !isEmpty(options.headers)) {\n    throw new Error(\"Headers cannot be set on an XDomainRequest object\");\n  }\n\n  if (\"responseType\" in options) {\n    xhr.responseType = options.responseType;\n  }\n\n  if (\"beforeSend\" in options && typeof options.beforeSend === \"function\") {\n    options.beforeSend(xhr);\n  } // Microsoft Edge browser sends \"undefined\" when send is called with undefined value.\n  // XMLHttpRequest spec says to pass null as body to indicate no body\n  // See https://github.com/naugtur/xhr/issues/100.\n\n\n  xhr.send(body || null);\n  return xhr;\n}\n\nfunction getXml(xhr) {\n  // xhr.responseXML will throw Exception \"InvalidStateError\" or \"DOMException\"\n  // See https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseXML.\n  try {\n    if (xhr.responseType === \"document\") {\n      return xhr.responseXML;\n    }\n\n    var firefoxBugTakenEffect = xhr.responseXML && xhr.responseXML.documentElement.nodeName === \"parsererror\";\n\n    if (xhr.responseType === \"\" && !firefoxBugTakenEffect) {\n      return xhr.responseXML;\n    }\n  } catch (e) {}\n\n  return null;\n}\n\nfunction noop() {}","/**\n * Copyright 2013 vtt.js Contributors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// Default exports for Node. Export the extended versions of VTTCue and\n// VTTRegion in Node since we likely want the capability to convert back and\n// forth between JSON. If we don't then it's not that big of a deal since we're\n// off browser.\n\nvar window = require('global/window');\n\nvar vttjs = module.exports = {\n  WebVTT: require(\"./vtt.js\"),\n  VTTCue: require(\"./vttcue.js\"),\n  VTTRegion: require(\"./vttregion.js\")\n};\n\nwindow.vttjs = vttjs;\nwindow.WebVTT = vttjs.WebVTT;\n\nvar cueShim = vttjs.VTTCue;\nvar regionShim = vttjs.VTTRegion;\nvar nativeVTTCue = window.VTTCue;\nvar nativeVTTRegion = window.VTTRegion;\n\nvttjs.shim = function() {\n  window.VTTCue = cueShim;\n  window.VTTRegion = regionShim;\n};\n\nvttjs.restore = function() {\n  window.VTTCue = nativeVTTCue;\n  window.VTTRegion = nativeVTTRegion;\n};\n\nif (!window.VTTCue) {\n  vttjs.shim();\n}\n","/**\n * Copyright 2013 vtt.js Contributors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */\n/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */\nvar document = require('global/document');\n\nvar _objCreate = Object.create || (function() {\n  function F() {}\n  return function(o) {\n    if (arguments.length !== 1) {\n      throw new Error('Object.create shim only accepts one parameter.');\n    }\n    F.prototype = o;\n    return new F();\n  };\n})();\n\n// Creates a new ParserError object from an errorData object. The errorData\n// object should have default code and message properties. The default message\n// property can be overriden by passing in a message parameter.\n// See ParsingError.Errors below for acceptable errors.\nfunction ParsingError(errorData, message) {\n  this.name = \"ParsingError\";\n  this.code = errorData.code;\n  this.message = message || errorData.message;\n}\nParsingError.prototype = _objCreate(Error.prototype);\nParsingError.prototype.constructor = ParsingError;\n\n// ParsingError metadata for acceptable ParsingErrors.\nParsingError.Errors = {\n  BadSignature: {\n    code: 0,\n    message: \"Malformed WebVTT signature.\"\n  },\n  BadTimeStamp: {\n    code: 1,\n    message: \"Malformed time stamp.\"\n  }\n};\n\n// Try to parse input as a time stamp.\nfunction parseTimeStamp(input) {\n\n  function computeSeconds(h, m, s, f) {\n    return (h | 0) * 3600 + (m | 0) * 60 + (s | 0) + (f | 0) / 1000;\n  }\n\n  var m = input.match(/^(\\d+):(\\d{1,2})(:\\d{1,2})?\\.(\\d{3})/);\n  if (!m) {\n    return null;\n  }\n\n  if (m[3]) {\n    // Timestamp takes the form of [hours]:[minutes]:[seconds].[milliseconds]\n    return computeSeconds(m[1], m[2], m[3].replace(\":\", \"\"), m[4]);\n  } else if (m[1] > 59) {\n    // Timestamp takes the form of [hours]:[minutes].[milliseconds]\n    // First position is hours as it's over 59.\n    return computeSeconds(m[1], m[2], 0,  m[4]);\n  } else {\n    // Timestamp takes the form of [minutes]:[seconds].[milliseconds]\n    return computeSeconds(0, m[1], m[2], m[4]);\n  }\n}\n\n// A settings object holds key/value pairs and will ignore anything but the first\n// assignment to a specific key.\nfunction Settings() {\n  this.values = _objCreate(null);\n}\n\nSettings.prototype = {\n  // Only accept the first assignment to any key.\n  set: function(k, v) {\n    if (!this.get(k) && v !== \"\") {\n      this.values[k] = v;\n    }\n  },\n  // Return the value for a key, or a default value.\n  // If 'defaultKey' is passed then 'dflt' is assumed to be an object with\n  // a number of possible default values as properties where 'defaultKey' is\n  // the key of the property that will be chosen; otherwise it's assumed to be\n  // a single value.\n  get: function(k, dflt, defaultKey) {\n    if (defaultKey) {\n      return this.has(k) ? this.values[k] : dflt[defaultKey];\n    }\n    return this.has(k) ? this.values[k] : dflt;\n  },\n  // Check whether we have a value for a key.\n  has: function(k) {\n    return k in this.values;\n  },\n  // Accept a setting if its one of the given alternatives.\n  alt: function(k, v, a) {\n    for (var n = 0; n < a.length; ++n) {\n      if (v === a[n]) {\n        this.set(k, v);\n        break;\n      }\n    }\n  },\n  // Accept a setting if its a valid (signed) integer.\n  integer: function(k, v) {\n    if (/^-?\\d+$/.test(v)) { // integer\n      this.set(k, parseInt(v, 10));\n    }\n  },\n  // Accept a setting if its a valid percentage.\n  percent: function(k, v) {\n    var m;\n    if ((m = v.match(/^([\\d]{1,3})(\\.[\\d]*)?%$/))) {\n      v = parseFloat(v);\n      if (v >= 0 && v <= 100) {\n        this.set(k, v);\n        return true;\n      }\n    }\n    return false;\n  }\n};\n\n// Helper function to parse input into groups separated by 'groupDelim', and\n// interprete each group as a key/value pair separated by 'keyValueDelim'.\nfunction parseOptions(input, callback, keyValueDelim, groupDelim) {\n  var groups = groupDelim ? input.split(groupDelim) : [input];\n  for (var i in groups) {\n    if (typeof groups[i] !== \"string\") {\n      continue;\n    }\n    var kv = groups[i].split(keyValueDelim);\n    if (kv.length !== 2) {\n      continue;\n    }\n    var k = kv[0];\n    var v = kv[1];\n    callback(k, v);\n  }\n}\n\nfunction parseCue(input, cue, regionList) {\n  // Remember the original input if we need to throw an error.\n  var oInput = input;\n  // 4.1 WebVTT timestamp\n  function consumeTimeStamp() {\n    var ts = parseTimeStamp(input);\n    if (ts === null) {\n      throw new ParsingError(ParsingError.Errors.BadTimeStamp,\n                            \"Malformed timestamp: \" + oInput);\n    }\n    // Remove time stamp from input.\n    input = input.replace(/^[^\\sa-zA-Z-]+/, \"\");\n    return ts;\n  }\n\n  // 4.4.2 WebVTT cue settings\n  function consumeCueSettings(input, cue) {\n    var settings = new Settings();\n\n    parseOptions(input, function (k, v) {\n      switch (k) {\n      case \"region\":\n        // Find the last region we parsed with the same region id.\n        for (var i = regionList.length - 1; i >= 0; i--) {\n          if (regionList[i].id === v) {\n            settings.set(k, regionList[i].region);\n            break;\n          }\n        }\n        break;\n      case \"vertical\":\n        settings.alt(k, v, [\"rl\", \"lr\"]);\n        break;\n      case \"line\":\n        var vals = v.split(\",\"),\n            vals0 = vals[0];\n        settings.integer(k, vals0);\n        settings.percent(k, vals0) ? settings.set(\"snapToLines\", false) : null;\n        settings.alt(k, vals0, [\"auto\"]);\n        if (vals.length === 2) {\n          settings.alt(\"lineAlign\", vals[1], [\"start\", \"center\", \"end\"]);\n        }\n        break;\n      case \"position\":\n        vals = v.split(\",\");\n        settings.percent(k, vals[0]);\n        if (vals.length === 2) {\n          settings.alt(\"positionAlign\", vals[1], [\"start\", \"center\", \"end\"]);\n        }\n        break;\n      case \"size\":\n        settings.percent(k, v);\n        break;\n      case \"align\":\n        settings.alt(k, v, [\"start\", \"center\", \"end\", \"left\", \"right\"]);\n        break;\n      }\n    }, /:/, /\\s/);\n\n    // Apply default values for any missing fields.\n    cue.region = settings.get(\"region\", null);\n    cue.vertical = settings.get(\"vertical\", \"\");\n    try {\n      cue.line = settings.get(\"line\", \"auto\");\n    } catch (e) {}\n    cue.lineAlign = settings.get(\"lineAlign\", \"start\");\n    cue.snapToLines = settings.get(\"snapToLines\", true);\n    cue.size = settings.get(\"size\", 100);\n    // Safari still uses the old middle value and won't accept center\n    try {\n      cue.align = settings.get(\"align\", \"center\");\n    } catch (e) {\n      cue.align = settings.get(\"align\", \"middle\");\n    }\n    try {\n      cue.position = settings.get(\"position\", \"auto\");\n    } catch (e) {\n      cue.position = settings.get(\"position\", {\n        start: 0,\n        left: 0,\n        center: 50,\n        middle: 50,\n        end: 100,\n        right: 100\n      }, cue.align);\n    }\n\n\n    cue.positionAlign = settings.get(\"positionAlign\", {\n      start: \"start\",\n      left: \"start\",\n      center: \"center\",\n      middle: \"center\",\n      end: \"end\",\n      right: \"end\"\n    }, cue.align);\n  }\n\n  function skipWhitespace() {\n    input = input.replace(/^\\s+/, \"\");\n  }\n\n  // 4.1 WebVTT cue timings.\n  skipWhitespace();\n  cue.startTime = consumeTimeStamp();   // (1) collect cue start time\n  skipWhitespace();\n  if (input.substr(0, 3) !== \"-->\") {     // (3) next characters must match \"-->\"\n    throw new ParsingError(ParsingError.Errors.BadTimeStamp,\n                           \"Malformed time stamp (time stamps must be separated by '-->'): \" +\n                           oInput);\n  }\n  input = input.substr(3);\n  skipWhitespace();\n  cue.endTime = consumeTimeStamp();     // (5) collect cue end time\n\n  // 4.1 WebVTT cue settings list.\n  skipWhitespace();\n  consumeCueSettings(input, cue);\n}\n\n// When evaluating this file as part of a Webpack bundle for server\n// side rendering, `document` is an empty object.\nvar TEXTAREA_ELEMENT = document.createElement && document.createElement(\"textarea\");\n\nvar TAG_NAME = {\n  c: \"span\",\n  i: \"i\",\n  b: \"b\",\n  u: \"u\",\n  ruby: \"ruby\",\n  rt: \"rt\",\n  v: \"span\",\n  lang: \"span\"\n};\n\n// 5.1 default text color\n// 5.2 default text background color is equivalent to text color with bg_ prefix\nvar DEFAULT_COLOR_CLASS = {\n  white: 'rgba(255,255,255,1)',\n  lime: 'rgba(0,255,0,1)',\n  cyan: 'rgba(0,255,255,1)',\n  red: 'rgba(255,0,0,1)',\n  yellow: 'rgba(255,255,0,1)',\n  magenta: 'rgba(255,0,255,1)',\n  blue: 'rgba(0,0,255,1)',\n  black: 'rgba(0,0,0,1)'\n};\n\nvar TAG_ANNOTATION = {\n  v: \"title\",\n  lang: \"lang\"\n};\n\nvar NEEDS_PARENT = {\n  rt: \"ruby\"\n};\n\n// Parse content into a document fragment.\nfunction parseContent(window, input) {\n  function nextToken() {\n    // Check for end-of-string.\n    if (!input) {\n      return null;\n    }\n\n    // Consume 'n' characters from the input.\n    function consume(result) {\n      input = input.substr(result.length);\n      return result;\n    }\n\n    var m = input.match(/^([^<]*)(<[^>]*>?)?/);\n    // If there is some text before the next tag, return it, otherwise return\n    // the tag.\n    return consume(m[1] ? m[1] : m[2]);\n  }\n\n  function unescape(s) {\n    TEXTAREA_ELEMENT.innerHTML = s;\n    s = TEXTAREA_ELEMENT.textContent;\n    TEXTAREA_ELEMENT.textContent = \"\";\n    return s;\n  }\n\n  function shouldAdd(current, element) {\n    return !NEEDS_PARENT[element.localName] ||\n           NEEDS_PARENT[element.localName] === current.localName;\n  }\n\n  // Create an element for this tag.\n  function createElement(type, annotation) {\n    var tagName = TAG_NAME[type];\n    if (!tagName) {\n      return null;\n    }\n    var element = window.document.createElement(tagName);\n    var name = TAG_ANNOTATION[type];\n    if (name && annotation) {\n      element[name] = annotation.trim();\n    }\n    return element;\n  }\n\n  var rootDiv = window.document.createElement(\"div\"),\n      current = rootDiv,\n      t,\n      tagStack = [];\n\n  while ((t = nextToken()) !== null) {\n    if (t[0] === '<') {\n      if (t[1] === \"/\") {\n        // If the closing tag matches, move back up to the parent node.\n        if (tagStack.length &&\n            tagStack[tagStack.length - 1] === t.substr(2).replace(\">\", \"\")) {\n          tagStack.pop();\n          current = current.parentNode;\n        }\n        // Otherwise just ignore the end tag.\n        continue;\n      }\n      var ts = parseTimeStamp(t.substr(1, t.length - 2));\n      var node;\n      if (ts) {\n        // Timestamps are lead nodes as well.\n        node = window.document.createProcessingInstruction(\"timestamp\", ts);\n        current.appendChild(node);\n        continue;\n      }\n      var m = t.match(/^<([^.\\s/0-9>]+)(\\.[^\\s\\\\>]+)?([^>\\\\]+)?(\\\\?)>?$/);\n      // If we can't parse the tag, skip to the next tag.\n      if (!m) {\n        continue;\n      }\n      // Try to construct an element, and ignore the tag if we couldn't.\n      node = createElement(m[1], m[3]);\n      if (!node) {\n        continue;\n      }\n      // Determine if the tag should be added based on the context of where it\n      // is placed in the cuetext.\n      if (!shouldAdd(current, node)) {\n        continue;\n      }\n      // Set the class list (as a list of classes, separated by space).\n      if (m[2]) {\n        var classes = m[2].split('.');\n\n        classes.forEach(function(cl) {\n          var bgColor = /^bg_/.test(cl);\n          // slice out `bg_` if it's a background color\n          var colorName = bgColor ? cl.slice(3) : cl;\n\n          if (DEFAULT_COLOR_CLASS.hasOwnProperty(colorName)) {\n            var propName = bgColor ? 'background-color' : 'color';\n            var propValue = DEFAULT_COLOR_CLASS[colorName];\n\n            node.style[propName] = propValue;\n          }\n        });\n\n        node.className = classes.join(' ');\n      }\n      // Append the node to the current node, and enter the scope of the new\n      // node.\n      tagStack.push(m[1]);\n      current.appendChild(node);\n      current = node;\n      continue;\n    }\n\n    // Text nodes are leaf nodes.\n    current.appendChild(window.document.createTextNode(unescape(t)));\n  }\n\n  return rootDiv;\n}\n\n// This is a list of all the Unicode characters that have a strong\n// right-to-left category. What this means is that these characters are\n// written right-to-left for sure. It was generated by pulling all the strong\n// right-to-left characters out of the Unicode data table. That table can\n// found at: http://www.unicode.org/Public/UNIDATA/UnicodeData.txt\nvar strongRTLRanges = [[0x5be, 0x5be], [0x5c0, 0x5c0], [0x5c3, 0x5c3], [0x5c6, 0x5c6],\n [0x5d0, 0x5ea], [0x5f0, 0x5f4], [0x608, 0x608], [0x60b, 0x60b], [0x60d, 0x60d],\n [0x61b, 0x61b], [0x61e, 0x64a], [0x66d, 0x66f], [0x671, 0x6d5], [0x6e5, 0x6e6],\n [0x6ee, 0x6ef], [0x6fa, 0x70d], [0x70f, 0x710], [0x712, 0x72f], [0x74d, 0x7a5],\n [0x7b1, 0x7b1], [0x7c0, 0x7ea], [0x7f4, 0x7f5], [0x7fa, 0x7fa], [0x800, 0x815],\n [0x81a, 0x81a], [0x824, 0x824], [0x828, 0x828], [0x830, 0x83e], [0x840, 0x858],\n [0x85e, 0x85e], [0x8a0, 0x8a0], [0x8a2, 0x8ac], [0x200f, 0x200f],\n [0xfb1d, 0xfb1d], [0xfb1f, 0xfb28], [0xfb2a, 0xfb36], [0xfb38, 0xfb3c],\n [0xfb3e, 0xfb3e], [0xfb40, 0xfb41], [0xfb43, 0xfb44], [0xfb46, 0xfbc1],\n [0xfbd3, 0xfd3d], [0xfd50, 0xfd8f], [0xfd92, 0xfdc7], [0xfdf0, 0xfdfc],\n [0xfe70, 0xfe74], [0xfe76, 0xfefc], [0x10800, 0x10805], [0x10808, 0x10808],\n [0x1080a, 0x10835], [0x10837, 0x10838], [0x1083c, 0x1083c], [0x1083f, 0x10855],\n [0x10857, 0x1085f], [0x10900, 0x1091b], [0x10920, 0x10939], [0x1093f, 0x1093f],\n [0x10980, 0x109b7], [0x109be, 0x109bf], [0x10a00, 0x10a00], [0x10a10, 0x10a13],\n [0x10a15, 0x10a17], [0x10a19, 0x10a33], [0x10a40, 0x10a47], [0x10a50, 0x10a58],\n [0x10a60, 0x10a7f], [0x10b00, 0x10b35], [0x10b40, 0x10b55], [0x10b58, 0x10b72],\n [0x10b78, 0x10b7f], [0x10c00, 0x10c48], [0x1ee00, 0x1ee03], [0x1ee05, 0x1ee1f],\n [0x1ee21, 0x1ee22], [0x1ee24, 0x1ee24], [0x1ee27, 0x1ee27], [0x1ee29, 0x1ee32],\n [0x1ee34, 0x1ee37], [0x1ee39, 0x1ee39], [0x1ee3b, 0x1ee3b], [0x1ee42, 0x1ee42],\n [0x1ee47, 0x1ee47], [0x1ee49, 0x1ee49], [0x1ee4b, 0x1ee4b], [0x1ee4d, 0x1ee4f],\n [0x1ee51, 0x1ee52], [0x1ee54, 0x1ee54], [0x1ee57, 0x1ee57], [0x1ee59, 0x1ee59],\n [0x1ee5b, 0x1ee5b], [0x1ee5d, 0x1ee5d], [0x1ee5f, 0x1ee5f], [0x1ee61, 0x1ee62],\n [0x1ee64, 0x1ee64], [0x1ee67, 0x1ee6a], [0x1ee6c, 0x1ee72], [0x1ee74, 0x1ee77],\n [0x1ee79, 0x1ee7c], [0x1ee7e, 0x1ee7e], [0x1ee80, 0x1ee89], [0x1ee8b, 0x1ee9b],\n [0x1eea1, 0x1eea3], [0x1eea5, 0x1eea9], [0x1eeab, 0x1eebb], [0x10fffd, 0x10fffd]];\n\nfunction isStrongRTLChar(charCode) {\n  for (var i = 0; i < strongRTLRanges.length; i++) {\n    var currentRange = strongRTLRanges[i];\n    if (charCode >= currentRange[0] && charCode <= currentRange[1]) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction determineBidi(cueDiv) {\n  var nodeStack = [],\n      text = \"\",\n      charCode;\n\n  if (!cueDiv || !cueDiv.childNodes) {\n    return \"ltr\";\n  }\n\n  function pushNodes(nodeStack, node) {\n    for (var i = node.childNodes.length - 1; i >= 0; i--) {\n      nodeStack.push(node.childNodes[i]);\n    }\n  }\n\n  function nextTextNode(nodeStack) {\n    if (!nodeStack || !nodeStack.length) {\n      return null;\n    }\n\n    var node = nodeStack.pop(),\n        text = node.textContent || node.innerText;\n    if (text) {\n      // TODO: This should match all unicode type B characters (paragraph\n      // separator characters). See issue #115.\n      var m = text.match(/^.*(\\n|\\r)/);\n      if (m) {\n        nodeStack.length = 0;\n        return m[0];\n      }\n      return text;\n    }\n    if (node.tagName === \"ruby\") {\n      return nextTextNode(nodeStack);\n    }\n    if (node.childNodes) {\n      pushNodes(nodeStack, node);\n      return nextTextNode(nodeStack);\n    }\n  }\n\n  pushNodes(nodeStack, cueDiv);\n  while ((text = nextTextNode(nodeStack))) {\n    for (var i = 0; i < text.length; i++) {\n      charCode = text.charCodeAt(i);\n      if (isStrongRTLChar(charCode)) {\n        return \"rtl\";\n      }\n    }\n  }\n  return \"ltr\";\n}\n\nfunction computeLinePos(cue) {\n  if (typeof cue.line === \"number\" &&\n      (cue.snapToLines || (cue.line >= 0 && cue.line <= 100))) {\n    return cue.line;\n  }\n  if (!cue.track || !cue.track.textTrackList ||\n      !cue.track.textTrackList.mediaElement) {\n    return -1;\n  }\n  var track = cue.track,\n      trackList = track.textTrackList,\n      count = 0;\n  for (var i = 0; i < trackList.length && trackList[i] !== track; i++) {\n    if (trackList[i].mode === \"showing\") {\n      count++;\n    }\n  }\n  return ++count * -1;\n}\n\nfunction StyleBox() {\n}\n\n// Apply styles to a div. If there is no div passed then it defaults to the\n// div on 'this'.\nStyleBox.prototype.applyStyles = function(styles, div) {\n  div = div || this.div;\n  for (var prop in styles) {\n    if (styles.hasOwnProperty(prop)) {\n      div.style[prop] = styles[prop];\n    }\n  }\n};\n\nStyleBox.prototype.formatStyle = function(val, unit) {\n  return val === 0 ? 0 : val + unit;\n};\n\n// Constructs the computed display state of the cue (a div). Places the div\n// into the overlay which should be a block level element (usually a div).\nfunction CueStyleBox(window, cue, styleOptions) {\n  StyleBox.call(this);\n  this.cue = cue;\n\n  // Parse our cue's text into a DOM tree rooted at 'cueDiv'. This div will\n  // have inline positioning and will function as the cue background box.\n  this.cueDiv = parseContent(window, cue.text);\n  var styles = {\n    color: \"rgba(255, 255, 255, 1)\",\n    backgroundColor:  \"rgba(0, 0, 0, 0.8)\",\n    position: \"relative\",\n    left: 0,\n    right: 0,\n    top: 0,\n    bottom: 0,\n    display: \"inline\",\n    writingMode: cue.vertical === \"\" ? \"horizontal-tb\"\n                                     : cue.vertical === \"lr\" ? \"vertical-lr\"\n                                                             : \"vertical-rl\",\n    unicodeBidi: \"plaintext\"\n  };\n\n  this.applyStyles(styles, this.cueDiv);\n\n  // Create an absolutely positioned div that will be used to position the cue\n  // div. Note, all WebVTT cue-setting alignments are equivalent to the CSS\n  // mirrors of them except middle instead of center on Safari.\n  this.div = window.document.createElement(\"div\");\n  styles = {\n    direction: determineBidi(this.cueDiv),\n    writingMode: cue.vertical === \"\" ? \"horizontal-tb\"\n                                     : cue.vertical === \"lr\" ? \"vertical-lr\"\n                                                             : \"vertical-rl\",\n    unicodeBidi: \"plaintext\",\n    textAlign: cue.align === \"middle\" ? \"center\" : cue.align,\n    font: styleOptions.font,\n    whiteSpace: \"pre-line\",\n    position: \"absolute\"\n  };\n\n  this.applyStyles(styles);\n  this.div.appendChild(this.cueDiv);\n\n  // Calculate the distance from the reference edge of the viewport to the text\n  // position of the cue box. The reference edge will be resolved later when\n  // the box orientation styles are applied.\n  var textPos = 0;\n  switch (cue.positionAlign) {\n  case \"start\":\n    textPos = cue.position;\n    break;\n  case \"center\":\n    textPos = cue.position - (cue.size / 2);\n    break;\n  case \"end\":\n    textPos = cue.position - cue.size;\n    break;\n  }\n\n  // Horizontal box orientation; textPos is the distance from the left edge of the\n  // area to the left edge of the box and cue.size is the distance extending to\n  // the right from there.\n  if (cue.vertical === \"\") {\n    this.applyStyles({\n      left:  this.formatStyle(textPos, \"%\"),\n      width: this.formatStyle(cue.size, \"%\")\n    });\n  // Vertical box orientation; textPos is the distance from the top edge of the\n  // area to the top edge of the box and cue.size is the height extending\n  // downwards from there.\n  } else {\n    this.applyStyles({\n      top: this.formatStyle(textPos, \"%\"),\n      height: this.formatStyle(cue.size, \"%\")\n    });\n  }\n\n  this.move = function(box) {\n    this.applyStyles({\n      top: this.formatStyle(box.top, \"px\"),\n      bottom: this.formatStyle(box.bottom, \"px\"),\n      left: this.formatStyle(box.left, \"px\"),\n      right: this.formatStyle(box.right, \"px\"),\n      height: this.formatStyle(box.height, \"px\"),\n      width: this.formatStyle(box.width, \"px\")\n    });\n  };\n}\nCueStyleBox.prototype = _objCreate(StyleBox.prototype);\nCueStyleBox.prototype.constructor = CueStyleBox;\n\n// Represents the co-ordinates of an Element in a way that we can easily\n// compute things with such as if it overlaps or intersects with another Element.\n// Can initialize it with either a StyleBox or another BoxPosition.\nfunction BoxPosition(obj) {\n  // Either a BoxPosition was passed in and we need to copy it, or a StyleBox\n  // was passed in and we need to copy the results of 'getBoundingClientRect'\n  // as the object returned is readonly. All co-ordinate values are in reference\n  // to the viewport origin (top left).\n  var lh, height, width, top;\n  if (obj.div) {\n    height = obj.div.offsetHeight;\n    width = obj.div.offsetWidth;\n    top = obj.div.offsetTop;\n\n    var rects = (rects = obj.div.childNodes) && (rects = rects[0]) &&\n                rects.getClientRects && rects.getClientRects();\n    obj = obj.div.getBoundingClientRect();\n    // In certain cases the outter div will be slightly larger then the sum of\n    // the inner div's lines. This could be due to bold text, etc, on some platforms.\n    // In this case we should get the average line height and use that. This will\n    // result in the desired behaviour.\n    lh = rects ? Math.max((rects[0] && rects[0].height) || 0, obj.height / rects.length)\n               : 0;\n\n  }\n  this.left = obj.left;\n  this.right = obj.right;\n  this.top = obj.top || top;\n  this.height = obj.height || height;\n  this.bottom = obj.bottom || (top + (obj.height || height));\n  this.width = obj.width || width;\n  this.lineHeight = lh !== undefined ? lh : obj.lineHeight;\n}\n\n// Move the box along a particular axis. Optionally pass in an amount to move\n// the box. If no amount is passed then the default is the line height of the\n// box.\nBoxPosition.prototype.move = function(axis, toMove) {\n  toMove = toMove !== undefined ? toMove : this.lineHeight;\n  switch (axis) {\n  case \"+x\":\n    this.left += toMove;\n    this.right += toMove;\n    break;\n  case \"-x\":\n    this.left -= toMove;\n    this.right -= toMove;\n    break;\n  case \"+y\":\n    this.top += toMove;\n    this.bottom += toMove;\n    break;\n  case \"-y\":\n    this.top -= toMove;\n    this.bottom -= toMove;\n    break;\n  }\n};\n\n// Check if this box overlaps another box, b2.\nBoxPosition.prototype.overlaps = function(b2) {\n  return this.left < b2.right &&\n         this.right > b2.left &&\n         this.top < b2.bottom &&\n         this.bottom > b2.top;\n};\n\n// Check if this box overlaps any other boxes in boxes.\nBoxPosition.prototype.overlapsAny = function(boxes) {\n  for (var i = 0; i < boxes.length; i++) {\n    if (this.overlaps(boxes[i])) {\n      return true;\n    }\n  }\n  return false;\n};\n\n// Check if this box is within another box.\nBoxPosition.prototype.within = function(container) {\n  return this.top >= container.top &&\n         this.bottom <= container.bottom &&\n         this.left >= container.left &&\n         this.right <= container.right;\n};\n\n// Check if this box is entirely within the container or it is overlapping\n// on the edge opposite of the axis direction passed. For example, if \"+x\" is\n// passed and the box is overlapping on the left edge of the container, then\n// return true.\nBoxPosition.prototype.overlapsOppositeAxis = function(container, axis) {\n  switch (axis) {\n  case \"+x\":\n    return this.left < container.left;\n  case \"-x\":\n    return this.right > container.right;\n  case \"+y\":\n    return this.top < container.top;\n  case \"-y\":\n    return this.bottom > container.bottom;\n  }\n};\n\n// Find the percentage of the area that this box is overlapping with another\n// box.\nBoxPosition.prototype.intersectPercentage = function(b2) {\n  var x = Math.max(0, Math.min(this.right, b2.right) - Math.max(this.left, b2.left)),\n      y = Math.max(0, Math.min(this.bottom, b2.bottom) - Math.max(this.top, b2.top)),\n      intersectArea = x * y;\n  return intersectArea / (this.height * this.width);\n};\n\n// Convert the positions from this box to CSS compatible positions using\n// the reference container's positions. This has to be done because this\n// box's positions are in reference to the viewport origin, whereas, CSS\n// values are in referecne to their respective edges.\nBoxPosition.prototype.toCSSCompatValues = function(reference) {\n  return {\n    top: this.top - reference.top,\n    bottom: reference.bottom - this.bottom,\n    left: this.left - reference.left,\n    right: reference.right - this.right,\n    height: this.height,\n    width: this.width\n  };\n};\n\n// Get an object that represents the box's position without anything extra.\n// Can pass a StyleBox, HTMLElement, or another BoxPositon.\nBoxPosition.getSimpleBoxPosition = function(obj) {\n  var height = obj.div ? obj.div.offsetHeight : obj.tagName ? obj.offsetHeight : 0;\n  var width = obj.div ? obj.div.offsetWidth : obj.tagName ? obj.offsetWidth : 0;\n  var top = obj.div ? obj.div.offsetTop : obj.tagName ? obj.offsetTop : 0;\n\n  obj = obj.div ? obj.div.getBoundingClientRect() :\n                obj.tagName ? obj.getBoundingClientRect() : obj;\n  var ret = {\n    left: obj.left,\n    right: obj.right,\n    top: obj.top || top,\n    height: obj.height || height,\n    bottom: obj.bottom || (top + (obj.height || height)),\n    width: obj.width || width\n  };\n  return ret;\n};\n\n// Move a StyleBox to its specified, or next best, position. The containerBox\n// is the box that contains the StyleBox, such as a div. boxPositions are\n// a list of other boxes that the styleBox can't overlap with.\nfunction moveBoxToLinePosition(window, styleBox, containerBox, boxPositions) {\n\n  // Find the best position for a cue box, b, on the video. The axis parameter\n  // is a list of axis, the order of which, it will move the box along. For example:\n  // Passing [\"+x\", \"-x\"] will move the box first along the x axis in the positive\n  // direction. If it doesn't find a good position for it there it will then move\n  // it along the x axis in the negative direction.\n  function findBestPosition(b, axis) {\n    var bestPosition,\n        specifiedPosition = new BoxPosition(b),\n        percentage = 1; // Highest possible so the first thing we get is better.\n\n    for (var i = 0; i < axis.length; i++) {\n      while (b.overlapsOppositeAxis(containerBox, axis[i]) ||\n             (b.within(containerBox) && b.overlapsAny(boxPositions))) {\n        b.move(axis[i]);\n      }\n      // We found a spot where we aren't overlapping anything. This is our\n      // best position.\n      if (b.within(containerBox)) {\n        return b;\n      }\n      var p = b.intersectPercentage(containerBox);\n      // If we're outside the container box less then we were on our last try\n      // then remember this position as the best position.\n      if (percentage > p) {\n        bestPosition = new BoxPosition(b);\n        percentage = p;\n      }\n      // Reset the box position to the specified position.\n      b = new BoxPosition(specifiedPosition);\n    }\n    return bestPosition || specifiedPosition;\n  }\n\n  var boxPosition = new BoxPosition(styleBox),\n      cue = styleBox.cue,\n      linePos = computeLinePos(cue),\n      axis = [];\n\n  // If we have a line number to align the cue to.\n  if (cue.snapToLines) {\n    var size;\n    switch (cue.vertical) {\n    case \"\":\n      axis = [ \"+y\", \"-y\" ];\n      size = \"height\";\n      break;\n    case \"rl\":\n      axis = [ \"+x\", \"-x\" ];\n      size = \"width\";\n      break;\n    case \"lr\":\n      axis = [ \"-x\", \"+x\" ];\n      size = \"width\";\n      break;\n    }\n\n    var step = boxPosition.lineHeight,\n        position = step * Math.round(linePos),\n        maxPosition = containerBox[size] + step,\n        initialAxis = axis[0];\n\n    // If the specified intial position is greater then the max position then\n    // clamp the box to the amount of steps it would take for the box to\n    // reach the max position.\n    if (Math.abs(position) > maxPosition) {\n      position = position < 0 ? -1 : 1;\n      position *= Math.ceil(maxPosition / step) * step;\n    }\n\n    // If computed line position returns negative then line numbers are\n    // relative to the bottom of the video instead of the top. Therefore, we\n    // need to increase our initial position by the length or width of the\n    // video, depending on the writing direction, and reverse our axis directions.\n    if (linePos < 0) {\n      position += cue.vertical === \"\" ? containerBox.height : containerBox.width;\n      axis = axis.reverse();\n    }\n\n    // Move the box to the specified position. This may not be its best\n    // position.\n    boxPosition.move(initialAxis, position);\n\n  } else {\n    // If we have a percentage line value for the cue.\n    var calculatedPercentage = (boxPosition.lineHeight / containerBox.height) * 100;\n\n    switch (cue.lineAlign) {\n    case \"center\":\n      linePos -= (calculatedPercentage / 2);\n      break;\n    case \"end\":\n      linePos -= calculatedPercentage;\n      break;\n    }\n\n    // Apply initial line position to the cue box.\n    switch (cue.vertical) {\n    case \"\":\n      styleBox.applyStyles({\n        top: styleBox.formatStyle(linePos, \"%\")\n      });\n      break;\n    case \"rl\":\n      styleBox.applyStyles({\n        left: styleBox.formatStyle(linePos, \"%\")\n      });\n      break;\n    case \"lr\":\n      styleBox.applyStyles({\n        right: styleBox.formatStyle(linePos, \"%\")\n      });\n      break;\n    }\n\n    axis = [ \"+y\", \"-x\", \"+x\", \"-y\" ];\n\n    // Get the box position again after we've applied the specified positioning\n    // to it.\n    boxPosition = new BoxPosition(styleBox);\n  }\n\n  var bestPosition = findBestPosition(boxPosition, axis);\n  styleBox.move(bestPosition.toCSSCompatValues(containerBox));\n}\n\nfunction WebVTT() {\n  // Nothing\n}\n\n// Helper to allow strings to be decoded instead of the default binary utf8 data.\nWebVTT.StringDecoder = function() {\n  return {\n    decode: function(data) {\n      if (!data) {\n        return \"\";\n      }\n      if (typeof data !== \"string\") {\n        throw new Error(\"Error - expected string data.\");\n      }\n      return decodeURIComponent(encodeURIComponent(data));\n    }\n  };\n};\n\nWebVTT.convertCueToDOMTree = function(window, cuetext) {\n  if (!window || !cuetext) {\n    return null;\n  }\n  return parseContent(window, cuetext);\n};\n\nvar FONT_SIZE_PERCENT = 0.05;\nvar FONT_STYLE = \"sans-serif\";\nvar CUE_BACKGROUND_PADDING = \"1.5%\";\n\n// Runs the processing model over the cues and regions passed to it.\n// @param overlay A block level element (usually a div) that the computed cues\n//                and regions will be placed into.\nWebVTT.processCues = function(window, cues, overlay) {\n  if (!window || !cues || !overlay) {\n    return null;\n  }\n\n  // Remove all previous children.\n  while (overlay.firstChild) {\n    overlay.removeChild(overlay.firstChild);\n  }\n\n  var paddedOverlay = window.document.createElement(\"div\");\n  paddedOverlay.style.position = \"absolute\";\n  paddedOverlay.style.left = \"0\";\n  paddedOverlay.style.right = \"0\";\n  paddedOverlay.style.top = \"0\";\n  paddedOverlay.style.bottom = \"0\";\n  paddedOverlay.style.margin = CUE_BACKGROUND_PADDING;\n  overlay.appendChild(paddedOverlay);\n\n  // Determine if we need to compute the display states of the cues. This could\n  // be the case if a cue's state has been changed since the last computation or\n  // if it has not been computed yet.\n  function shouldCompute(cues) {\n    for (var i = 0; i < cues.length; i++) {\n      if (cues[i].hasBeenReset || !cues[i].displayState) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // We don't need to recompute the cues' display states. Just reuse them.\n  if (!shouldCompute(cues)) {\n    for (var i = 0; i < cues.length; i++) {\n      paddedOverlay.appendChild(cues[i].displayState);\n    }\n    return;\n  }\n\n  var boxPositions = [],\n      containerBox = BoxPosition.getSimpleBoxPosition(paddedOverlay),\n      fontSize = Math.round(containerBox.height * FONT_SIZE_PERCENT * 100) / 100;\n  var styleOptions = {\n    font: fontSize + \"px \" + FONT_STYLE\n  };\n\n  (function() {\n    var styleBox, cue;\n\n    for (var i = 0; i < cues.length; i++) {\n      cue = cues[i];\n\n      // Compute the intial position and styles of the cue div.\n      styleBox = new CueStyleBox(window, cue, styleOptions);\n      paddedOverlay.appendChild(styleBox.div);\n\n      // Move the cue div to it's correct line position.\n      moveBoxToLinePosition(window, styleBox, containerBox, boxPositions);\n\n      // Remember the computed div so that we don't have to recompute it later\n      // if we don't have too.\n      cue.displayState = styleBox.div;\n\n      boxPositions.push(BoxPosition.getSimpleBoxPosition(styleBox));\n    }\n  })();\n};\n\nWebVTT.Parser = function(window, vttjs, decoder) {\n  if (!decoder) {\n    decoder = vttjs;\n    vttjs = {};\n  }\n  if (!vttjs) {\n    vttjs = {};\n  }\n\n  this.window = window;\n  this.vttjs = vttjs;\n  this.state = \"INITIAL\";\n  this.buffer = \"\";\n  this.decoder = decoder || new TextDecoder(\"utf8\");\n  this.regionList = [];\n};\n\nWebVTT.Parser.prototype = {\n  // If the error is a ParsingError then report it to the consumer if\n  // possible. If it's not a ParsingError then throw it like normal.\n  reportOrThrowError: function(e) {\n    if (e instanceof ParsingError) {\n      this.onparsingerror && this.onparsingerror(e);\n    } else {\n      throw e;\n    }\n  },\n  parse: function (data) {\n    var self = this;\n\n    // If there is no data then we won't decode it, but will just try to parse\n    // whatever is in buffer already. This may occur in circumstances, for\n    // example when flush() is called.\n    if (data) {\n      // Try to decode the data that we received.\n      self.buffer += self.decoder.decode(data, {stream: true});\n    }\n\n    function collectNextLine() {\n      var buffer = self.buffer;\n      var pos = 0;\n      while (pos < buffer.length && buffer[pos] !== '\\r' && buffer[pos] !== '\\n') {\n        ++pos;\n      }\n      var line = buffer.substr(0, pos);\n      // Advance the buffer early in case we fail below.\n      if (buffer[pos] === '\\r') {\n        ++pos;\n      }\n      if (buffer[pos] === '\\n') {\n        ++pos;\n      }\n      self.buffer = buffer.substr(pos);\n      return line;\n    }\n\n    // 3.4 WebVTT region and WebVTT region settings syntax\n    function parseRegion(input) {\n      var settings = new Settings();\n\n      parseOptions(input, function (k, v) {\n        switch (k) {\n        case \"id\":\n          settings.set(k, v);\n          break;\n        case \"width\":\n          settings.percent(k, v);\n          break;\n        case \"lines\":\n          settings.integer(k, v);\n          break;\n        case \"regionanchor\":\n        case \"viewportanchor\":\n          var xy = v.split(',');\n          if (xy.length !== 2) {\n            break;\n          }\n          // We have to make sure both x and y parse, so use a temporary\n          // settings object here.\n          var anchor = new Settings();\n          anchor.percent(\"x\", xy[0]);\n          anchor.percent(\"y\", xy[1]);\n          if (!anchor.has(\"x\") || !anchor.has(\"y\")) {\n            break;\n          }\n          settings.set(k + \"X\", anchor.get(\"x\"));\n          settings.set(k + \"Y\", anchor.get(\"y\"));\n          break;\n        case \"scroll\":\n          settings.alt(k, v, [\"up\"]);\n          break;\n        }\n      }, /=/, /\\s/);\n\n      // Create the region, using default values for any values that were not\n      // specified.\n      if (settings.has(\"id\")) {\n        var region = new (self.vttjs.VTTRegion || self.window.VTTRegion)();\n        region.width = settings.get(\"width\", 100);\n        region.lines = settings.get(\"lines\", 3);\n        region.regionAnchorX = settings.get(\"regionanchorX\", 0);\n        region.regionAnchorY = settings.get(\"regionanchorY\", 100);\n        region.viewportAnchorX = settings.get(\"viewportanchorX\", 0);\n        region.viewportAnchorY = settings.get(\"viewportanchorY\", 100);\n        region.scroll = settings.get(\"scroll\", \"\");\n        // Register the region.\n        self.onregion && self.onregion(region);\n        // Remember the VTTRegion for later in case we parse any VTTCues that\n        // reference it.\n        self.regionList.push({\n          id: settings.get(\"id\"),\n          region: region\n        });\n      }\n    }\n\n    // draft-pantos-http-live-streaming-20\n    // https://tools.ietf.org/html/draft-pantos-http-live-streaming-20#section-3.5\n    // 3.5 WebVTT\n    function parseTimestampMap(input) {\n      var settings = new Settings();\n\n      parseOptions(input, function(k, v) {\n        switch(k) {\n        case \"MPEGT\":\n          settings.integer(k + 'S', v);\n          break;\n        case \"LOCA\":\n          settings.set(k + 'L', parseTimeStamp(v));\n          break;\n        }\n      }, /[^\\d]:/, /,/);\n\n      self.ontimestampmap && self.ontimestampmap({\n        \"MPEGTS\": settings.get(\"MPEGTS\"),\n        \"LOCAL\": settings.get(\"LOCAL\")\n      });\n    }\n\n    // 3.2 WebVTT metadata header syntax\n    function parseHeader(input) {\n      if (input.match(/X-TIMESTAMP-MAP/)) {\n        // This line contains HLS X-TIMESTAMP-MAP metadata\n        parseOptions(input, function(k, v) {\n          switch(k) {\n          case \"X-TIMESTAMP-MAP\":\n            parseTimestampMap(v);\n            break;\n          }\n        }, /=/);\n      } else {\n        parseOptions(input, function (k, v) {\n          switch (k) {\n          case \"Region\":\n            // 3.3 WebVTT region metadata header syntax\n            parseRegion(v);\n            break;\n          }\n        }, /:/);\n      }\n\n    }\n\n    // 5.1 WebVTT file parsing.\n    try {\n      var line;\n      if (self.state === \"INITIAL\") {\n        // We can't start parsing until we have the first line.\n        if (!/\\r\\n|\\n/.test(self.buffer)) {\n          return this;\n        }\n\n        line = collectNextLine();\n\n        var m = line.match(/^WEBVTT([ \\t].*)?$/);\n        if (!m || !m[0]) {\n          throw new ParsingError(ParsingError.Errors.BadSignature);\n        }\n\n        self.state = \"HEADER\";\n      }\n\n      var alreadyCollectedLine = false;\n      while (self.buffer) {\n        // We can't parse a line until we have the full line.\n        if (!/\\r\\n|\\n/.test(self.buffer)) {\n          return this;\n        }\n\n        if (!alreadyCollectedLine) {\n          line = collectNextLine();\n        } else {\n          alreadyCollectedLine = false;\n        }\n\n        switch (self.state) {\n        case \"HEADER\":\n          // 13-18 - Allow a header (metadata) under the WEBVTT line.\n          if (/:/.test(line)) {\n            parseHeader(line);\n          } else if (!line) {\n            // An empty line terminates the header and starts the body (cues).\n            self.state = \"ID\";\n          }\n          continue;\n        case \"NOTE\":\n          // Ignore NOTE blocks.\n          if (!line) {\n            self.state = \"ID\";\n          }\n          continue;\n        case \"ID\":\n          // Check for the start of NOTE blocks.\n          if (/^NOTE($|[ \\t])/.test(line)) {\n            self.state = \"NOTE\";\n            break;\n          }\n          // 19-29 - Allow any number of line terminators, then initialize new cue values.\n          if (!line) {\n            continue;\n          }\n          self.cue = new (self.vttjs.VTTCue || self.window.VTTCue)(0, 0, \"\");\n          // Safari still uses the old middle value and won't accept center\n          try {\n            self.cue.align = \"center\";\n          } catch (e) {\n            self.cue.align = \"middle\";\n          }\n          self.state = \"CUE\";\n          // 30-39 - Check if self line contains an optional identifier or timing data.\n          if (line.indexOf(\"-->\") === -1) {\n            self.cue.id = line;\n            continue;\n          }\n          // Process line as start of a cue.\n          /*falls through*/\n        case \"CUE\":\n          // 40 - Collect cue timings and settings.\n          try {\n            parseCue(line, self.cue, self.regionList);\n          } catch (e) {\n            self.reportOrThrowError(e);\n            // In case of an error ignore rest of the cue.\n            self.cue = null;\n            self.state = \"BADCUE\";\n            continue;\n          }\n          self.state = \"CUETEXT\";\n          continue;\n        case \"CUETEXT\":\n          var hasSubstring = line.indexOf(\"-->\") !== -1;\n          // 34 - If we have an empty line then report the cue.\n          // 35 - If we have the special substring '-->' then report the cue,\n          // but do not collect the line as we need to process the current\n          // one as a new cue.\n          if (!line || hasSubstring && (alreadyCollectedLine = true)) {\n            // We are done parsing self cue.\n            self.oncue && self.oncue(self.cue);\n            self.cue = null;\n            self.state = \"ID\";\n            continue;\n          }\n          if (self.cue.text) {\n            self.cue.text += \"\\n\";\n          }\n          self.cue.text += line.replace(/\\u2028/g, '\\n').replace(/u2029/g, '\\n');\n          continue;\n        case \"BADCUE\": // BADCUE\n          // 54-62 - Collect and discard the remaining cue.\n          if (!line) {\n            self.state = \"ID\";\n          }\n          continue;\n        }\n      }\n    } catch (e) {\n      self.reportOrThrowError(e);\n\n      // If we are currently parsing a cue, report what we have.\n      if (self.state === \"CUETEXT\" && self.cue && self.oncue) {\n        self.oncue(self.cue);\n      }\n      self.cue = null;\n      // Enter BADWEBVTT state if header was not parsed correctly otherwise\n      // another exception occurred so enter BADCUE state.\n      self.state = self.state === \"INITIAL\" ? \"BADWEBVTT\" : \"BADCUE\";\n    }\n    return this;\n  },\n  flush: function () {\n    var self = this;\n    try {\n      // Finish decoding the stream.\n      self.buffer += self.decoder.decode();\n      // Synthesize the end of the current cue or region.\n      if (self.cue || self.state === \"HEADER\") {\n        self.buffer += \"\\n\\n\";\n        self.parse();\n      }\n      // If we've flushed, parsed, and we're still on the INITIAL state then\n      // that means we don't have enough of the stream to parse the first\n      // line.\n      if (self.state === \"INITIAL\") {\n        throw new ParsingError(ParsingError.Errors.BadSignature);\n      }\n    } catch(e) {\n      self.reportOrThrowError(e);\n    }\n    self.onflush && self.onflush();\n    return this;\n  }\n};\n\nmodule.exports = WebVTT;\n","/**\n * Copyright 2013 vtt.js Contributors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar autoKeyword = \"auto\";\nvar directionSetting = {\n  \"\": 1,\n  \"lr\": 1,\n  \"rl\": 1\n};\nvar alignSetting = {\n  \"start\": 1,\n  \"center\": 1,\n  \"end\": 1,\n  \"left\": 1,\n  \"right\": 1,\n  \"auto\": 1,\n  \"line-left\": 1,\n  \"line-right\": 1\n};\n\nfunction findDirectionSetting(value) {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n  var dir = directionSetting[value.toLowerCase()];\n  return dir ? value.toLowerCase() : false;\n}\n\nfunction findAlignSetting(value) {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n  var align = alignSetting[value.toLowerCase()];\n  return align ? value.toLowerCase() : false;\n}\n\nfunction VTTCue(startTime, endTime, text) {\n  /**\n   * Shim implementation specific properties. These properties are not in\n   * the spec.\n   */\n\n  // Lets us know when the VTTCue's data has changed in such a way that we need\n  // to recompute its display state. This lets us compute its display state\n  // lazily.\n  this.hasBeenReset = false;\n\n  /**\n   * VTTCue and TextTrackCue properties\n   * http://dev.w3.org/html5/webvtt/#vttcue-interface\n   */\n\n  var _id = \"\";\n  var _pauseOnExit = false;\n  var _startTime = startTime;\n  var _endTime = endTime;\n  var _text = text;\n  var _region = null;\n  var _vertical = \"\";\n  var _snapToLines = true;\n  var _line = \"auto\";\n  var _lineAlign = \"start\";\n  var _position = \"auto\";\n  var _positionAlign = \"auto\";\n  var _size = 100;\n  var _align = \"center\";\n\n  Object.defineProperties(this, {\n    \"id\": {\n      enumerable: true,\n      get: function() {\n        return _id;\n      },\n      set: function(value) {\n        _id = \"\" + value;\n      }\n    },\n\n    \"pauseOnExit\": {\n      enumerable: true,\n      get: function() {\n        return _pauseOnExit;\n      },\n      set: function(value) {\n        _pauseOnExit = !!value;\n      }\n    },\n\n    \"startTime\": {\n      enumerable: true,\n      get: function() {\n        return _startTime;\n      },\n      set: function(value) {\n        if (typeof value !== \"number\") {\n          throw new TypeError(\"Start time must be set to a number.\");\n        }\n        _startTime = value;\n        this.hasBeenReset = true;\n      }\n    },\n\n    \"endTime\": {\n      enumerable: true,\n      get: function() {\n        return _endTime;\n      },\n      set: function(value) {\n        if (typeof value !== \"number\") {\n          throw new TypeError(\"End time must be set to a number.\");\n        }\n        _endTime = value;\n        this.hasBeenReset = true;\n      }\n    },\n\n    \"text\": {\n      enumerable: true,\n      get: function() {\n        return _text;\n      },\n      set: function(value) {\n        _text = \"\" + value;\n        this.hasBeenReset = true;\n      }\n    },\n\n    \"region\": {\n      enumerable: true,\n      get: function() {\n        return _region;\n      },\n      set: function(value) {\n        _region = value;\n        this.hasBeenReset = true;\n      }\n    },\n\n    \"vertical\": {\n      enumerable: true,\n      get: function() {\n        return _vertical;\n      },\n      set: function(value) {\n        var setting = findDirectionSetting(value);\n        // Have to check for false because the setting an be an empty string.\n        if (setting === false) {\n          throw new SyntaxError(\"Vertical: an invalid or illegal direction string was specified.\");\n        }\n        _vertical = setting;\n        this.hasBeenReset = true;\n      }\n    },\n\n    \"snapToLines\": {\n      enumerable: true,\n      get: function() {\n        return _snapToLines;\n      },\n      set: function(value) {\n        _snapToLines = !!value;\n        this.hasBeenReset = true;\n      }\n    },\n\n    \"line\": {\n      enumerable: true,\n      get: function() {\n        return _line;\n      },\n      set: function(value) {\n        if (typeof value !== \"number\" && value !== autoKeyword) {\n          throw new SyntaxError(\"Line: an invalid number or illegal string was specified.\");\n        }\n        _line = value;\n        this.hasBeenReset = true;\n      }\n    },\n\n    \"lineAlign\": {\n      enumerable: true,\n      get: function() {\n        return _lineAlign;\n      },\n      set: function(value) {\n        var setting = findAlignSetting(value);\n        if (!setting) {\n          console.warn(\"lineAlign: an invalid or illegal string was specified.\");\n        } else {\n          _lineAlign = setting;\n          this.hasBeenReset = true;\n        }\n      }\n    },\n\n    \"position\": {\n      enumerable: true,\n      get: function() {\n        return _position;\n      },\n      set: function(value) {\n        if (value < 0 || value > 100) {\n          throw new Error(\"Position must be between 0 and 100.\");\n        }\n        _position = value;\n        this.hasBeenReset = true;\n      }\n    },\n\n    \"positionAlign\": {\n      enumerable: true,\n      get: function() {\n        return _positionAlign;\n      },\n      set: function(value) {\n        var setting = findAlignSetting(value);\n        if (!setting) {\n          console.warn(\"positionAlign: an invalid or illegal string was specified.\");\n        } else {\n          _positionAlign = setting;\n          this.hasBeenReset = true;\n        }\n      }\n    },\n\n    \"size\": {\n      enumerable: true,\n      get: function() {\n        return _size;\n      },\n      set: function(value) {\n        if (value < 0 || value > 100) {\n          throw new Error(\"Size must be between 0 and 100.\");\n        }\n        _size = value;\n        this.hasBeenReset = true;\n      }\n    },\n\n    \"align\": {\n      enumerable: true,\n      get: function() {\n        return _align;\n      },\n      set: function(value) {\n        var setting = findAlignSetting(value);\n        if (!setting) {\n          throw new SyntaxError(\"align: an invalid or illegal alignment string was specified.\");\n        }\n        _align = setting;\n        this.hasBeenReset = true;\n      }\n    }\n  });\n\n  /**\n   * Other <track> spec defined properties\n   */\n\n  // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#text-track-cue-display-state\n  this.displayState = undefined;\n}\n\n/**\n * VTTCue methods\n */\n\nVTTCue.prototype.getCueAsHTML = function() {\n  // Assume WebVTT.convertCueToDOMTree is on the global.\n  return WebVTT.convertCueToDOMTree(window, this.text);\n};\n\nmodule.exports = VTTCue;\n","/**\n * Copyright 2013 vtt.js Contributors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar scrollSetting = {\n  \"\": true,\n  \"up\": true\n};\n\nfunction findScrollSetting(value) {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n  var scroll = scrollSetting[value.toLowerCase()];\n  return scroll ? value.toLowerCase() : false;\n}\n\nfunction isValidPercentValue(value) {\n  return typeof value === \"number\" && (value >= 0 && value <= 100);\n}\n\n// VTTRegion shim http://dev.w3.org/html5/webvtt/#vttregion-interface\nfunction VTTRegion() {\n  var _width = 100;\n  var _lines = 3;\n  var _regionAnchorX = 0;\n  var _regionAnchorY = 100;\n  var _viewportAnchorX = 0;\n  var _viewportAnchorY = 100;\n  var _scroll = \"\";\n\n  Object.defineProperties(this, {\n    \"width\": {\n      enumerable: true,\n      get: function() {\n        return _width;\n      },\n      set: function(value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"Width must be between 0 and 100.\");\n        }\n        _width = value;\n      }\n    },\n    \"lines\": {\n      enumerable: true,\n      get: function() {\n        return _lines;\n      },\n      set: function(value) {\n        if (typeof value !== \"number\") {\n          throw new TypeError(\"Lines must be set to a number.\");\n        }\n        _lines = value;\n      }\n    },\n    \"regionAnchorY\": {\n      enumerable: true,\n      get: function() {\n        return _regionAnchorY;\n      },\n      set: function(value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"RegionAnchorX must be between 0 and 100.\");\n        }\n        _regionAnchorY = value;\n      }\n    },\n    \"regionAnchorX\": {\n      enumerable: true,\n      get: function() {\n        return _regionAnchorX;\n      },\n      set: function(value) {\n        if(!isValidPercentValue(value)) {\n          throw new Error(\"RegionAnchorY must be between 0 and 100.\");\n        }\n        _regionAnchorX = value;\n      }\n    },\n    \"viewportAnchorY\": {\n      enumerable: true,\n      get: function() {\n        return _viewportAnchorY;\n      },\n      set: function(value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"ViewportAnchorY must be between 0 and 100.\");\n        }\n        _viewportAnchorY = value;\n      }\n    },\n    \"viewportAnchorX\": {\n      enumerable: true,\n      get: function() {\n        return _viewportAnchorX;\n      },\n      set: function(value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"ViewportAnchorX must be between 0 and 100.\");\n        }\n        _viewportAnchorX = value;\n      }\n    },\n    \"scroll\": {\n      enumerable: true,\n      get: function() {\n        return _scroll;\n      },\n      set: function(value) {\n        var setting = findScrollSetting(value);\n        // Have to check for false as an empty string is a legal value.\n        if (setting === false) {\n          console.warn(\"Scroll: an invalid or illegal string was specified.\");\n        } else {\n          _scroll = setting;\n        }\n      }\n    }\n  });\n}\n\nmodule.exports = VTTRegion;\n"],"names":["countBits","x","toString","length","countBytes","Math","ceil","isTypedArray","obj","ArrayBuffer","isView","toUint8","bytes","Uint8Array","Array","isArray","buffer","byteOffset","byteLength","BigInt","window","Number","BYTE_TABLE","bytesToNumber","a","Uint16Array","b","_temp","_ref","_ref$signed","signed","_ref$le","le","fn","prototype","number","call","total","byte","i","exponent","abs","max","numberToBytes","_temp2","_ref2","_ref2$le","byteCount","byteIndex","bytesToString","slice","string","String","fromCharCode","apply","decodeURIComponent","escape","e","stringToBytes","stringIsBytes","unescape","encodeURIComponent","view","charCodeAt","concatTypedArrays","_len","arguments","buffers","_key","filter","totalLen","reduce","buf","tempBuffer","offset","forEach","set","bytesMatch","_temp3","_ref3","_ref3$offset","_ref3$mask","mask","every","bByte","aByte","regexs","mp4","webm","ogg","video","audio","text","muxerVideo","muxerAudio","muxerText","mediaTypes","upperMediaTypes","translateLegacyCodec","codec","replace","orig","profile","avcLevel","profileHex","avcLevelHex","parseCodecs","codecString","codecs","split","result","codecType","trim","name","match","exec","toLowerCase","type","substring","details","push","mediaType","codecsFromDefault","master","audioGroupId","mediaGroups","AUDIO","audioGroup","audioType","default","playlists","attributes","CODECS","isAudioCodec","test","isTextCodec","getMimeForCodec","map","c","container","browserSupportsCodec","muxerSupportsCodec","DEFAULT_AUDIO_CODEC","DEFAULT_VIDEO_CODEC","DESCRIPTORS","normalizePath","path","normalizePaths","paths","p","parseDescriptors","results","tag","size","headerSize","z","_DESCRIPTORS$z","id","parser","subarray","desc","flags","dependsOnEsId","ocrEsId","descriptors","url","len","oti","streamType","bufferSize","maxBitrate","avgBitrate","findBox","complete","end","data","EBML_TAGS","EBML","DocType","Segment","SegmentInfo","Tracks","Track","TrackNumber","DefaultDuration","TrackEntry","TrackType","FlagDefault","CodecID","CodecPrivate","VideoTrack","AudioTrack","Cluster","Timestamp","TimestampScale","BlockGroup","BlockDuration","Block","SimpleBlock","LENGTH_TABLE","getLength","getvint","removeLength","valueBytes","value","getInfinityDataSize","innerid","dataHeader","findEbml","dataStart","dataEnd","concat","totalLength","NAL_TYPE_ONE","NAL_TYPE_TWO","EMULATION_PREVENTION","discardEmulationPreventionBytes","positions","newLength","newData","sourceIndex","shift","findNal","dataType","types","nalLimit","Infinity","nalStart","nalsFound","nalOffset","nalType","indexOf","findH264Nal","findH265Nal","CONSTANTS","_isLikely","aac","getId3Offset","mp3","docType","mkv","matroska","mov","fmp4","moof","moov","ac3","ts","flac","avi","riff","wav","isLikelyTypes","Object","keys","t","isLikelyFn","isLikely","detectContainerForBytes","isLikelyFmp4MediaSegment","atob","s","Buffer","from","decodeB64ToUint8Array","b64Text","decodedString","array","ID3","getId3Size","returnSize","footerPresent","MPEGURL_REGEX","DASH_REGEX","simpleTypeFromSourceType","DEFAULT_LOCATION","resolveUrl","baseUrl","relativeUrl","nativeURL","protocolLess","removeLocation","URLToolkit","newUrl","URL","href","protocol","Stream","this","listeners","_proto","on","listener","off","index","splice","trigger","callbacks","args","_length","_i","dispose","pipe","destination","require","httpResponseHandler","callback","decodeResponseBody","err","response","responseBody","statusCode","cause","TextDecoder","charset","getCharset","headers","decode","contentTypeHeader","contentType","_contentType$split","module","exports","_extends","isFunction","createXHR","httpHandler","parseHeaders","row","key","forEachArray","iterator","isEmpty","hasOwnProperty","initParams","uri","options","params","_createXHR","Error","called","body","readystatechange","xhr","readyState","setTimeout","loadFunc","getBody","undefined","responseText","getXml","isJson","JSON","parse","errorFunc","evt","clearTimeout","timeoutTimer","failureResponse","aborted","status","useXDR","method","rawRequest","getAllResponseHeaders","cors","XDomainRequest","XMLHttpRequest","sync","json","stringify","onreadystatechange","onload","onerror","onprogress","onabort","ontimeout","open","username","password","withCredentials","timeout","abort","code","setRequestHeader","responseType","beforeSend","send","responseXML","firefoxBugTakenEffect","documentElement","nodeName","noop","toUpperCase","vttjs","WebVTT","VTTCue","VTTRegion","cueShim","regionShim","nativeVTTCue","nativeVTTRegion","shim","restore","document","_objCreate","create","F","o","ParsingError","errorData","message","parseTimeStamp","input","computeSeconds","h","m","f","Settings","values","parseOptions","keyValueDelim","groupDelim","groups","kv","k","v","parseCue","cue","regionList","oInput","consumeTimeStamp","Errors","BadTimeStamp","consumeCueSettings","settings","region","alt","vals","vals0","integer","percent","get","vertical","line","lineAlign","snapToLines","align","position","start","left","center","middle","right","positionAlign","skipWhitespace","startTime","substr","endTime","constructor","BadSignature","dflt","defaultKey","has","n","parseInt","parseFloat","TEXTAREA_ELEMENT","createElement","TAG_NAME","u","ruby","rt","lang","DEFAULT_COLOR_CLASS","white","lime","cyan","red","yellow","magenta","blue","black","TAG_ANNOTATION","NEEDS_PARENT","parseContent","nextToken","consume","innerHTML","textContent","shouldAdd","current","element","localName","annotation","tagName","rootDiv","tagStack","appendChild","createTextNode","pop","parentNode","node","createProcessingInstruction","classes","cl","bgColor","colorName","propName","propValue","style","className","join","strongRTLRanges","isStrongRTLChar","charCode","currentRange","determineBidi","cueDiv","nodeStack","childNodes","pushNodes","nextTextNode","innerText","computeLinePos","track","textTrackList","mediaElement","trackList","count","mode","StyleBox","CueStyleBox","styleOptions","styles","color","backgroundColor","top","bottom","display","writingMode","unicodeBidi","applyStyles","div","direction","textAlign","font","whiteSpace","textPos","formatStyle","width","height","move","box","BoxPosition","lh","offsetHeight","offsetWidth","offsetTop","rects","getClientRects","getBoundingClientRect","lineHeight","moveBoxToLinePosition","styleBox","containerBox","boxPositions","findBestPosition","axis","bestPosition","specifiedPosition","percentage","overlapsOppositeAxis","within","overlapsAny","intersectPercentage","boxPosition","linePos","step","round","maxPosition","initialAxis","reverse","calculatedPercentage","toCSSCompatValues","prop","val","unit","toMove","overlaps","b2","boxes","min","y","intersectArea","reference","getSimpleBoxPosition","ret","StringDecoder","convertCueToDOMTree","cuetext","FONT_SIZE_PERCENT","FONT_STYLE","CUE_BACKGROUND_PADDING","processCues","cues","overlay","firstChild","removeChild","paddedOverlay","shouldCompute","hasBeenReset","displayState","margin","fontSize","Parser","decoder","state","reportOrThrowError","onparsingerror","self","collectNextLine","pos","parseRegion","xy","anchor","lines","regionAnchorX","regionAnchorY","viewportAnchorX","viewportAnchorY","scroll","onregion","parseTimestampMap","ontimestampmap","parseHeader","stream","alreadyCollectedLine","hasSubstring","oncue","flush","onflush","autoKeyword","directionSetting","alignSetting","findDirectionSetting","dir","findAlignSetting","_id","_pauseOnExit","_startTime","_endTime","_text","_region","_vertical","_snapToLines","_line","_lineAlign","_position","_positionAlign","_size","_align","defineProperties","enumerable","TypeError","setting","SyntaxError","console","warn","getCueAsHTML","scrollSetting","findScrollSetting","isValidPercentValue","_width","_lines","_regionAnchorX","_regionAnchorY","_viewportAnchorX","_viewportAnchorY","_scroll"],"sourceRoot":""}